]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | /* |
2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
3 | * contributor license agreements. See the NOTICE file distributed with | |
4 | * this work for additional information regarding copyright ownership. | |
5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
6 | * (the "License"); you may not use this file except in compliance with | |
7 | * the License. You may obtain a copy of the License at | |
8 | * | |
9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
10 | * | |
11 | * Unless required by applicable law or agreed to in writing, software | |
12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
14 | * See the License for the specific language governing permissions and | |
15 | * limitations under the License. | |
16 | */ | |
17 | ||
18 | package org.apache.arrow.vector; | |
19 | ||
20 | import static org.apache.arrow.vector.TestUtils.newVector; | |
21 | import static org.junit.Assert.*; | |
22 | import static org.junit.Assert.assertEquals; | |
23 | import static org.junit.Assert.assertNull; | |
24 | ||
25 | import java.math.BigDecimal; | |
26 | import java.nio.charset.Charset; | |
27 | import java.time.Duration; | |
28 | import java.time.Period; | |
29 | ||
30 | import org.apache.arrow.memory.BufferAllocator; | |
31 | import org.apache.arrow.memory.RootAllocator; | |
32 | import org.apache.arrow.vector.types.Types.MinorType; | |
33 | import org.junit.After; | |
34 | import org.junit.Before; | |
35 | import org.junit.Test; | |
36 | ||
37 | /* | |
38 | * Tested field types: | |
39 | * | |
40 | * NullableInt | |
41 | * NullableBigInt | |
42 | * NullableFloat4 | |
43 | * NullableFloat8 | |
44 | * NullableBit | |
45 | * NullableDecimal | |
46 | * NullableIntervalDay | |
47 | * NullableIntervalYear | |
48 | * NullableSmallInt | |
49 | * NullableTinyInt | |
50 | * NullableVarChar | |
51 | * NullableTimeMicro | |
52 | * NullableTimeMilli | |
53 | * NullableTimeStamp* | |
54 | */ | |
55 | ||
56 | public class TestCopyFrom { | |
57 | ||
58 | private static final String EMPTY_SCHEMA_PATH = ""; | |
59 | ||
60 | private BufferAllocator allocator; | |
61 | ||
62 | @Before | |
63 | public void init() { | |
64 | allocator = new RootAllocator(Long.MAX_VALUE); | |
65 | } | |
66 | ||
67 | @After | |
68 | public void terminate() throws Exception { | |
69 | allocator.close(); | |
70 | } | |
71 | ||
72 | @Test /* NullableVarChar */ | |
73 | public void testCopyFromWithNulls() { | |
74 | try (final VarCharVector vector = | |
75 | newVector(VarCharVector.class, EMPTY_SCHEMA_PATH, MinorType.VARCHAR, allocator); | |
76 | final VarCharVector vector2 = | |
77 | newVector(VarCharVector.class, EMPTY_SCHEMA_PATH, MinorType.VARCHAR, allocator)) { | |
78 | vector.allocateNew(); | |
79 | assertTrue(vector.getValueCapacity() >= 1); | |
80 | assertEquals(0, vector.getValueCount()); | |
81 | int initialCapacity = vector.getValueCapacity(); | |
82 | ||
83 | for (int i = 0; i < initialCapacity; i++) { | |
84 | if (i % 3 == 0) { | |
85 | continue; | |
86 | } | |
87 | byte[] b = Integer.toString(i).getBytes(); | |
88 | vector.setSafe(i, b, 0, b.length); | |
89 | } | |
90 | ||
91 | /* NO reAlloc() should have happened in setSafe() */ | |
92 | int capacity = vector.getValueCapacity(); | |
93 | assertEquals(initialCapacity, capacity); | |
94 | ||
95 | vector.setValueCount(initialCapacity); | |
96 | ||
97 | for (int i = 0; i < initialCapacity; i++) { | |
98 | if (i % 3 == 0) { | |
99 | assertNull(vector.getObject(i)); | |
100 | } else { | |
101 | assertEquals( | |
102 | "unexpected value at index: " + i, | |
103 | Integer.toString(i), | |
104 | vector.getObject(i).toString()); | |
105 | } | |
106 | } | |
107 | ||
108 | vector2.setInitialCapacity(initialCapacity); | |
109 | vector2.allocateNew(); | |
110 | capacity = vector2.getValueCapacity(); | |
111 | assertEquals(initialCapacity, capacity); | |
112 | ||
113 | for (int i = 0; i < initialCapacity; i++) { | |
114 | vector2.copyFromSafe(i, i, vector); | |
115 | if (i % 3 == 0) { | |
116 | assertNull(vector2.getObject(i)); | |
117 | } else { | |
118 | assertEquals( | |
119 | "unexpected value at index: " + i, | |
120 | Integer.toString(i), | |
121 | vector2.getObject(i).toString()); | |
122 | } | |
123 | } | |
124 | ||
125 | /* NO reAlloc() should have happened in copyFrom */ | |
126 | capacity = vector2.getValueCapacity(); | |
127 | assertEquals(initialCapacity, capacity); | |
128 | ||
129 | vector2.setValueCount(initialCapacity); | |
130 | ||
131 | for (int i = 0; i < initialCapacity; i++) { | |
132 | if (i % 3 == 0) { | |
133 | assertNull(vector2.getObject(i)); | |
134 | } else { | |
135 | assertEquals( | |
136 | "unexpected value at index: " + i, | |
137 | Integer.toString(i), | |
138 | vector2.getObject(i).toString()); | |
139 | } | |
140 | } | |
141 | } | |
142 | } | |
143 | ||
144 | @Test /* NullableVarChar */ | |
145 | public void testCopyFromWithNulls1() { | |
146 | try (final VarCharVector vector = | |
147 | newVector(VarCharVector.class, EMPTY_SCHEMA_PATH, MinorType.VARCHAR, allocator); | |
148 | final VarCharVector vector2 = | |
149 | newVector(VarCharVector.class, EMPTY_SCHEMA_PATH, MinorType.VARCHAR, allocator)) { | |
150 | vector.allocateNew(); | |
151 | assertTrue(vector.getValueCapacity() >= 1); | |
152 | assertEquals(0, vector.getValueCount()); | |
153 | int initialCapacity = vector.getValueCapacity(); | |
154 | ||
155 | for (int i = 0; i < initialCapacity; i++) { | |
156 | if (i % 3 == 0) { | |
157 | continue; | |
158 | } | |
159 | byte[] b = Integer.toString(i).getBytes(); | |
160 | vector.setSafe(i, b, 0, b.length); | |
161 | } | |
162 | ||
163 | /* NO reAlloc() should have happened in setSafe() */ | |
164 | int capacity = vector.getValueCapacity(); | |
165 | assertEquals(initialCapacity, capacity); | |
166 | ||
167 | vector.setValueCount(initialCapacity); | |
168 | ||
169 | for (int i = 0; i < initialCapacity; i++) { | |
170 | if (i % 3 == 0) { | |
171 | assertNull(vector.getObject(i)); | |
172 | } else { | |
173 | assertEquals( | |
174 | "unexpected value at index: " + i, | |
175 | Integer.toString(i), | |
176 | vector.getObject(i).toString()); | |
177 | } | |
178 | } | |
179 | ||
180 | /* set lesser initial capacity than actually needed | |
181 | * to trigger reallocs in copyFromSafe() | |
182 | */ | |
183 | vector2.allocateNew((initialCapacity / 4) * 10, initialCapacity / 4); | |
184 | ||
185 | capacity = vector2.getValueCapacity(); | |
186 | assertTrue(capacity >= initialCapacity / 4); | |
187 | assertTrue(capacity < initialCapacity / 2); | |
188 | ||
189 | for (int i = 0; i < initialCapacity; i++) { | |
190 | vector2.copyFromSafe(i, i, vector); | |
191 | if (i % 3 == 0) { | |
192 | assertNull(vector2.getObject(i)); | |
193 | } else { | |
194 | assertEquals( | |
195 | "unexpected value at index: " + i, | |
196 | Integer.toString(i), | |
197 | vector2.getObject(i).toString()); | |
198 | } | |
199 | } | |
200 | ||
201 | /* 2 reAllocs should have happened in copyFromSafe() */ | |
202 | capacity = vector2.getValueCapacity(); | |
203 | assertTrue(capacity >= initialCapacity); | |
204 | ||
205 | vector2.setValueCount(initialCapacity); | |
206 | ||
207 | for (int i = 0; i < initialCapacity; i++) { | |
208 | if (i % 3 == 0) { | |
209 | assertNull(vector2.getObject(i)); | |
210 | } else { | |
211 | assertEquals( | |
212 | "unexpected value at index: " + i, | |
213 | Integer.toString(i), | |
214 | vector2.getObject(i).toString()); | |
215 | } | |
216 | } | |
217 | } | |
218 | } | |
219 | ||
220 | @Test /* IntVector */ | |
221 | public void testCopyFromWithNulls2() { | |
222 | try (final IntVector vector1 = new IntVector(EMPTY_SCHEMA_PATH, allocator); | |
223 | final IntVector vector2 = new IntVector(EMPTY_SCHEMA_PATH, allocator)) { | |
224 | ||
225 | vector1.allocateNew(); | |
226 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
227 | assertEquals(0, vector1.getValueCount()); | |
228 | int initialCapacity = vector1.getValueCapacity(); | |
229 | ||
230 | for (int i = 0; i < initialCapacity; i++) { | |
231 | if ((i & 1) == 0) { | |
232 | continue; | |
233 | } | |
234 | vector1.setSafe(i, 1000 + i); | |
235 | } | |
236 | ||
237 | vector1.setValueCount(initialCapacity); | |
238 | ||
239 | /* No realloc should have happened in setSafe or | |
240 | * setValueCount | |
241 | */ | |
242 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
243 | assertEquals(initialCapacity, vector1.getValueCount()); | |
244 | ||
245 | for (int i = 0; i < initialCapacity; i++) { | |
246 | if ((i & 1) == 0) { | |
247 | assertNull(vector1.getObject(i)); | |
248 | } else { | |
249 | assertEquals("unexpected value at index: " + i, 1000 + i, vector1.get(i)); | |
250 | } | |
251 | } | |
252 | ||
253 | /* set lesser initial capacity than actually needed | |
254 | * to trigger reallocs in copyFromSafe() | |
255 | */ | |
256 | vector2.allocateNew(initialCapacity / 4); | |
257 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
258 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
259 | ||
260 | for (int i = 0; i < initialCapacity; i++) { | |
261 | vector2.copyFromSafe(i, i, vector1); | |
262 | } | |
263 | ||
264 | /* 2 realloc should have happened in copyFromSafe() */ | |
265 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
266 | vector2.setValueCount(initialCapacity * 2); | |
267 | /* setValueCount() should have done another realloc */ | |
268 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
269 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
270 | ||
271 | /* check vector data after copy and realloc */ | |
272 | for (int i = 0; i < initialCapacity * 2; i++) { | |
273 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
274 | assertNull(vector2.getObject(i)); | |
275 | } else { | |
276 | assertEquals("unexpected value at index: " + i, 1000 + i, vector2.get(i)); | |
277 | } | |
278 | } | |
279 | } | |
280 | } | |
281 | ||
282 | @Test /* BigIntVector */ | |
283 | public void testCopyFromWithNulls3() { | |
284 | try (final BigIntVector vector1 = new BigIntVector(EMPTY_SCHEMA_PATH, allocator); | |
285 | final BigIntVector vector2 = new BigIntVector(EMPTY_SCHEMA_PATH, allocator)) { | |
286 | ||
287 | vector1.allocateNew(); | |
288 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
289 | assertEquals(0, vector1.getValueCount()); | |
290 | int initialCapacity = vector1.getValueCapacity(); | |
291 | ||
292 | for (int i = 0; i < initialCapacity; i++) { | |
293 | if ((i & 1) == 0) { | |
294 | continue; | |
295 | } | |
296 | vector1.setSafe(i, 10000000000L + (long) i); | |
297 | } | |
298 | ||
299 | vector1.setValueCount(initialCapacity); | |
300 | ||
301 | /* No realloc should have happened in setSafe or | |
302 | * setValueCount | |
303 | */ | |
304 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
305 | assertEquals(initialCapacity, vector1.getValueCount()); | |
306 | ||
307 | for (int i = 0; i < initialCapacity; i++) { | |
308 | if ((i & 1) == 0) { | |
309 | assertNull(vector1.getObject(i)); | |
310 | } else { | |
311 | assertEquals("unexpected value at index: " + i, 10000000000L + (long) i, vector1.get(i)); | |
312 | } | |
313 | } | |
314 | ||
315 | /* set lesser initial capacity than actually needed | |
316 | * to trigger reallocs in copyFromSafe() | |
317 | */ | |
318 | vector2.allocateNew(initialCapacity / 4); | |
319 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
320 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
321 | ||
322 | for (int i = 0; i < initialCapacity; i++) { | |
323 | vector2.copyFromSafe(i, i, vector1); | |
324 | } | |
325 | ||
326 | /* 2 realloc should have happened in copyFromSafe() */ | |
327 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
328 | vector2.setValueCount(initialCapacity * 2); | |
329 | /* setValueCount() should have done another realloc */ | |
330 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
331 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
332 | ||
333 | /* check vector data after copy and realloc */ | |
334 | for (int i = 0; i < initialCapacity * 2; i++) { | |
335 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
336 | assertNull(vector2.getObject(i)); | |
337 | } else { | |
338 | assertEquals("unexpected value at index: " + i, 10000000000L + (long) i, vector2.get(i)); | |
339 | } | |
340 | } | |
341 | } | |
342 | } | |
343 | ||
344 | @Test /* BitVector */ | |
345 | public void testCopyFromWithNulls4() { | |
346 | try (final BitVector vector1 = new BitVector(EMPTY_SCHEMA_PATH, allocator); | |
347 | final BitVector vector2 = new BitVector(EMPTY_SCHEMA_PATH, allocator)) { | |
348 | ||
349 | vector1.setInitialCapacity(4096); | |
350 | vector1.allocateNew(); | |
351 | assertEquals(4096, vector1.getValueCapacity()); | |
352 | assertEquals(0, vector1.getValueCount()); | |
353 | ||
354 | int counter = 0; | |
355 | for (int i = 0; i < 4096; i++) { | |
356 | if ((i & 1) == 0) { | |
357 | continue; | |
358 | } | |
359 | if ((counter & 1) == 0) { | |
360 | vector1.setSafe(i, 1); | |
361 | } else { | |
362 | vector1.setSafe(i, 0); | |
363 | } | |
364 | counter++; | |
365 | } | |
366 | ||
367 | vector1.setValueCount(4096); | |
368 | ||
369 | /* No realloc should have happened in setSafe or | |
370 | * setValueCount | |
371 | */ | |
372 | assertEquals(4096, vector1.getValueCapacity()); | |
373 | assertEquals(4096, vector1.getValueCount()); | |
374 | ||
375 | counter = 0; | |
376 | for (int i = 0; i < 4096; i++) { | |
377 | if ((i & 1) == 0) { | |
378 | assertNull(vector1.getObject(i)); | |
379 | } else { | |
380 | if ((counter & 1) == 0) { | |
381 | assertTrue(vector1.getObject(i)); | |
382 | } else { | |
383 | assertFalse(vector1.getObject(i)); | |
384 | } | |
385 | counter++; | |
386 | } | |
387 | } | |
388 | ||
389 | /* set lesser initial capacity than actually needed | |
390 | * to trigger reallocs in copyFromSafe() | |
391 | */ | |
392 | vector2.allocateNew(1024); | |
393 | assertEquals(1024, vector2.getValueCapacity()); | |
394 | ||
395 | for (int i = 0; i < 4096; i++) { | |
396 | vector2.copyFromSafe(i, i, vector1); | |
397 | } | |
398 | ||
399 | /* 2 realloc should have happened in copyFromSafe() */ | |
400 | assertEquals(4096, vector2.getValueCapacity()); | |
401 | vector2.setValueCount(8192); | |
402 | /* setValueCount() should have done another realloc */ | |
403 | assertEquals(8192, vector2.getValueCount()); | |
404 | assertEquals(8192, vector2.getValueCapacity()); | |
405 | ||
406 | /* check vector data after copy and realloc */ | |
407 | counter = 0; | |
408 | for (int i = 0; i < 8192; i++) { | |
409 | if (((i & 1) == 0) || (i >= 4096)) { | |
410 | assertNull(vector2.getObject(i)); | |
411 | } else { | |
412 | if ((counter & 1) == 0) { | |
413 | assertTrue(vector2.getObject(i)); | |
414 | } else { | |
415 | assertFalse(vector2.getObject(i)); | |
416 | } | |
417 | counter++; | |
418 | } | |
419 | } | |
420 | } | |
421 | } | |
422 | ||
423 | @Test /* Float4Vector */ | |
424 | public void testCopyFromWithNulls5() { | |
425 | try (final Float4Vector vector1 = new Float4Vector(EMPTY_SCHEMA_PATH, allocator); | |
426 | final Float4Vector vector2 = new Float4Vector(EMPTY_SCHEMA_PATH, allocator)) { | |
427 | ||
428 | vector1.allocateNew(); | |
429 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
430 | assertEquals(0, vector1.getValueCount()); | |
431 | int initialCapacity = vector1.getValueCapacity(); | |
432 | ||
433 | for (int i = 0; i < initialCapacity; i++) { | |
434 | if ((i & 1) == 0) { | |
435 | continue; | |
436 | } | |
437 | vector1.setSafe(i, 100.25f + (float) i); | |
438 | } | |
439 | ||
440 | vector1.setValueCount(initialCapacity); | |
441 | ||
442 | /* No realloc should have happened in setSafe or | |
443 | * setValueCount | |
444 | */ | |
445 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
446 | assertEquals(initialCapacity, vector1.getValueCount()); | |
447 | ||
448 | for (int i = 0; i < initialCapacity; i++) { | |
449 | if ((i & 1) == 0) { | |
450 | assertNull(vector1.getObject(i)); | |
451 | } else { | |
452 | assertEquals("unexpected value at index: " + i, 100.25f + (float) i, vector1.get(i), 0); | |
453 | } | |
454 | } | |
455 | ||
456 | /* set lesser initial capacity than actually needed | |
457 | * to trigger reallocs in copyFromSafe() | |
458 | */ | |
459 | vector2.allocateNew(initialCapacity / 4); | |
460 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
461 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
462 | ||
463 | for (int i = 0; i < initialCapacity; i++) { | |
464 | vector2.copyFromSafe(i, i, vector1); | |
465 | } | |
466 | ||
467 | /* 2 realloc should have happened in copyFromSafe() */ | |
468 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
469 | vector2.setValueCount(initialCapacity * 2); | |
470 | /* setValueCount() should have done another realloc */ | |
471 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
472 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
473 | ||
474 | /* check vector data after copy and realloc */ | |
475 | for (int i = 0; i < initialCapacity * 2; i++) { | |
476 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
477 | assertNull(vector2.getObject(i)); | |
478 | } else { | |
479 | assertEquals("unexpected value at index: " + i, 100.25f + i * 1.0f, vector2.get(i), 0); | |
480 | } | |
481 | } | |
482 | } | |
483 | } | |
484 | ||
485 | @Test /* Float8Vector */ | |
486 | public void testCopyFromWithNulls6() { | |
487 | try (final Float8Vector vector1 = new Float8Vector(EMPTY_SCHEMA_PATH, allocator); | |
488 | final Float8Vector vector2 = new Float8Vector(EMPTY_SCHEMA_PATH, allocator)) { | |
489 | ||
490 | vector1.allocateNew(); | |
491 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
492 | assertEquals(0, vector1.getValueCount()); | |
493 | int initialCapacity = vector1.getValueCapacity(); | |
494 | ||
495 | for (int i = 0; i < initialCapacity; i++) { | |
496 | if ((i & 1) == 0) { | |
497 | continue; | |
498 | } | |
499 | vector1.setSafe(i, 123456.7865 + (double) i); | |
500 | } | |
501 | ||
502 | vector1.setValueCount(initialCapacity); | |
503 | ||
504 | /* No realloc should have happened in setSafe or | |
505 | * setValueCount | |
506 | */ | |
507 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
508 | assertEquals(initialCapacity, vector1.getValueCount()); | |
509 | ||
510 | for (int i = 0; i < initialCapacity; i++) { | |
511 | if ((i & 1) == 0) { | |
512 | assertNull(vector1.getObject(i)); | |
513 | } else { | |
514 | assertEquals( | |
515 | "unexpected value at index: " + i, 123456.7865 + (double) i, vector1.get(i), 0); | |
516 | } | |
517 | } | |
518 | ||
519 | /* set lesser initial capacity than actually needed | |
520 | * to trigger reallocs in copyFromSafe() | |
521 | */ | |
522 | vector2.allocateNew(initialCapacity / 4); | |
523 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
524 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
525 | ||
526 | for (int i = 0; i < initialCapacity; i++) { | |
527 | vector2.copyFromSafe(i, i, vector1); | |
528 | } | |
529 | ||
530 | /* 2 realloc should have happened in copyFromSafe() */ | |
531 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
532 | vector2.setValueCount(initialCapacity * 2); | |
533 | /* setValueCount() should have done another realloc */ | |
534 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
535 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
536 | ||
537 | /* check vector data after copy and realloc */ | |
538 | for (int i = 0; i < initialCapacity * 2; i++) { | |
539 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
540 | assertNull(vector2.getObject(i)); | |
541 | } else { | |
542 | assertEquals( | |
543 | "unexpected value at index: " + i, 123456.7865 + (double) i, vector2.get(i), 0); | |
544 | } | |
545 | } | |
546 | } | |
547 | } | |
548 | ||
549 | @Test /* IntervalDayVector */ | |
550 | public void testCopyFromWithNulls7() { | |
551 | try (final IntervalDayVector vector1 = new IntervalDayVector(EMPTY_SCHEMA_PATH, allocator); | |
552 | final IntervalDayVector vector2 = new IntervalDayVector(EMPTY_SCHEMA_PATH, allocator)) { | |
553 | ||
554 | vector1.allocateNew(); | |
555 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
556 | assertEquals(0, vector1.getValueCount()); | |
557 | int initialCapacity = vector1.getValueCapacity(); | |
558 | ||
559 | final int days = 10; | |
560 | final int milliseconds = 10000; | |
561 | for (int i = 0; i < initialCapacity; i++) { | |
562 | if ((i & 1) == 0) { | |
563 | continue; | |
564 | } | |
565 | vector1.setSafe(i, days + i, milliseconds + i); | |
566 | } | |
567 | ||
568 | vector1.setValueCount(initialCapacity); | |
569 | ||
570 | /* No realloc should have happened in setSafe or | |
571 | * setValueCount | |
572 | */ | |
573 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
574 | assertEquals(initialCapacity, vector1.getValueCount()); | |
575 | ||
576 | for (int i = 0; i < initialCapacity; i++) { | |
577 | if ((i & 1) == 0) { | |
578 | assertNull(vector1.getObject(i)); | |
579 | } else { | |
580 | final Duration d = vector1.getObject(i); | |
581 | assertEquals(days + i, d.toDays()); | |
582 | assertEquals(milliseconds + i, d.minusDays(days + i).toMillis()); | |
583 | } | |
584 | } | |
585 | ||
586 | /* set lesser initial capacity than actually needed | |
587 | * to trigger reallocs in copyFromSafe() | |
588 | */ | |
589 | vector2.allocateNew(initialCapacity / 4); | |
590 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
591 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
592 | ||
593 | for (int i = 0; i < initialCapacity; i++) { | |
594 | vector2.copyFromSafe(i, i, vector1); | |
595 | } | |
596 | ||
597 | /* 2 realloc should have happened in copyFromSafe() */ | |
598 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
599 | vector2.setValueCount(initialCapacity * 2); | |
600 | /* setValueCount() should have done another realloc */ | |
601 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
602 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
603 | ||
604 | /* check vector data after copy and realloc */ | |
605 | for (int i = 0; i < initialCapacity * 2; i++) { | |
606 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
607 | assertNull(vector2.getObject(i)); | |
608 | } else { | |
609 | final Duration d = vector2.getObject(i); | |
610 | assertEquals(days + i, d.toDays()); | |
611 | assertEquals(milliseconds + i, d.minusDays(days + i).toMillis()); | |
612 | } | |
613 | } | |
614 | } | |
615 | } | |
616 | ||
617 | @Test /* IntervalYearVector */ | |
618 | public void testCopyFromWithNulls8() { | |
619 | try (final IntervalYearVector vector1 = new IntervalYearVector(EMPTY_SCHEMA_PATH, allocator); | |
620 | final IntervalYearVector vector2 = new IntervalYearVector(EMPTY_SCHEMA_PATH, allocator)) { | |
621 | ||
622 | vector1.allocateNew(); | |
623 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
624 | assertEquals(0, vector1.getValueCount()); | |
625 | int initialCapacity = vector1.getValueCapacity(); | |
626 | ||
627 | final int interval = 30; /* 2 years 6 months */ | |
628 | final Period[] periods = new Period[4096]; | |
629 | for (int i = 0; i < initialCapacity; i++) { | |
630 | if ((i & 1) == 0) { | |
631 | continue; | |
632 | } | |
633 | vector1.setSafe(i, interval + i); | |
634 | final int years = (interval + i) / org.apache.arrow.vector.util.DateUtility.yearsToMonths; | |
635 | final int months = (interval + i) % org.apache.arrow.vector.util.DateUtility.yearsToMonths; | |
636 | periods[i] = Period.ofYears(years).plusMonths(months).normalized(); | |
637 | } | |
638 | ||
639 | vector1.setValueCount(initialCapacity); | |
640 | ||
641 | /* No realloc should have happened in setSafe or | |
642 | * setValueCount | |
643 | */ | |
644 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
645 | assertEquals(initialCapacity, vector1.getValueCount()); | |
646 | ||
647 | for (int i = 0; i < initialCapacity; i++) { | |
648 | if ((i & 1) == 0) { | |
649 | assertNull(vector1.getObject(i)); | |
650 | } else { | |
651 | final Period p = vector1.getObject(i).normalized(); | |
652 | assertEquals(interval + i, vector1.get(i)); | |
653 | assertEquals(periods[i], p); | |
654 | } | |
655 | } | |
656 | ||
657 | /* set lesser initial capacity than actually needed | |
658 | * to trigger reallocs in copyFromSafe() | |
659 | */ | |
660 | vector2.allocateNew(initialCapacity / 4); | |
661 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
662 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
663 | ||
664 | for (int i = 0; i < initialCapacity; i++) { | |
665 | vector2.copyFromSafe(i, i, vector1); | |
666 | } | |
667 | ||
668 | /* 2 realloc should have happened in copyFromSafe() */ | |
669 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
670 | vector2.setValueCount(initialCapacity * 2); | |
671 | /* setValueCount() should have done another realloc */ | |
672 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
673 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
674 | ||
675 | /* check vector data after copy and realloc */ | |
676 | for (int i = 0; i < initialCapacity * 2; i++) { | |
677 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
678 | assertNull(vector2.getObject(i)); | |
679 | } else { | |
680 | final Period p = vector2.getObject(i).normalized(); | |
681 | assertEquals(periods[i], p); | |
682 | } | |
683 | } | |
684 | } | |
685 | } | |
686 | ||
687 | @Test /* SmallIntVector */ | |
688 | public void testCopyFromWithNulls9() { | |
689 | try (final SmallIntVector vector1 = new SmallIntVector(EMPTY_SCHEMA_PATH, allocator); | |
690 | final SmallIntVector vector2 = new SmallIntVector(EMPTY_SCHEMA_PATH, allocator)) { | |
691 | ||
692 | vector1.allocateNew(); | |
693 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
694 | assertEquals(0, vector1.getValueCount()); | |
695 | int initialCapacity = vector1.getValueCapacity(); | |
696 | ||
697 | final short val = 1000; | |
698 | for (int i = 0; i < initialCapacity; i++) { | |
699 | if ((i & 1) == 0) { | |
700 | continue; | |
701 | } | |
702 | vector1.setSafe(i, val + (short) i); | |
703 | } | |
704 | ||
705 | vector1.setValueCount(initialCapacity); | |
706 | ||
707 | /* No realloc should have happened in setSafe or | |
708 | * setValueCount | |
709 | */ | |
710 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
711 | assertEquals(initialCapacity, vector1.getValueCount()); | |
712 | ||
713 | for (int i = 0; i < initialCapacity; i++) { | |
714 | if ((i & 1) == 0) { | |
715 | assertNull(vector1.getObject(i)); | |
716 | } else { | |
717 | assertEquals("unexpected value at index: " + i, val + (short) i, vector1.get(i)); | |
718 | } | |
719 | } | |
720 | ||
721 | /* set lesser initial capacity than actually needed | |
722 | * to trigger reallocs in copyFromSafe() | |
723 | */ | |
724 | vector2.allocateNew(initialCapacity / 4); | |
725 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
726 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
727 | ||
728 | for (int i = 0; i < initialCapacity; i++) { | |
729 | vector2.copyFromSafe(i, i, vector1); | |
730 | } | |
731 | ||
732 | /* 2 realloc should have happened in copyFromSafe() */ | |
733 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
734 | vector2.setValueCount(initialCapacity * 2); | |
735 | /* setValueCount() should have done another realloc */ | |
736 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
737 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
738 | ||
739 | /* check vector data after copy and realloc */ | |
740 | for (int i = 0; i < initialCapacity * 2; i++) { | |
741 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
742 | assertNull(vector2.getObject(i)); | |
743 | } else { | |
744 | assertEquals("unexpected value at index: " + i, val + (short) i, vector2.get(i)); | |
745 | } | |
746 | } | |
747 | } | |
748 | } | |
749 | ||
750 | @Test /* TimeMicroVector */ | |
751 | public void testCopyFromWithNulls10() { | |
752 | try (final TimeMicroVector vector1 = new TimeMicroVector(EMPTY_SCHEMA_PATH, allocator); | |
753 | final TimeMicroVector vector2 = new TimeMicroVector(EMPTY_SCHEMA_PATH, allocator)) { | |
754 | ||
755 | vector1.allocateNew(); | |
756 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
757 | assertEquals(0, vector1.getValueCount()); | |
758 | int initialCapacity = vector1.getValueCapacity(); | |
759 | ||
760 | final long val = 100485765432L; | |
761 | for (int i = 0; i < initialCapacity; i++) { | |
762 | if ((i & 1) == 0) { | |
763 | continue; | |
764 | } | |
765 | vector1.setSafe(i, val + (long) i); | |
766 | } | |
767 | ||
768 | vector1.setValueCount(initialCapacity); | |
769 | ||
770 | /* No realloc should have happened in setSafe or | |
771 | * setValueCount | |
772 | */ | |
773 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
774 | assertEquals(initialCapacity, vector1.getValueCount()); | |
775 | ||
776 | for (int i = 0; i < initialCapacity; i++) { | |
777 | if ((i & 1) == 0) { | |
778 | assertNull(vector1.getObject(i)); | |
779 | } else { | |
780 | assertEquals("unexpected value at index: " + i, val + (long) i, vector1.get(i)); | |
781 | } | |
782 | } | |
783 | ||
784 | /* set lesser initial capacity than actually needed | |
785 | * to trigger reallocs in copyFromSafe() | |
786 | */ | |
787 | vector2.allocateNew(initialCapacity / 4); | |
788 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
789 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
790 | ||
791 | for (int i = 0; i < initialCapacity; i++) { | |
792 | vector2.copyFromSafe(i, i, vector1); | |
793 | } | |
794 | ||
795 | /* 2 realloc should have happened in copyFromSafe() */ | |
796 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
797 | vector2.setValueCount(initialCapacity * 2); | |
798 | /* setValueCount() should have done another realloc */ | |
799 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
800 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
801 | ||
802 | /* check vector data after copy and realloc */ | |
803 | for (int i = 0; i < initialCapacity * 2; i++) { | |
804 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
805 | assertNull(vector2.getObject(i)); | |
806 | } else { | |
807 | assertEquals("unexpected value at index: " + i, val + (long) i, vector2.get(i)); | |
808 | } | |
809 | } | |
810 | } | |
811 | } | |
812 | ||
813 | @Test /* TimeMilliVector */ | |
814 | public void testCopyFromWithNulls11() { | |
815 | try (final TimeMilliVector vector1 = new TimeMilliVector(EMPTY_SCHEMA_PATH, allocator); | |
816 | final TimeMilliVector vector2 = new TimeMilliVector(EMPTY_SCHEMA_PATH, allocator)) { | |
817 | ||
818 | vector1.allocateNew(); | |
819 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
820 | assertEquals(0, vector1.getValueCount()); | |
821 | int initialCapacity = vector1.getValueCapacity(); | |
822 | ||
823 | final int val = 1000; | |
824 | for (int i = 0; i < initialCapacity; i++) { | |
825 | if ((i & 1) == 0) { | |
826 | continue; | |
827 | } | |
828 | vector1.setSafe(i, val + i); | |
829 | } | |
830 | ||
831 | vector1.setValueCount(initialCapacity); | |
832 | ||
833 | /* No realloc should have happened in setSafe or | |
834 | * setValueCount | |
835 | */ | |
836 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
837 | assertEquals(initialCapacity, vector1.getValueCount()); | |
838 | ||
839 | for (int i = 0; i < initialCapacity; i++) { | |
840 | if ((i & 1) == 0) { | |
841 | assertNull(vector1.getObject(i)); | |
842 | } else { | |
843 | assertEquals("unexpected value at index: " + i, val + i, vector1.get(i)); | |
844 | } | |
845 | } | |
846 | ||
847 | /* set lesser initial capacity than actually needed | |
848 | * to trigger reallocs in copyFromSafe() | |
849 | */ | |
850 | vector2.allocateNew(initialCapacity / 4); | |
851 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
852 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
853 | ||
854 | for (int i = 0; i < initialCapacity; i++) { | |
855 | vector2.copyFromSafe(i, i, vector1); | |
856 | } | |
857 | ||
858 | /* 2 realloc should have happened in copyFromSafe() */ | |
859 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
860 | vector2.setValueCount(initialCapacity * 2); | |
861 | /* setValueCount() should have done another realloc */ | |
862 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
863 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
864 | ||
865 | /* check vector data after copy and realloc */ | |
866 | for (int i = 0; i < initialCapacity * 2; i++) { | |
867 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
868 | assertNull(vector2.getObject(i)); | |
869 | } else { | |
870 | assertEquals("unexpected value at index: " + i, val + i, vector2.get(i)); | |
871 | } | |
872 | } | |
873 | } | |
874 | } | |
875 | ||
876 | @Test /* TinyIntVector */ | |
877 | public void testCopyFromWithNulls12() { | |
878 | try (final TinyIntVector vector1 = new TinyIntVector(EMPTY_SCHEMA_PATH, allocator); | |
879 | final TinyIntVector vector2 = new TinyIntVector(EMPTY_SCHEMA_PATH, allocator)) { | |
880 | ||
881 | vector1.allocateNew(); | |
882 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
883 | assertEquals(0, vector1.getValueCount()); | |
884 | int initialCapacity = vector1.getValueCapacity(); | |
885 | ||
886 | byte val = -128; | |
887 | for (int i = 0; i < initialCapacity; i++) { | |
888 | if ((i & 1) == 0) { | |
889 | continue; | |
890 | } | |
891 | vector1.setSafe(i, val); | |
892 | val++; | |
893 | } | |
894 | ||
895 | vector1.setValueCount(initialCapacity); | |
896 | ||
897 | /* No realloc should have happened in setSafe or | |
898 | * setValueCount | |
899 | */ | |
900 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
901 | assertEquals(initialCapacity, vector1.getValueCount()); | |
902 | ||
903 | val = -128; | |
904 | for (int i = 0; i < initialCapacity; i++) { | |
905 | if ((i & 1) == 0) { | |
906 | assertNull(vector1.getObject(i)); | |
907 | } else { | |
908 | assertEquals("unexpected value at index: " + i, val, vector1.get(i)); | |
909 | val++; | |
910 | } | |
911 | } | |
912 | ||
913 | /* set lesser initial capacity than actually needed | |
914 | * to trigger reallocs in copyFromSafe() | |
915 | */ | |
916 | vector2.allocateNew(initialCapacity / 4); | |
917 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
918 | ||
919 | for (int i = 0; i < initialCapacity; i++) { | |
920 | vector2.copyFromSafe(i, i, vector1); | |
921 | } | |
922 | ||
923 | /* 2 realloc should have happened in copyFromSafe() */ | |
924 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
925 | vector2.setValueCount(initialCapacity * 2); | |
926 | /* setValueCount() should have done another realloc */ | |
927 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
928 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
929 | ||
930 | /* check vector data after copy and realloc */ | |
931 | val = -128; | |
932 | for (int i = 0; i < initialCapacity * 2; i++) { | |
933 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
934 | assertNull(vector2.getObject(i)); | |
935 | } else { | |
936 | assertEquals("unexpected value at index: " + i, val, vector2.get(i)); | |
937 | val++; | |
938 | } | |
939 | } | |
940 | } | |
941 | } | |
942 | ||
943 | @Test /* DecimalVector */ | |
944 | public void testCopyFromWithNulls13() { | |
945 | try (final DecimalVector vector1 = new DecimalVector(EMPTY_SCHEMA_PATH, allocator, 30, 16); | |
946 | final DecimalVector vector2 = new DecimalVector(EMPTY_SCHEMA_PATH, allocator, 30, 16)) { | |
947 | ||
948 | vector1.allocateNew(); | |
949 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
950 | assertEquals(0, vector1.getValueCount()); | |
951 | int initialCapacity = vector1.getValueCapacity(); | |
952 | ||
953 | final double baseValue = 104567897654.876543654; | |
954 | final BigDecimal[] decimals = new BigDecimal[4096]; | |
955 | for (int i = 0; i < initialCapacity; i++) { | |
956 | if ((i & 1) == 0) { | |
957 | continue; | |
958 | } | |
959 | BigDecimal decimal = new BigDecimal(baseValue + (double) i); | |
960 | vector1.setSafe(i, decimal); | |
961 | decimals[i] = decimal; | |
962 | } | |
963 | ||
964 | vector1.setValueCount(initialCapacity); | |
965 | ||
966 | /* No realloc should have happened in setSafe or | |
967 | * setValueCount | |
968 | */ | |
969 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
970 | assertEquals(initialCapacity, vector1.getValueCount()); | |
971 | ||
972 | for (int i = 0; i < initialCapacity; i++) { | |
973 | if ((i & 1) == 0) { | |
974 | assertNull(vector1.getObject(i)); | |
975 | } else { | |
976 | final BigDecimal decimal = vector1.getObject(i); | |
977 | assertEquals(decimals[i], decimal); | |
978 | } | |
979 | } | |
980 | ||
981 | /* set lesser initial capacity than actually needed | |
982 | * to trigger reallocs in copyFromSafe() | |
983 | */ | |
984 | vector2.allocateNew(initialCapacity / 4); | |
985 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
986 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
987 | ||
988 | for (int i = 0; i < initialCapacity; i++) { | |
989 | vector2.copyFromSafe(i, i, vector1); | |
990 | } | |
991 | ||
992 | /* 2 realloc should have happened in copyFromSafe() */ | |
993 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
994 | vector2.setValueCount(initialCapacity * 2); | |
995 | /* setValueCount() should have done another realloc */ | |
996 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
997 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
998 | ||
999 | /* check vector data after copy and realloc */ | |
1000 | for (int i = 0; i < initialCapacity * 2; i++) { | |
1001 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
1002 | assertNull(vector2.getObject(i)); | |
1003 | } else { | |
1004 | final BigDecimal decimal = vector2.getObject(i); | |
1005 | assertEquals(decimals[i], decimal); | |
1006 | } | |
1007 | } | |
1008 | } | |
1009 | } | |
1010 | ||
1011 | @Test /* TimeStampVector */ | |
1012 | public void testCopyFromWithNulls14() { | |
1013 | try (final TimeStampVector vector1 = new TimeStampMicroVector(EMPTY_SCHEMA_PATH, allocator); | |
1014 | final TimeStampVector vector2 = new TimeStampMicroVector(EMPTY_SCHEMA_PATH, allocator)) { | |
1015 | ||
1016 | vector1.allocateNew(); | |
1017 | assertTrue(vector1.getValueCapacity() >= vector1.INITIAL_VALUE_ALLOCATION); | |
1018 | assertEquals(0, vector1.getValueCount()); | |
1019 | int initialCapacity = vector1.getValueCapacity(); | |
1020 | ||
1021 | final long val = 20145678912L; | |
1022 | for (int i = 0; i < initialCapacity; i++) { | |
1023 | if ((i & 1) == 0) { | |
1024 | continue; | |
1025 | } | |
1026 | vector1.setSafe(i, val + (long) i); | |
1027 | } | |
1028 | ||
1029 | vector1.setValueCount(initialCapacity); | |
1030 | ||
1031 | /* No realloc should have happened in setSafe or | |
1032 | * setValueCount | |
1033 | */ | |
1034 | assertEquals(initialCapacity, vector1.getValueCapacity()); | |
1035 | assertEquals(initialCapacity, vector1.getValueCount()); | |
1036 | ||
1037 | for (int i = 0; i < initialCapacity; i++) { | |
1038 | if ((i & 1) == 0) { | |
1039 | assertNull(vector1.getObject(i)); | |
1040 | } else { | |
1041 | assertEquals("unexpected value at index: " + i, val + (long) i, vector1.get(i)); | |
1042 | } | |
1043 | } | |
1044 | ||
1045 | /* set lesser initial capacity than actually needed | |
1046 | * to trigger reallocs in copyFromSafe() | |
1047 | */ | |
1048 | vector2.allocateNew(initialCapacity / 4); | |
1049 | assertTrue(vector2.getValueCapacity() >= initialCapacity / 4); | |
1050 | assertTrue(vector2.getValueCapacity() < initialCapacity / 2); | |
1051 | ||
1052 | for (int i = 0; i < initialCapacity; i++) { | |
1053 | vector2.copyFromSafe(i, i, vector1); | |
1054 | } | |
1055 | ||
1056 | /* 2 realloc should have happened in copyFromSafe() */ | |
1057 | assertTrue(vector2.getValueCapacity() >= initialCapacity); | |
1058 | vector2.setValueCount(initialCapacity * 2); | |
1059 | /* setValueCount() should have done another realloc */ | |
1060 | assertEquals(initialCapacity * 2, vector2.getValueCount()); | |
1061 | assertTrue(vector2.getValueCapacity() >= initialCapacity * 2); | |
1062 | ||
1063 | /* check vector data after copy and realloc */ | |
1064 | for (int i = 0; i < initialCapacity * 2; i++) { | |
1065 | if (((i & 1) == 0) || (i >= initialCapacity)) { | |
1066 | assertNull(vector2.getObject(i)); | |
1067 | } else { | |
1068 | assertEquals("unexpected value at index: " + i, val + (long) i, vector2.get(i)); | |
1069 | } | |
1070 | } | |
1071 | } | |
1072 | } | |
1073 | ||
1074 | @Test //https://issues.apache.org/jira/browse/ARROW-7837 | |
1075 | public void testCopySafeArrow7837() { | |
1076 | // this test exposes a bug in `handleSafe` where | |
1077 | // it reads a stale index and as a result missed a required resize of the value vector. | |
1078 | try (VarCharVector vc1 = new VarCharVector("vc1", allocator); | |
1079 | VarCharVector vc2 = new VarCharVector("vc2", allocator); | |
1080 | ) { | |
1081 | //initial size is carefully set in order to force the second 'copyFromSafe' operation | |
1082 | // to trigger a reallocation of the vector. | |
1083 | vc2.setInitialCapacity(/*valueCount*/20, /*density*/0.5); | |
1084 | ||
1085 | vc1.setSafe(0, "1234567890".getBytes(Charset.forName("utf-8"))); | |
1086 | assertFalse(vc1.isNull(0)); | |
1087 | assertEquals(vc1.getObject(0).toString(), "1234567890"); | |
1088 | ||
1089 | vc2.copyFromSafe(0, 0, vc1); | |
1090 | assertFalse(vc2.isNull(0)); | |
1091 | assertEquals(vc2.getObject(0).toString(), "1234567890"); | |
1092 | ||
1093 | vc2.copyFromSafe(0, 5, vc1); | |
1094 | assertTrue(vc2.isNull(1)); | |
1095 | assertTrue(vc2.isNull(2)); | |
1096 | assertTrue(vc2.isNull(3)); | |
1097 | assertTrue(vc2.isNull(4)); | |
1098 | assertFalse(vc2.isNull(5)); | |
1099 | assertEquals(vc2.getObject(5).toString(), "1234567890"); | |
1100 | } | |
1101 | } | |
1102 | ||
1103 | ||
1104 | } |