Lines Matching refs:buf
37 protected CharBuffer buf;
44 buf = CharBuffer.wrap(charscopy);
45 baseBuf = buf;
49 buf = null;
54 char array[] = buf.array();
55 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
57 loadTestData1(array, buf.arrayOffset(), buf.capacity());
58 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
60 loadTestData2(array, buf.arrayOffset(), buf.capacity());
61 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
63 loadTestData1(buf);
64 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
66 loadTestData2(buf);
67 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
71 char array[] = buf.array();
72 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
74 loadTestData1(array, buf.arrayOffset(), buf.capacity());
75 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
77 loadTestData2(array, buf.arrayOffset(), buf.capacity());
78 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
80 loadTestData1(buf);
81 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
83 loadTestData2(buf);
84 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
88 buf.clear();
89 buf.mark();
90 buf.position(buf.limit());
92 // readonly's contents should be the same as buf
93 CharBuffer readonly = buf.asReadOnlyBuffer();
94 assertNotSame(buf, readonly);
96 assertEquals(buf.position(), readonly.position());
97 assertEquals(buf.limit(), readonly.limit());
98 assertEquals(buf.isDirect(), readonly.isDirect());
99 assertEquals(buf.order(), readonly.order());
100 assertEquals(buf.capacity(), readonly.capacity());
101 assertContentEquals(buf, readonly);
103 // readonly's position, mark, and limit should be independent to buf
107 assertEquals(buf.position(), buf.limit());
108 buf.reset();
109 assertEquals(buf.position(), 0);
111 buf.clear();
112 int originalPosition = (buf.position() + buf.limit()) / 2;
113 buf.position(originalPosition);
114 buf.mark();
115 buf.position(buf.limit());
117 // readonly's contents should be the same as buf
118 readonly = buf.asReadOnlyBuffer();
119 assertNotSame(buf, readonly);
121 assertEquals(buf.position(), readonly.position());
122 assertEquals(buf.limit(), readonly.limit());
123 assertEquals(buf.isDirect(), readonly.isDirect());
124 assertEquals(buf.order(), readonly.order());
125 assertEquals(buf.capacity(), readonly.capacity());
126 assertContentEquals(buf, readonly);
128 // readonly's position, mark, and limit should be independent to buf
132 assertEquals(buf.position(), buf.limit());
133 buf.reset();
134 assertEquals(buf.position(), originalPosition);
139 buf.clear();
140 buf.mark();
141 loadTestData1(buf);
142 CharBuffer ret = buf.compact();
143 assertSame(ret, buf);
144 assertEquals(buf.position(), buf.capacity());
145 assertEquals(buf.limit(), buf.capacity());
146 assertContentLikeTestData1(buf, 0, (char) 0, buf.capacity());
148 buf.reset();
155 buf.position(0);
156 buf.limit(0);
157 buf.mark();
158 ret = buf.compact();
159 assertSame(ret, buf);
160 assertEquals(buf.position(), 0);
161 assertEquals(buf.limit(), buf.capacity());
162 assertContentLikeTestData1(buf, 0, (char) 0, buf.capacity());
164 buf.reset();
171 assertTrue(buf.capacity() > 5);
172 buf.position(1);
173 buf.limit(5);
174 buf.mark();
175 ret = buf.compact();
176 assertSame(ret, buf);
177 assertEquals(buf.position(), 4);
178 assertEquals(buf.limit(), buf.capacity());
179 assertContentLikeTestData1(buf, 0, (char) 1, 4);
181 buf.reset();
190 assertEquals(0, buf.compareTo(buf));
192 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
193 buf.clear();
194 CharBuffer other = CharBuffer.allocate(buf.capacity());
195 other.put(buf);
197 buf.clear();
198 assertEquals(0, buf.compareTo(other));
199 assertEquals(0, other.compareTo(buf));
200 buf.position(1);
201 assertTrue(buf.compareTo(other) > 0);
202 assertTrue(other.compareTo(buf) < 0);
204 assertTrue(buf.compareTo(other) < 0);
205 assertTrue(other.compareTo(buf) > 0);
206 buf.position(2);
207 assertTrue(buf.compareTo(other) == 0);
208 assertTrue(other.compareTo(buf) == 0);
210 assertTrue(buf.compareTo(other) > 0);
211 assertTrue(other.compareTo(buf) < 0);
216 buf.clear();
217 buf.mark();
218 buf.position(buf.limit());
220 // duplicate's contents should be the same as buf
221 CharBuffer duplicate = buf.duplicate();
222 assertNotSame(buf, duplicate);
223 assertEquals(buf.position(), duplicate.position());
224 assertEquals(buf.limit(), duplicate.limit());
225 assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
226 assertEquals(buf.isDirect(), duplicate.isDirect());
227 assertEquals(buf.order(), duplicate.order());
228 assertEquals(buf.capacity(), duplicate.capacity());
229 assertContentEquals(buf, duplicate);
232 // buf
236 assertEquals(buf.position(), buf.limit());
237 buf.reset();
238 assertEquals(buf.position(), 0);
241 buf.clear();
242 int originalPosition = (buf.position() + buf.limit()) / 2;
243 buf.position(originalPosition);
244 buf.mark();
245 buf.position(buf.limit());
247 // duplicate's contents should be the same as buf
248 duplicate = buf.duplicate();
249 assertNotSame(buf, duplicate);
250 assertEquals(buf.position(), duplicate.position());
251 assertEquals(buf.limit(), duplicate.limit());
252 assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
253 assertEquals(buf.isDirect(), duplicate.isDirect());
254 assertEquals(buf.order(), duplicate.order());
255 assertEquals(buf.capacity(), duplicate.capacity());
256 assertContentEquals(buf, duplicate);
259 // buf
263 assertEquals(buf.position(), buf.limit());
264 buf.reset();
265 assertEquals(buf.position(), originalPosition);
267 // duplicate share the same content with buf
269 loadTestData1(buf);
270 assertContentEquals(buf, duplicate);
272 assertContentEquals(buf, duplicate);
278 assertTrue(buf.equals(buf));
279 CharBuffer readonly = buf.asReadOnlyBuffer();
280 assertTrue(buf.equals(readonly));
281 CharBuffer duplicate = buf.duplicate();
282 assertTrue(buf.equals(duplicate));
285 assertFalse(buf.equals(Boolean.TRUE));
287 assertTrue(buf.capacity() > 5);
289 buf.limit(buf.capacity()).position(0);
291 assertFalse(buf.equals(readonly));
293 buf.limit(buf.capacity() - 1).position(0);
295 assertFalse(buf.equals(duplicate));
302 buf.clear();
303 for (int i = 0; i < buf.capacity(); i++) {
304 assertEquals(buf.position(), i);
305 assertEquals(buf.get(), buf.get(i));
308 buf.get();
320 buf.clear();
321 for (int i = 0; i < buf.capacity(); i++) {
322 assertEquals(buf.position(), i);
323 CharBuffer ret = buf.get(array);
324 assertEquals(array[0], buf.get(i));
325 assertSame(ret, buf);
328 buf.get(array);
339 buf.clear();
340 char array[] = new char[buf.capacity()];
343 buf.get(new char[buf.capacity() + 1], 0, buf.capacity() + 1);
348 assertEquals(buf.position(), 0);
350 buf.get(array, -1, array.length);
355 buf.get(array, array.length, 0);
357 buf.get(array, array.length + 1, 1);
362 assertEquals(buf.position(), 0);
364 buf.get(array, 2, -1);
370 buf.get((char[])null, 2, -1);
376 buf.get(array, 2, array.length);
382 buf.get(array, 1, Integer.MAX_VALUE);
388 buf.get(array, Integer.MAX_VALUE, 1);
393 assertEquals(buf.position(), 0);
395 buf.clear();
396 CharBuffer ret = buf.get(array, 0, array.length);
397 assertEquals(buf.position(), buf.capacity());
398 assertContentEquals(buf, array, 0, array.length);
399 assertSame(ret, buf);
406 buf.clear();
407 for (int i = 0; i < buf.capacity(); i++) {
408 assertEquals(buf.position(), i);
409 assertEquals(buf.get(), buf.get(i));
412 buf.get(-1);
418 buf.get(buf.limit());
426 buf.clear();
427 loadTestData1(buf);
428 CharBuffer readonly = buf.asReadOnlyBuffer();
429 CharBuffer duplicate = buf.duplicate();
430 assertTrue(buf.hashCode() == readonly.hashCode());
431 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
432 duplicate.position(buf.capacity() / 2);
433 assertTrue(buf.hashCode() != duplicate.hashCode());
440 buf.clear();
441 for (int i = 0; i < buf.capacity(); i++) {
442 assertEquals(buf.position(), i);
443 CharBuffer ret = buf.put((char) i);
444 assertEquals(buf.get(i), (char) i);
445 assertSame(ret, buf);
448 buf.put((char) 0);
461 buf.clear();
462 for (int i = 0; i < buf.capacity(); i++) {
463 assertEquals(buf.position(), i);
465 CharBuffer ret = buf.put(array);
466 assertEquals(buf.get(i), (char) i);
467 assertSame(ret, buf);
470 buf.put(array);
476 buf.put((char[]) null);
487 buf.clear();
488 char array[] = new char[buf.capacity()];
490 buf.put((char[]) null, 0, 1);
496 buf.put(new char[buf.capacity() + 1], 0, buf.capacity() + 1);
501 assertEquals(buf.position(), 0);
503 buf.put(array, -1, array.length);
509 buf.put(array, array.length + 1, 0);
514 buf.put(array, array.length, 0);
515 assertEquals(buf.position(), 0);
517 buf.put(array, 0, -1);
523 buf.put((char[])null, 0, -1);
529 buf.put(array, 2, array.length);
535 buf.put(array, Integer.MAX_VALUE, 1);
541 buf.put(array, 1, Integer.MAX_VALUE);
546 assertEquals(buf.position(), 0);
549 CharBuffer ret = buf.put(array, 0, array.length);
550 assertEquals(buf.position(), buf.capacity());
551 assertContentEquals(buf, array, 0, array.length);
552 assertSame(ret, buf);
559 CharBuffer other = CharBuffer.allocate(buf.capacity());
562 buf.put((CharBuffer) null);
568 buf.put(buf);
574 buf.put(CharBuffer.allocate(buf.capacity() + 1));
580 buf.flip();
581 buf.put((CharBuffer)null);
589 buf.clear();
590 CharBuffer ret = buf.put(other);
592 assertEquals(buf.position(), buf.capacity());
593 assertContentEquals(other, buf);
594 assertSame(ret, buf);
601 buf.clear();
602 for (int i = 0; i < buf.capacity(); i++) {
603 assertEquals(buf.position(), 0);
604 CharBuffer ret = buf.put(i, (char) i);
605 assertEquals(buf.get(i), (char) i);
606 assertSame(ret, buf);
609 buf.put(-1, (char) 0);
615 buf.put(buf.limit(), (char) 0);
623 assertTrue(buf.capacity() > 5);
624 buf.position(1);
625 buf.limit(buf.capacity() - 1);
627 CharBuffer slice = buf.slice();
628 assertEquals(buf.isReadOnly(), slice.isReadOnly());
629 assertEquals(buf.isDirect(), slice.isDirect());
630 assertEquals(buf.order(), slice.order());
632 assertEquals(slice.limit(), buf.remaining());
633 assertEquals(slice.capacity(), buf.remaining());
641 // slice share the same content with buf
644 assertContentLikeTestData1(buf, 1, (char) 0, slice.capacity());
645 buf.put(2, (char) 500);
652 for (int i = buf.position(); i < buf.limit(); i++) {
653 expected += buf.get(i);
655 String str = buf.toString();
660 for (int i = 0; i < buf.remaining(); i++) {
661 assertEquals(buf.get(buf.position() + i), buf.charAt(i));
664 buf.charAt(-1);
670 buf.charAt(buf.remaining());
678 assertEquals(buf.length(), buf.remaining());
683 buf.subSequence(-1, buf.length());
689 buf.subSequence(buf.length() + 1, buf.length() + 1);
694 assertEquals(buf.subSequence(buf.length(), buf.length()).length(), 0);
696 buf.subSequence(1, 0);
702 buf.subSequence(1, buf.length() + 1);
708 assertEquals(buf.subSequence(0, buf.length()).toString(), buf
711 if (buf.length() >= 2) {
712 assertEquals(buf.subSequence(1, buf.length() - 1).toString(), buf
713 .toString().substring(1, buf.length() - 1));
720 buf.clear();
721 for (int i = 0; i < buf.capacity(); i++) {
722 assertEquals(buf.position(), i);
724 CharBuffer ret = buf.put(str);
725 assertEquals(buf.get(i), (char) i);
726 assertSame(ret, buf);
729 buf.put(str);
735 buf.put((String) null);
743 buf.clear();
744 String str = String.valueOf(new char[buf.capacity()]);
749 buf.put(String.valueOf(new char[buf.capacity() + 1]), 0, buf
756 buf.put((String) null, 0, buf.capacity() + 1);
761 assertEquals(0, buf.position());
763 buf.clear();
765 buf.put(str, -1, str.length());
771 buf.put(str, str.length() + 1, str.length() + 2);
777 buf.put((String) null, -1, 0);
782 buf.put(str, str.length(), str.length());
783 assertEquals(buf.position(), 0);
785 buf.put(str, 2, 1);
791 buf.put(str, 2, str.length() + 1);
796 assertEquals(buf.position(), 0);
798 char array[] = new char[buf.capacity()];
802 CharBuffer ret = buf.put(str, 0, str.length());
803 assertEquals(buf.position(), buf.capacity());
804 assertContentEquals(buf, str.toCharArray(), 0, str.length());
805 assertSame(ret, buf);
820 void loadTestData1(CharBuffer buf) {
821 buf.clear();
822 for (int i = 0; i < buf.capacity(); i++) {
823 buf.put(i, (char) i);
827 void loadTestData2(CharBuffer buf) {
828 buf.clear();
829 for (int i = 0; i < buf.capacity(); i++) {
830 buf.put(i, (char) (buf.capacity() - i));
834 private void assertContentEquals(CharBuffer buf, char array[], int offset,
837 assertEquals(buf.get(i), array[offset + i]);
841 private void assertContentEquals(CharBuffer buf, CharBuffer other) {
842 assertEquals(buf.capacity(), other.capacity());
843 for (int i = 0; i < buf.capacity(); i++) {
844 assertEquals(buf.get(i), other.get(i));
848 private void assertContentLikeTestData1(CharBuffer buf, int startIndex,
852 assertEquals(buf.get(startIndex + i), value);
1067 assertFalse(buf.isDirect());
1071 assertTrue(buf.hasArray());
1075 assertEquals(ByteOrder.nativeOrder(), buf.order());
1079 assertFalse(buf.isReadOnly());