1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.mina.core.buffer;
21
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertFalse;
24 import static org.junit.Assert.assertNotSame;
25 import static org.junit.Assert.assertSame;
26 import static org.junit.Assert.assertTrue;
27 import static org.junit.Assert.fail;
28
29 import java.nio.BufferOverflowException;
30 import java.nio.ByteBuffer;
31 import java.nio.ByteOrder;
32 import java.nio.ReadOnlyBufferException;
33 import java.nio.charset.CharacterCodingException;
34 import java.nio.charset.Charset;
35 import java.nio.charset.CharsetDecoder;
36 import java.nio.charset.CharsetEncoder;
37 import java.util.ArrayList;
38 import java.util.Date;
39 import java.util.EnumSet;
40 import java.util.List;
41
42 import org.apache.mina.util.Bar;
43 import org.junit.Test;
44
45
46
47
48
49
50 public class IoBufferTest {
51
52 private static interface NonserializableInterface {
53 }
54
55 public static class NonserializableClass {
56 }
57
58
59
60
61 @Test
62 public void testCapacity() {
63 IoBuffer buffer = IoBuffer.allocate(10);
64
65 buffer.put("012345".getBytes());
66 buffer.flip();
67
68
69 IoBuffer newBuffer = buffer.capacity(7);
70 assertEquals(10, newBuffer.capacity());
71 assertEquals(buffer, newBuffer);
72
73
74 buffer = IoBuffer.allocate(10);
75
76 buffer.put("012345".getBytes());
77 buffer.flip();
78 newBuffer = buffer.capacity(14);
79 assertEquals(14, newBuffer.capacity());
80 assertEquals(buffer, newBuffer);
81 newBuffer.put(0, (byte)'9');
82 assertEquals((byte)'9', newBuffer.get(0));
83 assertEquals((byte)'9', buffer.get(0));
84
85
86
87 buffer = IoBuffer.allocate(10);
88 buffer.capacity(5);
89 assertEquals(10, buffer.minimumCapacity());
90 assertEquals(10, buffer.capacity());
91 }
92
93
94
95
96 @Test
97 public void testExpand() {
98 IoBuffer buffer = IoBuffer.allocate(10);
99
100 buffer.put("012345".getBytes());
101 buffer.flip();
102
103 assertEquals(6, buffer.remaining());
104
105
106 IoBuffer newBuffer = buffer.expand(2);
107 assertEquals(6, newBuffer.limit());
108 assertEquals(10, newBuffer.capacity());
109 assertEquals(0, newBuffer.position());
110
111
112 buffer = IoBuffer.allocate(10);
113
114 buffer.put("012345".getBytes());
115 buffer.flip();
116 newBuffer = buffer.expand(8);
117 assertEquals(8, newBuffer.limit());
118 assertEquals(10, newBuffer.capacity());
119 assertEquals(0, newBuffer.position());
120
121
122 buffer = IoBuffer.allocate(10);
123
124 buffer.put("012345".getBytes());
125 buffer.flip();
126 newBuffer = buffer.expand(12);
127 assertEquals(12, newBuffer.limit());
128 assertEquals(12, newBuffer.capacity());
129 assertEquals(0, newBuffer.position());
130
131
132 buffer = IoBuffer.allocate(10);
133
134 buffer.put("012345".getBytes());
135 buffer.flip();
136 buffer.position(4);
137
138
139 newBuffer = buffer.expand(2);
140 assertEquals(6, newBuffer.limit());
141 assertEquals(10, newBuffer.capacity());
142 assertEquals(4, newBuffer.position());
143
144
145 buffer = IoBuffer.allocate(10);
146
147 buffer.put("012345".getBytes());
148 buffer.flip();
149 buffer.position(4);
150 newBuffer = buffer.expand(3);
151 assertEquals(7, newBuffer.limit());
152 assertEquals(10, newBuffer.capacity());
153 assertEquals(4, newBuffer.position());
154
155
156 buffer = IoBuffer.allocate(10);
157
158 buffer.put("012345".getBytes());
159 buffer.flip();
160 buffer.position(4);
161 newBuffer = buffer.expand(7);
162 assertEquals(11, newBuffer.limit());
163 assertEquals(11, newBuffer.capacity());
164 assertEquals(4, newBuffer.position());
165 }
166
167
168
169
170 @Test
171 public void testExpandPos() {
172 IoBuffer buffer = IoBuffer.allocate(10);
173
174 buffer.put("012345".getBytes());
175 buffer.flip();
176
177 assertEquals(6, buffer.remaining());
178
179
180 IoBuffer newBuffer = buffer.expand(3, 2);
181 assertEquals(6, newBuffer.limit());
182 assertEquals(10, newBuffer.capacity());
183 assertEquals(0, newBuffer.position());
184
185
186 buffer = IoBuffer.allocate(10);
187 buffer.put("012345".getBytes());
188 buffer.flip();
189
190 newBuffer = buffer.expand(3, 5);
191 assertEquals(8, newBuffer.limit());
192 assertEquals(10, newBuffer.capacity());
193 assertEquals(0, newBuffer.position());
194
195
196 buffer = IoBuffer.allocate(10);
197
198 buffer.put("012345".getBytes());
199 buffer.flip();
200 newBuffer = buffer.expand(3,9);
201 assertEquals(12, newBuffer.limit());
202 assertEquals(12, newBuffer.capacity());
203 assertEquals(0, newBuffer.position());
204
205
206 buffer = IoBuffer.allocate(10);
207
208 buffer.put("012345".getBytes());
209 buffer.flip();
210 buffer.position(4);
211
212
213 newBuffer = buffer.expand(5, 1);
214 assertEquals(6, newBuffer.limit());
215 assertEquals(10, newBuffer.capacity());
216 assertEquals(4, newBuffer.position());
217
218
219 buffer = IoBuffer.allocate(10);
220
221 buffer.put("012345".getBytes());
222 buffer.flip();
223 buffer.position(4);
224 newBuffer = buffer.expand(5, 2);
225 assertEquals(7, newBuffer.limit());
226 assertEquals(10, newBuffer.capacity());
227 assertEquals(4, newBuffer.position());
228
229
230 buffer = IoBuffer.allocate(10);
231
232 buffer.put("012345".getBytes());
233 buffer.flip();
234 buffer.position(4);
235 newBuffer = buffer.expand(5, 6);
236 assertEquals(11, newBuffer.limit());
237 assertEquals(11, newBuffer.capacity());
238 assertEquals(4, newBuffer.position());
239 }
240
241
242
243
244 @Test
245 public void testNormalizeCapacity() {
246
247 assertEquals(Integer.MAX_VALUE, IoBufferImpl.normalizeCapacity(-10));
248 assertEquals(0, IoBufferImpl.normalizeCapacity(0));
249 assertEquals(Integer.MAX_VALUE, IoBufferImpl.normalizeCapacity(Integer.MAX_VALUE));
250 assertEquals(Integer.MAX_VALUE, IoBufferImpl.normalizeCapacity(Integer.MIN_VALUE));
251 assertEquals(Integer.MAX_VALUE, IoBufferImpl.normalizeCapacity(Integer.MAX_VALUE - 10));
252
253
254 for (int i = 0; i < 30; i++) {
255 int n = 1 << i;
256
257 assertEquals(n, IoBufferImpl.normalizeCapacity(n));
258
259 if (i > 1) {
260
261 assertEquals(n, IoBufferImpl.normalizeCapacity(n - 1));
262 }
263
264
265 assertEquals(n << 1, IoBufferImpl.normalizeCapacity(n + 1));
266 }
267
268
269
270 long time = System.currentTimeMillis();
271
272 for (int i = 0; i < 1 << 27; i++) {
273 int n = IoBufferImpl.normalizeCapacity(i);
274
275
276
277 if (n == -1) {
278 System.out.println("n should never be -1");
279 }
280 }
281
282 long time2 = System.currentTimeMillis();
283
284
285
286
287
288 time = System.currentTimeMillis();
289 for (int i = Integer.MAX_VALUE; i > Integer.MAX_VALUE - (1 << 27); i--) {
290 int n = IoBufferImpl.normalizeCapacity(i);
291
292
293
294 if (n == -1) {
295 System.out.println("n should never be -1");
296 }
297 }
298
299 time2 = System.currentTimeMillis();
300
301 }
302
303 @Test
304 public void autoExpand() {
305 IoBuffer buffer = IoBuffer.allocate(8, false);
306 buffer.setAutoExpand(true);
307
308 assertTrue("Should AutoExpand", buffer.isAutoExpand());
309
310 IoBuffer slice = buffer.slice();
311 assertFalse("Should *NOT* AutoExpand", buffer.isAutoExpand());
312 assertFalse("Should *NOT* AutoExpand", slice.isAutoExpand());
313 }
314
315
316
317
318
319
320 private static class IoBufferImpl extends AbstractIoBuffer {
321
322 public static int normalizeCapacity(int requestedCapacity) {
323 return IoBuffer.normalizeCapacity(requestedCapacity);
324 }
325
326 protected IoBufferImpl(AbstractIoBuffer parent) {
327 super(parent);
328 }
329
330 protected IoBuffer asReadOnlyBuffer0() {
331 return null;
332 }
333
334 protected void buf(ByteBuffer newBuf) {
335 }
336
337 protected IoBuffer duplicate0() {
338 return null;
339 }
340
341 protected IoBuffer slice0() {
342 return null;
343 }
344
345 public byte[] array() {
346 return null;
347 }
348
349 public int arrayOffset() {
350 return 0;
351 }
352
353 public ByteBuffer buf() {
354 return null;
355 }
356
357 public void free() {
358 }
359
360 public boolean hasArray() {
361 return false;
362 }
363
364 }
365
366 @Test
367 public void testObjectSerialization() throws Exception {
368 IoBuffer buf = IoBuffer.allocate(16);
369 buf.setAutoExpand(true);
370 List<Object> o = new ArrayList<Object>();
371 o.add(new Date());
372 o.add(long.class);
373
374
375 buf.putObject(o);
376
377
378 buf.clear();
379 Object o2 = buf.getObject();
380 assertEquals(o, o2);
381
382
383 assertNotSame(o, o2);
384 }
385
386 @Test
387 public void testNonserializableClass() throws Exception {
388 Class<?> c = NonserializableClass.class;
389
390 IoBuffer buffer = IoBuffer.allocate(16);
391 buffer.setAutoExpand(true);
392 buffer.putObject(c);
393
394 buffer.flip();
395 Object o = buffer.getObject();
396
397 assertEquals(c, o);
398 assertSame(c, o);
399 }
400
401 @Test
402 public void testNonserializableInterface() throws Exception {
403 Class<?> c = NonserializableInterface.class;
404
405 IoBuffer buffer = IoBuffer.allocate(16);
406 buffer.setAutoExpand(true);
407 buffer.putObject(c);
408
409 buffer.flip();
410 Object o = buffer.getObject();
411
412 assertEquals(c, o);
413 assertSame(c, o);
414 }
415
416 @Test
417 public void testAllocate() throws Exception {
418 for (int i = 10; i < 1048576 * 2; i = i * 11 / 10)
419 {
420 IoBuffer buf = IoBuffer.allocate(i);
421 assertEquals(0, buf.position());
422 assertEquals(buf.capacity(), buf.remaining());
423 assertTrue(buf.capacity() >= i);
424 assertTrue(buf.capacity() < i * 2);
425 }
426 }
427
428
429
430
431
432 @Test(expected=IllegalArgumentException.class)
433 public void testAllocateNegative() throws Exception {
434 IoBuffer.allocate(-1);
435 }
436
437 @Test
438 public void testAutoExpand() throws Exception {
439 IoBuffer buf = IoBuffer.allocate(1);
440
441 buf.put((byte) 0);
442 try {
443 buf.put((byte) 0);
444 fail("Buffer can't auto expand, with autoExpand property set at false");
445 } catch (BufferOverflowException e) {
446
447 assertTrue(true);
448 }
449
450 buf.setAutoExpand(true);
451 buf.put((byte) 0);
452 assertEquals(2, buf.position());
453 assertEquals(2, buf.limit());
454 assertEquals(2, buf.capacity());
455
456 buf.setAutoExpand(false);
457 try {
458 buf.put(3, (byte) 0);
459 fail("Buffer can't auto expand, with autoExpand property set at false");
460 } catch (IndexOutOfBoundsException e) {
461
462 assertTrue(true);
463 }
464
465 buf.setAutoExpand(true);
466 buf.put(3, (byte) 0);
467 assertEquals(2, buf.position());
468 assertEquals(4, buf.limit());
469 assertEquals(4, buf.capacity());
470
471
472 buf = IoBuffer.allocate(1).setAutoExpand(true);
473 int lastCapacity = buf.capacity();
474 for (int i = 0; i < 1048576; i++) {
475 buf.put((byte) 0);
476 if (lastCapacity != buf.capacity()) {
477 assertEquals(lastCapacity * 2, buf.capacity());
478 lastCapacity = buf.capacity();
479 }
480 }
481 }
482
483 @Test
484 public void testAutoExpandMark() throws Exception {
485 IoBuffer buf = IoBuffer.allocate(4).setAutoExpand(true);
486
487 buf.put((byte) 0);
488 buf.put((byte) 0);
489 buf.put((byte) 0);
490
491
492 buf.mark();
493
494
495 buf.put((byte) 0);
496 buf.put((byte) 0);
497
498 assertEquals(5, buf.position());
499 buf.reset();
500 assertEquals(3, buf.position());
501 }
502
503 @Test
504 public void testAutoShrink() throws Exception {
505 IoBuffer buf = IoBuffer.allocate(8).setAutoShrink(true);
506
507
508
509 buf.sweep((byte) 1);
510 buf.fill(7);
511 buf.compact();
512 assertEquals(8, buf.capacity());
513 assertEquals(1, buf.position());
514 assertEquals(8, buf.limit());
515 buf.clear();
516 assertEquals(1, buf.get());
517
518
519 buf.capacity(32).clear();
520 assertEquals(32, buf.capacity());
521
522
523 buf.sweep((byte) 1);
524 buf.fill(24);
525 buf.compact();
526 assertEquals(16, buf.capacity());
527 assertEquals(8, buf.position());
528 assertEquals(16, buf.limit());
529 buf.clear();
530 for (int i = 0; i < 8; i++) {
531 assertEquals(1, buf.get());
532 }
533
534
535 buf.capacity(32).clear();
536 assertEquals(32, buf.capacity());
537
538
539 buf.sweep((byte) 1);
540 buf.fill(28);
541 buf.compact();
542 assertEquals(8, buf.capacity());
543 assertEquals(4, buf.position());
544 assertEquals(8, buf.limit());
545 buf.clear();
546 for (int i = 0; i < 4; i++) {
547 assertEquals(1, buf.get());
548 }
549
550
551 buf.capacity(32).clear();
552 assertEquals(32, buf.capacity());
553
554
555 buf.fill(32);
556 buf.compact();
557 assertEquals(8, buf.capacity());
558 assertEquals(0, buf.position());
559 assertEquals(8, buf.limit());
560
561
562 buf.capacity(32).clear();
563 assertEquals(32, buf.capacity());
564
565
566 buf.sweep((byte) 1);
567 buf.fill(23);
568 buf.compact();
569 assertEquals(32, buf.capacity());
570 assertEquals(9, buf.position());
571 assertEquals(32, buf.limit());
572 buf.clear();
573 for (int i = 0; i < 9; i++) {
574 assertEquals(1, buf.get());
575 }
576 }
577
578 @Test
579 public void testGetString() throws Exception {
580 IoBuffer buf = IoBuffer.allocate(16);
581 CharsetDecoder decoder;
582
583 Charset charset = Charset.forName("UTF-8");
584 buf.clear();
585 buf.putString("hello", charset.newEncoder());
586 buf.put((byte) 0);
587 buf.flip();
588 assertEquals("hello", buf.getString(charset.newDecoder()));
589
590 buf.clear();
591 buf.putString("hello", charset.newEncoder());
592 buf.flip();
593 assertEquals("hello", buf.getString(charset.newDecoder()));
594
595 decoder = Charset.forName("ISO-8859-1").newDecoder();
596 buf.clear();
597 buf.put((byte) 'A');
598 buf.put((byte) 'B');
599 buf.put((byte) 'C');
600 buf.put((byte) 0);
601
602 buf.position(0);
603 assertEquals("ABC", buf.getString(decoder));
604 assertEquals(4, buf.position());
605
606 buf.position(0);
607 buf.limit(1);
608 assertEquals("A", buf.getString(decoder));
609 assertEquals(1, buf.position());
610
611 buf.clear();
612 assertEquals("ABC", buf.getString(10, decoder));
613 assertEquals(10, buf.position());
614
615 buf.clear();
616 assertEquals("A", buf.getString(1, decoder));
617 assertEquals(1, buf.position());
618
619
620 buf.clear();
621 buf.put((byte) 'A');
622 buf.put((byte) 'B');
623 buf.put((byte) 0);
624 buf.put((byte) 'C');
625 buf.position(0);
626 assertEquals("AB", buf.getString(4, decoder));
627 assertEquals(4, buf.position());
628
629 buf.clear();
630 buf.fillAndReset(buf.limit());
631 decoder = Charset.forName("UTF-16").newDecoder();
632 buf.put((byte) 0);
633 buf.put((byte) 'A');
634 buf.put((byte) 0);
635 buf.put((byte) 'B');
636 buf.put((byte) 0);
637 buf.put((byte) 'C');
638 buf.put((byte) 0);
639 buf.put((byte) 0);
640
641 buf.position(0);
642 assertEquals("ABC", buf.getString(decoder));
643 assertEquals(8, buf.position());
644
645 buf.position(0);
646 buf.limit(2);
647 assertEquals("A", buf.getString(decoder));
648 assertEquals(2, buf.position());
649
650 buf.position(0);
651 buf.limit(3);
652 assertEquals("A", buf.getString(decoder));
653 assertEquals(2, buf.position());
654
655 buf.clear();
656 assertEquals("ABC", buf.getString(10, decoder));
657 assertEquals(10, buf.position());
658
659 buf.clear();
660 assertEquals("A", buf.getString(2, decoder));
661 assertEquals(2, buf.position());
662
663 buf.clear();
664 try {
665 buf.getString(1, decoder);
666 fail();
667 } catch (IllegalArgumentException e) {
668
669 assertTrue(true);
670 }
671
672
673 buf.clear();
674 buf.limit(0);
675 assertEquals("", buf.getString(decoder));
676 assertEquals("", buf.getString(2, decoder));
677
678
679 buf.clear();
680 buf.putInt(0);
681 buf.clear();
682 buf.limit(4);
683 assertEquals("", buf.getString(decoder));
684 assertEquals(2, buf.position());
685 assertEquals(4, buf.limit());
686
687 buf.position(0);
688 assertEquals("", buf.getString(2, decoder));
689 assertEquals(2, buf.position());
690 assertEquals(4, buf.limit());
691 }
692
693 @Test
694 public void testGetStringWithFailure() throws Exception {
695 String test = "\u30b3\u30e1\u30f3\u30c8\u7de8\u96c6";
696 IoBuffer buffer = IoBuffer.wrap(test.getBytes("Shift_JIS"));
697
698
699 int oldLimit = buffer.limit();
700 int oldPos = buffer.position();
701 try {
702 buffer.getString(3, Charset.forName("ASCII").newDecoder());
703 fail();
704 } catch (Exception e) {
705 assertEquals(oldLimit, buffer.limit());
706 assertEquals(oldPos, buffer.position());
707 }
708
709 try {
710 buffer.getString(Charset.forName("ASCII").newDecoder());
711 fail();
712 } catch (Exception e) {
713 assertEquals(oldLimit, buffer.limit());
714 assertEquals(oldPos, buffer.position());
715 }
716 }
717
718 @Test
719 public void testPutString() throws Exception {
720 CharsetEncoder encoder;
721 IoBuffer buf = IoBuffer.allocate(16);
722 encoder = Charset.forName("ISO-8859-1").newEncoder();
723
724 buf.putString("ABC", encoder);
725 assertEquals(3, buf.position());
726 buf.clear();
727 assertEquals('A', buf.get(0));
728 assertEquals('B', buf.get(1));
729 assertEquals('C', buf.get(2));
730
731 buf.putString("D", 5, encoder);
732 assertEquals(5, buf.position());
733 buf.clear();
734 assertEquals('D', buf.get(0));
735 assertEquals(0, buf.get(1));
736
737 buf.putString("EFG", 2, encoder);
738 assertEquals(2, buf.position());
739 buf.clear();
740 assertEquals('E', buf.get(0));
741 assertEquals('F', buf.get(1));
742 assertEquals('C', buf.get(2));
743
744
745 encoder = Charset.forName("UTF-16BE").newEncoder();
746 buf.clear();
747
748 buf.putString("ABC", encoder);
749 assertEquals(6, buf.position());
750 buf.clear();
751
752 assertEquals(0, buf.get(0));
753 assertEquals('A', buf.get(1));
754 assertEquals(0, buf.get(2));
755 assertEquals('B', buf.get(3));
756 assertEquals(0, buf.get(4));
757 assertEquals('C', buf.get(5));
758
759 buf.putString("D", 10, encoder);
760 assertEquals(10, buf.position());
761 buf.clear();
762 assertEquals(0, buf.get(0));
763 assertEquals('D', buf.get(1));
764 assertEquals(0, buf.get(2));
765 assertEquals(0, buf.get(3));
766
767 buf.putString("EFG", 4, encoder);
768 assertEquals(4, buf.position());
769 buf.clear();
770 assertEquals(0, buf.get(0));
771 assertEquals('E', buf.get(1));
772 assertEquals(0, buf.get(2));
773 assertEquals('F', buf.get(3));
774 assertEquals(0, buf.get(4));
775 assertEquals('C', buf.get(5));
776
777
778 buf.putString("", encoder);
779 assertEquals(0, buf.position());
780 buf.putString("", 4, encoder);
781 assertEquals(4, buf.position());
782 assertEquals(0, buf.get(0));
783 assertEquals(0, buf.get(1));
784 }
785
786 @Test
787 public void testGetPrefixedString() throws Exception {
788 IoBuffer buf = IoBuffer.allocate(16);
789 CharsetEncoder encoder;
790 CharsetDecoder decoder;
791 encoder = Charset.forName("ISO-8859-1").newEncoder();
792 decoder = Charset.forName("ISO-8859-1").newDecoder();
793
794 buf.putShort((short) 3);
795 buf.putString("ABCD", encoder);
796 buf.clear();
797 assertEquals("ABC", buf.getPrefixedString(decoder));
798 }
799
800 @Test
801 public void testPutPrefixedString() throws Exception {
802 CharsetEncoder encoder;
803 IoBuffer buf = IoBuffer.allocate(16);
804 buf.fillAndReset(buf.remaining());
805 encoder = Charset.forName("ISO-8859-1").newEncoder();
806
807
808 buf.putPrefixedString("ABC", encoder);
809 assertEquals(5, buf.position());
810 assertEquals(0, buf.get(0));
811 assertEquals(3, buf.get(1));
812 assertEquals('A', buf.get(2));
813 assertEquals('B', buf.get(3));
814 assertEquals('C', buf.get(4));
815
816 buf.clear();
817 try {
818 buf.putPrefixedString("123456789012345", encoder);
819 fail();
820 } catch (BufferOverflowException e) {
821
822 assertTrue(true);
823 }
824
825
826 buf.clear();
827 buf.setAutoExpand(true);
828 buf.putPrefixedString("123456789012345", encoder);
829 assertEquals(17, buf.position());
830 assertEquals(0, buf.get(0));
831 assertEquals(15, buf.get(1));
832 assertEquals('1', buf.get(2));
833 assertEquals('2', buf.get(3));
834 assertEquals('3', buf.get(4));
835 assertEquals('4', buf.get(5));
836 assertEquals('5', buf.get(6));
837 assertEquals('6', buf.get(7));
838 assertEquals('7', buf.get(8));
839 assertEquals('8', buf.get(9));
840 assertEquals('9', buf.get(10));
841 assertEquals('0', buf.get(11));
842 assertEquals('1', buf.get(12));
843 assertEquals('2', buf.get(13));
844 assertEquals('3', buf.get(14));
845 assertEquals('4', buf.get(15));
846 assertEquals('5', buf.get(16));
847 }
848
849 @Test
850 public void testPutPrefixedStringWithPrefixLength() throws Exception {
851 CharsetEncoder encoder = Charset.forName("ISO-8859-1").newEncoder();
852 IoBuffer buf = IoBuffer.allocate(16).sweep().setAutoExpand(true);
853
854 buf.putPrefixedString("A", 1, encoder);
855 assertEquals(2, buf.position());
856 assertEquals(1, buf.get(0));
857 assertEquals('A', buf.get(1));
858
859 buf.sweep();
860 buf.putPrefixedString("A", 2, encoder);
861 assertEquals(3, buf.position());
862 assertEquals(0, buf.get(0));
863 assertEquals(1, buf.get(1));
864 assertEquals('A', buf.get(2));
865
866 buf.sweep();
867 buf.putPrefixedString("A", 4, encoder);
868 assertEquals(5, buf.position());
869 assertEquals(0, buf.get(0));
870 assertEquals(0, buf.get(1));
871 assertEquals(0, buf.get(2));
872 assertEquals(1, buf.get(3));
873 assertEquals('A', buf.get(4));
874 }
875
876 @Test
877 public void testPutPrefixedStringWithPadding() throws Exception {
878 CharsetEncoder encoder = Charset.forName("ISO-8859-1").newEncoder();
879 IoBuffer buf = IoBuffer.allocate(16).sweep().setAutoExpand(true);
880
881 buf.putPrefixedString("A", 1, 2, (byte) 32, encoder);
882 assertEquals(3, buf.position());
883 assertEquals(2, buf.get(0));
884 assertEquals('A', buf.get(1));
885 assertEquals(' ', buf.get(2));
886
887 buf.sweep();
888 buf.putPrefixedString("A", 1, 4, (byte) 32, encoder);
889 assertEquals(5, buf.position());
890 assertEquals(4, buf.get(0));
891 assertEquals('A', buf.get(1));
892 assertEquals(' ', buf.get(2));
893 assertEquals(' ', buf.get(3));
894 assertEquals(' ', buf.get(4));
895 }
896
897 @Test
898 public void testWideUtf8Characters() throws Exception {
899 Runnable r = new Runnable() {
900 public void run() {
901 IoBuffer buffer = IoBuffer.allocate(1);
902 buffer.setAutoExpand(true);
903
904 Charset charset = Charset.forName("UTF-8");
905
906 CharsetEncoder encoder = charset.newEncoder();
907
908 for (int i = 0; i < 5; i++) {
909 try {
910 buffer.putString("\u89d2", encoder);
911 buffer.putPrefixedString("\u89d2", encoder);
912 } catch (CharacterCodingException e) {
913 fail(e.getMessage());
914 }
915 }
916 }
917 };
918
919 Thread t = new Thread(r);
920 t.setDaemon(true);
921 t.start();
922
923 for (int i = 0; i < 50; i++) {
924 Thread.sleep(100);
925 if (!t.isAlive()) {
926 break;
927 }
928 }
929
930 if (t.isAlive()) {
931 t.interrupt();
932
933 fail("Went into endless loop trying to encode character");
934 }
935 }
936
937 @Test
938 public void testInheritedObjectSerialization() throws Exception {
939 IoBuffer buf = IoBuffer.allocate(16);
940 buf.setAutoExpand(true);
941
942 Bar expected = new Bar();
943 expected.setFooValue(0x12345678);
944 expected.setBarValue(0x90ABCDEF);
945
946
947 buf.putObject(expected);
948
949
950 buf.clear();
951 Bar actual = (Bar) buf.getObject();
952 assertSame(Bar.class, actual.getClass());
953 assertEquals(expected.getFooValue(), actual.getFooValue());
954 assertEquals(expected.getBarValue(), actual.getBarValue());
955
956
957 assertNotSame(expected, actual);
958 }
959
960 @Test
961 public void testSweepWithZeros() throws Exception {
962 IoBuffer buf = IoBuffer.allocate(4);
963 buf.putInt(0xdeadbeef);
964 buf.clear();
965 assertEquals(0xdeadbeef, buf.getInt());
966 assertEquals(4, buf.position());
967 assertEquals(4, buf.limit());
968
969 buf.sweep();
970 assertEquals(0, buf.position());
971 assertEquals(4, buf.limit());
972 assertEquals(0x0, buf.getInt());
973 }
974
975 @Test
976 public void testSweepNonZeros() throws Exception {
977 IoBuffer buf = IoBuffer.allocate(4);
978 buf.putInt(0xdeadbeef);
979 buf.clear();
980 assertEquals(0xdeadbeef, buf.getInt());
981 assertEquals(4, buf.position());
982 assertEquals(4, buf.limit());
983
984 buf.sweep((byte) 0x45);
985 assertEquals(0, buf.position());
986 assertEquals(4, buf.limit());
987 assertEquals(0x45454545, buf.getInt());
988 }
989
990 @Test
991 public void testWrapNioBuffer() throws Exception {
992 ByteBuffer nioBuf = ByteBuffer.allocate(10);
993 nioBuf.position(3);
994 nioBuf.limit(7);
995
996 IoBuffer buf = IoBuffer.wrap(nioBuf);
997 assertEquals(3, buf.position());
998 assertEquals(7, buf.limit());
999 assertEquals(10, buf.capacity());
1000 }
1001
1002 @Test
1003 public void testWrapSubArray() throws Exception {
1004 byte[] array = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
1005
1006 IoBuffer buf = IoBuffer.wrap(array, 3, 4);
1007 assertEquals(3, buf.position());
1008 assertEquals(7, buf.limit());
1009 assertEquals(10, buf.capacity());
1010
1011 buf.clear();
1012 assertEquals(0, buf.position());
1013 assertEquals(10, buf.limit());
1014 assertEquals(10, buf.capacity());
1015 }
1016
1017 @Test
1018 public void testDuplicate() throws Exception {
1019 IoBuffer original;
1020 IoBuffer duplicate;
1021
1022
1023 original = IoBuffer.allocate(16).sweep();
1024 original.position(4);
1025 original.limit(10);
1026 duplicate = original.duplicate();
1027 original.put(4, (byte) 127);
1028 assertEquals(4, duplicate.position());
1029 assertEquals(10, duplicate.limit());
1030 assertEquals(16, duplicate.capacity());
1031 assertNotSame(original.buf(), duplicate.buf());
1032 assertSame(original.buf().array(), duplicate.buf().array());
1033 assertEquals(127, duplicate.get(4));
1034
1035
1036 original = IoBuffer.allocate(16);
1037 duplicate = original.duplicate().duplicate();
1038 assertNotSame(original.buf(), duplicate.buf());
1039 assertSame(original.buf().array(), duplicate.buf().array());
1040
1041
1042 original = IoBuffer.allocate(16);
1043 original.setAutoExpand(true);
1044 duplicate = original.duplicate();
1045 assertFalse(original.isAutoExpand());
1046
1047 try {
1048 original.setAutoExpand(true);
1049 fail("Derived buffers and their parent can't be expanded");
1050 } catch (IllegalStateException e) {
1051
1052 assertTrue(true);
1053 }
1054
1055 try {
1056 duplicate.setAutoExpand(true);
1057 fail("Derived buffers and their parent can't be expanded");
1058 } catch (IllegalStateException e) {
1059
1060 assertTrue(true);
1061 }
1062 }
1063
1064 @Test
1065 public void testSlice() throws Exception {
1066 IoBuffer original;
1067 IoBuffer slice;
1068
1069
1070 original = IoBuffer.allocate(16).sweep();
1071 original.position(4);
1072 original.limit(10);
1073 slice = original.slice();
1074 original.put(4, (byte) 127);
1075 assertEquals(0, slice.position());
1076 assertEquals(6, slice.limit());
1077 assertEquals(6, slice.capacity());
1078 assertNotSame(original.buf(), slice.buf());
1079 assertEquals(127, slice.get(0));
1080 }
1081
1082 @Test
1083 public void testReadOnlyBuffer() throws Exception {
1084 IoBuffer original;
1085 IoBuffer duplicate;
1086
1087
1088 original = IoBuffer.allocate(16).sweep();
1089 original.position(4);
1090 original.limit(10);
1091 duplicate = original.asReadOnlyBuffer();
1092 original.put(4, (byte) 127);
1093 assertEquals(4, duplicate.position());
1094 assertEquals(10, duplicate.limit());
1095 assertEquals(16, duplicate.capacity());
1096 assertNotSame(original.buf(), duplicate.buf());
1097 assertEquals(127, duplicate.get(4));
1098
1099
1100 try {
1101 original = IoBuffer.allocate(16);
1102 duplicate = original.asReadOnlyBuffer();
1103 duplicate.putString("A very very very very looooooong string", Charset.forName("ISO-8859-1").newEncoder());
1104 fail("ReadOnly buffer's can't be expanded");
1105 } catch (ReadOnlyBufferException e) {
1106
1107 assertTrue(true);
1108 }
1109 }
1110
1111 @Test
1112 public void testGetUnsigned() throws Exception {
1113 IoBuffer buf = IoBuffer.allocate(16);
1114 buf.put((byte) 0xA4);
1115 buf.put((byte) 0xD0);
1116 buf.put((byte) 0xB3);
1117 buf.put((byte) 0xCD);
1118 buf.flip();
1119
1120 buf.order(ByteOrder.LITTLE_ENDIAN);
1121
1122 buf.mark();
1123 assertEquals(0xA4, buf.getUnsigned());
1124 buf.reset();
1125 assertEquals(0xD0A4, buf.getUnsignedShort());
1126 buf.reset();
1127 assertEquals(0xCDB3D0A4L, buf.getUnsignedInt());
1128 }
1129
1130 @Test
1131 public void testIndexOf() throws Exception {
1132 boolean direct = false;
1133 for (int i = 0; i < 2; i++, direct = !direct) {
1134 IoBuffer buf = IoBuffer.allocate(16, direct);
1135 buf.put((byte) 0x1);
1136 buf.put((byte) 0x2);
1137 buf.put((byte) 0x3);
1138 buf.put((byte) 0x4);
1139 buf.put((byte) 0x1);
1140 buf.put((byte) 0x2);
1141 buf.put((byte) 0x3);
1142 buf.put((byte) 0x4);
1143 buf.position(2);
1144 buf.limit(5);
1145
1146 assertEquals(4, buf.indexOf((byte) 0x1));
1147 assertEquals(-1, buf.indexOf((byte) 0x2));
1148 assertEquals(2, buf.indexOf((byte) 0x3));
1149 assertEquals(3, buf.indexOf((byte) 0x4));
1150 }
1151 }
1152
1153
1154 private static enum TestEnum {
1155 E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13, E14, E15, E16, E17, E18, E19, E20, E21, E22, E23, E24, E25, E26, E27, E28, E29, E30, E31, E32, E33, E34, E35, E36, E37, E38, E39, E40, E41, E42, E43, E44, E45, E46, E77, E48, E49, E50, E51, E52, E53, E54, E55, E56, E57, E58, E59, E60, E61, E62, E63, E64
1156 }
1157
1158 private static enum TooBigEnum {
1159 E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13, E14, E15, E16, E17, E18, E19, E20, E21, E22, E23, E24, E25, E26, E27, E28, E29, E30, E31, E32, E33, E34, E35, E36, E37, E38, E39, E40, E41, E42, E43, E44, E45, E46, E77, E48, E49, E50, E51, E52, E53, E54, E55, E56, E57, E58, E59, E60, E61, E62, E63, E64, E65
1160 }
1161
1162 @Test
1163 public void testPutEnumSet() {
1164 IoBuffer buf = IoBuffer.allocate(8);
1165
1166
1167 buf.putEnumSet(EnumSet.noneOf(TestEnum.class));
1168 buf.flip();
1169 assertEquals(0, buf.get());
1170
1171 buf.clear();
1172 buf.putEnumSetShort(EnumSet.noneOf(TestEnum.class));
1173 buf.flip();
1174 assertEquals(0, buf.getShort());
1175
1176 buf.clear();
1177 buf.putEnumSetInt(EnumSet.noneOf(TestEnum.class));
1178 buf.flip();
1179 assertEquals(0, buf.getInt());
1180
1181 buf.clear();
1182 buf.putEnumSetLong(EnumSet.noneOf(TestEnum.class));
1183 buf.flip();
1184 assertEquals(0, buf.getLong());
1185
1186
1187 buf.clear();
1188 buf.putEnumSet(EnumSet.range(TestEnum.E1, TestEnum.E8));
1189 buf.flip();
1190 assertEquals((byte) -1, buf.get());
1191
1192 buf.clear();
1193 buf.putEnumSetShort(EnumSet.range(TestEnum.E1, TestEnum.E16));
1194 buf.flip();
1195 assertEquals((short) -1, buf.getShort());
1196
1197 buf.clear();
1198 buf.putEnumSetInt(EnumSet.range(TestEnum.E1, TestEnum.E32));
1199 buf.flip();
1200 assertEquals(-1, buf.getInt());
1201
1202 buf.clear();
1203 buf.putEnumSetLong(EnumSet.allOf(TestEnum.class));
1204 buf.flip();
1205 assertEquals(-1L, buf.getLong());
1206
1207
1208 buf.clear();
1209 buf.putEnumSet(EnumSet.of(TestEnum.E8));
1210 buf.flip();
1211 assertEquals(Byte.MIN_VALUE, buf.get());
1212
1213 buf.clear();
1214 buf.putEnumSetShort(EnumSet.of(TestEnum.E16));
1215 buf.flip();
1216 assertEquals(Short.MIN_VALUE, buf.getShort());
1217
1218 buf.clear();
1219 buf.putEnumSetInt(EnumSet.of(TestEnum.E32));
1220 buf.flip();
1221 assertEquals(Integer.MIN_VALUE, buf.getInt());
1222
1223 buf.clear();
1224 buf.putEnumSetLong(EnumSet.of(TestEnum.E64));
1225 buf.flip();
1226 assertEquals(Long.MIN_VALUE, buf.getLong());
1227
1228
1229 buf.clear();
1230 buf.putEnumSet(EnumSet.of(TestEnum.E1, TestEnum.E8));
1231 buf.flip();
1232 assertEquals(Byte.MIN_VALUE + 1, buf.get());
1233
1234 buf.clear();
1235 buf.putEnumSetShort(EnumSet.of(TestEnum.E1, TestEnum.E16));
1236 buf.flip();
1237 assertEquals(Short.MIN_VALUE + 1, buf.getShort());
1238
1239 buf.clear();
1240 buf.putEnumSetInt(EnumSet.of(TestEnum.E1, TestEnum.E32));
1241 buf.flip();
1242 assertEquals(Integer.MIN_VALUE + 1, buf.getInt());
1243
1244 buf.clear();
1245 buf.putEnumSetLong(EnumSet.of(TestEnum.E1, TestEnum.E64));
1246 buf.flip();
1247 assertEquals(Long.MIN_VALUE + 1, buf.getLong());
1248 }
1249
1250 @Test
1251 public void testGetEnumSet() {
1252 IoBuffer buf = IoBuffer.allocate(8);
1253
1254
1255 buf.put((byte) 0);
1256 buf.flip();
1257 assertEquals(EnumSet.noneOf(TestEnum.class), buf.getEnumSet(TestEnum.class));
1258
1259 buf.clear();
1260 buf.putShort((short) 0);
1261 buf.flip();
1262 assertEquals(EnumSet.noneOf(TestEnum.class), buf.getEnumSet(TestEnum.class));
1263
1264 buf.clear();
1265 buf.putInt(0);
1266 buf.flip();
1267 assertEquals(EnumSet.noneOf(TestEnum.class), buf.getEnumSet(TestEnum.class));
1268
1269 buf.clear();
1270 buf.putLong(0L);
1271 buf.flip();
1272 assertEquals(EnumSet.noneOf(TestEnum.class), buf.getEnumSet(TestEnum.class));
1273
1274
1275 buf.clear();
1276 buf.put((byte) -1);
1277 buf.flip();
1278 assertEquals(EnumSet.range(TestEnum.E1, TestEnum.E8), buf.getEnumSet(TestEnum.class));
1279
1280 buf.clear();
1281 buf.putShort((short) -1);
1282 buf.flip();
1283 assertEquals(EnumSet.range(TestEnum.E1, TestEnum.E16), buf.getEnumSetShort(TestEnum.class));
1284
1285 buf.clear();
1286 buf.putInt(-1);
1287 buf.flip();
1288 assertEquals(EnumSet.range(TestEnum.E1, TestEnum.E32), buf.getEnumSetInt(TestEnum.class));
1289
1290 buf.clear();
1291 buf.putLong(-1L);
1292 buf.flip();
1293 assertEquals(EnumSet.allOf(TestEnum.class), buf.getEnumSetLong(TestEnum.class));
1294
1295
1296 buf.clear();
1297 buf.put(Byte.MIN_VALUE);
1298 buf.flip();
1299 assertEquals(EnumSet.of(TestEnum.E8), buf.getEnumSet(TestEnum.class));
1300
1301 buf.clear();
1302 buf.putShort(Short.MIN_VALUE);
1303 buf.flip();
1304 assertEquals(EnumSet.of(TestEnum.E16), buf.getEnumSetShort(TestEnum.class));
1305
1306 buf.clear();
1307 buf.putInt(Integer.MIN_VALUE);
1308 buf.flip();
1309 assertEquals(EnumSet.of(TestEnum.E32), buf.getEnumSetInt(TestEnum.class));
1310
1311 buf.clear();
1312 buf.putLong(Long.MIN_VALUE);
1313 buf.flip();
1314 assertEquals(EnumSet.of(TestEnum.E64), buf.getEnumSetLong(TestEnum.class));
1315
1316
1317 buf.clear();
1318 byte b = Byte.MIN_VALUE + 1;
1319 buf.put(b);
1320 buf.flip();
1321 assertEquals(EnumSet.of(TestEnum.E1, TestEnum.E8), buf.getEnumSet(TestEnum.class));
1322
1323 buf.clear();
1324 short s = Short.MIN_VALUE + 1;
1325 buf.putShort(s);
1326 buf.flip();
1327 assertEquals(EnumSet.of(TestEnum.E1, TestEnum.E16), buf.getEnumSetShort(TestEnum.class));
1328
1329 buf.clear();
1330 buf.putInt(Integer.MIN_VALUE + 1);
1331 buf.flip();
1332 assertEquals(EnumSet.of(TestEnum.E1, TestEnum.E32), buf.getEnumSetInt(TestEnum.class));
1333
1334 buf.clear();
1335 buf.putLong(Long.MIN_VALUE + 1);
1336 buf.flip();
1337 assertEquals(EnumSet.of(TestEnum.E1, TestEnum.E64), buf.getEnumSetLong(TestEnum.class));
1338 }
1339
1340 @Test
1341 public void testBitVectorOverFlow() {
1342 IoBuffer buf = IoBuffer.allocate(8);
1343 try {
1344 buf.putEnumSet(EnumSet.of(TestEnum.E9));
1345 fail("Should have thrown IllegalArgumentException");
1346 } catch (IllegalArgumentException e) {
1347
1348 assertTrue(true);
1349 }
1350
1351 try {
1352 buf.putEnumSetShort(EnumSet.of(TestEnum.E17));
1353 fail("Should have thrown IllegalArgumentException");
1354 } catch (IllegalArgumentException e) {
1355
1356 assertTrue(true);
1357 }
1358
1359 try {
1360 buf.putEnumSetInt(EnumSet.of(TestEnum.E33));
1361 fail("Should have thrown IllegalArgumentException");
1362 } catch (IllegalArgumentException e) {
1363
1364 assertTrue(true);
1365 }
1366
1367 try {
1368 buf.putEnumSetLong(EnumSet.of(TooBigEnum.E65));
1369 fail("Should have thrown IllegalArgumentException");
1370 } catch (IllegalArgumentException e) {
1371
1372 assertTrue(true);
1373 }
1374 }
1375
1376 @Test
1377 public void testGetPutEnum() {
1378 IoBuffer buf = IoBuffer.allocate(4);
1379
1380 buf.putEnum(TestEnum.E64);
1381 buf.flip();
1382 assertEquals(TestEnum.E64, buf.getEnum(TestEnum.class));
1383
1384 buf.clear();
1385 buf.putEnumShort(TestEnum.E64);
1386 buf.flip();
1387 assertEquals(TestEnum.E64, buf.getEnumShort(TestEnum.class));
1388
1389 buf.clear();
1390 buf.putEnumInt(TestEnum.E64);
1391 buf.flip();
1392 assertEquals(TestEnum.E64, buf.getEnumInt(TestEnum.class));
1393 }
1394
1395 @Test
1396 public void testGetMediumInt() {
1397 IoBuffer buf = IoBuffer.allocate(3);
1398
1399 buf.put((byte) 0x01);
1400 buf.put((byte) 0x02);
1401 buf.put((byte) 0x03);
1402 assertEquals(3, buf.position());
1403
1404 buf.flip();
1405 assertEquals(0x010203, buf.getMediumInt());
1406 assertEquals(0x010203, buf.getMediumInt(0));
1407 buf.flip();
1408 assertEquals(0x010203, buf.getUnsignedMediumInt());
1409 assertEquals(0x010203, buf.getUnsignedMediumInt(0));
1410 buf.flip();
1411 assertEquals(0x010203, buf.getUnsignedMediumInt());
1412 buf.flip().order(ByteOrder.LITTLE_ENDIAN);
1413 assertEquals(0x030201, buf.getMediumInt());
1414 assertEquals(0x030201, buf.getMediumInt(0));
1415
1416
1417 buf.flip().order(ByteOrder.BIG_ENDIAN);
1418 buf.put((byte) 0x7f);
1419 buf.put((byte) 0xff);
1420 buf.put((byte) 0xff);
1421 buf.flip();
1422 assertEquals(0x7fffff, buf.getMediumInt());
1423 assertEquals(0x7fffff, buf.getMediumInt(0));
1424
1425
1426 buf.flip().order(ByteOrder.BIG_ENDIAN);
1427 buf.put((byte) 0xff);
1428 buf.put((byte) 0x02);
1429 buf.put((byte) 0x03);
1430 buf.flip();
1431
1432 assertEquals(0xffff0203, buf.getMediumInt());
1433 assertEquals(0xffff0203, buf.getMediumInt(0));
1434 buf.flip();
1435
1436 assertEquals(0x00ff0203, buf.getUnsignedMediumInt());
1437 assertEquals(0x00ff0203, buf.getUnsignedMediumInt(0));
1438 }
1439
1440 @Test
1441 public void testPutMediumInt() {
1442 IoBuffer buf = IoBuffer.allocate(3);
1443
1444 checkMediumInt(buf, 0);
1445 checkMediumInt(buf, 1);
1446 checkMediumInt(buf, -1);
1447 checkMediumInt(buf, 0x7fffff);
1448 }
1449
1450 private void checkMediumInt(IoBuffer buf, int x) {
1451 buf.putMediumInt(x);
1452 assertEquals(3, buf.position());
1453 buf.flip();
1454 assertEquals(x, buf.getMediumInt());
1455 assertEquals(3, buf.position());
1456
1457 buf.putMediumInt(0, x);
1458 assertEquals(3, buf.position());
1459 assertEquals(x, buf.getMediumInt(0));
1460
1461 buf.flip();
1462 }
1463
1464 @Test
1465 public void testPutUnsigned() {
1466 IoBuffer buf = IoBuffer.allocate(4);
1467 byte b = (byte) 0x80;
1468 short s = (short) 0x8F81;
1469 int i = 0x8FFFFF82;
1470 long l = 0x8FFFFFFFFFFFFF83L;
1471
1472 buf.mark();
1473
1474
1475 buf.putUnsigned(b);
1476 buf.putUnsigned(s);
1477 buf.putUnsigned(i);
1478 buf.putUnsigned(l);
1479
1480 buf.reset();
1481
1482
1483 assertEquals(0x0080, buf.getUnsigned());
1484 assertEquals(0x0081, buf.getUnsigned());
1485 assertEquals(0x0082, buf.getUnsigned());
1486 assertEquals(0x0083, buf.getUnsigned());
1487 }
1488
1489 @Test
1490 public void testPutUnsignedIndex() {
1491 IoBuffer buf = IoBuffer.allocate(4);
1492 byte b = (byte) 0x80;
1493 short s = (short) 0x8F81;
1494 int i = 0x8FFFFF82;
1495 long l = 0x8FFFFFFFFFFFFF83L;
1496
1497 buf.mark();
1498
1499
1500 buf.putUnsigned(3, b);
1501 buf.putUnsigned(2, s);
1502 buf.putUnsigned(1, i);
1503 buf.putUnsigned(0, l);
1504
1505 buf.reset();
1506
1507
1508 assertEquals(0x0083, buf.getUnsigned());
1509 assertEquals(0x0082, buf.getUnsigned());
1510 assertEquals(0x0081, buf.getUnsigned());
1511 assertEquals(0x0080, buf.getUnsigned());
1512 }
1513
1514 @Test
1515 public void testPutUnsignedShort() {
1516 IoBuffer buf = IoBuffer.allocate(8);
1517 byte b = (byte) 0x80;
1518 short s = (short) 0x8181;
1519 int i = 0x82828282;
1520 long l = 0x8383838383838383L;
1521
1522 buf.mark();
1523
1524
1525 buf.putUnsignedShort(b);
1526 buf.putUnsignedShort(s);
1527 buf.putUnsignedShort(i);
1528 buf.putUnsignedShort(l);
1529
1530 buf.reset();
1531
1532
1533 assertEquals(0x0080L, buf.getUnsignedShort());
1534 assertEquals(0x8181L, buf.getUnsignedShort());
1535 assertEquals(0x8282L, buf.getUnsignedShort());
1536 assertEquals(0x8383L, buf.getUnsignedShort());
1537 }
1538
1539 @Test
1540 public void testPutUnsignedShortIndex() {
1541 IoBuffer buf = IoBuffer.allocate(8);
1542 byte b = (byte) 0x80;
1543 short s = (short) 0x8181;
1544 int i = 0x82828282;
1545 long l = 0x8383838383838383L;
1546
1547 buf.mark();
1548
1549
1550 buf.putUnsignedShort(6, b);
1551 buf.putUnsignedShort(4, s);
1552 buf.putUnsignedShort(2, i);
1553 buf.putUnsignedShort(0, l);
1554
1555 buf.reset();
1556
1557
1558 assertEquals(0x8383L, buf.getUnsignedShort());
1559 assertEquals(0x8282L, buf.getUnsignedShort());
1560 assertEquals(0x8181L, buf.getUnsignedShort());
1561 assertEquals(0x0080L, buf.getUnsignedShort());
1562 }
1563
1564 @Test
1565 public void testPutUnsignedInt() {
1566 IoBuffer buf = IoBuffer.allocate(16);
1567 byte b = (byte) 0x80;
1568 short s = (short) 0x8181;
1569 int i = 0x82828282;
1570 long l = 0x8383838383838383L;
1571
1572 buf.mark();
1573
1574
1575 buf.putUnsignedInt(b);
1576 buf.putUnsignedInt(s);
1577 buf.putUnsignedInt(i);
1578 buf.putUnsignedInt(l);
1579
1580 buf.reset();
1581
1582
1583 assertEquals(0x0000000000000080L, buf.getUnsignedInt());
1584 assertEquals(0x0000000000008181L, buf.getUnsignedInt());
1585 assertEquals(0x0000000082828282L, buf.getUnsignedInt());
1586 assertEquals(0x0000000083838383L, buf.getUnsignedInt());
1587 }
1588
1589
1590
1591
1592 @Test
1593 public void testPutUnsignedIntIndex() {
1594 IoBuffer buf = IoBuffer.allocate(16);
1595 byte b = (byte) 0x80;
1596 short s = (short) 0x8181;
1597 int i = 0x82828282;
1598 long l = 0x8383838383838383L;
1599
1600 buf.mark();
1601
1602
1603 buf.putUnsignedInt(12, b);
1604 buf.putUnsignedInt(8, s);
1605 buf.putUnsignedInt(4, i);
1606 buf.putUnsignedInt(0, l);
1607
1608 buf.reset();
1609
1610
1611 assertEquals(0x0000000083838383L, buf.getUnsignedInt());
1612 assertEquals(0x0000000082828282L, buf.getUnsignedInt());
1613 assertEquals(0x0000000000008181L, buf.getUnsignedInt());
1614 assertEquals(0x0000000000000080L, buf.getUnsignedInt());
1615 }
1616
1617
1618
1619
1620 @Test
1621 public void testGetSlice() {
1622 IoBuffer buf = IoBuffer.allocate(36);
1623
1624 for (byte i = 0; i < 36; i++) {
1625 buf.put(i);
1626 }
1627
1628 IoBuffer res = buf.getSlice(1, 3);
1629
1630
1631
1632 assertEquals(0, res.position());
1633 assertEquals(3, res.limit());
1634 assertEquals(0x01, res.get());
1635 assertEquals(0x02, res.get());
1636 assertEquals(0x03, res.get());
1637
1638
1639 buf.flip();
1640
1641 res = buf.getSlice(1, 3);
1642
1643
1644 assertEquals(0, res.position());
1645 assertEquals(3, res.limit());
1646 assertEquals(0x01, res.get());
1647 assertEquals(0x02, res.get());
1648 assertEquals(0x03, res.get());
1649 }
1650
1651
1652
1653
1654 @Test
1655 public void testShrink() {
1656 IoBuffer buf = IoBuffer.allocate(36);
1657 buf.put( "012345".getBytes());
1658 buf.flip();
1659 buf.position(4);
1660 buf.minimumCapacity(8);
1661
1662 IoBuffer newBuf = buf.shrink();
1663 assertEquals(4, newBuf.position());
1664 assertEquals(6, newBuf.limit());
1665 assertEquals(9, newBuf.capacity());
1666 assertEquals(8, newBuf.minimumCapacity());
1667
1668 buf = IoBuffer.allocate(6);
1669 buf.put( "012345".getBytes());
1670 buf.flip();
1671 buf.position(4);
1672
1673 newBuf = buf.shrink();
1674 assertEquals(4, newBuf.position());
1675 assertEquals(6, newBuf.limit());
1676 assertEquals(6, newBuf.capacity());
1677 assertEquals(6, newBuf.minimumCapacity());
1678 }
1679
1680
1681
1682
1683
1684 @Test
1685 public void testSetPosition()
1686 {
1687
1688 }
1689 }