The Tor Browser / file comparison

comparison: ipc/ipdl/test/cxx/TestDataStructures.cpp

ipc/ipdl/test/cxx/TestDataStructures.cpp

branch
TOR_BUG_3246
changeset 6
8bccb770b82d
equal deleted inserted replaced
-1:000000000000 0:87eb514bae19
1 #include "TestDataStructures.h"
2
3 #include "mozilla/unused.h"
4
5 #include "IPDLUnitTests.h" // fail etc.
6
7 typedef InfallibleTArray<nsIntRegion> RegionArray;
8
9 namespace mozilla {
10 namespace _ipdltest {
11
12 static const uint32_t nactors = 10;
13
14 #define test_assert(_cond, _msg) \
15 if (!(_cond)) fail(_msg)
16
17 template<typename T>
18 static void
19 assert_arrays_equal(const InfallibleTArray<T>& a, const InfallibleTArray<T>& b)
20 {
21 test_assert(a == b, "arrays equal");
22 }
23
24 inline static TestDataStructuresSub&
25 Cast(PTestDataStructuresSubParent* a)
26 {
27 return *static_cast<TestDataStructuresSub*>(a);
28 }
29
30 inline static TestDataStructuresSub&
31 Cast(PTestDataStructuresSubChild* a)
32 {
33 return *static_cast<TestDataStructuresSub*>(a);
34 }
35
36 //-----------------------------------------------------------------------------
37 // parent
38
39 TestDataStructuresParent::TestDataStructuresParent()
40 {
41 MOZ_COUNT_CTOR(TestDataStructuresParent);
42 }
43
44 TestDataStructuresParent::~TestDataStructuresParent()
45 {
46 MOZ_COUNT_DTOR(TestDataStructuresParent);
47 }
48
49 void
50 TestDataStructuresParent::Main()
51 {
52 for (uint32_t i = 0; i < nactors; ++i)
53 if (!SendPTestDataStructuresSubConstructor(i))
54 fail("can't alloc actor");
55
56 if (!SendStart())
57 fail("can't send Start()");
58 }
59
60 bool
61 TestDataStructuresParent::DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor)
62 {
63 test_assert(Cast(actor).mI == Cast(mKids[0]).mI,
64 "dtor sent to wrong actor");
65 mKids.RemoveElementAt(0);
66 delete actor;
67 if (mKids.Length() > 0)
68 return true;
69
70 return true;
71 }
72
73 bool TestDataStructuresParent::RecvTest1(
74 const InfallibleTArray<int>& ia,
75 InfallibleTArray<int>* oa)
76 {
77 test_assert(5 == ia.Length(), "wrong length");
78 for (int i = 0; i < 5; ++i)
79 test_assert(i == ia[i], "wrong value");
80
81 *oa = ia;
82
83 return true;
84 }
85
86 bool TestDataStructuresParent::RecvTest2(
87 const InfallibleTArray<PTestDataStructuresSubParent*>& i1,
88 InfallibleTArray<PTestDataStructuresSubParent*>* o1)
89 {
90 test_assert(nactors == i1.Length(), "wrong #actors");
91 for (uint32_t i = 0; i < i1.Length(); ++i)
92 test_assert(i == Cast(i1[i]).mI, "wrong mI value");
93 *o1 = i1;
94 return true;
95 }
96
97 bool TestDataStructuresParent::RecvTest3(
98 const IntDouble& i1,
99 const IntDouble& i2,
100 IntDouble* o1,
101 IntDouble* o2)
102 {
103 test_assert(42 == i1.get_int(), "wrong value");
104 test_assert(4.0 == i2.get_double(), "wrong value");
105
106 *o1 = i1;
107 *o2 = i2;
108
109 return true;
110 }
111
112 bool TestDataStructuresParent::RecvTest4(
113 const InfallibleTArray<IntDouble>& i1,
114 InfallibleTArray<IntDouble>* o1)
115 {
116 test_assert(4 == i1.Length(), "wrong length");
117 test_assert(1 == i1[0].get_int(), "wrong value");
118 test_assert(2.0 == i1[1].get_double(), "wrong value");
119 test_assert(3 == i1[2].get_int(), "wrong value");
120 test_assert(4.0 == i1[3].get_double(), "wrong value");
121
122 *o1 = i1;
123
124 return true;
125 }
126
127 bool TestDataStructuresParent::RecvTest5(
128 const IntDoubleArrays& i1,
129 const IntDoubleArrays& i2,
130 const IntDoubleArrays& i3,
131 IntDoubleArrays* o1,
132 IntDoubleArrays* o2,
133 IntDoubleArrays* o3)
134 {
135 test_assert(42 == i1.get_int(), "wrong value");
136
137 const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
138 test_assert(3 == i2a.Length(), "wrong length");
139 test_assert(1 == i2a[0], "wrong value");
140 test_assert(2 == i2a[1], "wrong value");
141 test_assert(3 == i2a[2], "wrong value");
142
143 const InfallibleTArray<double>& i3a = i3.get_ArrayOfdouble();
144 test_assert(3 == i3a.Length(), "wrong length");
145 test_assert(1.0 == i3a[0], "wrong value");
146 test_assert(2.0 == i3a[1], "wrong value");
147 test_assert(3.0 == i3a[2], "wrong value");
148
149 *o1 = i1;
150 *o2 = i2a;
151 *o3 = i3a;
152
153 return true;
154 }
155
156 bool
157 TestDataStructuresParent::RecvTest7_0(const ActorWrapper& i1,
158 ActorWrapper* o1)
159 {
160 if (i1.actorChild() != nullptr)
161 fail("child side actor should always be null");
162
163 if (i1.actorParent() != mKids[0])
164 fail("should have got back same actor on parent side");
165
166 o1->actorParent() = mKids[0];
167 // malicious behavior
168 o1->actorChild() =
169 reinterpret_cast<PTestDataStructuresSubChild*>(0xdeadbeef);
170 return true;
171 }
172
173 bool TestDataStructuresParent::RecvTest6(
174 const InfallibleTArray<IntDoubleArrays>& i1,
175 InfallibleTArray<IntDoubleArrays>* o1)
176 {
177 test_assert(3 == i1.Length(), "wrong length");
178
179 IntDoubleArrays id1(i1[0]);
180 test_assert(42 == id1.get_int(), "wrong value");
181
182 InfallibleTArray<int> i2a(i1[1].get_ArrayOfint());
183 test_assert(3 == i2a.Length(), "wrong length");
184 test_assert(1 == i2a[0], "wrong value");
185 test_assert(2 == i2a[1], "wrong value");
186 test_assert(3 == i2a[2], "wrong value");
187
188 InfallibleTArray<double> i3a(i1[2].get_ArrayOfdouble());
189 test_assert(3 == i3a.Length(), "wrong length");
190 test_assert(1.0 == i3a[0], "wrong value");
191 test_assert(2.0 == i3a[1], "wrong value");
192 test_assert(3.0 == i3a[2], "wrong value");
193
194 o1->AppendElement(id1);
195 o1->AppendElement(IntDoubleArrays(i2a));
196 o1->AppendElement(IntDoubleArrays(i3a));
197
198 return true;
199 }
200
201 bool TestDataStructuresParent::RecvTest7(
202 const Actors& i1,
203 const Actors& i2,
204 const Actors& i3,
205 Actors* o1,
206 Actors* o2,
207 Actors* o3)
208 {
209 test_assert(42 == i1.get_int(), "wrong value");
210
211 InfallibleTArray<int> i2a(i2.get_ArrayOfint());
212 test_assert(3 == i2a.Length(), "wrong length");
213 test_assert(1 == i2a[0], "wrong value");
214 test_assert(2 == i2a[1], "wrong value");
215 test_assert(3 == i2a[2], "wrong value");
216
217 assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
218
219 *o1 = 42;
220 *o2 = i2a;
221 *o3 = mKids;
222
223 return true;
224 }
225
226 bool TestDataStructuresParent::RecvTest8(
227 const InfallibleTArray<Actors>& i1,
228 InfallibleTArray<Actors>* o1)
229 {
230 test_assert(3 == i1.Length(), "wrong length");
231 test_assert(42 == i1[0].get_int(), "wrong value");
232
233 const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
234 test_assert(3 == i2a.Length(), "wrong length");
235 test_assert(1 == i2a[0], "wrong value");
236 test_assert(2 == i2a[1], "wrong value");
237 test_assert(3 == i2a[2], "wrong value");
238
239 assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
240
241 *o1 = i1;
242
243 return true;
244 }
245
246 bool TestDataStructuresParent::RecvTest9(
247 const Unions& i1,
248 const Unions& i2,
249 const Unions& i3,
250 const Unions& i4,
251 Unions* o1,
252 Unions* o2,
253 Unions* o3,
254 Unions* o4)
255 {
256 test_assert(42 == i1.get_int(), "wrong value");
257
258 const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
259 test_assert(3 == i2a.Length(), "wrong length");
260 test_assert(1 == i2a[0], "wrong value");
261 test_assert(2 == i2a[1], "wrong value");
262 test_assert(3 == i2a[2], "wrong value");
263
264 assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
265
266 const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
267 i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
268 assert_arrays_equal(mKids, i4a);
269
270 *o1 = i1;
271 *o2 = i2;
272 *o3 = i3;
273 *o4 = i4;
274
275 return true;
276 }
277
278 bool TestDataStructuresParent::RecvTest10(
279 const InfallibleTArray<Unions>& i1,
280 InfallibleTArray<Unions>* o1)
281 {
282 test_assert(42 == i1[0].get_int(), "wrong value");
283
284 const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
285 test_assert(3 == i2a.Length(), "wrong length");
286 test_assert(1 == i2a[0], "wrong value");
287 test_assert(2 == i2a[1], "wrong value");
288 test_assert(3 == i2a[2], "wrong value");
289
290 assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
291
292 const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
293 i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
294 assert_arrays_equal(mKids, i4a);
295
296 *o1 = i1;
297
298 return true;
299 }
300
301 bool TestDataStructuresParent::RecvTest11(
302 const SIntDouble& i,
303 SIntDouble* o)
304 {
305 test_assert(1 == i.i(), "wrong value");
306 test_assert(2.0 == i.d(), "wrong value");
307 *o = i;
308 return true;
309 }
310
311 bool TestDataStructuresParent::RecvTest12(
312 const SIntDoubleArrays& i,
313 SIntDoubleArrays* o)
314 {
315 InfallibleTArray<int> ai;
316 ai.AppendElement(1);
317 ai.AppendElement(2);
318 ai.AppendElement(3);
319
320 InfallibleTArray<double> ad;
321 ad.AppendElement(.5);
322 ad.AppendElement(1.0);
323 ad.AppendElement(2.0);
324
325 test_assert(42 == i.i(), "wrong value");
326 assert_arrays_equal(ai, i.ai());
327 assert_arrays_equal(ad, i.ad());
328
329 *o = i;
330
331 return true;
332 }
333
334 bool TestDataStructuresParent::RecvTest13(
335 const SActors& i,
336 SActors* o)
337 {
338 InfallibleTArray<int> ai;
339 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
340
341 test_assert(42 == i.i(), "wrong value");
342 assert_arrays_equal(ai, i.ai());
343 assert_arrays_equal(mKids, i.apParent());
344
345 *o = i;
346
347 return true;
348 }
349
350 bool TestDataStructuresParent::RecvTest14(
351 const Structs& i,
352 Structs* o)
353 {
354 InfallibleTArray<int> ai;
355 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
356
357 test_assert(42 == i.i(), "wrong value");
358 assert_arrays_equal(ai, i.ai());
359 assert_arrays_equal(mKids, i.apParent());
360
361 const SActors& ia = i.aa()[0];
362 test_assert(42 == ia.i(), "wrong value");
363 assert_arrays_equal(ai, ia.ai());
364 assert_arrays_equal(mKids, ia.apParent());
365
366 *o = i;
367
368 return true;
369 }
370
371 bool TestDataStructuresParent::RecvTest15(
372 const WithStructs& i1,
373 const WithStructs& i2,
374 const WithStructs& i3,
375 const WithStructs& i4,
376 const WithStructs& i5,
377 WithStructs* o1,
378 WithStructs* o2,
379 WithStructs* o3,
380 WithStructs* o4,
381 WithStructs* o5)
382 {
383 InfallibleTArray<int> ai;
384 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
385
386 test_assert(i1 == int(42), "wrong value");
387 assert_arrays_equal(i2.get_ArrayOfint(), ai);
388 assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);
389
390 const SActors& ia = i4.get_ArrayOfSActors()[0];
391 test_assert(42 == ia.i(), "wrong value");
392 assert_arrays_equal(ai, ia.ai());
393 assert_arrays_equal(mKids, ia.apParent());
394
395 const Structs& is = i5.get_ArrayOfStructs()[0];
396 test_assert(42 == is.i(), "wrong value");
397 assert_arrays_equal(ai, is.ai());
398 assert_arrays_equal(mKids, is.apParent());
399
400 const SActors& isa = is.aa()[0];
401 test_assert(42 == isa.i(), "wrong value");
402 assert_arrays_equal(ai, isa.ai());
403 assert_arrays_equal(mKids, isa.apParent());
404
405 *o1 = i1;
406 *o2 = i2;
407 *o3 = i3;
408 *o4 = i4;
409 *o5 = i5;
410
411 return true;
412 }
413
414 bool TestDataStructuresParent::RecvTest16(
415 const WithUnions& i,
416 WithUnions* o)
417 {
418 test_assert(i.i() == 42, "wrong value");
419
420 InfallibleTArray<int> ai;
421 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
422 assert_arrays_equal(ai, i.ai());
423
424 assert_arrays_equal(i.apParent(), mKids);
425
426 assert_arrays_equal(mKids, i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());
427
428 const InfallibleTArray<Unions>& iau = i.au();
429 test_assert(iau[0] == 42, "wrong value");
430 assert_arrays_equal(ai, iau[1].get_ArrayOfint());
431 assert_arrays_equal(mKids, iau[2].get_ArrayOfPTestDataStructuresSubParent());
432 assert_arrays_equal(mKids,
433 iau[3].get_ArrayOfActors()[0]
434 .get_ArrayOfPTestDataStructuresSubParent());
435
436 *o = i;
437
438 return true;
439 }
440
441 bool TestDataStructuresParent::RecvTest17(const InfallibleTArray<Op>& sa)
442 {
443 test_assert(sa.Length() == 1 && Op::TSetAttrs == sa[0].type(),
444 "wrong value");
445 return true;
446 }
447
448 bool TestDataStructuresParent::RecvTest18(const RegionArray& ra)
449 {
450 for (RegionArray::index_type i = 0; i < ra.Length(); ++i) {
451 nsIntRegionRectIterator it(ra[i]);
452 // if |ra| has been realloc()d and given a different allocator
453 // chunk, this next line will nondeterministically crash or
454 // iloop
455 while (const nsIntRect* sr = it.Next()) unused << sr;
456 }
457
458 return true;
459 }
460
461 //-----------------------------------------------------------------------------
462 // child
463
464 TestDataStructuresChild::TestDataStructuresChild()
465 {
466 MOZ_COUNT_CTOR(TestDataStructuresChild);
467 }
468
469 TestDataStructuresChild::~TestDataStructuresChild()
470 {
471 MOZ_COUNT_DTOR(TestDataStructuresChild);
472 }
473
474 bool
475 TestDataStructuresChild::RecvStart()
476 {
477 puts("[TestDataStructuresChild] starting");
478
479 Test1();
480 Test2();
481 Test3();
482 Test4();
483 Test5();
484 Test6();
485 Test7_0();
486 Test7();
487 Test8();
488 Test9();
489 Test10();
490 Test11();
491 Test12();
492 Test13();
493 Test14();
494 Test15();
495 Test16();
496 Test17();
497 if (OtherProcess() != 0) {
498 //FIXME/bug 703317 allocation of nsIntRegion uses a global
499 //region pool which breaks threads
500 Test18();
501 }
502
503 for (uint32_t i = 0; i < nactors; ++i)
504 if (!PTestDataStructuresSubChild::Send__delete__(mKids[i]))
505 fail("can't send dtor");
506
507 Close();
508
509 return true;
510 }
511
512 void
513 TestDataStructuresChild::Test1()
514 {
515 InfallibleTArray<int> ia;
516
517 for (int i = 0; i < 5; ++i)
518 ia.AppendElement(i);
519
520 InfallibleTArray<int> oa;
521 if (!SendTest1(ia, &oa))
522 fail("can't send Test1");
523
524 assert_arrays_equal(ia, oa);
525
526 printf(" passed %s\n", __FUNCTION__);
527 }
528
529 void
530 TestDataStructuresChild::Test2()
531 {
532 InfallibleTArray<PTestDataStructuresSubChild*> oa;
533 if (!SendTest2(mKids, &oa))
534 fail("can't send Test2");
535 assert_arrays_equal(mKids, oa);
536
537 printf(" passed %s\n", __FUNCTION__);
538 }
539
540 void
541 TestDataStructuresChild::Test3()
542 {
543 int i1i = 42;
544 double i2d = 4.0;
545 IntDouble i1(i1i);
546 IntDouble i2(i2d);
547 IntDouble o1, o2;
548
549 SendTest3(i1, i2, &o1, &o2);
550
551 test_assert(i1i == o1.get_int(), "wrong value");
552 test_assert(i2d == o2.get_double(), "wrong value");
553
554 printf(" passed %s\n", __FUNCTION__);
555 }
556
557 void
558 TestDataStructuresChild::Test4()
559 {
560 InfallibleTArray<IntDouble> i1;
561 i1.AppendElement(IntDouble(int(1)));
562 i1.AppendElement(IntDouble(2.0));
563 i1.AppendElement(IntDouble(int(3)));
564 i1.AppendElement(IntDouble(4.0));
565
566 InfallibleTArray<IntDouble> o1;
567 if (!SendTest4(i1, &o1))
568 fail("can't send Test4");
569
570 // TODO Union::operator==()
571 test_assert(i1.Length() == o1.Length(), "wrong length");
572 test_assert(1 == o1[0].get_int(), "wrong value");
573 test_assert(2.0 == o1[1].get_double(), "wrong value");
574 test_assert(3 == o1[2].get_int(), "wrong value");
575 test_assert(4.0 == o1[3].get_double(), "wrong value");
576
577 printf(" passed %s\n", __FUNCTION__);
578 }
579
580 void
581 TestDataStructuresChild::Test5()
582 {
583 IntDoubleArrays i1(int(42));
584 InfallibleTArray<int> i2;
585 i2.AppendElement(1); i2.AppendElement(2); i2.AppendElement(3);
586 InfallibleTArray<double> i3;
587 i3.AppendElement(1.0); i3.AppendElement(2.0); i3.AppendElement(3.0);
588
589 IntDoubleArrays o1, o2, o3;
590 if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3),
591 &o1, &o2, &o3))
592 fail("can't send Test5");
593
594 test_assert(42 == o1.get_int(), "wrong value");
595 assert_arrays_equal(i2, o2.get_ArrayOfint());
596 assert_arrays_equal(i3, o3.get_ArrayOfdouble());
597
598 printf(" passed %s\n", __FUNCTION__);
599 }
600
601 void
602 TestDataStructuresChild::Test6()
603 {
604 IntDoubleArrays id1(int(42));
605 InfallibleTArray<int> id2;
606 id2.AppendElement(1); id2.AppendElement(2); id2.AppendElement(3);
607 InfallibleTArray<double> id3;
608 id3.AppendElement(1.0); id3.AppendElement(2.0); id3.AppendElement(3.0);
609
610 InfallibleTArray<IntDoubleArrays> i1;
611 i1.AppendElement(id1);
612 i1.AppendElement(IntDoubleArrays(id2));
613 i1.AppendElement(IntDoubleArrays(id3));
614
615 InfallibleTArray<IntDoubleArrays> o1;
616 if (!SendTest6(i1, &o1))
617 fail("can't send Test6");
618
619 test_assert(3 == o1.Length(), "wrong length");
620 IntDoubleArrays od1(o1[0]);
621 InfallibleTArray<int> od2(o1[1].get_ArrayOfint());
622 InfallibleTArray<double> od3(o1[2].get_ArrayOfdouble());
623
624 test_assert(42 == od1.get_int(), "wrong value");
625 assert_arrays_equal(id2, od2);
626 assert_arrays_equal(id3, od3);
627
628 printf(" passed %s\n", __FUNCTION__);
629 }
630
631 void
632 TestDataStructuresChild::Test7_0()
633 {
634 ActorWrapper iaw;
635 if (iaw.actorChild() != nullptr || iaw.actorParent() != nullptr)
636 fail("actor members should be null initially");
637
638 iaw.actorChild() = mKids[0];
639 if (iaw.actorParent() != nullptr)
640 fail("parent should be null on child side after set");
641
642 ActorWrapper oaw;
643 if (!SendTest7_0(iaw, &oaw))
644 fail("sending Test7_0");
645
646 if (oaw.actorParent() != nullptr)
647 fail("parent accessor on actor-struct members should always be null in child");
648
649 if (oaw.actorChild() != mKids[0])
650 fail("should have got back same child-side actor");
651 }
652
653 void
654 TestDataStructuresChild::Test7()
655 {
656 Actors i1(42);
657 InfallibleTArray<int> i2a;
658 i2a.AppendElement(1); i2a.AppendElement(2); i2a.AppendElement(3);
659
660 Actors o1, o2, o3;
661 if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))
662 fail("can't send Test7");
663
664 test_assert(42 == o1.get_int(), "wrong value");
665 assert_arrays_equal(i2a, o2.get_ArrayOfint());
666 assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
667
668 printf(" passed %s\n", __FUNCTION__);
669 }
670
671 void
672 TestDataStructuresChild::Test8()
673 {
674 Actors i1e(42);
675 InfallibleTArray<int> i2a;
676 i2a.AppendElement(1); i2a.AppendElement(2); i2a.AppendElement(3);
677
678 InfallibleTArray<Actors> i1;
679 i1.AppendElement(i1e);
680 i1.AppendElement(i2a);
681 i1.AppendElement(mKids);
682
683 InfallibleTArray<Actors> o1;
684 if (!SendTest8(i1, &o1))
685 fail("can't send Test8");
686
687 test_assert(3 == o1.Length(), "wrong length");
688 test_assert(42 == o1[0].get_int(), "wrong value");
689 assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
690 assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
691
692 printf(" passed %s\n", __FUNCTION__);
693 }
694
695 void
696 TestDataStructuresChild::Test9()
697 {
698 Unions i1(int(42));
699
700 InfallibleTArray<int> i2a;
701 i2a.AppendElement(1);
702 i2a.AppendElement(2);
703 i2a.AppendElement(3);
704
705 InfallibleTArray<Actors> i4a;
706 i4a.AppendElement(mKids);
707
708 Unions o1, o2, o3, o4;
709 if (!SendTest9(i1, Unions(i2a), Unions(mKids), Unions(i4a),
710 &o1, &o2, &o3, &o4))
711 fail("can't send Test9");
712
713 test_assert(42 == o1.get_int(), "wrong value");
714 assert_arrays_equal(i2a, o2.get_ArrayOfint());
715 assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
716 assert_arrays_equal(
717 mKids,
718 o4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
719
720 printf(" passed %s\n", __FUNCTION__);
721 }
722
723 void
724 TestDataStructuresChild::Test10()
725 {
726 Unions i1a(int(42));
727
728 InfallibleTArray<int> i2a;
729 i2a.AppendElement(1);
730 i2a.AppendElement(2);
731 i2a.AppendElement(3);
732
733 InfallibleTArray<Actors> i4a;
734 i4a.AppendElement(mKids);
735
736 InfallibleTArray<Unions> i1;
737 i1.AppendElement(i1a);
738 i1.AppendElement(Unions(i2a));
739 i1.AppendElement(Unions(mKids));
740 i1.AppendElement(Unions(i4a));
741
742 InfallibleTArray<Unions> o1;
743 if (!SendTest10(i1, &o1))
744 fail("can't send Test10");
745
746 test_assert(4 == o1.Length(), "wrong length");
747 test_assert(42 == o1[0].get_int(), "wrong value");
748 assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
749 assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
750 assert_arrays_equal(
751 mKids,
752 o1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
753
754 printf(" passed %s\n", __FUNCTION__);
755 }
756
757 void
758 TestDataStructuresChild::Test11()
759 {
760 SIntDouble i(1, 2.0);
761 SIntDouble o;
762
763 if (!SendTest11(i, &o))
764 fail("sending Test11");
765
766 test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");
767
768 printf(" passed %s\n", __FUNCTION__);
769 }
770
771 void
772 TestDataStructuresChild::Test12()
773 {
774 InfallibleTArray<int> ai;
775 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
776
777 InfallibleTArray<double> ad;
778 ad.AppendElement(.5); ad.AppendElement(1.0); ad.AppendElement(2.0);
779
780 SIntDoubleArrays i(42, ai, ad);
781 SIntDoubleArrays o;
782
783 if (!SendTest12(i, &o))
784 fail("sending Test12");
785
786 test_assert(42 == o.i(), "wrong value");
787 assert_arrays_equal(ai, o.ai());
788 assert_arrays_equal(ad, o.ad());
789
790 printf(" passed %s\n", __FUNCTION__);
791 }
792
793 void
794 TestDataStructuresChild::Test13()
795 {
796 InfallibleTArray<int> ai;
797 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
798
799 SActors i;
800 i.i() = 42;
801 i.ai() = ai;
802 i.apChild() = mKids;
803
804 SActors o;
805 if (!SendTest13(i, &o))
806 fail("can't send Test13");
807
808 test_assert(42 == o.i(), "wrong value");
809 assert_arrays_equal(ai, o.ai());
810 assert_arrays_equal(mKids, o.apChild());
811
812 printf(" passed %s\n", __FUNCTION__);
813 }
814
815 void
816 TestDataStructuresChild::Test14()
817 {
818 InfallibleTArray<int> ai;
819 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
820
821 SActors ia;
822 ia.i() = 42;
823 ia.ai() = ai;
824 ia.apChild() = mKids;
825 InfallibleTArray<SActors> aa; aa.AppendElement(ia);
826
827 Structs i;
828 i.i() = 42;
829 i.ai() = ai;
830 i.apChild() = mKids;
831 i.aa() = aa;
832
833 Structs o;
834 if (!SendTest14(i, &o))
835 fail("can't send Test14");
836
837 test_assert(42 == o.i(), "wrong value");
838 assert_arrays_equal(ai, o.ai());
839 assert_arrays_equal(mKids, o.apChild());
840
841 const SActors& os = o.aa()[0];
842 test_assert(42 == os.i(), "wrong value");
843 assert_arrays_equal(ai, os.ai());
844 assert_arrays_equal(mKids, os.apChild());
845
846 printf(" passed %s\n", __FUNCTION__);
847 }
848
849 void
850 TestDataStructuresChild::Test15()
851 {
852 InfallibleTArray<int> ai;
853 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
854
855 SActors ia;
856 ia.i() = 42;
857 ia.ai() = ai;
858 ia.apChild() = mKids;
859 InfallibleTArray<SActors> iaa; iaa.AppendElement(ia);
860
861 Structs is;
862 is.i() = 42;
863 is.ai() = ai;
864 is.apChild() = mKids;
865 is.aa() = iaa;
866 InfallibleTArray<Structs> isa; isa.AppendElement(is);
867
868 WithStructs o1, o2, o3, o4, o5;
869 if (!SendTest15(WithStructs(42),
870 WithStructs(ai),
871 WithStructs(mKids),
872 WithStructs(iaa),
873 WithStructs(isa),
874 &o1, &o2, &o3, &o4, &o5))
875 fail("sending Test15");
876
877 test_assert(o1 == int(42), "wrong value");
878 assert_arrays_equal(o2.get_ArrayOfint(), ai);
879 assert_arrays_equal(o3.get_ArrayOfPTestDataStructuresSubChild(), mKids);
880
881 const SActors& oa = o4.get_ArrayOfSActors()[0];
882 test_assert(42 == oa.i(), "wrong value");
883 assert_arrays_equal(ai, oa.ai());
884 assert_arrays_equal(mKids, oa.apChild());
885
886 const Structs& os = o5.get_ArrayOfStructs()[0];
887 test_assert(42 == os.i(), "wrong value");
888 assert_arrays_equal(ai, os.ai());
889 assert_arrays_equal(mKids, os.apChild());
890
891 const SActors& osa = os.aa()[0];
892 test_assert(42 == osa.i(), "wrong value");
893 assert_arrays_equal(ai, osa.ai());
894 assert_arrays_equal(mKids, osa.apChild());
895
896 printf(" passed %s\n", __FUNCTION__);
897 }
898
899 void
900 TestDataStructuresChild::Test16()
901 {
902 WithUnions i;
903
904 i.i() = 42;
905
906 InfallibleTArray<int> ai;
907 ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
908 i.ai() = ai;
909
910 i.apChild() = mKids;
911
912 InfallibleTArray<Actors> iaa;
913 iaa.AppendElement(mKids);
914 i.aa() = iaa;
915
916 InfallibleTArray<Unions> iau;
917 iau.AppendElement(int(42));
918 iau.AppendElement(ai);
919 iau.AppendElement(mKids);
920 iau.AppendElement(iaa);
921 i.au() = iau;
922
923 WithUnions o;
924 if (!SendTest16(i, &o))
925 fail("sending Test16");
926
927 test_assert(42 == o.i(), "wrong value");
928 assert_arrays_equal(o.ai(), ai);
929 assert_arrays_equal(o.apChild(), mKids);
930
931 const Actors& oaa = o.aa()[0];
932 assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);
933
934 const InfallibleTArray<Unions>& oau = o.au();
935 test_assert(oau[0] == 42, "wrong value");
936 assert_arrays_equal(oau[1].get_ArrayOfint(), ai);
937 assert_arrays_equal(oau[2].get_ArrayOfPTestDataStructuresSubChild(),
938 mKids);
939 assert_arrays_equal(oau[3].get_ArrayOfActors()[0]
940 .get_ArrayOfPTestDataStructuresSubChild(),
941 mKids);
942
943 printf(" passed %s\n", __FUNCTION__);
944 }
945
946 void
947 TestDataStructuresChild::Test17()
948 {
949 Attrs attrs;
950 attrs.common() = CommonAttrs(true);
951 attrs.specific() = BarAttrs(1.0f);
952
953 InfallibleTArray<Op> ops;
954 ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));
955
956 if (!SendTest17(ops))
957 fail("sending Test17");
958
959 printf(" passed %s\n", __FUNCTION__);
960 }
961
962 void
963 TestDataStructuresChild::Test18()
964 {
965 const int nelements = 1000;
966 RegionArray ra;
967 // big enough to hopefully force a realloc to a different chunk of
968 // memory on the receiving side, if the workaround isn't working
969 // correctly. But SetCapacity() here because we don't want to
970 // crash on the sending side.
971 ra.SetCapacity(nelements);
972 for (int i = 0; i < nelements; ++i) {
973 nsIntRegion r;
974 r = r.Or(nsIntRect(0, 0, 10, 10), nsIntRect(10, 10, 10, 10));
975 ra.AppendElement(r);
976 }
977
978 if (!SendTest18(ra))
979 fail("sending Test18");
980
981 printf(" passed %s\n", __FUNCTION__);
982 }
983
984 } // namespace _ipdltest
985 } // namespace mozilla

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial