← Back to branch summary

~ubuntu-branches/ubuntu/saucy/db/saucy-proposed

« back to all changes in this revision

Viewing changes to test/scr024/src/com/sleepycat/bind/tuple/test/TupleFormatTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2010-11-05 15:02:09 UTC
  • mfrom: (13.1.12 sid)
  • Revision ID: james.westby@ubuntu.com-20101105150209-ppvyn0619pu014xo
Tags: 5.1.19-1ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - Pass --build/--host to configure to support cross-building, and don't
    override CC.
  - Disable the Java build when cross-building, for now.

Show diffs side-by-side

added added

removed removed

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