1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 2002,2008 Oracle.  All rights reserved.
5 *
6 * $Id: TupleFormatTest.java,v 12.9 2008/02/07 17:12:30 mark Exp $
7 */
8
9package com.sleepycat.bind.tuple.test;
10
11import java.util.Arrays;
12
13import junit.framework.Test;
14import junit.framework.TestCase;
15import junit.framework.TestSuite;
16
17import com.sleepycat.bind.tuple.TupleBinding;
18import com.sleepycat.bind.tuple.TupleInput;
19import com.sleepycat.bind.tuple.TupleOutput;
20import com.sleepycat.db.DatabaseEntry;
21import com.sleepycat.util.test.SharedTestUtils;
22
23/**
24 * @author Mark Hayes
25 */
26public class TupleFormatTest extends TestCase {
27
28    private TupleInput in;
29    private TupleOutput out;
30    private DatabaseEntry buffer;
31
32    public static void main(String[] args)
33        throws Exception {
34
35        junit.framework.TestResult tr =
36            junit.textui.TestRunner.run(suite());
37        if (tr.errorCount() > 0 ||
38            tr.failureCount() > 0) {
39            System.exit(1);
40        } else {
41            System.exit(0);
42        }
43    }
44
45    public static Test suite()
46        throws Exception {
47
48        TestSuite suite = new TestSuite(TupleFormatTest.class);
49        return suite;
50    }
51
52    public TupleFormatTest(String name) {
53
54        super(name);
55    }
56
57    public void setUp() {
58
59        SharedTestUtils.printTestName("TupleFormatTest." + getName());
60        buffer = new DatabaseEntry();
61        out = new TupleOutput();
62    }
63
64    public void tearDown() {
65
66        /* Ensure that GC can cleanup. */
67        in = null;
68        out = null;
69        buffer = null;
70    }
71
72    private void copyOutputToInput() {
73
74        TupleBinding.outputToEntry(out, buffer);
75        assertEquals(out.size(), buffer.getSize());
76        in = TupleBinding.entryToInput(buffer);
77        assertEquals(in.available(), buffer.getSize());
78        assertEquals(in.getBufferLength(), buffer.getSize());
79    }
80
81    private void stringTest(String val) {
82
83        out.reset();
84        out.writeString(val);
85        assertEquals(val.length() + 1, out.size()); // assume 1-byte chars
86        copyOutputToInput();
87        assertEquals(val, in.readString());
88        assertEquals(0, in.available());
89    }
90
91    public void testString() {
92
93        stringTest("");
94        stringTest("a");
95        stringTest("abc");
96
97        out.reset();
98        out.writeString("abc");
99        out.writeString("defg");
100        assertEquals(9, out.size());
101        copyOutputToInput();
102        assertEquals("abc", in.readString());
103        assertEquals("defg", in.readString());
104        assertEquals(0, in.available());
105
106        out.reset();
107        out.writeString("abc");
108        out.writeString("defg");
109        out.writeString("hijkl");
110        assertEquals(15, out.size());
111        copyOutputToInput();
112        assertEquals("abc", in.readString());
113        assertEquals("defg", in.readString());
114        assertEquals("hijkl", in.readString());
115        assertEquals(0, in.available());
116    }
117
118    private void fixedStringTest(char[] val) {
119
120        out.reset();
121        out.writeString(val);
122        assertEquals(val.length, out.size()); // assume 1 byte chars
123        copyOutputToInput();
124        char[] val2 = new char[val.length];
125        in.readString(val2);
126        assertTrue(Arrays.equals(val, val2));
127        assertEquals(0, in.available());
128        in.reset();
129        String val3 = in.readString(val.length);
130        assertTrue(Arrays.equals(val, val3.toCharArray()));
131        assertEquals(0, in.available());
132    }
133
134    public void testFixedString() {
135
136        fixedStringTest(new char[0]);
137        fixedStringTest(new char[] {'a'});
138        fixedStringTest(new char[] {'a', 'b', 'c'});
139
140        out.reset();
141        out.writeString(new char[] {'a', 'b', 'c'});
142        out.writeString(new char[] {'d', 'e', 'f', 'g'});
143        assertEquals(7, out.size());
144        copyOutputToInput();
145        assertEquals("abc", in.readString(3));
146        assertEquals("defg", in.readString(4));
147        assertEquals(0, in.available());
148
149        out.reset();
150        out.writeString(new char[] {'a', 'b', 'c'});
151        out.writeString(new char[] {'d', 'e', 'f', 'g'});
152        out.writeString(new char[] {'h', 'i', 'j', 'k', 'l'});
153        assertEquals(12, out.size());
154        copyOutputToInput();
155        assertEquals("abc", in.readString(3));
156        assertEquals("defg", in.readString(4));
157        assertEquals("hijkl", in.readString(5));
158        assertEquals(0, in.available());
159    }
160
161    public void testNullString() {
162
163        out.reset();
164        out.writeString((String) null);
165        assertEquals(2, out.size());
166        copyOutputToInput();
167        assertEquals(null, in.readString());
168        assertEquals(0, in.available());
169
170        out.reset();
171        out.writeString((String) null);
172        out.writeString("x");
173        assertEquals(4, out.size());
174        copyOutputToInput();
175        assertEquals(null, in.readString());
176        assertEquals(2, in.available());
177        assertEquals("x", in.readString());
178        assertEquals(0, in.available());
179
180        out.reset();
181        out.writeString("x");
182        out.writeString((String) null);
183        assertEquals(4, out.size());
184        copyOutputToInput();
185        assertEquals("x", in.readString());
186        assertEquals(2, in.available());
187        assertEquals(null, in.readString());
188        assertEquals(0, in.available());
189
190        out.reset();
191        out.writeString((String) null);
192        out.writeInt(123);
193        assertEquals(6, out.size());
194        copyOutputToInput();
195        assertEquals(null, in.readString());
196        assertEquals(4, in.available());
197        assertEquals(123, in.readInt());
198        assertEquals(0, in.available());
199
200        out.reset();
201        out.writeInt(123);
202        out.writeString((String) null);
203        assertEquals(6, out.size());
204        copyOutputToInput();
205        assertEquals(123, in.readInt());
206        assertEquals(2, in.available());
207        assertEquals(null, in.readString());
208        assertEquals(0, in.available());
209    }
210
211    private void charsTest(char[] val) {
212
213        for (int mode = 0; mode < 2; mode += 1) {
214            out.reset();
215            switch (mode) {
216                case 0: out.writeChars(val); break;
217                case 1: out.writeChars(new String(val)); break;
218                default: throw new IllegalStateException();
219            }
220            assertEquals(val.length * 2, out.size());
221            copyOutputToInput();
222            char[] val2 = new char[val.length];
223            in.readChars(val2);
224            assertTrue(Arrays.equals(val, val2));
225            assertEquals(0, in.available());
226            in.reset();
227            String val3 = in.readChars(val.length);
228            assertTrue(Arrays.equals(val, val3.toCharArray()));
229            assertEquals(0, in.available());
230        }
231    }
232
233    public void testChars() {
234
235        charsTest(new char[0]);
236        charsTest(new char[] {'a'});
237        charsTest(new char[] {'a', 'b', 'c'});
238
239        out.reset();
240        out.writeChars("abc");
241        out.writeChars("defg");
242        assertEquals(7 * 2, out.size());
243        copyOutputToInput();
244        assertEquals("abc", in.readChars(3));
245        assertEquals("defg", in.readChars(4));
246        assertEquals(0, in.available());
247
248        out.reset();
249        out.writeChars("abc");
250        out.writeChars("defg");
251        out.writeChars("hijkl");
252        assertEquals(12 * 2, out.size());
253        copyOutputToInput();
254        assertEquals("abc", in.readChars(3));
255        assertEquals("defg", in.readChars(4));
256        assertEquals("hijkl", in.readChars(5));
257        assertEquals(0, in.available());
258    }
259
260    private void bytesTest(char[] val) {
261
262        char[] valBytes = new char[val.length];
263        for (int i = 0; i < val.length; i += 1)
264            valBytes[i] = (char) (val[i] & 0xFF);
265
266        for (int mode = 0; mode < 2; mode += 1) {
267            out.reset();
268            switch (mode) {
269                case 0: out.writeBytes(val); break;
270                case 1: out.writeBytes(new String(val)); break;
271                default: throw new IllegalStateException();
272            }
273            assertEquals(val.length, out.size());
274            copyOutputToInput();
275            char[] val2 = new char[val.length];
276            in.readBytes(val2);
277            assertTrue(Arrays.equals(valBytes, val2));
278            assertEquals(0, in.available());
279            in.reset();
280            String val3 = in.readBytes(val.length);
281            assertTrue(Arrays.equals(valBytes, val3.toCharArray()));
282            assertEquals(0, in.available());
283        }
284    }
285
286    public void testBytes() {
287
288        bytesTest(new char[0]);
289        bytesTest(new char[] {'a'});
290        bytesTest(new char[] {'a', 'b', 'c'});
291        bytesTest(new char[] {0x7F00, 0x7FFF, 0xFF00, 0xFFFF});
292
293        out.reset();
294        out.writeBytes("abc");
295        out.writeBytes("defg");
296        assertEquals(7, out.size());
297        copyOutputToInput();
298        assertEquals("abc", in.readBytes(3));
299        assertEquals("defg", in.readBytes(4));
300        assertEquals(0, in.available());
301
302        out.reset();
303        out.writeBytes("abc");
304        out.writeBytes("defg");
305        out.writeBytes("hijkl");
306        assertEquals(12, out.size());
307        copyOutputToInput();
308        assertEquals("abc", in.readBytes(3));
309        assertEquals("defg", in.readBytes(4));
310        assertEquals("hijkl", in.readBytes(5));
311        assertEquals(0, in.available());
312    }
313
314    private void booleanTest(boolean val) {
315
316        out.reset();
317        out.writeBoolean(val);
318        assertEquals(1, out.size());
319        copyOutputToInput();
320        assertEquals(val, in.readBoolean());
321        assertEquals(0, in.available());
322    }
323
324    public void testBoolean() {
325
326        booleanTest(true);
327        booleanTest(false);
328
329        out.reset();
330        out.writeBoolean(true);
331        out.writeBoolean(false);
332        assertEquals(2, out.size());
333        copyOutputToInput();
334        assertEquals(true, in.readBoolean());
335        assertEquals(false, in.readBoolean());
336        assertEquals(0, in.available());
337
338        out.reset();
339        out.writeBoolean(true);
340        out.writeBoolean(false);
341        out.writeBoolean(true);
342        assertEquals(3, out.size());
343        copyOutputToInput();
344        assertEquals(true, in.readBoolean());
345        assertEquals(false, in.readBoolean());
346        assertEquals(true, in.readBoolean());
347        assertEquals(0, in.available());
348    }
349
350    private void unsignedByteTest(int val) {
351
352        unsignedByteTest(val, val);
353    }
354
355    private void unsignedByteTest(int val, int expected) {
356
357        out.reset();
358        out.writeUnsignedByte(val);
359        assertEquals(1, out.size());
360        copyOutputToInput();
361        assertEquals(expected, in.readUnsignedByte());
362    }
363
364    public void testUnsignedByte() {
365
366        unsignedByteTest(0);
367        unsignedByteTest(1);
368        unsignedByteTest(254);
369        unsignedByteTest(255);
370        unsignedByteTest(256, 0);
371        unsignedByteTest(-1, 255);
372        unsignedByteTest(-2, 254);
373        unsignedByteTest(-255, 1);
374
375        out.reset();
376        out.writeUnsignedByte(0);
377        out.writeUnsignedByte(1);
378        out.writeUnsignedByte(255);
379        assertEquals(3, out.size());
380        copyOutputToInput();
381        assertEquals(0, in.readUnsignedByte());
382        assertEquals(1, in.readUnsignedByte());
383        assertEquals(255, in.readUnsignedByte());
384        assertEquals(0, in.available());
385    }
386
387    private void unsignedShortTest(int val) {
388
389        unsignedShortTest(val, val);
390    }
391
392    private void unsignedShortTest(int val, int expected) {
393
394        out.reset();
395        out.writeUnsignedShort(val);
396        assertEquals(2, out.size());
397        copyOutputToInput();
398        assertEquals(expected, in.readUnsignedShort());
399    }
400
401    public void testUnsignedShort() {
402
403        unsignedShortTest(0);
404        unsignedShortTest(1);
405        unsignedShortTest(255);
406        unsignedShortTest(256);
407        unsignedShortTest(257);
408        unsignedShortTest(Short.MAX_VALUE - 1);
409        unsignedShortTest(Short.MAX_VALUE);
410        unsignedShortTest(Short.MAX_VALUE + 1);
411        unsignedShortTest(0xFFFF - 1);
412        unsignedShortTest(0xFFFF);
413        unsignedShortTest(0xFFFF + 1, 0);
414        unsignedShortTest(0x7FFF0000, 0);
415        unsignedShortTest(0xFFFF0000, 0);
416        unsignedShortTest(-1, 0xFFFF);
417        unsignedShortTest(-2, 0xFFFF - 1);
418        unsignedShortTest(-0xFFFF, 1);
419
420        out.reset();
421        out.writeUnsignedShort(0);
422        out.writeUnsignedShort(1);
423        out.writeUnsignedShort(0xFFFF);
424        assertEquals(6, out.size());
425        copyOutputToInput();
426        assertEquals(0, in.readUnsignedShort());
427        assertEquals(1, in.readUnsignedShort());
428        assertEquals(0xFFFF, in.readUnsignedShort());
429        assertEquals(0, in.available());
430    }
431
432    private void unsignedIntTest(long val) {
433
434        unsignedIntTest(val, val);
435    }
436
437    private void unsignedIntTest(long val, long expected) {
438
439        out.reset();
440        out.writeUnsignedInt(val);
441        assertEquals(4, out.size());
442        copyOutputToInput();
443        assertEquals(expected, in.readUnsignedInt());
444    }
445
446    public void testUnsignedInt() {
447
448        unsignedIntTest(0L);
449        unsignedIntTest(1L);
450        unsignedIntTest(255L);
451        unsignedIntTest(256L);
452        unsignedIntTest(257L);
453        unsignedIntTest(Short.MAX_VALUE - 1L);
454        unsignedIntTest(Short.MAX_VALUE);
455        unsignedIntTest(Short.MAX_VALUE + 1L);
456        unsignedIntTest(Integer.MAX_VALUE - 1L);
457        unsignedIntTest(Integer.MAX_VALUE);
458        unsignedIntTest(Integer.MAX_VALUE + 1L);
459        unsignedIntTest(0xFFFFFFFFL - 1L);
460        unsignedIntTest(0xFFFFFFFFL);
461        unsignedIntTest(0xFFFFFFFFL + 1L, 0L);
462        unsignedIntTest(0x7FFFFFFF00000000L, 0L);
463        unsignedIntTest(0xFFFFFFFF00000000L, 0L);
464        unsignedIntTest(-1, 0xFFFFFFFFL);
465        unsignedIntTest(-2, 0xFFFFFFFFL - 1L);
466        unsignedIntTest(-0xFFFFFFFFL, 1L);
467
468        out.reset();
469        out.writeUnsignedInt(0L);
470        out.writeUnsignedInt(1L);
471        out.writeUnsignedInt(0xFFFFFFFFL);
472        assertEquals(12, out.size());
473        copyOutputToInput();
474        assertEquals(0L, in.readUnsignedInt());
475        assertEquals(1L, in.readUnsignedInt());
476        assertEquals(0xFFFFFFFFL, in.readUnsignedInt());
477        assertEquals(0L, in.available());
478    }
479
480    private void byteTest(int val) {
481
482        out.reset();
483        out.writeByte(val);
484        assertEquals(1, out.size());
485        copyOutputToInput();
486        assertEquals((byte) val, in.readByte());
487    }
488
489    public void testByte() {
490
491        byteTest(0);
492        byteTest(1);
493        byteTest(-1);
494        byteTest(Byte.MAX_VALUE - 1);
495        byteTest(Byte.MAX_VALUE);
496        byteTest(Byte.MAX_VALUE + 1);
497        byteTest(Byte.MIN_VALUE + 1);
498        byteTest(Byte.MIN_VALUE);
499        byteTest(Byte.MIN_VALUE - 1);
500        byteTest(0x7F);
501        byteTest(0xFF);
502        byteTest(0x7FFF);
503        byteTest(0xFFFF);
504        byteTest(0x7FFFFFFF);
505        byteTest(0xFFFFFFFF);
506
507        out.reset();
508        out.writeByte(0);
509        out.writeByte(1);
510        out.writeByte(-1);
511        assertEquals(3, out.size());
512        copyOutputToInput();
513        assertEquals(0, in.readByte());
514        assertEquals(1, in.readByte());
515        assertEquals(-1, in.readByte());
516        assertEquals(0, in.available());
517    }
518
519    private void shortTest(int val) {
520
521        out.reset();
522        out.writeShort(val);
523        assertEquals(2, out.size());
524        copyOutputToInput();
525        assertEquals((short) val, in.readShort());
526    }
527
528    public void testShort() {
529
530        shortTest(0);
531        shortTest(1);
532        shortTest(-1);
533        shortTest(Short.MAX_VALUE - 1);
534        shortTest(Short.MAX_VALUE);
535        shortTest(Short.MAX_VALUE + 1);
536        shortTest(Short.MIN_VALUE + 1);
537        shortTest(Short.MIN_VALUE);
538        shortTest(Short.MIN_VALUE - 1);
539        shortTest(0x7F);
540        shortTest(0xFF);
541        shortTest(0x7FFF);
542        shortTest(0xFFFF);
543        shortTest(0x7FFFFFFF);
544        shortTest(0xFFFFFFFF);
545
546        out.reset();
547        out.writeShort(0);
548        out.writeShort(1);
549        out.writeShort(-1);
550        assertEquals(3 * 2, out.size());
551        copyOutputToInput();
552        assertEquals(0, in.readShort());
553        assertEquals(1, in.readShort());
554        assertEquals(-1, in.readShort());
555        assertEquals(0, in.available());
556    }
557
558    private void intTest(int val) {
559
560        out.reset();
561        out.writeInt(val);
562        assertEquals(4, out.size());
563        copyOutputToInput();
564        assertEquals((int) val, in.readInt());
565    }
566
567    public void testInt() {
568
569        intTest(0);
570        intTest(1);
571        intTest(-1);
572        intTest(Integer.MAX_VALUE - 1);
573        intTest(Integer.MAX_VALUE);
574        intTest(Integer.MAX_VALUE + 1);
575        intTest(Integer.MIN_VALUE + 1);
576        intTest(Integer.MIN_VALUE);
577        intTest(Integer.MIN_VALUE - 1);
578        intTest(0x7F);
579        intTest(0xFF);
580        intTest(0x7FFF);
581        intTest(0xFFFF);
582        intTest(0x7FFFFFFF);
583        intTest(0xFFFFFFFF);
584
585        out.reset();
586        out.writeInt(0);
587        out.writeInt(1);
588        out.writeInt(-1);
589        assertEquals(3 * 4, out.size());
590        copyOutputToInput();
591        assertEquals(0, in.readInt());
592        assertEquals(1, in.readInt());
593        assertEquals(-1, in.readInt());
594        assertEquals(0, in.available());
595    }
596
597    private void longTest(long val) {
598
599        out.reset();
600        out.writeLong(val);
601        assertEquals(8, out.size());
602        copyOutputToInput();
603        assertEquals((long) val, in.readLong());
604    }
605
606    public void testLong() {
607
608        longTest(0);
609        longTest(1);
610        longTest(-1);
611        longTest(Long.MAX_VALUE - 1);
612        longTest(Long.MAX_VALUE);
613        longTest(Long.MAX_VALUE + 1);
614        longTest(Long.MIN_VALUE + 1);
615        longTest(Long.MIN_VALUE);
616        longTest(Long.MIN_VALUE - 1);
617        longTest(0x7F);
618        longTest(0xFF);
619        longTest(0x7FFF);
620        longTest(0xFFFF);
621        longTest(0x7FFFFFFF);
622        longTest(0xFFFFFFFF);
623        longTest(0x7FFFFFFFFFFFFFFFL);
624        longTest(0xFFFFFFFFFFFFFFFFL);
625
626        out.reset();
627        out.writeLong(0);
628        out.writeLong(1);
629        out.writeLong(-1);
630        assertEquals(3 * 8, out.size());
631        copyOutputToInput();
632        assertEquals(0, in.readLong());
633        assertEquals(1, in.readLong());
634        assertEquals(-1, in.readLong());
635        assertEquals(0, in.available());
636    }
637
638    private void floatTest(double val) {
639
640        out.reset();
641        out.writeFloat((float) val);
642        assertEquals(4, out.size());
643        copyOutputToInput();
644        if (Double.isNaN(val)) {
645            assertTrue(Float.isNaN(in.readFloat()));
646        } else {
647            assertEquals((float) val, in.readFloat(), 0);
648        }
649    }
650
651    public void testFloat() {
652
653        floatTest(0);
654        floatTest(1);
655        floatTest(-1);
656        floatTest(1.0);
657        floatTest(0.1);
658        floatTest(-1.0);
659        floatTest(-0.1);
660        floatTest(Float.NaN);
661        floatTest(Float.NEGATIVE_INFINITY);
662        floatTest(Float.POSITIVE_INFINITY);
663        floatTest(Short.MAX_VALUE);
664        floatTest(Short.MIN_VALUE);
665        floatTest(Integer.MAX_VALUE);
666        floatTest(Integer.MIN_VALUE);
667        floatTest(Long.MAX_VALUE);
668        floatTest(Long.MIN_VALUE);
669        floatTest(Float.MAX_VALUE);
670        floatTest(Float.MAX_VALUE + 1);
671        floatTest(Float.MIN_VALUE + 1);
672        floatTest(Float.MIN_VALUE);
673        floatTest(Float.MIN_VALUE - 1);
674        floatTest(0x7F);
675        floatTest(0xFF);
676        floatTest(0x7FFF);
677        floatTest(0xFFFF);
678        floatTest(0x7FFFFFFF);
679        floatTest(0xFFFFFFFF);
680        floatTest(0x7FFFFFFFFFFFFFFFL);
681        floatTest(0xFFFFFFFFFFFFFFFFL);
682
683        out.reset();
684        out.writeFloat(0);
685        out.writeFloat(1);
686        out.writeFloat(-1);
687        assertEquals(3 * 4, out.size());
688        copyOutputToInput();
689        assertEquals(0, in.readFloat(), 0);
690        assertEquals(1, in.readFloat(), 0);
691        assertEquals(-1, in.readFloat(), 0);
692        assertEquals(0, in.available(), 0);
693    }
694
695    private void doubleTest(double val) {
696
697        out.reset();
698        out.writeDouble((double) val);
699        assertEquals(8, out.size());
700        copyOutputToInput();
701        if (Double.isNaN(val)) {
702            assertTrue(Double.isNaN(in.readDouble()));
703        } else {
704            assertEquals((double) val, in.readDouble(), 0);
705        }
706    }
707
708    public void testDouble() {
709
710        doubleTest(0);
711        doubleTest(1);
712        doubleTest(-1);
713        doubleTest(1.0);
714        doubleTest(0.1);
715        doubleTest(-1.0);
716        doubleTest(-0.1);
717        doubleTest(Double.NaN);
718        doubleTest(Double.NEGATIVE_INFINITY);
719        doubleTest(Double.POSITIVE_INFINITY);
720        doubleTest(Short.MAX_VALUE);
721        doubleTest(Short.MIN_VALUE);
722        doubleTest(Integer.MAX_VALUE);
723        doubleTest(Integer.MIN_VALUE);
724        doubleTest(Long.MAX_VALUE);
725        doubleTest(Long.MIN_VALUE);
726        doubleTest(Float.MAX_VALUE);
727        doubleTest(Float.MIN_VALUE);
728        doubleTest(Double.MAX_VALUE - 1);
729        doubleTest(Double.MAX_VALUE);
730        doubleTest(Double.MAX_VALUE + 1);
731        doubleTest(Double.MIN_VALUE + 1);
732        doubleTest(Double.MIN_VALUE);
733        doubleTest(Double.MIN_VALUE - 1);
734        doubleTest(0x7F);
735        doubleTest(0xFF);
736        doubleTest(0x7FFF);
737        doubleTest(0xFFFF);
738        doubleTest(0x7FFFFFFF);
739        doubleTest(0xFFFFFFFF);
740        doubleTest(0x7FFFFFFFFFFFFFFFL);
741        doubleTest(0xFFFFFFFFFFFFFFFFL);
742
743        out.reset();
744        out.writeDouble(0);
745        out.writeDouble(1);
746        out.writeDouble(-1);
747        assertEquals(3 * 8, out.size());
748        copyOutputToInput();
749        assertEquals(0, in.readDouble(), 0);
750        assertEquals(1, in.readDouble(), 0);
751        assertEquals(-1, in.readDouble(), 0);
752        assertEquals(0, in.available(), 0);
753    }
754
755    private void sortedFloatTest(double val) {
756
757        out.reset();
758        out.writeSortedFloat((float) val);
759        assertEquals(4, out.size());
760        copyOutputToInput();
761        if (Double.isNaN(val)) {
762            assertTrue(Float.isNaN(in.readSortedFloat()));
763        } else {
764            assertEquals((float) val, in.readSortedFloat(), 0);
765        }
766    }
767
768    public void testSortedFloat() {
769
770        sortedFloatTest(0);
771        sortedFloatTest(1);
772        sortedFloatTest(-1);
773        sortedFloatTest(1.0);
774        sortedFloatTest(0.1);
775        sortedFloatTest(-1.0);
776        sortedFloatTest(-0.1);
777        sortedFloatTest(Float.NaN);
778        sortedFloatTest(Float.NEGATIVE_INFINITY);
779        sortedFloatTest(Float.POSITIVE_INFINITY);
780        sortedFloatTest(Short.MAX_VALUE);
781        sortedFloatTest(Short.MIN_VALUE);
782        sortedFloatTest(Integer.MAX_VALUE);
783        sortedFloatTest(Integer.MIN_VALUE);
784        sortedFloatTest(Long.MAX_VALUE);
785        sortedFloatTest(Long.MIN_VALUE);
786        sortedFloatTest(Float.MAX_VALUE);
787        sortedFloatTest(Float.MAX_VALUE + 1);
788        sortedFloatTest(Float.MIN_VALUE + 1);
789        sortedFloatTest(Float.MIN_VALUE);
790        sortedFloatTest(Float.MIN_VALUE - 1);
791        sortedFloatTest(0x7F);
792        sortedFloatTest(0xFF);
793        sortedFloatTest(0x7FFF);
794        sortedFloatTest(0xFFFF);
795        sortedFloatTest(0x7FFFFFFF);
796        sortedFloatTest(0xFFFFFFFF);
797        sortedFloatTest(0x7FFFFFFFFFFFFFFFL);
798        sortedFloatTest(0xFFFFFFFFFFFFFFFFL);
799
800        out.reset();
801        out.writeSortedFloat(0);
802        out.writeSortedFloat(1);
803        out.writeSortedFloat(-1);
804        assertEquals(3 * 4, out.size());
805        copyOutputToInput();
806        assertEquals(0, in.readSortedFloat(), 0);
807        assertEquals(1, in.readSortedFloat(), 0);
808        assertEquals(-1, in.readSortedFloat(), 0);
809        assertEquals(0, in.available(), 0);
810    }
811
812    private void sortedDoubleTest(double val) {
813
814        out.reset();
815        out.writeSortedDouble((double) val);
816        assertEquals(8, out.size());
817        copyOutputToInput();
818        if (Double.isNaN(val)) {
819            assertTrue(Double.isNaN(in.readSortedDouble()));
820        } else {
821            assertEquals((double) val, in.readSortedDouble(), 0);
822        }
823    }
824
825    public void testSortedDouble() {
826
827        sortedDoubleTest(0);
828        sortedDoubleTest(1);
829        sortedDoubleTest(-1);
830        sortedDoubleTest(1.0);
831        sortedDoubleTest(0.1);
832        sortedDoubleTest(-1.0);
833        sortedDoubleTest(-0.1);
834        sortedDoubleTest(Double.NaN);
835        sortedDoubleTest(Double.NEGATIVE_INFINITY);
836        sortedDoubleTest(Double.POSITIVE_INFINITY);
837        sortedDoubleTest(Short.MAX_VALUE);
838        sortedDoubleTest(Short.MIN_VALUE);
839        sortedDoubleTest(Integer.MAX_VALUE);
840        sortedDoubleTest(Integer.MIN_VALUE);
841        sortedDoubleTest(Long.MAX_VALUE);
842        sortedDoubleTest(Long.MIN_VALUE);
843        sortedDoubleTest(Float.MAX_VALUE);
844        sortedDoubleTest(Float.MIN_VALUE);
845        sortedDoubleTest(Double.MAX_VALUE - 1);
846        sortedDoubleTest(Double.MAX_VALUE);
847        sortedDoubleTest(Double.MAX_VALUE + 1);
848        sortedDoubleTest(Double.MIN_VALUE + 1);
849        sortedDoubleTest(Double.MIN_VALUE);
850        sortedDoubleTest(Double.MIN_VALUE - 1);
851        sortedDoubleTest(0x7F);
852        sortedDoubleTest(0xFF);
853        sortedDoubleTest(0x7FFF);
854        sortedDoubleTest(0xFFFF);
855        sortedDoubleTest(0x7FFFFFFF);
856        sortedDoubleTest(0xFFFFFFFF);
857        sortedDoubleTest(0x7FFFFFFFFFFFFFFFL);
858        sortedDoubleTest(0xFFFFFFFFFFFFFFFFL);
859
860        out.reset();
861        out.writeSortedDouble(0);
862        out.writeSortedDouble(1);
863        out.writeSortedDouble(-1);
864        assertEquals(3 * 8, out.size());
865        copyOutputToInput();
866        assertEquals(0, in.readSortedDouble(), 0);
867        assertEquals(1, in.readSortedDouble(), 0);
868        assertEquals(-1, in.readSortedDouble(), 0);
869        assertEquals(0, in.available(), 0);
870    }
871
872    private void packedIntTest(int val, int size) {
873
874        out.reset();
875        out.writePackedInt(val);
876        assertEquals(size, out.size());
877        copyOutputToInput();
878        assertEquals(size, in.getPackedIntByteLength());
879        assertEquals(val, in.readPackedInt());
880    }
881
882    public void testPackedInt() {
883
884        /* Exhaustive value testing is in PackedIntTest. */
885        packedIntTest(119, 1);
886        packedIntTest(0xFFFF + 119, 3);
887        packedIntTest(Integer.MAX_VALUE, 5);
888
889        out.reset();
890        out.writePackedInt(119);
891        out.writePackedInt(0xFFFF + 119);
892        out.writePackedInt(Integer.MAX_VALUE);
893        assertEquals(1 + 3 + 5, out.size());
894        copyOutputToInput();
895        assertEquals(119, in.readPackedInt(), 0);
896        assertEquals(0xFFFF + 119, in.readPackedInt(), 0);
897        assertEquals(Integer.MAX_VALUE, in.readPackedInt(), 0);
898        assertEquals(0, in.available(), 0);
899    }
900
901    private void packedLongTest(long val, int size) {
902
903        out.reset();
904        out.writePackedLong(val);
905        assertEquals(size, out.size());
906        copyOutputToInput();
907        assertEquals(size, in.getPackedLongByteLength());
908        assertEquals(val, in.readPackedLong());
909    }
910
911    public void testPackedLong() {
912
913        /* Exhaustive value testing is in PackedIntTest. */
914        packedLongTest(119, 1);
915        packedLongTest(0xFFFFFFFFL + 119, 5);
916        packedLongTest(Long.MAX_VALUE, 9);
917
918        out.reset();
919        out.writePackedLong(119);
920        out.writePackedLong(0xFFFFFFFFL + 119);
921        out.writePackedLong(Long.MAX_VALUE);
922        assertEquals(1 + 5 + 9, out.size());
923        copyOutputToInput();
924        assertEquals(119, in.readPackedLong(), 0);
925        assertEquals(0xFFFFFFFFL + 119, in.readPackedLong(), 0);
926        assertEquals(Long.MAX_VALUE, in.readPackedLong(), 0);
927        assertEquals(0, in.available(), 0);
928    }
929}
930