Debian Codegraph @

lib/Alembic/AbcCoreHDF5/Tests/ArrayPropertyTests.cpp

raw
1 //-*****************************************************************************
2 //
3 // Copyright (c) 2009-2012,
4 // Sony Pictures Imageworks Inc. and
5 // Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
6 //
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are
11 // met:
12 // * Redistributions of source code must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 // * Redistributions in binary form must reproduce the above
15 // copyright notice, this list of conditions and the following disclaimer
16 // in the documentation and/or other materials provided with the
17 // distribution.
18 // * Neither the name of Sony Pictures Imageworks, nor
19 // Industrial Light & Magic, nor the names of their contributors may be used
20 // to endorse or promote products derived from this software without specific
21 // prior written permission.
22 //
23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 //
35 //-*****************************************************************************
36
37 #include <Alembic/AbcCoreAbstract/All.h>
38 #include <Alembic/AbcCoreHDF5/All.h>
39 #include <Alembic/Util/All.h>
40
41 #include <Alembic/AbcCoreAbstract/Tests/Assert.h>
42
43 #include <iostream>
44 #include <vector>
45
46 #include <hdf5.h>
47
48 //-*****************************************************************************
49 namespace A5 = Alembic::AbcCoreHDF5;
50
51 namespace ABCA = Alembic::AbcCoreAbstract;
52
53 using namespace Alembic::Util;
54
55 //-*****************************************************************************
56 void testDuplicateArray()
57 {
58 std::string archiveName = "repeatArray.abc";
59
60 size_t numVals = 35;
61
62 {
63 A5::WriteArchive w;
64 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
65 ABCA::ObjectWriterPtr archive = a->getTop();
66
67 ABCA::CompoundPropertyWriterPtr parent = archive->getProperties();
68
69 ABCA::ArrayPropertyWriterPtr awp =
70 parent->createArrayProperty("a", ABCA::MetaData(),
71 ABCA::DataType(Alembic::Util::kInt16POD, 1), 0);
72
73 ABCA::ArrayPropertyWriterPtr bwp =
74 parent->createArrayProperty("b", ABCA::MetaData(),
75 ABCA::DataType(Alembic::Util::kInt16POD, 1), 0);
76
77 ABCA::ArrayPropertyWriterPtr cwp =
78 parent->createArrayProperty("c", ABCA::MetaData(),
79 ABCA::DataType(Alembic::Util::kInt8POD, 1), 0);
80
81 Alembic::Util::Dimensions dims(numVals);
82 ABCA::DataType i16d(Alembic::Util::kInt16POD, 1);
83 std::vector <Alembic::Util::int16_t> vali(numVals, 0);
84 vali[0] = 7;
85 vali[1] = 7;
86 vali[2] = 7;
87
88 awp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
89
90 vali[0] = 8;
91 vali[1] = 16;
92 vali[2] = 32;
93 awp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
94
95 vali[0] = 7;
96 vali[1] = 7;
97 vali[2] = 7;
98 awp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
99
100 // lets write b and make sure it shares
101 vali[0] = 8;
102 vali[1] = 16;
103 vali[2] = 32;
104 bwp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
105
106 vali[0] = 7;
107 vali[1] = 7;
108 vali[2] = 7;
109 bwp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
110
111 vali[0] = 8;
112 vali[1] = 16;
113 vali[2] = 32;
114 bwp->setSample(ABCA::ArraySample(&(vali.front()), i16d, dims));
115
116 // c shouldn't share because it's pod type and extent is different
117 std::vector <Alembic::Util::int8_t> vals(numVals*2);
118 ABCA::DataType i8d(Alembic::Util::kInt8POD, 1);
119
120 vals[0] = 8;
121 vals[1] = 0;
122 vals[2] = 16;
123 vals[3] = 0;
124 vals[4] = 32;
125 vals[5] = 0;
126 dims = Alembic::Util::Dimensions(numVals*2);
127 cwp->setSample(ABCA::ArraySample(&(vals.front()), i8d, dims));
128
129
130 vals[0] = 7;
131 vals[1] = 0;
132 vals[2] = 7;
133 vals[3] = 0;
134 vals[4] = 7;
135 vals[5] = 0;
136 cwp->setSample(ABCA::ArraySample(&(vals.front()), i8d, dims));
137 cwp->setSample(ABCA::ArraySample(&(vals.front()), i8d, dims));
138 }
139
140 {
141 A5::ReadArchive r;
142 ABCA::ArchiveReaderPtr a = r( archiveName );
143 ABCA::ObjectReaderPtr archive = a->getTop();
144 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
145
146 TESTING_ASSERT(parent->getNumProperties() == 3);
147 for (size_t i = 0; i < parent->getNumProperties(); ++i)
148 {
149 ABCA::BasePropertyReaderPtr bp = parent->getProperty( i );
150 TESTING_ASSERT(bp->isArray());
151 ABCA::ArrayPropertyReaderPtr ap = bp->asArrayPtr();
152 TESTING_ASSERT(ap->getNumSamples() == 3);
153
154
155 if (ap->getName() == "a")
156 {
157 Dimensions dims0;
158 Dimensions dims1;
159 Dimensions dims2;
160 ap->getDimensions(0, dims0);
161 ap->getDimensions(1, dims1);
162 ap->getDimensions(2, dims2);
163
164 TESTING_ASSERT(dims0.numPoints() == numVals);
165 TESTING_ASSERT(dims1.numPoints() == numVals);
166 TESTING_ASSERT(dims2.numPoints() == numVals);
167
168 ABCA::ArraySamplePtr samp0;
169 ABCA::ArraySamplePtr samp1;
170 ABCA::ArraySamplePtr samp2;
171 ap->getSample(0, samp0);
172 ap->getSample(1, samp1);
173 ap->getSample(2, samp2);
174
175 TESTING_ASSERT(samp0->getDimensions().numPoints() == numVals);
176 TESTING_ASSERT(samp1->getDimensions().numPoints() == numVals);
177 TESTING_ASSERT(samp2->getDimensions().numPoints() == numVals);
178
179 Alembic::Util::int16_t * data = (Alembic::Util::int16_t *)(samp0->getData());
180 TESTING_ASSERT(data[0] == 7);
181 TESTING_ASSERT(data[1] == 7);
182 TESTING_ASSERT(data[2] == 7);
183 for (size_t j = 3; j < numVals; ++j)
184 {
185 TESTING_ASSERT(data[j] == 0);
186 }
187
188 data = (Alembic::Util::int16_t *)(samp1->getData());
189 TESTING_ASSERT(data[0] == 8);
190 TESTING_ASSERT(data[1] == 16);
191 TESTING_ASSERT(data[2] == 32);
192 for (size_t j = 3; j < numVals; ++j)
193 {
194 TESTING_ASSERT(data[j] == 0);
195 }
196
197 data = (Alembic::Util::int16_t *)(samp2->getData());
198 TESTING_ASSERT(data[0] == 7);
199 TESTING_ASSERT(data[1] == 7);
200 TESTING_ASSERT(data[2] == 7);
201 for (size_t j = 3; j < numVals; ++j)
202 {
203 TESTING_ASSERT(data[j] == 0);
204 }
205 }
206 else if (ap->getName() == "b")
207 {
208 ABCA::ArraySamplePtr samp0;
209 ABCA::ArraySamplePtr samp1;
210 ABCA::ArraySamplePtr samp2;
211 ap->getSample(0, samp0);
212 ap->getSample(1, samp1);
213 ap->getSample(2, samp2);
214
215 TESTING_ASSERT(samp0->getDimensions().numPoints() == numVals);
216 TESTING_ASSERT(samp1->getDimensions().numPoints() == numVals);
217 TESTING_ASSERT(samp2->getDimensions().numPoints() == numVals);
218
219 Dimensions dims0;
220 Dimensions dims1;
221 Dimensions dims2;
222 ap->getDimensions(0, dims0);
223 ap->getDimensions(1, dims1);
224 ap->getDimensions(2, dims2);
225
226 TESTING_ASSERT(dims0.numPoints() == numVals);
227 TESTING_ASSERT(dims1.numPoints() == numVals);
228 TESTING_ASSERT(dims2.numPoints() == numVals);
229
230 Alembic::Util::int16_t * data = (Alembic::Util::int16_t *)(samp0->getData());
231 TESTING_ASSERT(data[0] == 8);
232 TESTING_ASSERT(data[1] == 16);
233 TESTING_ASSERT(data[2] == 32);
234 for (size_t j = 3; j < numVals; ++j)
235 {
236 TESTING_ASSERT(data[j] == 0);
237 }
238
239 data = (Alembic::Util::int16_t *)(samp1->getData());
240 TESTING_ASSERT(data[0] == 7);
241 TESTING_ASSERT(data[1] == 7);
242 TESTING_ASSERT(data[2] == 7);
243 for (size_t j = 3; j < numVals; ++j)
244 {
245 TESTING_ASSERT(data[j] == 0);
246 }
247
248 data = (Alembic::Util::int16_t *)(samp2->getData());
249 TESTING_ASSERT(data[0] == 8);
250 TESTING_ASSERT(data[1] == 16);
251 TESTING_ASSERT(data[2] == 32);
252 for (size_t j = 3; j < numVals; ++j)
253 {
254 TESTING_ASSERT(data[j] == 0);
255 }
256 }
257 else if (ap->getName() == "c")
258 {
259 ABCA::ArraySamplePtr samp0;
260 ABCA::ArraySamplePtr samp1;
261 ABCA::ArraySamplePtr samp2;
262 ap->getSample(0, samp0);
263 ap->getSample(1, samp1);
264 ap->getSample(2, samp2);
265
266 TESTING_ASSERT(samp0->getDimensions().numPoints() == numVals*2);
267 TESTING_ASSERT(samp1->getDimensions().numPoints() == numVals*2);
268 TESTING_ASSERT(samp2->getDimensions().numPoints() == numVals*2);
269
270 Dimensions dims0;
271 Dimensions dims1;
272 Dimensions dims2;
273 ap->getDimensions(0, dims0);
274 ap->getDimensions(1, dims1);
275 ap->getDimensions(2, dims2);
276
277 TESTING_ASSERT(dims0.numPoints() == numVals*2);
278 TESTING_ASSERT(dims1.numPoints() == numVals*2);
279 TESTING_ASSERT(dims2.numPoints() == numVals*2);
280
281 Alembic::Util::int8_t * data = (Alembic::Util::int8_t *)(samp0->getData());
282 TESTING_ASSERT(data[0] == 8);
283 TESTING_ASSERT(data[1] == 0);
284 TESTING_ASSERT(data[2] == 16);
285 TESTING_ASSERT(data[3] == 0);
286 TESTING_ASSERT(data[4] == 32);
287 TESTING_ASSERT(data[5] == 0);
288 for (size_t j = 6; j < numVals*2; ++j)
289 {
290 TESTING_ASSERT(data[j] == 0);
291 }
292
293 data = (Alembic::Util::int8_t *)(samp1->getData());
294 TESTING_ASSERT(data[0] == 7);
295 TESTING_ASSERT(data[1] == 0);
296 TESTING_ASSERT(data[2] == 7);
297 TESTING_ASSERT(data[3] == 0);
298 TESTING_ASSERT(data[4] == 7);
299 TESTING_ASSERT(data[5] == 0);
300 for (size_t j = 6; j < numVals*2; ++j)
301 {
302 TESTING_ASSERT(data[j] == 0);
303 }
304
305 data = (Alembic::Util::int8_t *)(samp2->getData());
306 TESTING_ASSERT(data[0] == 7);
307 TESTING_ASSERT(data[1] == 0);
308 TESTING_ASSERT(data[2] == 7);
309 TESTING_ASSERT(data[3] == 0);
310 TESTING_ASSERT(data[4] == 7);
311 TESTING_ASSERT(data[5] == 0);
312 for (size_t j = 6; j < numVals*2; ++j)
313 {
314 TESTING_ASSERT(data[j] == 0);
315 }
316 }
317 }
318 }
319 }
320
321 //-*****************************************************************************
322 void testReadWriteArrays()
323 {
324
325 std::string archiveName = "arrayProperties.abc";
326
327 {
328 A5::WriteArchive w;
329 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
330 ABCA::ObjectWriterPtr archive = a->getTop();
331
332 ABCA::CompoundPropertyWriterPtr props = archive->getProperties();
333
334 {
335 ABCA::DataType dtype(Alembic::Util::kUint8POD, 1);
336 TESTING_ASSERT_THROW(props->createArrayProperty("/slashy",
337 ABCA::MetaData(), dtype, 0 ), Alembic::Util::Exception);
338 }
339
340 {
341 ABCA::DataType dtype(Alembic::Util::kBooleanPOD, 1);
342 ABCA::ArrayPropertyWriterPtr boolWrtPtr =
343 props->createArrayProperty("bool", ABCA::MetaData(), dtype, 0 );
344
345
346 std::vector < Alembic::Util::bool_t > vals(3);
347 vals[0] = false;
348 vals[1] = true;
349 vals[2] = false;
350 Alembic::Util::Dimensions dims(vals.size());
351 boolWrtPtr->setSample(
352 ABCA::ArraySample(&(vals.front()), dtype, dims));
353 }
354
355
356 {
357 ABCA::DataType dtype(Alembic::Util::kUint8POD, 1);
358 ABCA::ArrayPropertyWriterPtr uint8WrtPtr =
359 props->createArrayProperty("uint8", ABCA::MetaData(), dtype, 0);
360
361 std::vector< Alembic::Util::uint8_t > vals(4);
362 vals[0] = 200;
363 vals[1] = 45;
364 vals[2] = 37;
365 vals[3] = 192;
366
367 TESTING_ASSERT(uint8WrtPtr->getNumSamples() == 0);
368 Alembic::Util::Dimensions dims(vals.size());
369 uint8WrtPtr->setSample(
370 ABCA::ArraySample(&(vals.front()), dtype, dims));
371 TESTING_ASSERT(uint8WrtPtr->getNumSamples() == 1);
372 }
373
374 {
375 ABCA::DataType dtype(Alembic::Util::kUint8POD, 1);
376 ABCA::ArrayPropertyWriterPtr uint8WrtPtr =
377 props->createArrayProperty("uint8_newDims",
378 ABCA::MetaData(), dtype, 0);
379
380 std::vector< Alembic::Util::uint8_t > vals(4);
381 vals[0] = 200;
382 vals[1] = 45;
383 vals[2] = 37;
384 vals[3] = 192;
385
386 TESTING_ASSERT(uint8WrtPtr->getNumSamples() == 0);
387 Alembic::Util::Dimensions dims;
388 dims.setRank(2);
389 dims[0] = 2;
390 dims[1] = 2;
391 uint8WrtPtr->setSample(
392 ABCA::ArraySample(&(vals.front()), dtype, dims));
393 TESTING_ASSERT(uint8WrtPtr->getNumSamples() == 1);
394 }
395
396 {
397 ABCA::DataType dtype(Alembic::Util::kInt8POD, 1);
398 ABCA::ArrayPropertyWriterPtr charWrtPtr =
399 props->createArrayProperty("int8", ABCA::MetaData(), dtype, 0 );
400
401 std::vector < Alembic::Util::int8_t > vals(2);
402 vals[0] = -20;
403 vals[1] = 45;
404
405 Alembic::Util::Dimensions dims(vals.size());
406 charWrtPtr->setSample(
407 ABCA::ArraySample(&(vals.front()), dtype, dims));
408 }
409
410 {
411 ABCA::DataType dtype(Alembic::Util::kUint16POD, 1);
412 ABCA::ArrayPropertyWriterPtr uint16WrtPtr =
413 props->createArrayProperty("uint16", ABCA::MetaData(),
414 ABCA::DataType(Alembic::Util::kUint16POD, 1), 0 );
415
416 std::vector < Alembic::Util::uint16_t > vals(3);
417 vals[0] = 60000;
418 vals[1] = 2;
419 vals[2] = 3987;
420
421 Alembic::Util::Dimensions dims(vals.size());
422 uint16WrtPtr->setSample(
423 ABCA::ArraySample(&(vals.front()), dtype, dims));
424
425 }
426
427 {
428 ABCA::DataType dtype(Alembic::Util::kInt16POD, 1);
429 ABCA::ArrayPropertyWriterPtr int16WrtPtr =
430 props->createArrayProperty("int16", ABCA::MetaData(),
431 dtype, 0);
432 std::vector < Alembic::Util::int16_t > vals(2);
433 vals[0] = -20000;
434 vals[1] = 77;
435 Alembic::Util::Dimensions dims(vals.size());
436 int16WrtPtr->setSample(
437 ABCA::ArraySample(&(vals.front()), dtype, dims));
438 }
439
440 {
441 ABCA::DataType dtype(Alembic::Util::kUint32POD, 1);
442 ABCA::ArrayPropertyWriterPtr uint32WrtPtr =
443 props->createArrayProperty("uint32", ABCA::MetaData(), dtype,
444 0);
445
446 std::vector < Alembic::Util::uint32_t > vals(1);
447 vals[0] = 1000000;
448
449 Alembic::Util::Dimensions dims(vals.size());
450 uint32WrtPtr->setSample(
451 ABCA::ArraySample(&(vals.front()), dtype, dims));
452 }
453
454 {
455 ABCA::DataType dtype(Alembic::Util::kInt32POD, 1);
456 ABCA::ArrayPropertyWriterPtr int32WrtPtr =
457 props->createArrayProperty("int32", ABCA::MetaData(), dtype, 0);
458 std::vector < Alembic::Util::int32_t > vals(4);
459 vals[0] = -1000000;
460 vals[1] = 42;
461 vals[2] = -20000;
462 vals[3] = 123456;
463
464 Alembic::Util::Dimensions dims(vals.size());
465 int32WrtPtr->setSample(
466 ABCA::ArraySample(&(vals.front()), dtype, dims));
467 }
468
469 {
470 ABCA::DataType dtype(Alembic::Util::kUint64POD, 1);
471 ABCA::ArrayPropertyWriterPtr ui64WrtPtr =
472 props->createArrayProperty("uint64", ABCA::MetaData(), dtype, 0);
473 std::vector < Alembic::Util::uint64_t > vals(3);
474 vals[0] = 5000000000LL;
475 vals[1] = 1234567891011LL;
476 vals[2] = 12;
477
478 Alembic::Util::Dimensions dims(vals.size());
479 ui64WrtPtr->setSample(
480 ABCA::ArraySample(&(vals.front()), dtype, dims));
481 }
482
483 {
484 ABCA::DataType dtype(Alembic::Util::kInt64POD, 1);
485 ABCA::ArrayPropertyWriterPtr i64WrtPtr =
486 props->createArrayProperty("int64", ABCA::MetaData(), dtype, 0);
487
488 std::vector < Alembic::Util::int64_t > vals(2);
489 vals[0] = -5000000000LL;
490 vals[1] = 9876543210LL;
491 Alembic::Util::Dimensions dims(vals.size());
492 i64WrtPtr->setSample(
493 ABCA::ArraySample(&(vals.front()), dtype, dims));
494 }
495
496 {
497 ABCA::DataType dtype(Alembic::Util::kFloat16POD, 1);
498 ABCA::ArrayPropertyWriterPtr halfWrtPtr =
499 props->createArrayProperty("float16",
500 ABCA::MetaData(), dtype, 0);
501
502 std::vector < Alembic::Util::float16_t > vals(2);
503 vals[0] = 16.0;
504 vals[1] = -3.0;
505
506 Alembic::Util::Dimensions dims(vals.size());
507 halfWrtPtr->setSample(
508 ABCA::ArraySample(&(vals.front()), dtype, dims));
509 }
510
511 {
512 ABCA::DataType dtype(Alembic::Util::kFloat32POD, 2);
513 ABCA::ArrayPropertyWriterPtr floatWrtPtr =
514 props->createArrayProperty("float32", ABCA::MetaData(), dtype,
515 0);
516 std::vector < Alembic::Util::float32_t > vals(4);
517 vals[0] = 128.0;
518 vals[1] = -13.25;
519 vals[2] = 35.5;
520 vals[3] = 128.125;
521 Alembic::Util::Dimensions dims(vals.size()/2);
522 floatWrtPtr->setSample(
523 ABCA::ArraySample(&(vals.front()), dtype, dims));
524 }
525
526 {
527 ABCA::DataType dtype(Alembic::Util::kFloat32POD, 1);
528 ABCA::ArrayPropertyWriterPtr floatWrtPtr =
529 props->createArrayProperty("float32_ext1",
530 ABCA::MetaData(), dtype, 0);
531 std::vector < Alembic::Util::float32_t > vals(4);
532 vals[0] = 128.0;
533 vals[1] = -13.25;
534 vals[2] = 35.5;
535 vals[3] = 128.125;
536 Alembic::Util::Dimensions dims(vals.size());
537 floatWrtPtr->setSample(
538 ABCA::ArraySample(&(vals.front()), dtype, dims));
539 }
540
541 {
542 ABCA::DataType dtype(Alembic::Util::kFloat64POD, 1);
543 ABCA::ArrayPropertyWriterPtr doubleWrtPtr =
544 props->createArrayProperty("float64", ABCA::MetaData(),
545 dtype, 0);
546
547 std::vector < Alembic::Util::float64_t > vals(30);
548 for (size_t i = 0; i < vals.size(); ++i)
549 vals[i] = i * 100.0;
550 TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 0);
551 Alembic::Util::Dimensions dims(vals.size());
552 doubleWrtPtr->setSample(
553 ABCA::ArraySample(&(vals.front()), dtype, dims));
554 TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 1);
555 }
556
557 {
558 ABCA::DataType dtype(Alembic::Util::kFloat64POD, 3);
559 ABCA::ArrayPropertyWriterPtr doubleWrtPtr =
560 props->createArrayProperty("float64_ext3",
561 ABCA::MetaData(), dtype, 0);
562
563 std::vector < Alembic::Util::float64_t > vals(30);
564 for (size_t i = 0; i < vals.size(); ++i)
565 vals[i] = i * 100.0;
566 TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 0);
567 Alembic::Util::Dimensions dims(vals.size() / 3);
568 doubleWrtPtr->setSample(
569 ABCA::ArraySample(&(vals.front()), dtype, dims));
570 TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 1);
571 }
572
573 {
574 ABCA::DataType dtype(Alembic::Util::kStringPOD, 1);
575 ABCA::ArrayPropertyWriterPtr strWrtPtr =
576 props->createArrayProperty("str",
577 ABCA::MetaData(), dtype, 0);
578
579 std::vector < Alembic::Util::string > vals(4);
580 vals[0] = "Now it's time";
581 vals[1] = "";
582 vals[2] = "for";
583 vals[3] = "cake!";
584 Alembic::Util::Dimensions dims(vals.size());
585 strWrtPtr->setSample(
586 ABCA::ArraySample(&(vals.front()), dtype, dims));
587 }
588
589 {
590 ABCA::DataType dtype(Alembic::Util::kWstringPOD, 1);
591 ABCA::ArrayPropertyWriterPtr wstrWrtPtr =
592 props->createArrayProperty("wstr", ABCA::MetaData(), dtype, 0);
593
594 std::vector < Alembic::Util::wstring > vals(4);
595 vals[0] = L"We do what we must ";
596 vals[1] = L"because we can.";
597 vals[2] = L"";
598 vals[3] = L"\uf8e4 \uf8e2 \uf8d3";
599 Alembic::Util::Dimensions dims(vals.size());
600 wstrWrtPtr->setSample(
601 ABCA::ArraySample(&(vals.front()), dtype, dims));
602 }
603
604 }
605
606 // now we read what we've written
607 {
608 A5::ReadArchive r;
609 ABCA::ArchiveReaderPtr a = r( archiveName );
610 ABCA::ObjectReaderPtr archive = a->getTop();
611 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
612
613 TESTING_ASSERT(parent->getNumProperties() == 17);
614
615 ABCA::ArraySampleKey key;
616 for ( size_t i = 0; i < parent->getNumProperties(); ++i )
617 {
618 ABCA::BasePropertyReaderPtr bp = parent->getProperty( i );
619
620 // they are all supposed to be arrays
621 TESTING_ASSERT( bp->isArray() );
622
623 ABCA::ArrayPropertyReaderPtr ap = bp->asArrayPtr();
624 TESTING_ASSERT( ap->getNumSamples() == 1 );
625 TESTING_ASSERT( ap->isConstant() );
626 TESTING_ASSERT( ap->getParent() == parent);
627
628 if (ap->getName() != "float64_ext3" && ap->getName() != "float32")
629 TESTING_ASSERT( ap->getDataType().getExtent() == 1);
630
631 switch (ap->getDataType().getPod())
632 {
633 case Alembic::Util::kBooleanPOD:
634 {
635 TESTING_ASSERT(ap->getName() == "bool");
636 TESTING_ASSERT(!ap->isScalarLike());
637 ABCA::ArraySamplePtr val;
638 ap->getSample(0, val);
639 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
640 TESTING_ASSERT(val->getDimensions().rank() == 1);
641
642 Dimensions dims0;
643 ap->getDimensions(0, dims0);
644 TESTING_ASSERT(dims0.numPoints() == 3);
645 TESTING_ASSERT(dims0.rank() == 1);
646
647 Alembic::Util::bool_t * data =
648 (Alembic::Util::bool_t *)(val->getData());
649 TESTING_ASSERT(data[0] == false);
650 TESTING_ASSERT(data[1] == true);
651 TESTING_ASSERT(data[2] == false);
652
653 // read as something else
654 Alembic::Util::int32_t data2[3];
655 ap->getAs(0, data2, Alembic::Util::kInt32POD);
656 TESTING_ASSERT(data2[0] == 0);
657 TESTING_ASSERT(data2[1] == 1);
658 TESTING_ASSERT(data2[2] == 0);
659
660 // read it as it is
661 Alembic::Util::bool_t data3[3];
662 ap->getAs(0, data3, Alembic::Util::kBooleanPOD);
663 TESTING_ASSERT(data3[0] == false);
664 TESTING_ASSERT(data3[1] == true);
665 TESTING_ASSERT(data3[2] == false);
666
667 TESTING_ASSERT(ap->getKey(0, key));
668 TESTING_ASSERT(key.numBytes == 3);
669 TESTING_ASSERT(key.origPOD == Alembic::Util::kBooleanPOD);
670 TESTING_ASSERT(key.readPOD == Alembic::Util::kBooleanPOD);
671 TESTING_ASSERT(key.digest.str() ==
672 "bbde8ffe4b7e061c7e03081c2bf184c4");
673 }
674 break;
675
676 case Alembic::Util::kUint8POD:
677 {
678 TESTING_ASSERT(ap->getName() == "uint8" ||
679 ap->getName() == "uint8_newDims");
680 TESTING_ASSERT(!ap->isScalarLike());
681 ABCA::ArraySamplePtr val;
682 ap->getSample(0, val);
683
684 Alembic::Util::uint8_t * data =
685 (Alembic::Util::uint8_t *)(val->getData());
686 TESTING_ASSERT(data[0] == 200);
687 TESTING_ASSERT(data[1] == 45);
688 TESTING_ASSERT(data[2] == 37);
689 TESTING_ASSERT(data[3] == 192);
690 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
691
692 // read as something else
693 Alembic::Util::int32_t data2[4];
694 ap->getAs(0, data2, kInt32POD);
695 TESTING_ASSERT(data2[0] == 200);
696 TESTING_ASSERT(data2[1] == 45);
697 TESTING_ASSERT(data2[2] == 37);
698 TESTING_ASSERT(data2[3] == 192);
699
700 // read it as it is
701 Alembic::Util::uint8_t data3[4];
702 ap->getAs(0, data3, kUint8POD);
703 TESTING_ASSERT(data3[0] == 200);
704 TESTING_ASSERT(data3[1] == 45);
705 TESTING_ASSERT(data3[2] == 37);
706 TESTING_ASSERT(data3[3] == 192);
707
708 TESTING_ASSERT(ap->getKey(0, key));
709 TESTING_ASSERT(key.numBytes == 4);
710 TESTING_ASSERT(key.origPOD == Alembic::Util::kUint8POD);
711 TESTING_ASSERT(key.readPOD == Alembic::Util::kUint8POD);
712 TESTING_ASSERT(key.digest.str() ==
713 "2972c92c7f534e37ee116ae01c707741");
714
715 if (ap->getName() == "uint8")
716 {
717 Dimensions dims0;
718 ap->getDimensions(0, dims0);
719 TESTING_ASSERT(dims0.rank() == 1);
720 TESTING_ASSERT(dims0[0] == 4);
721 }
722 else if (ap->getName() == "uint8_newDims")
723 {
724 Dimensions dims0;
725 ap->getDimensions(0, dims0);
726 TESTING_ASSERT(dims0.rank() == 2);
727 TESTING_ASSERT(dims0[0] == 2);
728 TESTING_ASSERT(dims0[1] == 2);
729 }
730 }
731 break;
732
733 case Alembic::Util::kInt8POD:
734 {
735 TESTING_ASSERT(ap->getName() == "int8");
736 Dimensions dims0;
737 ap->getDimensions(0, dims0);
738 TESTING_ASSERT(dims0.rank() == 1);
739 TESTING_ASSERT(dims0.numPoints() == 2);
740 TESTING_ASSERT(!ap->isScalarLike());
741 ABCA::ArraySamplePtr val;
742 ap->getSample(0, val);
743 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
744 TESTING_ASSERT(val->getDimensions().rank() == 1);
745 Alembic::Util::int8_t * data =
746 (Alembic::Util::int8_t *)(val->getData());
747 TESTING_ASSERT(data[0] == -20);
748 TESTING_ASSERT(data[1] == 45);
749
750 // read as something else
751 Alembic::Util::int32_t data2[2];
752 ap->getAs(0, data2, kInt32POD);
753 TESTING_ASSERT(data2[0] == -20);
754 TESTING_ASSERT(data2[1] == 45);
755
756 // read it as it is
757 Alembic::Util::int8_t data3[2];
758 ap->getAs(0, data3, kInt8POD);
759 TESTING_ASSERT(data3[0] == -20);
760 TESTING_ASSERT(data3[1] == 45);
761 }
762 break;
763
764 case Alembic::Util::kUint16POD:
765 {
766 TESTING_ASSERT(ap->getName() == "uint16");
767 TESTING_ASSERT(!ap->isScalarLike());
768 ABCA::ArraySamplePtr val;
769 ap->getSample(0, val);
770 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
771 TESTING_ASSERT(val->getDimensions().rank() == 1);
772 Dimensions dims0;
773 ap->getDimensions(0, dims0);
774 TESTING_ASSERT(dims0.rank() == 1);
775 TESTING_ASSERT(dims0.numPoints() == 3);
776 Alembic::Util::uint16_t * data =
777 (Alembic::Util::uint16_t *)(val->getData());
778 TESTING_ASSERT(data[0] == 60000);
779 TESTING_ASSERT(data[1] == 2);
780 TESTING_ASSERT(data[2] == 3987);
781
782 // read as something else
783 Alembic::Util::int32_t data2[3];
784 ap->getAs(0, data2, kInt32POD);
785 TESTING_ASSERT(data2[0] == 60000);
786 TESTING_ASSERT(data2[1] == 2);
787 TESTING_ASSERT(data2[2] == 3987);
788
789 // read it as it is
790 Alembic::Util::uint16_t data3[3];
791 ap->getAs(0, data3, kUint16POD);
792 TESTING_ASSERT(data3[0] == 60000);
793 TESTING_ASSERT(data3[1] == 2);
794 TESTING_ASSERT(data2[2] == 3987);
795 }
796 break;
797
798 case Alembic::Util::kInt16POD:
799 {
800 TESTING_ASSERT(ap->getName() == "int16");
801 TESTING_ASSERT(!ap->isScalarLike());
802 Dimensions dims0;
803 ap->getDimensions(0, dims0);
804 TESTING_ASSERT(dims0.rank() == 1);
805 TESTING_ASSERT(dims0.numPoints() == 2);
806 ABCA::ArraySamplePtr val;
807 ap->getSample(0, val);
808 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
809 TESTING_ASSERT(val->getDimensions().rank() == 1);
810 Alembic::Util::int16_t * data =
811 (Alembic::Util::int16_t *)(val->getData());
812 TESTING_ASSERT(data[0] == -20000);
813 TESTING_ASSERT(data[1] == 77);
814
815 // read as something else
816 Alembic::Util::int32_t data2[2];
817 ap->getAs(0, data2, kInt32POD);
818 TESTING_ASSERT(data2[0] == -20000);
819 TESTING_ASSERT(data2[1] == 77);
820
821 // read it as it is
822 Alembic::Util::int16_t data3[2];
823 ap->getAs(0, data3, kInt16POD);
824 TESTING_ASSERT(data3[0] == -20000);
825 TESTING_ASSERT(data3[1] == 77);
826 }
827 break;
828
829 case Alembic::Util::kUint32POD:
830 {
831 TESTING_ASSERT(ap->getName() == "uint32");
832 TESTING_ASSERT(ap->isScalarLike());
833 ABCA::ArraySamplePtr val;
834 ap->getSample(0, val);
835 TESTING_ASSERT(val->getDimensions().numPoints() == 1);
836 TESTING_ASSERT(val->getDimensions().rank() == 1);
837 Dimensions dims0;
838 ap->getDimensions(0, dims0);
839 TESTING_ASSERT(dims0.rank() == 1);
840 TESTING_ASSERT(dims0.numPoints() == 1);
841 Alembic::Util::uint32_t * data =
842 (Alembic::Util::uint32_t *)(val->getData());
843 TESTING_ASSERT(data[0] == 1000000);
844
845 // read as something else
846 Alembic::Util::int16_t data2;
847 ap->getAs(0, &data2, kInt16POD);
848 TESTING_ASSERT(data2 == 32767); // maxed out
849
850 // read it as it is
851 Alembic::Util::int32_t data3;
852 ap->getAs(0, &data3, kUint32POD);
853 TESTING_ASSERT(data3 == 1000000);
854 }
855 break;
856
857 case Alembic::Util::kInt32POD:
858 {
859 TESTING_ASSERT(ap->getName() == "int32");
860 TESTING_ASSERT(!ap->isScalarLike());
861 ABCA::ArraySamplePtr val;
862 ap->getSample(0, val);
863 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
864 TESTING_ASSERT(val->getDimensions().rank() == 1);
865 Dimensions dims0;
866 ap->getDimensions(0, dims0);
867 TESTING_ASSERT(dims0.rank() == 1);
868 TESTING_ASSERT(dims0.numPoints() == 4);
869 Alembic::Util::int32_t * data =
870 (Alembic::Util::int32_t *)(val->getData());
871 TESTING_ASSERT(data[0] == -1000000);
872 TESTING_ASSERT(data[1] == 42);
873 TESTING_ASSERT(data[2] == -20000);
874 TESTING_ASSERT(data[3] == 123456);
875
876 // read as something else
877 Alembic::Util::int16_t data2[4];
878 ap->getAs(0, data2, kInt16POD);
879 TESTING_ASSERT(data2[0] == -32768); // maxed out negative
880 TESTING_ASSERT(data2[1] == 42);
881 TESTING_ASSERT(data2[2] == -20000);
882 TESTING_ASSERT(data2[3] == 32767); // maxed out positive
883
884 // read it as it is
885 Alembic::Util::int32_t data3[4];
886 ap->getAs(0, data3, kInt32POD);
887 TESTING_ASSERT(data3[0] == -1000000);
888 TESTING_ASSERT(data3[1] == 42);
889 TESTING_ASSERT(data3[2] == -20000);
890 TESTING_ASSERT(data3[3] == 123456);
891
892 // can't read as strings, and it shouldn't touch the buffer
893 TESTING_ASSERT_THROW(ap->getAs(0, data3, kStringPOD),
894 Alembic::Util::Exception);
895
896 TESTING_ASSERT_THROW(ap->getAs(0, data3, kWstringPOD),
897 Alembic::Util::Exception);
898 TESTING_ASSERT(data3[0] == -1000000);
899 TESTING_ASSERT(data3[1] == 42);
900 TESTING_ASSERT(data3[2] == -20000);
901 TESTING_ASSERT(data3[3] == 123456);
902 }
903 break;
904
905 case Alembic::Util::kUint64POD:
906 {
907 TESTING_ASSERT(ap->getName() == "uint64");
908 TESTING_ASSERT(!ap->isScalarLike());
909 ABCA::ArraySamplePtr val;
910 ap->getSample(0, val);
911 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
912 TESTING_ASSERT(val->getDimensions().rank() == 1);
913 Dimensions dims0;
914 ap->getDimensions(0, dims0);
915 TESTING_ASSERT(dims0.rank() == 1);
916 TESTING_ASSERT(dims0.numPoints() == 3);
917 Alembic::Util::uint64_t * data =
918 (Alembic::Util::uint64_t *)(val->getData());
919 TESTING_ASSERT(data[0] == 5000000000LL);
920 TESTING_ASSERT(data[1] == 1234567891011LL);
921 TESTING_ASSERT(data[2] == 12);
922
923 // read as something else
924 Alembic::Util::int16_t data2[3];
925 ap->getAs(0, data2, kInt16POD);
926 TESTING_ASSERT(data2[0] == 32767); // maxed out positive
927 TESTING_ASSERT(data2[1] == 32767); // maxed out positive
928 TESTING_ASSERT(data2[2] == 12);
929
930 // read it as it is
931 Alembic::Util::uint64_t data3[3];
932 ap->getAs(0, data3, kUint64POD);
933 TESTING_ASSERT(data3[0] == 5000000000LL);
934 TESTING_ASSERT(data3[1] == 1234567891011LL);
935 TESTING_ASSERT(data3[2] == 12);
936 }
937 break;
938
939 case Alembic::Util::kInt64POD:
940 {
941 TESTING_ASSERT(ap->getName() == "int64");
942 TESTING_ASSERT(!ap->isScalarLike());
943 ABCA::ArraySamplePtr val;
944 ap->getSample(0, val);
945 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
946 TESTING_ASSERT(val->getDimensions().rank() == 1);
947 Dimensions dims0;
948 ap->getDimensions(0, dims0);
949 TESTING_ASSERT(dims0.rank() == 1);
950 TESTING_ASSERT(dims0.numPoints() == 2);
951 Alembic::Util::int64_t * data =
952 (Alembic::Util::int64_t *)(val->getData());
953 TESTING_ASSERT(data[0] == -5000000000LL);
954 TESTING_ASSERT(data[1] == 9876543210LL);
955
956 // read as something else
957 Alembic::Util::int16_t data2[2];
958 ap->getAs(0, data2, kInt16POD);
959 TESTING_ASSERT(data2[0] == -32768); // maxed out negative
960 TESTING_ASSERT(data2[1] == 32767); // maxed out positive
961
962 // read it as it is
963 Alembic::Util::int64_t data3[2];
964 ap->getAs(0, data3, kInt64POD);
965 TESTING_ASSERT(data3[0] == -5000000000LL);
966 TESTING_ASSERT(data3[1] == 9876543210LL);
967 }
968 break;
969
970 case Alembic::Util::kFloat16POD:
971 {
972 TESTING_ASSERT(ap->getName() == "float16");
973 TESTING_ASSERT(!ap->isScalarLike());
974 ABCA::ArraySamplePtr val;
975 ap->getSample(0, val);
976 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
977 TESTING_ASSERT(val->getDimensions().rank() == 1);
978 Dimensions dims0;
979 ap->getDimensions(0, dims0);
980 TESTING_ASSERT(dims0.rank() == 1);
981 TESTING_ASSERT(dims0.numPoints() == 2);
982 Alembic::Util::float16_t * data =
983 (Alembic::Util::float16_t *)(val->getData());
984 TESTING_ASSERT(data[0] == 16.0);
985 TESTING_ASSERT(data[1] == -3.0);
986
987 // can't currently read it as another data type
988 Alembic::Util::float32_t data2[2];
989 TESTING_ASSERT_THROW(ap->getAs(0, data2, kFloat32POD),
990 Alembic::Util::Exception);
991 // read it as it is
992 Alembic::Util::float16_t data3[2];
993 ap->getAs(0, data3, kFloat16POD);
994 TESTING_ASSERT(data3[0] == 16.0);
995 TESTING_ASSERT(data3[1] == -3.0);
996
997 }
998 break;
999
1000 case Alembic::Util::kFloat32POD:
1001 {
1002 TESTING_ASSERT(ap->getName() == "float32" ||
1003 ap->getName() == "float32_ext1");
1004 TESTING_ASSERT(!ap->isScalarLike());
1005 ABCA::ArraySamplePtr val;
1006 ap->getSample(0, val);
1007 ABCA::ArraySampleKey key;
1008
1009 if (ap->getName() == "float32_ext1")
1010 {
1011 Dimensions dims0;
1012 ap->getDimensions(0, dims0);
1013 TESTING_ASSERT(dims0.rank() == 1);
1014 TESTING_ASSERT(dims0.numPoints() == 4);
1015 ap->getKey(0, key);
1016 TESTING_ASSERT(key.numBytes == 16);
1017 }
1018
1019 if (ap->getName() == "float32")
1020 {
1021 TESTING_ASSERT( ap->getDataType().getExtent() == 2);
1022 Dimensions dims0;
1023 ap->getDimensions(0, dims0);
1024 TESTING_ASSERT(dims0.rank() == 1);
1025 TESTING_ASSERT(dims0.numPoints() == 2);
1026 ap->getKey(0, key);
1027 TESTING_ASSERT(key.numBytes == 16);
1028 }
1029
1030 TESTING_ASSERT(val->getDimensions().rank() == 1);
1031 Alembic::Util::float32_t * data =
1032 (Alembic::Util::float32_t *)(val->getData());
1033 TESTING_ASSERT(data[0] == 128.0);
1034 TESTING_ASSERT(data[1] == -13.25);
1035 TESTING_ASSERT(data[2] == 35.5);
1036 TESTING_ASSERT(data[3] == 128.125);
1037
1038 // read as something else
1039 Alembic::Util::float64_t data2[4];
1040 ap->getAs(0, data2, kFloat64POD);
1041 TESTING_ASSERT(data2[0] == 128.0);
1042 TESTING_ASSERT(data2[1] == -13.25);
1043 TESTING_ASSERT(data2[2] == 35.5);
1044 TESTING_ASSERT(data2[3] == 128.125);
1045
1046 // read it as it is
1047 Alembic::Util::float32_t data3[4];
1048 ap->getAs(0, data3, kFloat32POD);
1049 TESTING_ASSERT(data3[0] == 128.0);
1050 TESTING_ASSERT(data3[1] == -13.25);
1051 TESTING_ASSERT(data3[2] == 35.5);
1052 TESTING_ASSERT(data3[3] == 128.125);
1053
1054 // read it as an int32_t
1055 Alembic::Util::int32_t data4[4];
1056 ap->getAs(0, data4, kInt32POD);
1057 TESTING_ASSERT(data4[0] == 128);
1058 TESTING_ASSERT(data4[1] == -13);
1059 TESTING_ASSERT(data4[2] == 35);
1060 TESTING_ASSERT(data4[3] == 128);
1061
1062 // can't read as strings, and it shouldn't touch the buffer
1063 TESTING_ASSERT_THROW(ap->getAs(0, data4, kStringPOD),
1064 Alembic::Util::Exception);
1065
1066 TESTING_ASSERT_THROW(ap->getAs(0, data4, kWstringPOD),
1067 Alembic::Util::Exception);
1068 TESTING_ASSERT(data4[0] == 128);
1069 TESTING_ASSERT(data4[1] == -13);
1070 TESTING_ASSERT(data4[2] == 35);
1071 TESTING_ASSERT(data4[3] == 128);
1072 }
1073 break;
1074
1075 case Alembic::Util::kFloat64POD:
1076 {
1077 TESTING_ASSERT(ap->getName() == "float64" ||
1078 ap->getName() == "float64_ext3");
1079 TESTING_ASSERT(!ap->isScalarLike());
1080
1081 ABCA::ArraySamplePtr val;
1082 ap->getSample(0, val);
1083 TESTING_ASSERT(val->getDimensions().rank() == 1);
1084 ABCA::ArraySampleKey key;
1085
1086 if (ap->getName() == "float64")
1087 {
1088 Dimensions dims0;
1089 ap->getDimensions(0, dims0);
1090 TESTING_ASSERT(dims0.rank() == 1);
1091 TESTING_ASSERT(dims0.numPoints() == 30);
1092 ap->getKey(0, key);
1093 TESTING_ASSERT(key.numBytes == 240);
1094 }
1095
1096 if (ap->getName() == "float64_ext3")
1097 {
1098 Dimensions dims0;
1099 ap->getDimensions(0, dims0);
1100 TESTING_ASSERT(dims0.rank() == 1);
1101 TESTING_ASSERT(dims0.numPoints() == 10);
1102 TESTING_ASSERT( ap->getDataType().getExtent() == 3);
1103 ap->getKey(0, key);
1104 TESTING_ASSERT(key.numBytes == 240);
1105 }
1106
1107 Alembic::Util::float64_t * data =
1108 (Alembic::Util::float64_t *)(val->getData());
1109
1110 Alembic::Util::float32_t data2[30];
1111 ap->getAs(0, data2, kFloat32POD);
1112
1113 Alembic::Util::float64_t data3[30];
1114 ap->getAs(0, data3, kFloat64POD);
1115
1116 Alembic::Util::uint32_t data4[30];
1117 ap->getAs(0, data4, kUint32POD);
1118
1119 for (size_t i = 0; i < val->size(); ++i)
1120 {
1121 TESTING_ASSERT(data[i] == i* 100);
1122 TESTING_ASSERT(data2[i] == i* 100);
1123 TESTING_ASSERT(data3[i] == i* 100);
1124 TESTING_ASSERT(data4[i] == i* 100);
1125 }
1126 }
1127 break;
1128
1129 case Alembic::Util::kStringPOD:
1130 {
1131 TESTING_ASSERT(ap->getName() == "str");
1132 ABCA::ArraySamplePtr val;
1133 ap->getSample(0, val);
1134 TESTING_ASSERT(!ap->isScalarLike());
1135 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
1136 TESTING_ASSERT(val->getDimensions().rank() == 1);
1137 Dimensions dims0;
1138 ap->getDimensions(0, dims0);
1139 TESTING_ASSERT(dims0.rank() == 1);
1140 TESTING_ASSERT(dims0.numPoints() == 4);
1141 Alembic::Util::string * data =
1142 (Alembic::Util::string *)(val->getData());
1143 TESTING_ASSERT(data[0] == "Now it's time");
1144 TESTING_ASSERT(data[1] == "");
1145 TESTING_ASSERT(data[2] == "for");
1146 TESTING_ASSERT(data[3] == "cake!");
1147
1148 Alembic::Util::string data2[4];
1149 ap->getAs(0, data2, kStringPOD);
1150 TESTING_ASSERT(data2[0] == "Now it's time");
1151 TESTING_ASSERT(data2[1] == "");
1152 TESTING_ASSERT(data2[2] == "for");
1153 TESTING_ASSERT(data2[3] == "cake!");
1154
1155 // can't read strings as anything else
1156 Alembic::Util::int32_t data3[4];
1157 TESTING_ASSERT_THROW(ap->getAs(0, data3, kInt32POD),
1158 Alembic::Util::Exception);
1159 }
1160 break;
1161
1162 case Alembic::Util::kWstringPOD:
1163 {
1164 TESTING_ASSERT(ap->getName() == "wstr");
1165 ABCA::ArraySamplePtr val;
1166 ap->getSample(0, val);
1167 TESTING_ASSERT(!ap->isScalarLike());
1168 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
1169 TESTING_ASSERT(val->getDimensions().rank() == 1);
1170 Dimensions dims0;
1171 ap->getDimensions(0, dims0);
1172 TESTING_ASSERT(dims0.rank() == 1);
1173 TESTING_ASSERT(dims0.numPoints() == 4);
1174 Alembic::Util::wstring * data =
1175 (Alembic::Util::wstring *)(val->getData());
1176 TESTING_ASSERT(data[0] == L"We do what we must ");
1177 TESTING_ASSERT(data[1] == L"because we can.");
1178 TESTING_ASSERT(data[2] == L"");
1179 TESTING_ASSERT(data[3] == L"\uf8e4 \uf8e2 \uf8d3");
1180
1181 Alembic::Util::wstring data2[4];
1182 ap->getAs(0, data2, kWstringPOD);
1183 TESTING_ASSERT(data[0] == L"We do what we must ");
1184 TESTING_ASSERT(data[1] == L"because we can.");
1185 TESTING_ASSERT(data[2] == L"");
1186 TESTING_ASSERT(data[3] == L"\uf8e4 \uf8e2 \uf8d3");
1187
1188 // can't read strings as anything else
1189 Alembic::Util::int32_t data3[4];
1190 TESTING_ASSERT_THROW(ap->getAs(0, data3, kInt32POD),
1191 Alembic::Util::Exception);
1192 }
1193 break;
1194
1195 default:
1196 TESTING_ASSERT(false);
1197 break;
1198 }
1199 }
1200 } // end of reading
1201 }
1202
1203 //-*****************************************************************************
1204 void testEmptyArray()
1205 {
1206 std::string archiveName = "emptyArray.abc";
1207 {
1208 A5::WriteArchive w;
1209 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
1210 ABCA::ObjectWriterPtr archive = a->getTop();
1211
1212 ABCA::CompoundPropertyWriterPtr parent = archive->getProperties();
1213
1214 ABCA::ArrayPropertyWriterPtr awp =
1215 parent->createArrayProperty("emptyInt32", ABCA::MetaData(),
1216 ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
1217 TESTING_ASSERT(awp->getNumSamples() == 0);
1218 }
1219
1220 {
1221 A5::ReadArchive r;
1222 ABCA::ArchiveReaderPtr a = r( archiveName );
1223 ABCA::ObjectReaderPtr archive = a->getTop();
1224 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
1225
1226 TESTING_ASSERT(parent->getNumProperties() == 1);
1227
1228 ABCA::BasePropertyReaderPtr bp = parent->getProperty( 0 );
1229 TESTING_ASSERT(bp->isArray());
1230 TESTING_ASSERT(bp->asScalarPtr() == NULL);
1231 TESTING_ASSERT(bp->getParent() == parent);
1232 ABCA::ArrayPropertyReaderPtr ap = bp->asArrayPtr();
1233 TESTING_ASSERT(ap->getNumSamples() == 0);
1234 TESTING_ASSERT(ap->getNumSamples() == 0);
1235 TESTING_ASSERT(ap->isConstant());
1236 ABCA::ArraySamplePtr as;
1237
1238 TESTING_ASSERT_THROW(ap->getSample(0, as), Alembic::Util::Exception);
1239 }
1240
1241 {
1242 A5::WriteArchive w;
1243 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
1244 ABCA::ObjectWriterPtr archive = a->getTop();
1245
1246 ABCA::CompoundPropertyWriterPtr parent = archive->getProperties();
1247
1248 // no extent should throw
1249 TESTING_ASSERT_THROW(parent->createArrayProperty("emptyInt32",
1250 ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 0), 0),
1251 Alembic::Util::Exception);
1252
1253 // 2 parts of the enum that shouldn't be written out
1254 TESTING_ASSERT_THROW(parent->createArrayProperty("emptyInt32",
1255 ABCA::MetaData(), ABCA::DataType(Alembic::Util::kUnknownPOD, 1), 0),
1256 Alembic::Util::Exception);
1257
1258 TESTING_ASSERT_THROW(parent->createArrayProperty("emptyInt32",
1259 ABCA::MetaData(),
1260 ABCA::DataType(Alembic::Util::kNumPlainOldDataTypes, 1), 0),
1261 Alembic::Util::Exception);
1262
1263 // illegal time sampling index
1264 TESTING_ASSERT_THROW(parent->createArrayProperty("emptyInt32",
1265 ABCA::MetaData(),
1266 ABCA::DataType(Alembic::Util::kInt32POD, 1), 45),
1267 Alembic::Util::Exception);
1268
1269 // lets do it again for the Scalars
1270
1271 // no extent should throw
1272 TESTING_ASSERT_THROW(parent->createScalarProperty("emptyInt32",
1273 ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 0), 0),
1274 Alembic::Util::Exception);
1275
1276 // 2 parts of the enum that shouldn't be written out
1277 TESTING_ASSERT_THROW(parent->createScalarProperty("emptyInt32",
1278 ABCA::MetaData(),
1279 ABCA::DataType(Alembic::Util::kUnknownPOD, 1), 0),
1280 Alembic::Util::Exception);
1281
1282 TESTING_ASSERT_THROW(parent->createScalarProperty("emptyInt32",
1283 ABCA::MetaData(),
1284 ABCA::DataType(Alembic::Util::kNumPlainOldDataTypes, 1), 0),
1285 Alembic::Util::Exception);
1286
1287 // illegal time sampling index
1288 TESTING_ASSERT_THROW(parent->createScalarProperty("emptyInt32",
1289 ABCA::MetaData(),
1290 ABCA::DataType(Alembic::Util::kInt32POD, 1), 42),
1291 Alembic::Util::Exception);
1292
1293 parent->createArrayProperty("veryEmptyInt32",
1294 ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
1295
1296 // this should throw because the name isn't unique
1297 TESTING_ASSERT_THROW(parent->createScalarProperty("veryEmptyInt32",
1298 ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0),
1299 Alembic::Util::Exception);
1300
1301 ABCA::ArrayPropertyWriterPtr ap = parent->createArrayProperty(
1302 "emptyInt64", ABCA::MetaData(),
1303 ABCA::DataType(Alembic::Util::kInt64POD, 1), 0);
1304
1305 // In order to write a zero-length array, you still have to specify
1306 // non-rank-0 dimensions.
1307 ABCA::Dimensions zeroLengthDims;
1308 zeroLengthDims.setRank( 1 );
1309 zeroLengthDims[0] = 0;
1310 ABCA::ArraySample samp(NULL, ABCA::DataType(Alembic::Util::kInt64POD, 1),
1311 zeroLengthDims );
1312 ap->setSample( samp );
1313 }
1314
1315 {
1316 A5::ReadArchive r;
1317 ABCA::ArchiveReaderPtr a = r( archiveName );
1318 ABCA::ObjectReaderPtr archive = a->getTop();
1319 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
1320
1321 TESTING_ASSERT(parent->getNumProperties() == 2);
1322
1323 for (size_t i = 0; i < parent->getNumProperties(); ++i)
1324 {
1325 ABCA::BasePropertyReaderPtr bp = parent->getProperty( i );
1326 TESTING_ASSERT(bp->isArray());
1327 TESTING_ASSERT(bp->asScalarPtr() == NULL);
1328 TESTING_ASSERT(bp->getParent() == parent);
1329 ABCA::ArrayPropertyReaderPtr ap = bp->asArrayPtr();
1330 if (ap->getName() == "veryEmptyInt32")
1331 {
1332 TESTING_ASSERT(ap->getNumSamples() == 0);
1333
1334 // no samples? it's scalar like
1335 TESTING_ASSERT(ap->isScalarLike());
1336 }
1337 else if (ap->getName() == "emptyInt64")
1338 {
1339 ABCA::ArraySampleKey key;
1340
1341 TESTING_ASSERT(ap->getNumSamples() == 1);
1342 ABCA::ArraySamplePtr samp;
1343 ap->getSample(0, samp);
1344 Dimensions dims0;
1345 TESTING_ASSERT(dims0.numPoints() == 0);
1346 TESTING_ASSERT(samp->getDimensions().numPoints() == 0);
1347 TESTING_ASSERT(!ap->isScalarLike());
1348 TESTING_ASSERT(ap->getKey(0, key));
1349 TESTING_ASSERT(key.numBytes == 0);
1350 TESTING_ASSERT(key.origPOD == Alembic::Util::kInt64POD);
1351 TESTING_ASSERT(key.readPOD == Alembic::Util::kInt64POD);
1352 TESTING_ASSERT(key.digest.str() ==
1353 "00000000000000000000000000000000");
1354 }
1355 }
1356 }
1357 }
1358
1359 //-*****************************************************************************
1360 void testExtentArrayStrings()
1361 {
1362 std::string archiveName = "extentStrArray.abc";
1363 {
1364 A5::WriteArchive w;
1365 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
1366 ABCA::ObjectWriterPtr archive = a->getTop();
1367
1368 ABCA::CompoundPropertyWriterPtr parent = archive->getProperties();
1369
1370 ABCA::DataType dtype(Alembic::Util::kStringPOD, 2);
1371
1372 ABCA::ArrayPropertyWriterPtr awp =
1373 parent->createArrayProperty("str", ABCA::MetaData(), dtype, 0);
1374
1375 std::vector < Alembic::Util::string > vals(6);
1376 vals[0] = "Peanut";
1377 vals[1] = "butter";
1378 vals[2] = "jelly";
1379 vals[3] = "time";
1380 vals[4] = "nom nom";
1381 vals[5] = "";
1382
1383 std::vector < Alembic::Util::string > vals2(4);
1384 vals2[0] = "";
1385 vals2[1] = "Is the cake really a lie?";
1386 vals2[2] = "";
1387 vals2[3] = "I certainly hope not.";
1388
1389 std::vector < Alembic::Util::string > vals3(4);
1390 vals3[0] = "Is the cake really a lie?";
1391 vals3[1] = "";
1392 vals3[2] = "";
1393 vals3[3] = "I certainly hope not.";
1394
1395 std::vector < Alembic::Util::string > vals4(6);
1396 vals4[0] = "a";
1397 vals4[1] = "b";
1398 vals4[2] = "c";
1399 vals4[3] = "d";
1400 vals4[4] = "e";
1401 vals4[5] = "f";
1402
1403 awp->setSample(
1404 ABCA::ArraySample(&(vals.front()), dtype,
1405 Alembic::Util::Dimensions(3)));
1406
1407 awp->setSample(
1408 ABCA::ArraySample(&(vals2.front()), dtype,
1409 Alembic::Util::Dimensions(2)));
1410
1411 std::vector < Alembic::Util::string > badVals(1);
1412 badVals[0] = "This better fail.";
1413 TESTING_ASSERT_THROW(awp->setSample(
1414 ABCA::ArraySample(&(badVals.front()),
1415 ABCA::DataType(Alembic::Util::kStringPOD, 1),
1416 Alembic::Util::Dimensions(1))), Alembic::Util::Exception);
1417
1418 awp->setSample(
1419 ABCA::ArraySample(&(vals3.front()), dtype,
1420 Alembic::Util::Dimensions(2)));
1421
1422 awp->setSample(
1423 ABCA::ArraySample(&(vals2.front()), dtype,
1424 Alembic::Util::Dimensions(2)));
1425
1426 awp->setSample(
1427 ABCA::ArraySample(&(vals4.front()), dtype,
1428 Alembic::Util::Dimensions(3)));
1429
1430 std::vector < Alembic::Util::float32_t > vals5(3);
1431 vals5[0] = 1.0;
1432 vals5[1] = 2.0;
1433 vals5[2] = 3.0;
1434
1435 // this should fail since we are trying to write float data to
1436 // a string array property
1437 TESTING_ASSERT_THROW(awp->setSample(
1438 ABCA::ArraySample(&(vals5.front()),
1439 ABCA::DataType(Alembic::Util::kFloat32POD, 1),
1440 Alembic::Util::Dimensions(3))), Alembic::Util::Exception);
1441 }
1442
1443 {
1444 A5::ReadArchive r;
1445 ABCA::ArchiveReaderPtr a = r( archiveName );
1446 ABCA::ObjectReaderPtr archive = a->getTop();
1447 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
1448 TESTING_ASSERT(parent->getNumProperties() == 1);
1449
1450 ABCA::BasePropertyReaderPtr bp = parent->getProperty( 0 );
1451 TESTING_ASSERT(bp->isArray());
1452 ABCA::ArrayPropertyReaderPtr ap = bp->asArrayPtr();
1453 TESTING_ASSERT(ap->getNumSamples() == 5);
1454
1455 ABCA::ArraySamplePtr val;
1456
1457 ap->getSample(0, val);
1458 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
1459 TESTING_ASSERT(val->getDimensions().rank() == 1);
1460
1461 Dimensions dims0;
1462 ap->getDimensions(0, dims0);
1463 TESTING_ASSERT(dims0.numPoints() == 3);
1464 TESTING_ASSERT(dims0.rank() == 1);
1465
1466 Alembic::Util::string * data = (Alembic::Util::string *)(val->getData());
1467
1468 TESTING_ASSERT(data[0] == "Peanut");
1469 TESTING_ASSERT(data[1] == "butter");
1470 TESTING_ASSERT(data[2] == "jelly");
1471 TESTING_ASSERT(data[3] == "time");
1472 TESTING_ASSERT(data[4] == "nom nom");
1473 TESTING_ASSERT(data[5] == "");
1474
1475 ABCA::ArraySampleKey key;
1476 TESTING_ASSERT(ap->getKey(0, key));
1477
1478 // includes NULL seperator
1479 TESTING_ASSERT(key.numBytes == 34);
1480 TESTING_ASSERT(key.origPOD == Alembic::Util::kStringPOD);
1481 TESTING_ASSERT(key.readPOD == Alembic::Util::kStringPOD);
1482 TESTING_ASSERT(key.digest.str() ==
1483 "88d5ea1d772131992c9be9a192938df7");
1484
1485 ap->getSample(1, val);
1486 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
1487 TESTING_ASSERT(val->getDimensions().rank() == 1);
1488
1489 ap->getDimensions(1, dims0);
1490 TESTING_ASSERT(dims0.numPoints() == 2);
1491 TESTING_ASSERT(dims0.rank() == 1);
1492
1493 data = (Alembic::Util::string *)(val->getData());
1494 TESTING_ASSERT(data[0] == "");
1495 TESTING_ASSERT(data[1] == "Is the cake really a lie?");
1496 TESTING_ASSERT(data[2] == "");
1497 TESTING_ASSERT(data[3] == "I certainly hope not.");
1498 TESTING_ASSERT(ap->getKey(1, key));
1499 TESTING_ASSERT(key.numBytes == 50);
1500 TESTING_ASSERT(key.origPOD == Alembic::Util::kStringPOD);
1501 TESTING_ASSERT(key.readPOD == Alembic::Util::kStringPOD);
1502 TESTING_ASSERT(key.digest.str() ==
1503 "126ebab40166a642d3c8cc4c5929074d");
1504
1505 ap->getSample(2, val);
1506 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
1507 TESTING_ASSERT(val->getDimensions().rank() == 1);
1508 ap->getDimensions(2, dims0);
1509 TESTING_ASSERT(dims0.numPoints() == 2);
1510 TESTING_ASSERT(dims0.rank() == 1);
1511 data = (Alembic::Util::string *)(val->getData());
1512 TESTING_ASSERT(data[0] == "Is the cake really a lie?");
1513 TESTING_ASSERT(data[1] == "");
1514 TESTING_ASSERT(data[2] == "");
1515 TESTING_ASSERT(data[3] == "I certainly hope not.");
1516 TESTING_ASSERT(ap->getKey(2, key));
1517 TESTING_ASSERT(key.numBytes == 50);
1518 TESTING_ASSERT(key.origPOD == Alembic::Util::kStringPOD);
1519 TESTING_ASSERT(key.readPOD == Alembic::Util::kStringPOD);
1520 TESTING_ASSERT(key.digest.str() ==
1521 "a197a3747b0666dfacdc17634f5cabff");
1522
1523 ap->getSample(3, val);
1524 ap->getDimensions(3, dims0);
1525 TESTING_ASSERT(dims0.numPoints() == 2);
1526 TESTING_ASSERT(dims0.rank() == 1);
1527 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
1528 TESTING_ASSERT(val->getDimensions().rank() == 1);
1529 data = (Alembic::Util::string *)(val->getData());
1530 TESTING_ASSERT(data[0] == "");
1531 TESTING_ASSERT(data[1] == "Is the cake really a lie?");
1532 TESTING_ASSERT(data[2] == "");
1533 TESTING_ASSERT(data[3] == "I certainly hope not.");
1534 TESTING_ASSERT(ap->getKey(3, key));
1535 TESTING_ASSERT(key.numBytes == 50);
1536 TESTING_ASSERT(key.origPOD == Alembic::Util::kStringPOD);
1537 TESTING_ASSERT(key.readPOD == Alembic::Util::kStringPOD);
1538 TESTING_ASSERT(key.digest.str() ==
1539 "126ebab40166a642d3c8cc4c5929074d");
1540
1541 ap->getSample(4, val);
1542 ap->getDimensions(4, dims0);
1543 TESTING_ASSERT(dims0.numPoints() == 3);
1544 TESTING_ASSERT(dims0.rank() == 1);
1545 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
1546 TESTING_ASSERT(val->getDimensions().rank() == 1);
1547 data = (Alembic::Util::string *)(val->getData());
1548 TESTING_ASSERT(data[0] == "a");
1549 TESTING_ASSERT(data[1] == "b");
1550 TESTING_ASSERT(data[2] == "c");
1551 TESTING_ASSERT(data[3] == "d");
1552 TESTING_ASSERT(data[4] == "e");
1553 TESTING_ASSERT(data[5] == "f");
1554 TESTING_ASSERT(ap->getKey(4, key));
1555 TESTING_ASSERT(key.numBytes == 12);
1556 TESTING_ASSERT(key.origPOD == Alembic::Util::kStringPOD);
1557 TESTING_ASSERT(key.readPOD == Alembic::Util::kStringPOD);
1558 }
1559 }
1560
1561 //-*****************************************************************************
1562 void testArrayStringsRepeats()
1563 {
1564 std::string archiveName = "strArrayRepeats.abc";
1565 std::vector < Alembic::Util::string > vals(6);
1566 vals[0] = "if you want";
1567 vals[1] = "a revolution";
1568 vals[2] = "the only";
1569 vals[3] = "solution";
1570 vals[4] = "...";
1571 vals[5] = "evolve";
1572
1573 std::vector < Alembic::Util::string > vals2(4);
1574 vals2[0] = "bom bom";
1575 vals2[1] = "bom";
1576 vals2[2] = "bom bom";
1577 vals2[3] = "bom";
1578
1579 std::vector < Alembic::Util::string > valsEmpty(4);
1580
1581 ABCA::DataType dtype(Alembic::Util::kStringPOD);
1582
1583 {
1584 A5::WriteArchive w;
1585 ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
1586 ABCA::ObjectWriterPtr archive = a->getTop();
1587
1588 ABCA::CompoundPropertyWriterPtr parent = archive->getProperties();
1589
1590 ABCA::ArrayPropertyWriterPtr awp =
1591 parent->createArrayProperty("str", ABCA::MetaData(), dtype, 0);
1592
1593 // 0
1594 awp->setSample(ABCA::ArraySample(&(valsEmpty.front()), dtype,
1595 Alembic::Util::Dimensions(valsEmpty.size())));
1596
1597 // 1
1598 awp->setSample(ABCA::ArraySample(&(valsEmpty.front()), dtype,
1599 Alembic::Util::Dimensions(valsEmpty.size())));
1600
1601 // 2
1602 awp->setSample(ABCA::ArraySample(&(valsEmpty.front()), dtype,
1603 Alembic::Util::Dimensions(valsEmpty.size())));
1604
1605 // 3
1606 awp->setSample(
1607 ABCA::ArraySample(&(vals.front()), dtype,
1608 Alembic::Util::Dimensions(vals.size())));
1609
1610 // 4
1611 awp->setSample(
1612 ABCA::ArraySample(&(vals.front()), dtype,
1613 Alembic::Util::Dimensions(vals.size())));
1614
1615 // 5
1616 awp->setSample(
1617 ABCA::ArraySample(&(vals.front()), dtype,
1618 Alembic::Util::Dimensions(vals.size())));
1619
1620 // 6
1621 awp->setSample(
1622 ABCA::ArraySample(&(vals2.front()), dtype,
1623 Alembic::Util::Dimensions(vals2.size())));
1624
1625 // 7
1626 awp->setSample(
1627 ABCA::ArraySample(&(vals2.front()), dtype,
1628 Alembic::Util::Dimensions(vals2.size())));
1629
1630 // 8
1631 awp->setSample(ABCA::ArraySample(&(valsEmpty.front()), dtype,
1632 Alembic::Util::Dimensions(valsEmpty.size())));
1633
1634 // 9
1635 awp->setSample(ABCA::ArraySample(&(valsEmpty.front()), dtype,
1636 Alembic::Util::Dimensions(valsEmpty.size())));
1637
1638 dtype.setExtent(2);
1639 ABCA::ArrayPropertyWriterPtr awp2 =
1640 parent->createArrayProperty("str2", ABCA::MetaData(), dtype, 0);
1641
1642 // 0
1643 awp2->setSample(
1644 ABCA::ArraySample(&(vals.front()), dtype,
1645 Alembic::Util::Dimensions(vals.size() / 2)));
1646
1647 // 1
1648 awp2->setSample(
1649 ABCA::ArraySample(&(vals.front()), dtype,
1650 Alembic::Util::Dimensions(vals.size() / 2)));
1651
1652 // 2
1653 awp2->setSample(
1654 ABCA::ArraySample(&(vals.front()), dtype,
1655 Alembic::Util::Dimensions(vals.size() / 2)));
1656
1657 // 3
1658 awp2->setSample(
1659 ABCA::ArraySample(NULL, dtype, Alembic::Util::Dimensions(0)));
1660
1661 // 4
1662 awp2->setSample(
1663 ABCA::ArraySample(&(vals2.front()), dtype,
1664 Alembic::Util::Dimensions(vals2.size() / 2)));
1665
1666 // 5
1667 awp2->setSample(
1668 ABCA::ArraySample(&(vals2.front()), dtype,
1669 Alembic::Util::Dimensions(vals2.size() / 2)));
1670
1671 }
1672
1673 {
1674 A5::ReadArchive r;
1675 ABCA::ArchiveReaderPtr a = r( archiveName,
1676 ABCA::ReadArraySampleCachePtr() );
1677 ABCA::ObjectReaderPtr archive = a->getTop();
1678 ABCA::CompoundPropertyReaderPtr parent = archive->getProperties();
1679 TESTING_ASSERT(parent->getNumProperties() == 2);
1680
1681 ABCA::ArrayPropertyReaderPtr ap = parent->getArrayProperty("str");
1682 TESTING_ASSERT(ap->getNumSamples() == 10);
1683
1684 ABCA::ArrayPropertyReaderPtr ap2 = parent->getArrayProperty("str2");
1685 TESTING_ASSERT(ap2->getNumSamples() == 6);
1686
1687 ABCA::ArraySamplePtr val;
1688 for (int i = 0; i < 10; ++i)
1689 {
1690 ap->getSample(i, val);
1691 Alembic::Util::string * data =
1692 (Alembic::Util::string *)(val->getData());
1693 if (i < 3 || i > 7)
1694 {
1695 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
1696 TESTING_ASSERT(val->getDimensions().rank() == 1);
1697 TESTING_ASSERT(data[0] == "");
1698 TESTING_ASSERT(data[1] == "");
1699 TESTING_ASSERT(data[2] == "");
1700 TESTING_ASSERT(data[3] == "");
1701 }
1702
1703 if (i == 3 || i == 4 || i == 5)
1704 {
1705 TESTING_ASSERT(val->getDimensions().numPoints() == 6);
1706 TESTING_ASSERT(val->getDimensions().rank() == 1);
1707 for (unsigned int j = 0; j < vals.size(); ++j)
1708 {
1709 TESTING_ASSERT(data[j] == vals[j]);
1710 }
1711 }
1712
1713 if (i == 6 || i == 7)
1714 {
1715 TESTING_ASSERT(val->getDimensions().numPoints() == 4);
1716 TESTING_ASSERT(val->getDimensions().rank() == 1);
1717 for (unsigned int j = 0; j < vals2.size(); ++j)
1718 {
1719 TESTING_ASSERT(data[j] == vals2[j]);
1720 }
1721 }
1722 }
1723
1724 for (int i = 0; i < 6; ++i)
1725 {
1726 ap2->getSample(i, val);
1727 Alembic::Util::string * data =
1728 (Alembic::Util::string *)(val->getData());
1729
1730 if (i < 3)
1731 {
1732 TESTING_ASSERT(val->getDimensions().numPoints() == 3);
1733 TESTING_ASSERT(val->getDimensions().rank() == 1);
1734 for (unsigned int j = 0; j < vals.size(); ++j)
1735 {
1736 TESTING_ASSERT(data[j] == vals[j]);
1737 }
1738 }
1739
1740 if (i == 3)
1741 {
1742 TESTING_ASSERT(val->getDimensions().numPoints() == 0);
1743 TESTING_ASSERT(val->getDimensions().rank() == 1);
1744 }
1745
1746 if (i > 3)
1747 {
1748 TESTING_ASSERT(val->getDimensions().numPoints() == 2);
1749 TESTING_ASSERT(val->getDimensions().rank() == 1);
1750 for (unsigned int j = 0; j < vals2.size(); ++j)
1751 {
1752 TESTING_ASSERT(data[j] == vals2[j]);
1753 }
1754 }
1755 }
1756 }
1757 }
1758
1759 int main ( int argc, char *argv[] )
1760 {
1761 testEmptyArray();
1762 testDuplicateArray();
1763 testReadWriteArrays();
1764 testExtentArrayStrings();
1765 testArrayStringsRepeats();
1766 return 0;
1767 }