1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.javafx.sg.prism;
27
28 import org.junit.Test;
29
30 import static org.junit.Assert.assertFalse;
31 import static org.junit.Assert.assertTrue;
32
33 /**
34 */
35 public class GrowableDataBufferTest {
36
37 public boolean encodableBooleans[] = {
38 false, true
39 };
40
41 public char encodableChars[] = {
42 ' ', 'A', 'Z', 'a', 'z', '0', '9'
43 };
44
45 public byte encodableBytes[] = {
46 -1, 0, 1, Byte.MIN_VALUE, Byte.MAX_VALUE
47 };
48
49 public short encodableShorts[] = {
50 -1, 0, 1, Short.MIN_VALUE, Short.MAX_VALUE
51 };
52
53 public int encodableInts[] = {
54 -1, 0, 1, Integer.MIN_VALUE, Integer.MAX_VALUE
55 };
56
57 public long encodableLongs[] = {
58 -1L, 0L, 1L, Long.MIN_VALUE, Long.MAX_VALUE
59 };
60
61 public float encodableFloats[] = {
62 -1.0f, 0.0f, 1.0f, Float.MIN_VALUE, Float.MAX_VALUE,
63 Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY
64 };
65
66 public double encodableDoubles[] = {
67 -1.0, 0.0, 1.0, Double.MIN_VALUE, Double.MAX_VALUE,
68 Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY
69 };
70
71 int NUM_VALUES =
72 encodableBooleans.length +
73 encodableChars.length +
74 encodableBytes.length +
75 encodableShorts.length +
76 encodableInts.length +
77 encodableLongs.length +
78 encodableFloats.length +
79 encodableDoubles.length;
80 int NUM_BYTES =
81 encodableBooleans.length +
82 encodableChars.length * 2 +
83 encodableBytes.length +
84 encodableShorts.length * 2 +
85 encodableInts.length * 4 +
86 encodableLongs.length * 8 +
87 encodableFloats.length * 4 +
88 encodableDoubles.length * 8;
89
90 void putBooleans(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
91 for (boolean b : encodableBooleans) {
92 if (putPrim) gdb.putBoolean(b);
93 if (putObj) gdb.putObject(Boolean.valueOf(b));
94 }
95 }
96
97 void getBooleans(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
98 for (boolean b : encodableBooleans) {
99 if (getPrim) assertTrue(gdb.getBoolean() == b);
100 if (getObj) assertTrue(gdb.getObject().equals(Boolean.valueOf(b)));
101 }
102 }
103
104 void putChars(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
105 for (char c : encodableChars) {
106 if (putPrim) gdb.putChar(c);
107 if (putObj) gdb.putObject(Character.valueOf(c));
108 }
109 }
110
111 void getChars(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
112 for (char c : encodableChars) {
113 if (getPrim) assertTrue(gdb.getChar() == c);
114 if (getObj) assertTrue(gdb.getObject().equals(Character.valueOf(c)));
115 }
116 }
117
118 void putBytes(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
119 for (byte b : encodableBytes) {
120 if (putPrim) gdb.putByte(b);
121 if (putObj) gdb.putObject(Byte.valueOf(b));
122 }
123 }
124
125 void getBytes(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
126 for (byte b : encodableBytes) {
127 if (getPrim) assertTrue(gdb.getByte() == b);
128 if (getObj) assertTrue(gdb.getObject().equals(Byte.valueOf(b)));
129 }
130 }
131
132 void putUBytes(GrowableDataBuffer gdb) {
133 for (byte b : encodableBytes) {
134 gdb.putByte(b);
135 }
136 }
137
138 void getUBytes(GrowableDataBuffer gdb) {
139 for (byte b : encodableBytes) {
140 assertTrue(gdb.getUByte() == (b & 0xff));
141 }
142 }
143
144 void putShorts(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
145 for (short s : encodableShorts) {
146 if (putPrim) gdb.putShort(s);
147 if (putObj) gdb.putObject(Short.valueOf(s));
148 }
149 }
150
151 void getShorts(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
152 for (short s : encodableShorts) {
153 if (getPrim) assertTrue(gdb.getShort() == s);
154 if (getObj) assertTrue(gdb.getObject().equals(Short.valueOf(s)));
155 }
156 }
157
158 void putInts(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
159 for (int i : encodableInts) {
160 if (putPrim) gdb.putInt(i);
161 if (putObj) gdb.putObject(Integer.valueOf(i));
162 }
163 }
164
165 void getInts(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
166 for (int i : encodableInts) {
167 if (getPrim) assertTrue(gdb.getInt() == i);
168 if (getObj) assertTrue(gdb.getObject().equals(Integer.valueOf(i)));
169 }
170 }
171
172 void putLongs(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
173 for (long l : encodableLongs) {
174 if (putPrim) gdb.putLong(l);
175 if (putObj) gdb.putObject(Long.valueOf(l));
176 }
177 }
178
179 void getLongs(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
180 for (long c : encodableLongs) {
181 if (getPrim) assertTrue(gdb.getLong() == c);
182 if (getObj) assertTrue(gdb.getObject().equals(Long.valueOf(c)));
183 }
184 }
185
186 void putFloats(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
187 for (float f : encodableFloats) {
188 if (putPrim) gdb.putFloat(f);
189 if (putObj) gdb.putObject(Float.valueOf(f));
190 }
191 }
192
193 void getFloats(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
194 for (float f : encodableFloats) {
195 if (getPrim) assertTrue(gdb.getFloat() == f);
196 if (getObj) assertTrue(gdb.getObject().equals(Float.valueOf(f)));
197 }
198 }
199
200 void putFloatNaN(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
201 if (putPrim) gdb.putFloat(Float.NaN);
202 if (putObj) gdb.putObject(Float.valueOf(Float.NaN));
203 }
204
205 void getFloatNaN(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
206 if (getPrim) assertTrue(Float.isNaN(gdb.getFloat()));
207 if (getObj) assertTrue(gdb.getObject().equals(Float.valueOf(Float.NaN)));
208 }
209
210 void putDoubles(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
211 for (double d : encodableDoubles) {
212 if (putPrim) gdb.putDouble(d);
213 if (putObj) gdb.putObject(Double.valueOf(d));
214 }
215 }
216
217 void getDoubles(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
218 for (double d : encodableDoubles) {
219 if (getPrim) assertTrue(gdb.getDouble() == d);
220 if (getObj) assertTrue(gdb.getObject().equals(Double.valueOf(d)));
221 }
222 }
223
224 void putDoubleNaN(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
225 if (putPrim) gdb.putDouble(Double.NaN);
226 if (putObj) gdb.putObject(Double.valueOf(Double.NaN));
227 }
228
229 void getDoubleNaN(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
230 if (getPrim) assertTrue(Double.isNaN(gdb.getDouble()));
231 if (getObj) assertTrue(gdb.getObject().equals(Double.valueOf(Double.NaN)));
232 }
233
234 void fill(GrowableDataBuffer gdb, boolean putPrim, boolean putObj) {
235 putBooleans(gdb, putPrim, putObj);
236 putChars(gdb, putPrim, putObj);
237 putBytes(gdb, putPrim, putObj);
238 putShorts(gdb, putPrim, putObj);
239 putInts(gdb, putPrim, putObj);
240 putLongs(gdb, putPrim, putObj);
241 putFloats(gdb, putPrim, putObj);
242 putFloatNaN(gdb, putPrim, putObj);
243 putDoubles(gdb, putPrim, putObj);
244 putDoubleNaN(gdb, putPrim, putObj);
245 }
246
247 void test(GrowableDataBuffer gdb, boolean getPrim, boolean getObj) {
248 getBooleans(gdb, getPrim, getObj);
249 getChars(gdb, getPrim, getObj);
250 getBytes(gdb, getPrim, getObj);
251 getShorts(gdb, getPrim, getObj);
252 getInts(gdb, getPrim, getObj);
253 getLongs(gdb, getPrim, getObj);
254 getFloats(gdb, getPrim, getObj);
255 getFloatNaN(gdb, getPrim, getObj);
256 getDoubles(gdb, getPrim, getObj);
257 getDoubleNaN(gdb, getPrim, getObj);
258 }
259
260 @Test public void testCapacities() {
261 for (int i = 1; i < 100000; i += 100) {
262 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(i, i);
263 assertFalse(gdb.hasValues());
264 assertFalse(gdb.hasObjects());
265 assertTrue(gdb.isEmpty());
266 assertTrue(gdb.valueCapacity() >= i);
267 assertTrue(gdb.objectCapacity() >= i);
268 }
269 }
270
271 @Test public void testWriteAndReadValues() {
272 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
273 fill(gdb, true, false);
274 assertTrue(gdb.hasValues());
275 assertFalse(gdb.hasObjects());
276 test(gdb, true, false);
277 assertFalse(gdb.hasValues());
278 assertFalse(gdb.hasObjects());
279 }
280
281 @Test public void testWriteAndReadUbytes() {
282 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
283 putUBytes(gdb);
284 assertTrue(gdb.hasValues());
285 assertFalse(gdb.hasObjects());
286 getUBytes(gdb);
287 assertFalse(gdb.hasValues());
288 assertFalse(gdb.hasObjects());
289 }
290
291 @Test public void testWriteAndReadObjects() {
292 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
293 fill(gdb, false, true);
294 assertFalse(gdb.hasValues());
295 assertTrue(gdb.hasObjects());
296 test(gdb, false, true);
297 assertFalse(gdb.hasValues());
298 assertFalse(gdb.hasObjects());
299 }
300
301 @Test public void testWriteAndReadValuesAndObjects() {
302 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
303 fill(gdb, true, true);
304 assertTrue(gdb.hasValues());
305 assertTrue(gdb.hasObjects());
306 test(gdb, true, true);
307 assertFalse(gdb.hasValues());
308 assertFalse(gdb.hasObjects());
309 }
310
311 @Test public void testWriteAndReadGrowableValues() {
312 for (int i = 0; i < NUM_BYTES; i++) {
313 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(i, NUM_VALUES);
314 fill(gdb, true, false);
315 assertTrue(gdb.hasValues());
316 assertFalse(gdb.hasObjects());
317 test(gdb, true, false);
318 assertFalse(gdb.hasValues());
319 assertFalse(gdb.hasObjects());
320 }
321 }
322
323 @Test public void testWriteAndReadGrowableObjects() {
324 for (int i = 0; i < NUM_VALUES; i++) {
325 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, i);
326 fill(gdb, false, true);
327 assertFalse(gdb.hasValues());
328 assertTrue(gdb.hasObjects());
329 test(gdb, false, true);
330 assertFalse(gdb.hasValues());
331 assertFalse(gdb.hasObjects());
332 }
333 }
334
335 @Test public void testWriteAndMultipleReads() {
336 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
337 fill(gdb, true, true);
338 assertTrue(gdb.hasValues());
339 assertTrue(gdb.hasObjects());
340 gdb.save();
341 assertTrue(gdb.hasValues());
342 assertTrue(gdb.hasObjects());
343 test(gdb, true, true);
344 assertFalse(gdb.hasValues());
345 assertFalse(gdb.hasObjects());
346 gdb.restore();
347 assertTrue(gdb.hasValues());
348 assertTrue(gdb.hasObjects());
349 test(gdb, true, true);
350 assertFalse(gdb.hasValues());
351 assertFalse(gdb.hasObjects());
352 }
353
354 @Test public void testPeekValues() {
355 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
356 fill(gdb, true, false);
357 assertTrue(gdb.hasValues());
358 assertFalse(gdb.hasObjects());
359 for (int i = 0; i < gdb.writeValuePosition(); i++) {
360 gdb.peekByte(i);
361 }
362 assertTrue(gdb.hasValues());
363 assertFalse(gdb.hasObjects());
364 }
365
366 @Test public void testPeekObjects() {
367 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
368 fill(gdb, false, true);
369 assertFalse(gdb.hasValues());
370 assertTrue(gdb.hasObjects());
371 for (int i = 0; i < gdb.writeValuePosition(); i++) {
372 gdb.peekByte(i);
373 }
374 assertFalse(gdb.hasValues());
375 assertTrue(gdb.hasObjects());
376 }
377
378 @Test public void testAppend() {
379 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
380 fill(gdb, true, true);
381 GrowableDataBuffer gdb2 = GrowableDataBuffer.getBuffer(NUM_BYTES, NUM_VALUES);
382 fill(gdb2, true, true);
383 gdb.append(gdb2);
384 assertTrue(gdb.hasValues());
385 assertTrue(gdb.hasObjects());
386 test(gdb, true, true);
387 assertTrue(gdb.hasValues());
388 assertTrue(gdb.hasObjects());
389 test(gdb, true, true);
390 assertFalse(gdb.hasValues());
391 assertFalse(gdb.hasObjects());
392 }
393
394 @Test public void testReset() {
395 GrowableDataBuffer gdb = GrowableDataBuffer.getBuffer(0, 0);
396 fill(gdb, true, true);
397 assertTrue(gdb.hasValues());
398 assertTrue(gdb.hasObjects());
399 int valcapacity = gdb.valueCapacity();
400 int objcapacity = gdb.objectCapacity();
401 for (int i = 0; i < 5; i++) {
402 gdb.reset();
403 assertFalse(gdb.hasValues());
404 assertFalse(gdb.hasObjects());
405 fill(gdb, true, true);
406 assertTrue(gdb.hasValues());
407 assertTrue(gdb.hasObjects());
408 }
409 assertTrue(gdb.valueCapacity() == valcapacity);
410 assertTrue(gdb.objectCapacity() == objcapacity);
411 test(gdb, true, true);
412 assertFalse(gdb.hasValues());
413 assertFalse(gdb.hasObjects());
414 }
415 }