예제 #1
0
        public static void AssertEquals(string id, CustomHashtable exp, CustomHashtable ob)
        {
            if (!AssertionHelper.AssertType(id, exp, ob))
            {
                return;
            }
            if (!AssertionHelper.AssertType(id, exp.data, ob.data))
            {
                return;
            }

            Assertion.AssertEquals(id + " data Count", exp.data.Count, ob.data.Count);

            foreach (DictionaryEntry entry in exp.data)
            {
                Assertion.AssertEquals(entry.Value, ob.data[entry.Key]);
            }
        }
예제 #2
0
        void CheckObjectContent(Test exp, Test t)
        {
            AssertEquals("t.a", exp.a, t.a);
            AssertEquals("t.b", exp.b, t.b);
            AssertEquals("t.bbis", exp.bbis, t.bbis);
            AssertEquals("t.c", exp.c, t.c);

            AssertNotNull("t.parts", t.parts);
            CheckParts("t.parts", exp.parts, t.parts);

            TestPart.AssertEquals("t.part", exp.part, t.part);

            AssertionHelper.AssertEqualsArray("t.strings", exp.strings, t.strings);
            AssertionHelper.AssertEqualsArray("t.ushorts", exp.ushorts, t.ushorts);

            TA.AssertEquals("t.ta", exp.ta, t.ta);

            AssertNotNull("t.tam2", t.tam2);
            CheckTaArray("t.tam2", exp.tam2, t.tam2);

            AssertNotNull("t.tam3", t.tam3);
            CheckTaArray("t.tam3", exp.tam3, t.tam3);

            AssertNotNull("t.flatParts", t.flatParts);
            CheckParts("t.flatParts", exp.flatParts, t.flatParts);

            // Null element is ignored
            AssertNotNull("t.flatParts2", t.flatParts2);
            AssertEquals("t.flatParts2.Length", 3, t.flatParts2.Length);
            TA.AssertEquals("t.flatParts2 0", exp.flatParts2[0], t.flatParts2[0]);
            TA.AssertEquals("t.flatParts2 1", exp.flatParts2[1], t.flatParts2[1]);
            TA.AssertEquals("t.flatParts2 2", exp.flatParts2[3], t.flatParts2[2]);

            AssertNotNull("t.anot", t.anot);
            AssertEquals("t.anot.lo", ((AnotherTestPart)exp.anot).lo, ((AnotherTestPart)t.anot).lo);

            TestPart.AssertEquals("t.ob", exp.ob as TestPart, t.ob as TestPart);
            TestPart.AssertEquals("t.ob2", exp.ob2 as TestPart, t.ob2 as TestPart);

            AssertionHelper.AssertEqualsXml("t.oneElem", exp.oneElem, t.oneElem);
            AssertionHelper.AssertEqualsXml("t.oneElem2", exp.oneElem2, t.oneElem2);

            // One of the elements was null and it is ignored
            AssertNotNull("t.someElems", t.someElems);
            AssertEquals("t.someElems.Length", 2, t.someElems.Length);
            AssertionHelper.AssertEqualsXml("t.someElems[0]", exp.someElems[0], t.someElems[0]);
            AssertionHelper.AssertEqualsXml("t.someElems[1]", exp.someElems[2], t.someElems[1]);

            AssertNotNull("t.extraElems", t.extraElems);
            AssertEquals("t.extraElems.Length", exp.extraElems.Length, t.extraElems.Length);
            for (int n = 0; n < exp.extraElems.Length; n++)
            {
                AssertionHelper.AssertEqualsXml("t.extraElems[" + n + "]", exp.extraElems[n], t.extraElems[n]);
            }

            AssertNotNull("t.extraElems23", t.extraElems23);
            AssertEquals("t.extraElems23.Length", exp.extraElems23.Length, t.extraElems23.Length);
            for (int n = 0; n < t.extraElems23.Length; n++)
            {
                AssertionHelper.AssertEqualsXml("t.extraElems23[" + n + "]", exp.extraElems23[n], t.extraElems23[n]);
            }

            AssertionHelper.AssertEqualsXml("t.extraElemsRest", exp.extraElemsRest, t.extraElemsRest);

            UnknownAttributeTester.AssertEquals("t.uktester", exp.uktester, t.uktester);

            AssertEquals("t.ob3", exp.ob3, t.ob3);
            AssertEquals("t.ob4", exp.ob4, t.ob4);
            AssertEquals("t.op1", exp.op1, t.op1);

            AssertionHelper.AssertEqualsArray("t.opArray", exp.opArray, t.opArray);

            AssertEquals("t.ukOpt", exp.ukOpt, t.ukOpt);
            AssertEquals("t.opAtt", exp.opAtt, t.opAtt);

            AssertionHelper.AssertEqualsArray("t.byteArray", exp.byteArray, t.byteArray);
            AssertionHelper.AssertEqualsArray("t.byteByteArray", exp.byteByteArray, t.byteByteArray);

            AssertNotNull("t.ttList", t.ttList);
            AssertionHelper.AssertEqualsArray("t.ttList", exp.ttList.ToArray(), t.ttList.ToArray());

            AssertNotNull("t.RoList", t.RoList);
            AssertEquals("t.RoList.Count", exp.RoList.Count, t.RoList.Count);
            for (int n = 0; n < exp.RoList.Count; n++)
            {
                TestPart.AssertEquals("t.RoList " + n, (TestPart)exp.RoList[n], (TestPart)t.RoList[n]);
            }

            AssertEquals("t.struc.aa", exp.struc.aa, t.struc.aa);
            AssertEquals("t.struc.cc", exp.struc.cc, t.struc.cc);

            AssertNotNull("t.multiList", t.multiList);
            AssertEquals("t.multiList.Count", exp.multiList.Length, t.multiList.Length);
            for (int n = 0; n < exp.multiList.Length; n++)
            {
                AssertionHelper.AssertEqualsArray("t.multiList " + n, exp.multiList[n].ToArray(), t.multiList[n].ToArray());
            }

            AssertEquals("t.defElem", exp.defElem, t.defElem);
            AssertEquals("t.defAttr", exp.defAttr, t.defAttr);

            CustomHashtable.AssertEquals("t.special", exp.special, t.special);

            AssertEquals("t.attqname", exp.attqname, t.attqname);

            AssertNotNull("t.dbscontainer", t.dbscontainer);
            DblStringContainer tdbca   = t.dbscontainer.at as DblStringContainer;
            DblStringContainer expdbca = exp.dbscontainer.at as DblStringContainer;

            AssertNotNull("t.dbscontainer.at", tdbca);

            AssertNotNull("t.dbscontainer.dbca", tdbca);
            AssertionHelper.AssertEqualsArray("t.dbscontainer.at.doublestring", expdbca.doublestring, tdbca.doublestring);

            AnotherTestPart tat   = tdbca.at as AnotherTestPart;
            AnotherTestPart expat = expdbca.at as AnotherTestPart;

            AssertNotNull("t.dbscontainer.dbca.at", tat);
            AssertEquals("t.dbscontainer.dbca.at.lo", expat.lo, tat.lo);
        }
예제 #3
0
		public static void AssertEquals (string id, CustomHashtable exp, CustomHashtable ob)
		{
			if (!AssertionHelper.AssertType (id, exp, ob)) return;
			if (!AssertionHelper.AssertType (id, exp.data, ob.data)) return;
			
			Assert.AreEqual (exp.data.Count, ob.data.Count, id + " data Count");
			
			foreach (DictionaryEntry entry in exp.data)
				Assert.AreEqual (entry.Value, ob.data[entry.Key]);
		}