The Tor Browser: ipc/ipdl/test/cxx/TestDataStructures.cpp@8bccb770b82d

     1 #include "TestDataStructures.h"

     3 #include "mozilla/unused.h"

     5 #include "IPDLUnitTests.h"      // fail etc.

     7 typedef InfallibleTArray<nsIntRegion> RegionArray;

     9 namespace mozilla {

    10 namespace _ipdltest {

    12 static const uint32_t nactors = 10;

    14 #define test_assert(_cond, _msg) \

    15     if (!(_cond)) fail(_msg)

    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 }

    24 inline static TestDataStructuresSub&

    25 Cast(PTestDataStructuresSubParent* a)

    26 {

    27     return *static_cast<TestDataStructuresSub*>(a);

    28 }

    30 inline static TestDataStructuresSub&

    31 Cast(PTestDataStructuresSubChild* a)

    32 {

    33     return *static_cast<TestDataStructuresSub*>(a);

    34 }

    36 //-----------------------------------------------------------------------------

    37 // parent

    39 TestDataStructuresParent::TestDataStructuresParent()

    40 {

    41     MOZ_COUNT_CTOR(TestDataStructuresParent);

    42 }

    44 TestDataStructuresParent::~TestDataStructuresParent()

    45 {

    46     MOZ_COUNT_DTOR(TestDataStructuresParent);

    47 }

    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");

    56     if (!SendStart())

    57         fail("can't send Start()");

    58 }

    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;

    70     return true;

    71 }

    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");

    81     *oa = ia;

    83     return true;

    84 }

    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 }

    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");

   106     *o1 = i1;

   107     *o2 = i2;

   109     return true;

   110 }

   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");

   122     *o1 = i1;

   124     return true;

   125 }

   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");

   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");

   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");

   149     *o1 = i1;

   150     *o2 = i2a;

   151     *o3 = i3a;

   153     return true;

   154 }

   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");

   163     if (i1.actorParent() != mKids[0])

   164         fail("should have got back same actor on parent side");

   166     o1->actorParent() = mKids[0];

   167     // malicious behavior

   168     o1->actorChild() =

   169         reinterpret_cast<PTestDataStructuresSubChild*>(0xdeadbeef);

   170     return true;

   171 }

   173 bool TestDataStructuresParent::RecvTest6(

   174         const InfallibleTArray<IntDoubleArrays>& i1,

   175         InfallibleTArray<IntDoubleArrays>* o1)

   176 {

   177     test_assert(3 == i1.Length(), "wrong length");

   179     IntDoubleArrays id1(i1[0]);

   180     test_assert(42 == id1.get_int(), "wrong value");

   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");

   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");

   194     o1->AppendElement(id1);

   195     o1->AppendElement(IntDoubleArrays(i2a));

   196     o1->AppendElement(IntDoubleArrays(i3a));

   198     return true;

   199 }

   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");

   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");

   217     assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());

   219     *o1 = 42;

   220     *o2 = i2a;

   221     *o3 = mKids;

   223     return true;

   224 }

   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");

   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");

   239     assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());

   241     *o1 = i1;

   243     return true;

   244 }

   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");

   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");

   264     assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());

   266     const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =

   267         i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();

   268     assert_arrays_equal(mKids, i4a);

   270     *o1 = i1;

   271     *o2 = i2;

   272     *o3 = i3;

   273     *o4 = i4;

   275     return true;

   276 }

   278 bool TestDataStructuresParent::RecvTest10(

   279         const InfallibleTArray<Unions>& i1,

   280         InfallibleTArray<Unions>* o1)

   281 {

   282     test_assert(42 == i1[0].get_int(), "wrong value");

   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");

   290     assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());

   292     const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =

   293         i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();

   294     assert_arrays_equal(mKids, i4a);

   296     *o1 = i1;

   298     return true;

   299 }

   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 }

   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);

   320     InfallibleTArray<double> ad;

   321     ad.AppendElement(.5);

   322     ad.AppendElement(1.0);

   323     ad.AppendElement(2.0);

   325     test_assert(42 == i.i(), "wrong value");

   326     assert_arrays_equal(ai, i.ai());

   327     assert_arrays_equal(ad, i.ad());

   329     *o = i;

   331     return true;

   332 }

   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);

   341     test_assert(42 == i.i(), "wrong value");

   342     assert_arrays_equal(ai, i.ai());

   343     assert_arrays_equal(mKids, i.apParent());

   345     *o = i;

   347     return true;

   348 }

   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);

   357     test_assert(42 == i.i(), "wrong value");

   358     assert_arrays_equal(ai, i.ai());

   359     assert_arrays_equal(mKids, i.apParent());

   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());

   366     *o = i;

   368     return true;

   369 }

   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);

   386     test_assert(i1 == int(42), "wrong value");

   387     assert_arrays_equal(i2.get_ArrayOfint(), ai);

   388     assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);

   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());

   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());

   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());

   405     *o1 = i1;

   406     *o2 = i2;

   407     *o3 = i3;

   408     *o4 = i4;

   409     *o5 = i5;

   411     return true;

   412 }

   414 bool TestDataStructuresParent::RecvTest16(

   415             const WithUnions& i,

   416             WithUnions* o)

   417 {

   418     test_assert(i.i() == 42, "wrong value");

   420     InfallibleTArray<int> ai;

   421     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   422     assert_arrays_equal(ai, i.ai());

   424     assert_arrays_equal(i.apParent(), mKids);

   426     assert_arrays_equal(mKids, i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());

   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());

   436     *o = i;

   438     return true;

   439 }

   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 }

   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     }

   458     return true;

   459 }

   461 //-----------------------------------------------------------------------------

   462 // child

   464 TestDataStructuresChild::TestDataStructuresChild()

   465 {

   466     MOZ_COUNT_CTOR(TestDataStructuresChild);

   467 }

   469 TestDataStructuresChild::~TestDataStructuresChild()

   470 {

   471     MOZ_COUNT_DTOR(TestDataStructuresChild);

   472 }

   474 bool

   475 TestDataStructuresChild::RecvStart()

   476 {

   477     puts("[TestDataStructuresChild] starting");

   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     }

   503     for (uint32_t i = 0; i < nactors; ++i)

   504         if (!PTestDataStructuresSubChild::Send__delete__(mKids[i]))

   505             fail("can't send dtor");

   507     Close();

   509     return true;

   510 }

   512 void

   513 TestDataStructuresChild::Test1()

   514 {

   515     InfallibleTArray<int> ia;

   517     for (int i = 0; i < 5; ++i)

   518         ia.AppendElement(i);

   520     InfallibleTArray<int> oa;

   521     if (!SendTest1(ia, &oa))

   522         fail("can't send Test1");

   524     assert_arrays_equal(ia, oa);

   526     printf("  passed %s\n", __FUNCTION__);

   527 }

   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);

   537     printf("  passed %s\n", __FUNCTION__);

   538 }

   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;

   549     SendTest3(i1, i2, &o1, &o2);

   551     test_assert(i1i == o1.get_int(), "wrong value");

   552     test_assert(i2d == o2.get_double(), "wrong value");

   554     printf("  passed %s\n", __FUNCTION__);

   555 }

   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));

   566     InfallibleTArray<IntDouble> o1;

   567     if (!SendTest4(i1, &o1))

   568         fail("can't send Test4");

   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");

   577     printf("  passed %s\n", __FUNCTION__);

   578 }

   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);

   589     IntDoubleArrays o1, o2, o3;

   590     if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3),

   591                    &o1, &o2, &o3))

   592         fail("can't send Test5");

   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());

   598     printf("  passed %s\n", __FUNCTION__);

   599 }

   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);

   610     InfallibleTArray<IntDoubleArrays> i1;

   611     i1.AppendElement(id1);

   612     i1.AppendElement(IntDoubleArrays(id2));

   613     i1.AppendElement(IntDoubleArrays(id3));

   615     InfallibleTArray<IntDoubleArrays> o1;

   616     if (!SendTest6(i1, &o1))

   617         fail("can't send Test6");

   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());

   624     test_assert(42 == od1.get_int(), "wrong value");

   625     assert_arrays_equal(id2, od2);

   626     assert_arrays_equal(id3, od3);

   628     printf("  passed %s\n", __FUNCTION__);

   629 }

   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");

   638     iaw.actorChild() = mKids[0];

   639     if (iaw.actorParent() != nullptr)

   640         fail("parent should be null on child side after set");

   642     ActorWrapper oaw;

   643     if (!SendTest7_0(iaw, &oaw))

   644         fail("sending Test7_0");

   646     if (oaw.actorParent() != nullptr)

   647         fail("parent accessor on actor-struct members should always be null in child");

   649     if (oaw.actorChild() != mKids[0])

   650         fail("should have got back same child-side actor");

   651 }

   653 void

   654 TestDataStructuresChild::Test7()

   655 {

   656     Actors i1(42);

   657     InfallibleTArray<int> i2a;

   658     i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);

   660     Actors o1, o2, o3;

   661     if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))

   662         fail("can't send Test7");

   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());

   668     printf("  passed %s\n", __FUNCTION__);

   669 }

   671 void

   672 TestDataStructuresChild::Test8()

   673 {

   674     Actors i1e(42);

   675     InfallibleTArray<int> i2a;

   676     i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);

   678     InfallibleTArray<Actors> i1;

   679     i1.AppendElement(i1e);

   680     i1.AppendElement(i2a);

   681     i1.AppendElement(mKids);

   683     InfallibleTArray<Actors> o1;

   684     if (!SendTest8(i1, &o1))

   685         fail("can't send Test8");

   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());

   692     printf("  passed %s\n", __FUNCTION__);

   693 }

   695 void

   696 TestDataStructuresChild::Test9()

   697 {

   698     Unions i1(int(42));

   700     InfallibleTArray<int> i2a;

   701     i2a.AppendElement(1);

   702     i2a.AppendElement(2);

   703     i2a.AppendElement(3);

   705     InfallibleTArray<Actors> i4a;

   706     i4a.AppendElement(mKids);

   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");

   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());

   720     printf("  passed %s\n", __FUNCTION__);

   721 }

   723 void

   724 TestDataStructuresChild::Test10()

   725 {

   726     Unions i1a(int(42));

   728     InfallibleTArray<int> i2a;

   729     i2a.AppendElement(1);

   730     i2a.AppendElement(2);

   731     i2a.AppendElement(3);

   733     InfallibleTArray<Actors> i4a;

   734     i4a.AppendElement(mKids);

   736     InfallibleTArray<Unions> i1;

   737     i1.AppendElement(i1a);

   738     i1.AppendElement(Unions(i2a));

   739     i1.AppendElement(Unions(mKids));

   740     i1.AppendElement(Unions(i4a));

   742     InfallibleTArray<Unions> o1;

   743     if (!SendTest10(i1, &o1))

   744         fail("can't send Test10");

   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());

   754     printf("  passed %s\n", __FUNCTION__);

   755 }

   757 void

   758 TestDataStructuresChild::Test11()

   759 {

   760     SIntDouble i(1, 2.0);

   761     SIntDouble o;

   763     if (!SendTest11(i, &o))

   764         fail("sending Test11");

   766     test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");

   768     printf("  passed %s\n", __FUNCTION__);

   769 }

   771 void

   772 TestDataStructuresChild::Test12()

   773 {

   774     InfallibleTArray<int> ai;

   775     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   777     InfallibleTArray<double> ad;

   778     ad.AppendElement(.5);  ad.AppendElement(1.0);  ad.AppendElement(2.0);

   780     SIntDoubleArrays i(42, ai, ad);

   781     SIntDoubleArrays o;

   783     if (!SendTest12(i, &o))

   784         fail("sending Test12");

   786     test_assert(42 == o.i(), "wrong value");

   787     assert_arrays_equal(ai, o.ai());

   788     assert_arrays_equal(ad, o.ad());

   790     printf("  passed %s\n", __FUNCTION__);

   791 }

   793 void

   794 TestDataStructuresChild::Test13()

   795 {

   796     InfallibleTArray<int> ai;

   797     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   799     SActors i;

   800     i.i() = 42;

   801     i.ai() = ai;

   802     i.apChild() = mKids;

   804     SActors o;

   805     if (!SendTest13(i, &o))

   806         fail("can't send Test13");

   808     test_assert(42 == o.i(), "wrong value");

   809     assert_arrays_equal(ai, o.ai());

   810     assert_arrays_equal(mKids, o.apChild());

   812     printf("  passed %s\n", __FUNCTION__);

   813 }

   815 void

   816 TestDataStructuresChild::Test14()

   817 {

   818     InfallibleTArray<int> ai;

   819     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   821     SActors ia;

   822     ia.i() = 42;

   823     ia.ai() = ai;

   824     ia.apChild() = mKids;

   825     InfallibleTArray<SActors> aa;  aa.AppendElement(ia);

   827     Structs i;

   828     i.i() = 42;

   829     i.ai() = ai;

   830     i.apChild() = mKids;

   831     i.aa() = aa;

   833     Structs o;

   834     if (!SendTest14(i, &o))

   835         fail("can't send Test14");

   837     test_assert(42 == o.i(), "wrong value");

   838     assert_arrays_equal(ai, o.ai());

   839     assert_arrays_equal(mKids, o.apChild());

   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());

   846     printf("  passed %s\n", __FUNCTION__);

   847 }

   849 void

   850 TestDataStructuresChild::Test15()

   851 {

   852     InfallibleTArray<int> ai;

   853     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   855     SActors ia;

   856     ia.i() = 42;

   857     ia.ai() = ai;

   858     ia.apChild() = mKids;

   859     InfallibleTArray<SActors> iaa;  iaa.AppendElement(ia);

   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);

   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");

   877     test_assert(o1 == int(42), "wrong value");

   878     assert_arrays_equal(o2.get_ArrayOfint(), ai);

   879     assert_arrays_equal(o3.get_ArrayOfPTestDataStructuresSubChild(), mKids);

   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());

   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());

   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());

   896     printf("  passed %s\n", __FUNCTION__);

   897 }

   899 void

   900 TestDataStructuresChild::Test16()

   901 {

   902     WithUnions i;

   904     i.i() = 42;

   906     InfallibleTArray<int> ai;

   907     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);

   908     i.ai() = ai;

   910     i.apChild() = mKids;

   912     InfallibleTArray<Actors> iaa;

   913     iaa.AppendElement(mKids);

   914     i.aa() = iaa;

   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;

   923     WithUnions o;

   924     if (!SendTest16(i, &o))

   925         fail("sending Test16");

   927     test_assert(42 == o.i(), "wrong value");

   928     assert_arrays_equal(o.ai(), ai);

   929     assert_arrays_equal(o.apChild(), mKids);

   931     const Actors& oaa = o.aa()[0];

   932     assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);

   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);

   943     printf("  passed %s\n", __FUNCTION__);

   944 }

   946 void

   947 TestDataStructuresChild::Test17()

   948 {

   949     Attrs attrs;

   950     attrs.common() = CommonAttrs(true);

   951     attrs.specific() = BarAttrs(1.0f);

   953     InfallibleTArray<Op> ops;

   954     ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));

   956     if (!SendTest17(ops))

   957         fail("sending Test17");

   959     printf("  passed %s\n", __FUNCTION__);

   960 }

   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     }

   978     if (!SendTest18(ra))

   979         fail("sending Test18");

   981     printf("  passed %s\n", __FUNCTION__);

   982 }

   984 } // namespace _ipdltest

   985 } // namespace mozilla

The Tor Browser / file revision

ipc/ipdl/test/cxx/TestDataStructures.cpp@8bccb770b82d

ipc/ipdl/test/cxx/TestDataStructures.cpp