michael@0: #include "TestDataStructures.h"
michael@0: 
michael@0: #include "mozilla/unused.h"
michael@0: 
michael@0: #include "IPDLUnitTests.h"      // fail etc.
michael@0: 
michael@0: typedef InfallibleTArray<nsIntRegion> RegionArray;
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace _ipdltest {
michael@0: 
michael@0: static const uint32_t nactors = 10;
michael@0: 
michael@0: #define test_assert(_cond, _msg) \
michael@0:     if (!(_cond)) fail(_msg)
michael@0: 
michael@0: template<typename T>
michael@0: static void
michael@0: assert_arrays_equal(const InfallibleTArray<T>& a, const InfallibleTArray<T>& b)
michael@0: {
michael@0:     test_assert(a == b, "arrays equal");
michael@0: }
michael@0: 
michael@0: inline static TestDataStructuresSub&
michael@0: Cast(PTestDataStructuresSubParent* a)
michael@0: {
michael@0:     return *static_cast<TestDataStructuresSub*>(a);
michael@0: }
michael@0: 
michael@0: inline static TestDataStructuresSub&
michael@0: Cast(PTestDataStructuresSubChild* a)
michael@0: {
michael@0:     return *static_cast<TestDataStructuresSub*>(a);
michael@0: }
michael@0: 
michael@0: //-----------------------------------------------------------------------------
michael@0: // parent
michael@0: 
michael@0: TestDataStructuresParent::TestDataStructuresParent()
michael@0: {
michael@0:     MOZ_COUNT_CTOR(TestDataStructuresParent);
michael@0: }
michael@0: 
michael@0: TestDataStructuresParent::~TestDataStructuresParent()
michael@0: {
michael@0:     MOZ_COUNT_DTOR(TestDataStructuresParent);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresParent::Main()
michael@0: {
michael@0:     for (uint32_t i = 0; i < nactors; ++i)
michael@0:         if (!SendPTestDataStructuresSubConstructor(i))
michael@0:             fail("can't alloc actor");
michael@0: 
michael@0:     if (!SendStart())
michael@0:         fail("can't send Start()");
michael@0: }
michael@0: 
michael@0: bool
michael@0: TestDataStructuresParent::DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor)
michael@0: {
michael@0:     test_assert(Cast(actor).mI == Cast(mKids[0]).mI,
michael@0:                 "dtor sent to wrong actor");
michael@0:     mKids.RemoveElementAt(0);
michael@0:     delete actor;
michael@0:     if (mKids.Length() > 0)
michael@0:         return true;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest1(
michael@0:         const InfallibleTArray<int>& ia,
michael@0:         InfallibleTArray<int>* oa)
michael@0: {
michael@0:     test_assert(5 == ia.Length(), "wrong length");
michael@0:     for (int i = 0; i < 5; ++i)
michael@0:         test_assert(i == ia[i], "wrong value");
michael@0: 
michael@0:     *oa = ia;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest2(
michael@0:         const InfallibleTArray<PTestDataStructuresSubParent*>& i1,
michael@0:         InfallibleTArray<PTestDataStructuresSubParent*>* o1)
michael@0: {
michael@0:     test_assert(nactors == i1.Length(), "wrong #actors");
michael@0:     for (uint32_t i = 0; i < i1.Length(); ++i)
michael@0:         test_assert(i == Cast(i1[i]).mI, "wrong mI value");
michael@0:     *o1 = i1;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest3(
michael@0:         const IntDouble& i1,
michael@0:         const IntDouble& i2,
michael@0:         IntDouble* o1,
michael@0:         IntDouble* o2)
michael@0: {   
michael@0:     test_assert(42 == i1.get_int(), "wrong value");
michael@0:     test_assert(4.0 == i2.get_double(), "wrong value");
michael@0: 
michael@0:     *o1 = i1;
michael@0:     *o2 = i2;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest4(
michael@0:         const InfallibleTArray<IntDouble>& i1,
michael@0:         InfallibleTArray<IntDouble>* o1)
michael@0: {
michael@0:     test_assert(4 == i1.Length(), "wrong length");
michael@0:     test_assert(1 == i1[0].get_int(), "wrong value");
michael@0:     test_assert(2.0 == i1[1].get_double(), "wrong value");
michael@0:     test_assert(3 == i1[2].get_int(), "wrong value");
michael@0:     test_assert(4.0 == i1[3].get_double(), "wrong value");    
michael@0: 
michael@0:     *o1 = i1;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest5(
michael@0:         const IntDoubleArrays& i1,
michael@0:         const IntDoubleArrays& i2,
michael@0:         const IntDoubleArrays& i3,
michael@0:         IntDoubleArrays* o1,
michael@0:         IntDoubleArrays* o2,
michael@0:         IntDoubleArrays* o3)
michael@0: {
michael@0:     test_assert(42 == i1.get_int(), "wrong value");
michael@0: 
michael@0:     const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     const InfallibleTArray<double>& i3a = i3.get_ArrayOfdouble();
michael@0:     test_assert(3 == i3a.Length(), "wrong length");
michael@0:     test_assert(1.0 == i3a[0], "wrong value");
michael@0:     test_assert(2.0 == i3a[1], "wrong value");
michael@0:     test_assert(3.0 == i3a[2], "wrong value");
michael@0: 
michael@0:     *o1 = i1;
michael@0:     *o2 = i2a;
michael@0:     *o3 = i3a;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: TestDataStructuresParent::RecvTest7_0(const ActorWrapper& i1,
michael@0:                                       ActorWrapper* o1)
michael@0: {
michael@0:     if (i1.actorChild() != nullptr)
michael@0:         fail("child side actor should always be null");
michael@0: 
michael@0:     if (i1.actorParent() != mKids[0])
michael@0:         fail("should have got back same actor on parent side");
michael@0: 
michael@0:     o1->actorParent() = mKids[0];
michael@0:     // malicious behavior
michael@0:     o1->actorChild() =
michael@0:         reinterpret_cast<PTestDataStructuresSubChild*>(0xdeadbeef);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest6(
michael@0:         const InfallibleTArray<IntDoubleArrays>& i1,
michael@0:         InfallibleTArray<IntDoubleArrays>* o1)
michael@0: {
michael@0:     test_assert(3 == i1.Length(), "wrong length");
michael@0: 
michael@0:     IntDoubleArrays id1(i1[0]);
michael@0:     test_assert(42 == id1.get_int(), "wrong value");
michael@0: 
michael@0:     InfallibleTArray<int> i2a(i1[1].get_ArrayOfint());
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     InfallibleTArray<double> i3a(i1[2].get_ArrayOfdouble());
michael@0:     test_assert(3 == i3a.Length(), "wrong length");
michael@0:     test_assert(1.0 == i3a[0], "wrong value");
michael@0:     test_assert(2.0 == i3a[1], "wrong value");
michael@0:     test_assert(3.0 == i3a[2], "wrong value");
michael@0: 
michael@0:     o1->AppendElement(id1);
michael@0:     o1->AppendElement(IntDoubleArrays(i2a));
michael@0:     o1->AppendElement(IntDoubleArrays(i3a));
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest7(
michael@0:         const Actors& i1,
michael@0:         const Actors& i2,
michael@0:         const Actors& i3,
michael@0:         Actors* o1,
michael@0:         Actors* o2,
michael@0:         Actors* o3)
michael@0: {
michael@0:     test_assert(42 == i1.get_int(), "wrong value");
michael@0: 
michael@0:     InfallibleTArray<int> i2a(i2.get_ArrayOfint());
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     *o1 = 42;
michael@0:     *o2 = i2a;
michael@0:     *o3 = mKids;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest8(
michael@0:         const InfallibleTArray<Actors>& i1,
michael@0:         InfallibleTArray<Actors>* o1)
michael@0: {
michael@0:     test_assert(3 == i1.Length(), "wrong length");
michael@0:     test_assert(42 == i1[0].get_int(), "wrong value");
michael@0: 
michael@0:     const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     *o1 = i1;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest9(
michael@0:         const Unions& i1,
michael@0:         const Unions& i2,
michael@0:         const Unions& i3,
michael@0:         const Unions& i4,
michael@0:         Unions* o1,
michael@0:         Unions* o2,
michael@0:         Unions* o3,
michael@0:         Unions* o4)
michael@0: {
michael@0:     test_assert(42 == i1.get_int(), "wrong value");
michael@0: 
michael@0:     const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     const InfallibleTArray<PTestDataStructuresSubParent*>& i4a = 
michael@0:         i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
michael@0:     assert_arrays_equal(mKids, i4a);
michael@0: 
michael@0:     *o1 = i1;
michael@0:     *o2 = i2;
michael@0:     *o3 = i3;
michael@0:     *o4 = i4;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest10(
michael@0:         const InfallibleTArray<Unions>& i1,
michael@0:         InfallibleTArray<Unions>* o1)
michael@0: {
michael@0:     test_assert(42 == i1[0].get_int(), "wrong value");
michael@0: 
michael@0:     const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
michael@0:     test_assert(3 == i2a.Length(), "wrong length");
michael@0:     test_assert(1 == i2a[0], "wrong value");
michael@0:     test_assert(2 == i2a[1], "wrong value");
michael@0:     test_assert(3 == i2a[2], "wrong value");
michael@0: 
michael@0:     assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     const InfallibleTArray<PTestDataStructuresSubParent*>& i4a = 
michael@0:         i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
michael@0:     assert_arrays_equal(mKids, i4a);
michael@0: 
michael@0:     *o1 = i1;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest11(
michael@0:             const SIntDouble& i,
michael@0:             SIntDouble* o)
michael@0: {
michael@0:     test_assert(1 == i.i(), "wrong value");
michael@0:     test_assert(2.0 == i.d(), "wrong value");
michael@0:     *o = i;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest12(
michael@0:             const SIntDoubleArrays& i,
michael@0:             SIntDoubleArrays* o)
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);
michael@0:     ai.AppendElement(2);
michael@0:     ai.AppendElement(3);
michael@0: 
michael@0:     InfallibleTArray<double> ad;
michael@0:     ad.AppendElement(.5);
michael@0:     ad.AppendElement(1.0);
michael@0:     ad.AppendElement(2.0);
michael@0: 
michael@0:     test_assert(42 == i.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, i.ai());
michael@0:     assert_arrays_equal(ad, i.ad());
michael@0: 
michael@0:     *o = i;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest13(
michael@0:             const SActors& i,
michael@0:             SActors* o)
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     test_assert(42 == i.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, i.ai());
michael@0:     assert_arrays_equal(mKids, i.apParent());
michael@0: 
michael@0:     *o = i;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest14(
michael@0:             const Structs& i,
michael@0:             Structs* o)
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     test_assert(42 == i.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, i.ai());
michael@0:     assert_arrays_equal(mKids, i.apParent());
michael@0: 
michael@0:     const SActors& ia = i.aa()[0];
michael@0:     test_assert(42 == ia.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, ia.ai());
michael@0:     assert_arrays_equal(mKids, ia.apParent());
michael@0: 
michael@0:     *o = i;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest15(
michael@0:             const WithStructs& i1,
michael@0:             const WithStructs& i2,
michael@0:             const WithStructs& i3,
michael@0:             const WithStructs& i4,
michael@0:             const WithStructs& i5,
michael@0:             WithStructs* o1,
michael@0:             WithStructs* o2,
michael@0:             WithStructs* o3,
michael@0:             WithStructs* o4,
michael@0:             WithStructs* o5)
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     test_assert(i1 == int(42), "wrong value");
michael@0:     assert_arrays_equal(i2.get_ArrayOfint(), ai);
michael@0:     assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);
michael@0: 
michael@0:     const SActors& ia = i4.get_ArrayOfSActors()[0];
michael@0:     test_assert(42 == ia.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, ia.ai());
michael@0:     assert_arrays_equal(mKids, ia.apParent());
michael@0: 
michael@0:     const Structs& is = i5.get_ArrayOfStructs()[0];
michael@0:     test_assert(42 == is.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, is.ai());
michael@0:     assert_arrays_equal(mKids, is.apParent());   
michael@0: 
michael@0:     const SActors& isa = is.aa()[0];
michael@0:     test_assert(42 == isa.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, isa.ai());
michael@0:     assert_arrays_equal(mKids, isa.apParent());
michael@0: 
michael@0:     *o1 = i1;
michael@0:     *o2 = i2;
michael@0:     *o3 = i3;
michael@0:     *o4 = i4;
michael@0:     *o5 = i5;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest16(
michael@0:             const WithUnions& i,
michael@0:             WithUnions* o)
michael@0: {
michael@0:     test_assert(i.i() == 42, "wrong value");
michael@0: 
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0:     assert_arrays_equal(ai, i.ai());
michael@0: 
michael@0:     assert_arrays_equal(i.apParent(), mKids);
michael@0: 
michael@0:     assert_arrays_equal(mKids, i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     const InfallibleTArray<Unions>& iau = i.au();
michael@0:     test_assert(iau[0] == 42, "wrong value");
michael@0:     assert_arrays_equal(ai, iau[1].get_ArrayOfint());
michael@0:     assert_arrays_equal(mKids, iau[2].get_ArrayOfPTestDataStructuresSubParent());
michael@0:     assert_arrays_equal(mKids,
michael@0:                         iau[3].get_ArrayOfActors()[0]
michael@0:                         .get_ArrayOfPTestDataStructuresSubParent());
michael@0: 
michael@0:     *o = i;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest17(const InfallibleTArray<Op>& sa)
michael@0: {
michael@0:     test_assert(sa.Length() == 1 && Op::TSetAttrs == sa[0].type(),
michael@0:                 "wrong value");
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: bool TestDataStructuresParent::RecvTest18(const RegionArray& ra)
michael@0: {
michael@0:     for (RegionArray::index_type i = 0; i < ra.Length(); ++i) {
michael@0:         nsIntRegionRectIterator it(ra[i]);
michael@0:         // if |ra| has been realloc()d and given a different allocator
michael@0:         // chunk, this next line will nondeterministically crash or
michael@0:         // iloop
michael@0:         while (const nsIntRect* sr = it.Next()) unused << sr;
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: //-----------------------------------------------------------------------------
michael@0: // child
michael@0: 
michael@0: TestDataStructuresChild::TestDataStructuresChild()
michael@0: {
michael@0:     MOZ_COUNT_CTOR(TestDataStructuresChild);
michael@0: }
michael@0: 
michael@0: TestDataStructuresChild::~TestDataStructuresChild()
michael@0: {
michael@0:     MOZ_COUNT_DTOR(TestDataStructuresChild);
michael@0: }
michael@0: 
michael@0: bool
michael@0: TestDataStructuresChild::RecvStart()
michael@0: {
michael@0:     puts("[TestDataStructuresChild] starting");
michael@0: 
michael@0:     Test1();
michael@0:     Test2();
michael@0:     Test3();
michael@0:     Test4();
michael@0:     Test5();
michael@0:     Test6();
michael@0:     Test7_0();
michael@0:     Test7();
michael@0:     Test8();
michael@0:     Test9();
michael@0:     Test10();
michael@0:     Test11();
michael@0:     Test12();
michael@0:     Test13();
michael@0:     Test14();
michael@0:     Test15();
michael@0:     Test16();
michael@0:     Test17();
michael@0:     if (OtherProcess() != 0) {
michael@0:         //FIXME/bug 703317 allocation of nsIntRegion uses a global
michael@0:         //region pool which breaks threads
michael@0:         Test18();
michael@0:     }
michael@0: 
michael@0:     for (uint32_t i = 0; i < nactors; ++i)
michael@0:         if (!PTestDataStructuresSubChild::Send__delete__(mKids[i]))
michael@0:             fail("can't send dtor");
michael@0: 
michael@0:     Close();
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test1()
michael@0: {
michael@0:     InfallibleTArray<int> ia;
michael@0: 
michael@0:     for (int i = 0; i < 5; ++i)
michael@0:         ia.AppendElement(i);
michael@0: 
michael@0:     InfallibleTArray<int> oa;
michael@0:     if (!SendTest1(ia, &oa))
michael@0:         fail("can't send Test1");
michael@0: 
michael@0:     assert_arrays_equal(ia, oa);
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test2()
michael@0: {
michael@0:     InfallibleTArray<PTestDataStructuresSubChild*> oa;
michael@0:     if (!SendTest2(mKids, &oa))
michael@0:         fail("can't send Test2");
michael@0:     assert_arrays_equal(mKids, oa);
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test3()
michael@0: {
michael@0:     int i1i = 42;
michael@0:     double i2d = 4.0;
michael@0:     IntDouble i1(i1i);
michael@0:     IntDouble i2(i2d);
michael@0:     IntDouble o1, o2;
michael@0: 
michael@0:     SendTest3(i1, i2, &o1, &o2);
michael@0: 
michael@0:     test_assert(i1i == o1.get_int(), "wrong value");
michael@0:     test_assert(i2d == o2.get_double(), "wrong value");
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test4()
michael@0: {
michael@0:     InfallibleTArray<IntDouble> i1;
michael@0:     i1.AppendElement(IntDouble(int(1)));
michael@0:     i1.AppendElement(IntDouble(2.0));
michael@0:     i1.AppendElement(IntDouble(int(3)));
michael@0:     i1.AppendElement(IntDouble(4.0));
michael@0: 
michael@0:     InfallibleTArray<IntDouble> o1;
michael@0:     if (!SendTest4(i1, &o1))
michael@0:         fail("can't send Test4");
michael@0: 
michael@0:     // TODO Union::operator==()
michael@0:     test_assert(i1.Length() == o1.Length(), "wrong length");
michael@0:     test_assert(1 == o1[0].get_int(), "wrong value");
michael@0:     test_assert(2.0 == o1[1].get_double(), "wrong value");
michael@0:     test_assert(3 == o1[2].get_int(), "wrong value");
michael@0:     test_assert(4.0 == o1[3].get_double(), "wrong value");
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test5()
michael@0: {
michael@0:     IntDoubleArrays i1(int(42));
michael@0:     InfallibleTArray<int> i2;
michael@0:     i2.AppendElement(1); i2.AppendElement(2); i2.AppendElement(3);
michael@0:     InfallibleTArray<double> i3;
michael@0:     i3.AppendElement(1.0); i3.AppendElement(2.0); i3.AppendElement(3.0);
michael@0: 
michael@0:     IntDoubleArrays o1, o2, o3;
michael@0:     if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3),
michael@0:                    &o1, &o2, &o3))
michael@0:         fail("can't send Test5");
michael@0: 
michael@0:     test_assert(42 == o1.get_int(), "wrong value");
michael@0:     assert_arrays_equal(i2, o2.get_ArrayOfint());
michael@0:     assert_arrays_equal(i3, o3.get_ArrayOfdouble());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test6()
michael@0: {
michael@0:     IntDoubleArrays id1(int(42));
michael@0:     InfallibleTArray<int> id2;
michael@0:     id2.AppendElement(1); id2.AppendElement(2); id2.AppendElement(3);
michael@0:     InfallibleTArray<double> id3;
michael@0:     id3.AppendElement(1.0); id3.AppendElement(2.0); id3.AppendElement(3.0);
michael@0: 
michael@0:     InfallibleTArray<IntDoubleArrays> i1;
michael@0:     i1.AppendElement(id1);
michael@0:     i1.AppendElement(IntDoubleArrays(id2));
michael@0:     i1.AppendElement(IntDoubleArrays(id3));
michael@0: 
michael@0:     InfallibleTArray<IntDoubleArrays> o1;
michael@0:     if (!SendTest6(i1, &o1))
michael@0:         fail("can't send Test6");
michael@0: 
michael@0:     test_assert(3 == o1.Length(), "wrong length");
michael@0:     IntDoubleArrays od1(o1[0]);
michael@0:     InfallibleTArray<int> od2(o1[1].get_ArrayOfint());
michael@0:     InfallibleTArray<double> od3(o1[2].get_ArrayOfdouble());
michael@0: 
michael@0:     test_assert(42 == od1.get_int(), "wrong value");
michael@0:     assert_arrays_equal(id2, od2);
michael@0:     assert_arrays_equal(id3, od3);
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test7_0()
michael@0: {
michael@0:     ActorWrapper iaw;
michael@0:     if (iaw.actorChild() != nullptr || iaw.actorParent() != nullptr)
michael@0:         fail("actor members should be null initially");
michael@0: 
michael@0:     iaw.actorChild() = mKids[0];
michael@0:     if (iaw.actorParent() != nullptr)
michael@0:         fail("parent should be null on child side after set");
michael@0: 
michael@0:     ActorWrapper oaw;
michael@0:     if (!SendTest7_0(iaw, &oaw))
michael@0:         fail("sending Test7_0");
michael@0: 
michael@0:     if (oaw.actorParent() != nullptr)
michael@0:         fail("parent accessor on actor-struct members should always be null in child");
michael@0: 
michael@0:     if (oaw.actorChild() != mKids[0])
michael@0:         fail("should have got back same child-side actor");
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test7()
michael@0: {
michael@0:     Actors i1(42);
michael@0:     InfallibleTArray<int> i2a;
michael@0:     i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);
michael@0: 
michael@0:     Actors o1, o2, o3;
michael@0:     if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))
michael@0:         fail("can't send Test7");
michael@0: 
michael@0:     test_assert(42 == o1.get_int(), "wrong value");
michael@0:     assert_arrays_equal(i2a, o2.get_ArrayOfint());
michael@0:     assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test8()
michael@0: {
michael@0:     Actors i1e(42);
michael@0:     InfallibleTArray<int> i2a;
michael@0:     i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);
michael@0: 
michael@0:     InfallibleTArray<Actors> i1;
michael@0:     i1.AppendElement(i1e);
michael@0:     i1.AppendElement(i2a);
michael@0:     i1.AppendElement(mKids);
michael@0: 
michael@0:     InfallibleTArray<Actors> o1;
michael@0:     if (!SendTest8(i1, &o1))
michael@0:         fail("can't send Test8");
michael@0: 
michael@0:     test_assert(3 == o1.Length(), "wrong length");
michael@0:     test_assert(42 == o1[0].get_int(), "wrong value");
michael@0:     assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
michael@0:     assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test9()
michael@0: {
michael@0:     Unions i1(int(42));
michael@0: 
michael@0:     InfallibleTArray<int> i2a;
michael@0:     i2a.AppendElement(1);
michael@0:     i2a.AppendElement(2);
michael@0:     i2a.AppendElement(3);
michael@0: 
michael@0:     InfallibleTArray<Actors> i4a;
michael@0:     i4a.AppendElement(mKids);
michael@0: 
michael@0:     Unions o1, o2, o3, o4;
michael@0:     if (!SendTest9(i1, Unions(i2a), Unions(mKids), Unions(i4a),
michael@0:                    &o1, &o2, &o3, &o4))
michael@0:         fail("can't send Test9");
michael@0: 
michael@0:     test_assert(42 == o1.get_int(), "wrong value");
michael@0:     assert_arrays_equal(i2a, o2.get_ArrayOfint());
michael@0:     assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
michael@0:     assert_arrays_equal(
michael@0:         mKids,
michael@0:         o4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test10()
michael@0: {
michael@0:     Unions i1a(int(42));
michael@0: 
michael@0:     InfallibleTArray<int> i2a;
michael@0:     i2a.AppendElement(1);
michael@0:     i2a.AppendElement(2);
michael@0:     i2a.AppendElement(3);
michael@0: 
michael@0:     InfallibleTArray<Actors> i4a;
michael@0:     i4a.AppendElement(mKids);
michael@0: 
michael@0:     InfallibleTArray<Unions> i1;
michael@0:     i1.AppendElement(i1a);
michael@0:     i1.AppendElement(Unions(i2a));
michael@0:     i1.AppendElement(Unions(mKids));
michael@0:     i1.AppendElement(Unions(i4a));
michael@0: 
michael@0:     InfallibleTArray<Unions> o1;
michael@0:     if (!SendTest10(i1, &o1))
michael@0:         fail("can't send Test10");
michael@0: 
michael@0:     test_assert(4 == o1.Length(), "wrong length");
michael@0:     test_assert(42 == o1[0].get_int(), "wrong value");
michael@0:     assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
michael@0:     assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
michael@0:     assert_arrays_equal(
michael@0:         mKids,
michael@0:         o1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test11()
michael@0: {
michael@0:     SIntDouble i(1, 2.0);
michael@0:     SIntDouble o;
michael@0: 
michael@0:     if (!SendTest11(i, &o))
michael@0:         fail("sending Test11");
michael@0: 
michael@0:     test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test12()
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     InfallibleTArray<double> ad;
michael@0:     ad.AppendElement(.5);  ad.AppendElement(1.0);  ad.AppendElement(2.0);
michael@0: 
michael@0:     SIntDoubleArrays i(42, ai, ad);
michael@0:     SIntDoubleArrays o;
michael@0: 
michael@0:     if (!SendTest12(i, &o))
michael@0:         fail("sending Test12");
michael@0: 
michael@0:     test_assert(42 == o.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, o.ai());
michael@0:     assert_arrays_equal(ad, o.ad());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test13()
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     SActors i;
michael@0:     i.i() = 42;
michael@0:     i.ai() = ai;
michael@0:     i.apChild() = mKids;
michael@0: 
michael@0:     SActors o;
michael@0:     if (!SendTest13(i, &o))
michael@0:         fail("can't send Test13");
michael@0: 
michael@0:     test_assert(42 == o.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, o.ai());
michael@0:     assert_arrays_equal(mKids, o.apChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test14()
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     SActors ia;
michael@0:     ia.i() = 42;
michael@0:     ia.ai() = ai;
michael@0:     ia.apChild() = mKids;
michael@0:     InfallibleTArray<SActors> aa;  aa.AppendElement(ia);
michael@0: 
michael@0:     Structs i;
michael@0:     i.i() = 42;
michael@0:     i.ai() = ai;
michael@0:     i.apChild() = mKids;
michael@0:     i.aa() = aa;
michael@0: 
michael@0:     Structs o;
michael@0:     if (!SendTest14(i, &o))
michael@0:         fail("can't send Test14");
michael@0: 
michael@0:     test_assert(42 == o.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, o.ai());
michael@0:     assert_arrays_equal(mKids, o.apChild());
michael@0: 
michael@0:     const SActors& os = o.aa()[0];
michael@0:     test_assert(42 == os.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, os.ai());
michael@0:     assert_arrays_equal(mKids, os.apChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test15()
michael@0: {
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0: 
michael@0:     SActors ia;
michael@0:     ia.i() = 42;
michael@0:     ia.ai() = ai;
michael@0:     ia.apChild() = mKids;
michael@0:     InfallibleTArray<SActors> iaa;  iaa.AppendElement(ia);
michael@0: 
michael@0:     Structs is;
michael@0:     is.i() = 42;
michael@0:     is.ai() = ai;
michael@0:     is.apChild() = mKids;
michael@0:     is.aa() = iaa;
michael@0:     InfallibleTArray<Structs> isa;  isa.AppendElement(is);
michael@0: 
michael@0:     WithStructs o1, o2, o3, o4, o5;
michael@0:     if (!SendTest15(WithStructs(42),
michael@0:                     WithStructs(ai),
michael@0:                     WithStructs(mKids),
michael@0:                     WithStructs(iaa),
michael@0:                     WithStructs(isa),
michael@0:                     &o1, &o2, &o3, &o4, &o5))
michael@0:         fail("sending Test15");
michael@0: 
michael@0:     test_assert(o1 == int(42), "wrong value");
michael@0:     assert_arrays_equal(o2.get_ArrayOfint(), ai);
michael@0:     assert_arrays_equal(o3.get_ArrayOfPTestDataStructuresSubChild(), mKids);
michael@0: 
michael@0:     const SActors& oa = o4.get_ArrayOfSActors()[0];
michael@0:     test_assert(42 == oa.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, oa.ai());
michael@0:     assert_arrays_equal(mKids, oa.apChild());
michael@0: 
michael@0:     const Structs& os = o5.get_ArrayOfStructs()[0];
michael@0:     test_assert(42 == os.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, os.ai());
michael@0:     assert_arrays_equal(mKids, os.apChild());   
michael@0: 
michael@0:     const SActors& osa = os.aa()[0];
michael@0:     test_assert(42 == osa.i(), "wrong value");
michael@0:     assert_arrays_equal(ai, osa.ai());
michael@0:     assert_arrays_equal(mKids, osa.apChild());
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test16()
michael@0: {
michael@0:     WithUnions i;
michael@0: 
michael@0:     i.i() = 42;
michael@0: 
michael@0:     InfallibleTArray<int> ai;
michael@0:     ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
michael@0:     i.ai() = ai;
michael@0: 
michael@0:     i.apChild() = mKids;
michael@0: 
michael@0:     InfallibleTArray<Actors> iaa;
michael@0:     iaa.AppendElement(mKids);
michael@0:     i.aa() = iaa;
michael@0: 
michael@0:     InfallibleTArray<Unions> iau;
michael@0:     iau.AppendElement(int(42));
michael@0:     iau.AppendElement(ai);
michael@0:     iau.AppendElement(mKids);
michael@0:     iau.AppendElement(iaa);
michael@0:     i.au() = iau;
michael@0: 
michael@0:     WithUnions o;
michael@0:     if (!SendTest16(i, &o))
michael@0:         fail("sending Test16");
michael@0: 
michael@0:     test_assert(42 == o.i(), "wrong value");
michael@0:     assert_arrays_equal(o.ai(), ai);
michael@0:     assert_arrays_equal(o.apChild(), mKids);
michael@0: 
michael@0:     const Actors& oaa = o.aa()[0];
michael@0:     assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);
michael@0: 
michael@0:     const InfallibleTArray<Unions>& oau = o.au();
michael@0:     test_assert(oau[0] == 42, "wrong value");
michael@0:     assert_arrays_equal(oau[1].get_ArrayOfint(), ai);
michael@0:     assert_arrays_equal(oau[2].get_ArrayOfPTestDataStructuresSubChild(),
michael@0:                         mKids);
michael@0:     assert_arrays_equal(oau[3].get_ArrayOfActors()[0]
michael@0:                         .get_ArrayOfPTestDataStructuresSubChild(),
michael@0:                         mKids);
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test17()
michael@0: {
michael@0:     Attrs attrs;
michael@0:     attrs.common() = CommonAttrs(true);
michael@0:     attrs.specific() = BarAttrs(1.0f);
michael@0: 
michael@0:     InfallibleTArray<Op> ops;
michael@0:     ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));
michael@0: 
michael@0:     if (!SendTest17(ops))
michael@0:         fail("sending Test17");
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: void
michael@0: TestDataStructuresChild::Test18()
michael@0: {
michael@0:     const int nelements = 1000;
michael@0:     RegionArray ra;
michael@0:     // big enough to hopefully force a realloc to a different chunk of
michael@0:     // memory on the receiving side, if the workaround isn't working
michael@0:     // correctly.  But SetCapacity() here because we don't want to
michael@0:     // crash on the sending side.
michael@0:     ra.SetCapacity(nelements);
michael@0:     for (int i = 0; i < nelements; ++i) {
michael@0:         nsIntRegion r;
michael@0:         r = r.Or(nsIntRect(0, 0, 10, 10), nsIntRect(10, 10, 10, 10));
michael@0:         ra.AppendElement(r);
michael@0:     }
michael@0: 
michael@0:     if (!SendTest18(ra))
michael@0:         fail("sending Test18");
michael@0: 
michael@0:     printf("  passed %s\n", __FUNCTION__);
michael@0: }
michael@0: 
michael@0: } // namespace _ipdltest
michael@0: } // namespace mozilla