public void EnumKey([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(HashSetEnumDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <HashSetEnumDec decName=""TestDec""> <data> <Alpha /> <Beta /> <Gamma /> <Delta /> </data> </HashSetEnumDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <HashSetEnumDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.data, new HashSet <GenericEnum> { GenericEnum.Alpha, GenericEnum.Beta, GenericEnum.Gamma, GenericEnum.Delta, }); }
public void Null() { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitStaticRefs = new System.Type[] { typeof(Decs) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <SystemDec decName=""TestSystem""> <type>NullSystem</type> </SystemDec> <ProcessDec decName=""TestProcess""> <order> <li>TestSystem</li> </order> </ProcessDec> </Decs> "); parser.Finish(); Environment.Startup(); NullSystem.Executions = 0; Environment.Process(Decs.TestProcess); Assert.AreEqual(1, NullSystem.Executions); }
public void Nested([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(NestedDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <NestedDec decName=""TestDec""> <data> <li> <li>8</li> <li>16</li> </li> <li> <li>9</li> <li>81</li> </li> </data> </NestedDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <NestedDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.data, new[] { new[] { 8, 16 }, new[] { 9, 81 } }); }
public void StructConstructionInterface([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StructConstructionDec), typeof(StructDataFromInterface) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StructConstructionDec decName=""TestDec""> <interfaceList> <li class=""StructDataFromInterface""><value>42</value></li> <li class=""StructDataFromInterface""><value>100</value></li> <li class=""StructDataFromInterface""><value>8</value></li> </interfaceList> </StructConstructionDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <StructConstructionDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(3, result.interfaceList.Count); Assert.AreEqual(42, ((StructDataFromInterface)result.interfaceList[0]).value); Assert.AreEqual(100, ((StructDataFromInterface)result.interfaceList[1]).value); Assert.AreEqual(8, ((StructDataFromInterface)result.interfaceList[2]).value); }
public void AbstractRoot([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ConcreteChildADec), typeof(ConcreteChildBDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ConcreteChildADec decName=""TestDec""> <absInt>20</absInt> <ccaInt>30</ccaInt> </ConcreteChildADec> <ConcreteChildBDec decName=""TestDec""> <absInt>40</absInt> <ccbInt>50</ccbInt> </ConcreteChildBDec> </Decs>"); parser.Finish(); DoBehavior(mode); Assert.AreEqual(20, Dec.Database <ConcreteChildADec> .Get("TestDec").absInt); Assert.AreEqual(30, Dec.Database <ConcreteChildADec> .Get("TestDec").ccaInt); Assert.AreEqual(40, Dec.Database <ConcreteChildBDec> .Get("TestDec").absInt); Assert.AreEqual(50, Dec.Database <ConcreteChildBDec> .Get("TestDec").ccbInt); }
public void MissingMember([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(MissingMemberDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <MissingMemberDec decName=""TestDec""> <value1>9</value1> <value2>99</value2> <value3>999</value3> </MissingMemberDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode); var result = Dec.Database <MissingMemberDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.value1, 9); Assert.AreEqual(result.value3, 999); }
public void TypeOverridden([Values] BehaviorMode mode) { Dec.Config.UsingNamespaces = new string[] { "DecTest.Primitives", "DecTest.Primitives.ContainerA", "DecTest.Primitives.ContainerB" }; Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(TypeDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <TypeDec decName=""TestDec""> <type>Overridden</type> </TypeDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode, rewrite_expectParseErrors: true); var result = Dec.Database <TypeDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.IsNotNull(result.type); }
public void HierarchyDuplicateField([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(DupeChildDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <DupeChildDec decName=""TestDec""> <value>12</value> </DupeChildDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode, rewrite_expectWriteErrors: true, rewrite_expectParseErrors: true, validation_expectWriteErrors: true); var result = (DupeChildDec)Dec.Database <DupeParentDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(12, result.value); Assert.AreEqual(4, ((DupeParentDec)result).value); }
public void ForbiddenField([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StubDec) } }; var parser = new Dec.Parser(); // This is a little silly because, as of this writing, DecName is a property and we don't even support writing to properties. // So we're not really testing forbidden fields here. We're really just double-checking the fact that properties can't be written to. // But someday I'll probably support properties, and then this had better work. parser.AddString(@" <Decs> <StubDec decName=""TestDec""> <DecName>NotTestDec</DecName> </StubDec> </Decs>"); // Just in case I rename it back to lowercase, make sure we don't just get a spelling mismatch error here. ExpectErrors(() => parser.Finish(), err => !err.Contains("decName")); DoBehavior(mode); Assert.AreEqual("TestDec", Dec.Database <StubDec> .Get("TestDec").DecName); }
public void Override([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ListOverrideDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ListOverrideDec decName=""TestDec""> <dataA> <li>2020</li> </dataA> <dataB /> </ListOverrideDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <ListOverrideDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.dataA, new[] { 2020 }); Assert.AreEqual(result.dataB, new int[0]); Assert.AreEqual(result.dataC, new[] { 9, 10, 11 }); }
public void DuplicateDec([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(IntDec) } }; var parser = new Dec.Parser(); ExpectErrors(() => parser.AddString(@" <Decs> <IntDec decName=""TestDec""> <value>10</value> </IntDec> <IntDec decName=""TestDec""> <value>20</value> </IntDec> </Decs>")); parser.Finish(); DoBehavior(mode, errorValidator: err => err.Contains("IntDec:TestDec")); var result = Dec.Database <IntDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(20, result.value); }
public void Basic([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ListDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ListDec decName=""TestDec""> <data> <li>10</li> <li>9</li> <li>8</li> <li>7</li> <li>6</li> </data> </ListDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <ListDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.data, new[] { 10, 9, 8, 7, 6 }); }
public void OverrideString([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(HashSetStringOverrideDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <HashSetStringOverrideDec decName=""TestDec""> <dataA> <u /> </dataA> <dataB /> </HashSetStringOverrideDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <HashSetStringOverrideDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.dataA, new HashSet <string> { "u" }); Assert.AreEqual(result.dataB, new HashSet <string> { }); Assert.AreEqual(result.dataC, new HashSet <string> { "g", "h", "i" }); }
public void Duplicate([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(HashSetStringDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <HashSetStringDec decName=""TestDec""> <data> <li>Prefix</li> <li>Dupe</li> <li>Dupe</li> <li>Suffix</li> </data> </HashSetStringDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode); var result = Dec.Database <HashSetStringDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.data, new HashSet <string> { "Prefix", "Dupe", "Suffix" }); }
public void Decs([Values] RecorderMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(StaticReferenceDecs) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StubDec decName=""TestDecA"" /> <StubDec decName=""TestDecB"" /> </Decs>"); parser.Finish(); var decs = new DecRecordable(); decs.a = StaticReferenceDecs.TestDecA; decs.b = StaticReferenceDecs.TestDecB; // leave empty empty, of course decs.forceEmpty = null; var deserialized = DoRecorderRoundTrip(decs, mode); Assert.AreEqual(decs.a, deserialized.a); Assert.AreEqual(decs.b, deserialized.b); Assert.AreEqual(decs.empty, deserialized.empty); Assert.AreEqual(decs.forceEmpty, deserialized.forceEmpty); }
public void InternalInheritance([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(InternalInheritanceDec), typeof(InternalDerived) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <InternalInheritanceDec decName=""TestDec""> <value class=""InternalDerived""> <baseOnly>42</baseOnly> <derivedOnly>100</derivedOnly> </value> </InternalInheritanceDec> </Decs>"); parser.Finish(); DoBehavior(mode); Assert.AreEqual(typeof(InternalDerived), Dec.Database <InternalInheritanceDec> .Get("TestDec").value.GetType()); Assert.AreEqual(42, Dec.Database <InternalInheritanceDec> .Get("TestDec").value.baseOnly); Assert.AreEqual(100, ((InternalDerived)Dec.Database <InternalInheritanceDec> .Get("TestDec").value).derivedOnly); }
public void DecsRemoved([ValuesExcept(RecorderMode.Validation)] RecorderMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(StaticReferenceDecs) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StubDec decName=""TestDecA"" /> <StubDec decName=""TestDecB"" /> </Decs>"); parser.Finish(); var decs = new DecRecordable(); decs.a = StaticReferenceDecs.TestDecA; decs.b = StaticReferenceDecs.TestDecB; Dec.Database.Delete(StaticReferenceDecs.TestDecA); var deserialized = DoRecorderRoundTrip(decs, mode, expectWriteErrors: true, expectReadErrors: true); Assert.IsNull(deserialized.a); Assert.AreEqual(decs.b, deserialized.b); }
public void InvalidDecName([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StubDec) } }; var parser = new Dec.Parser(); ExpectErrors(() => parser.AddString(@" <Decs> <StubDec decName=""1NumberPrefix"" /> <StubDec decName=""Contains Spaces"" /> <StubDec decName=""HasPunctuation!"" /> <StubDec decName="""Quotes""" /> <StubDec decName=""ActuallyAValidDecName"" /> </Decs>")); parser.Finish(); DoBehavior(mode); Assert.IsNull(Dec.Database <StubDec> .Get("1NumberPrefix")); Assert.IsNull(Dec.Database <StubDec> .Get("Contains Spaces")); Assert.IsNull(Dec.Database <StubDec> .Get("HasPunctuation!")); Assert.IsNull(Dec.Database <StubDec> .Get("\"Quotes\"")); Assert.IsNotNull(Dec.Database <StubDec> .Get("ActuallyAValidDecName")); }
public void TypeAbstract([Values] BehaviorMode mode) { Dec.Config.UsingNamespaces = new string[] { "DecTest.Primitives" }; Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(TypeDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <TypeDec decName=""TestDec""> <type>Abstract</type> </TypeDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <TypeDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.type, typeof(Abstract)); }
public void ClearRef() { // Had a bug where Dec.Database.Clear() wasn't properly clearing the lookup table used for references // This double-checks it { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(RefTargetDec), typeof(RefSourceDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <RefTargetDec decName=""Target"" /> <RefSourceDec decName=""Source""> <target>Target</target> </RefSourceDec> </Decs>"); parser.Finish(); } { var target = Dec.Database <RefTargetDec> .Get("Target"); var source = Dec.Database <RefSourceDec> .Get("Source"); Assert.IsNotNull(target); Assert.IsNotNull(source); Assert.AreEqual(source.target, target); } Dec.Database.Clear(); { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(RefTargetDec), typeof(RefSourceDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <RefSourceDec decName=""Source""> <target>Target</target> </RefSourceDec> </Decs>"); ExpectErrors(() => parser.Finish()); } { var target = Dec.Database <RefTargetDec> .Get("Target"); var source = Dec.Database <RefSourceDec> .Get("Source"); Assert.IsNull(target); Assert.IsNotNull(source); Assert.IsNull(source.target); } }
public void StructConstructionDirect([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StructConstructionDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StructConstructionDec decName=""TestDec""> <directList> <li><value>42</value></li> <li><value>100</value></li> <li><value>8</value></li> </directList> </StructConstructionDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <StructConstructionDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(3, result.directList.Count); Assert.AreEqual(42, result.directList[0].value); Assert.AreEqual(100, result.directList[1].value); Assert.AreEqual(8, result.directList[2].value); }
public void ParserRef([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ParserRefDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ParserRefDec decName=""Test""> <initialized ref=""invalid"" /> <setToNull ref=""invalid"" /> </ParserRefDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode); var test = Dec.Database <ParserRefDec> .Get("Test"); Assert.IsNotNull(test); Assert.IsNotNull(test.initialized); Assert.IsNotNull(test.setToNull); }
public void PrimitiveConstructionObject([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StructConstructionDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StructConstructionDec decName=""TestDec""> <objectList> <li class=""int"">42</li> <li class=""int"">100</li> <li class=""int"">8</li> </objectList> </StructConstructionDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <StructConstructionDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(3, result.objectList.Count); Assert.AreEqual(42, (int)result.objectList[0]); Assert.AreEqual(100, (int)result.objectList[1]); Assert.AreEqual(8, (int)result.objectList[2]); }
public void DatabaseList([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(StubDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <StubDec decName=""TestDecA"" /> <StubDec decName=""TestDecB"" /> <StubDec decName=""TestDecC"" /> </Decs>"); parser.Finish(); DoBehavior(mode); Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDecA")); Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDecB")); Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDecC")); Assert.AreEqual(3, Dec.Database <StubDec> .List.Length); Assert.IsTrue(Dec.Database <StubDec> .List.Contains(Dec.Database <StubDec> .Get("TestDecA"))); Assert.IsTrue(Dec.Database <StubDec> .List.Contains(Dec.Database <StubDec> .Get("TestDecB"))); Assert.IsTrue(Dec.Database <StubDec> .List.Contains(Dec.Database <StubDec> .Get("TestDecC"))); }
public void Validation(string id, [Values] BehaviorMode mode) { string directory = Path.Combine("data", "golden", "parser", id); Assembly assembly; if (!AssemblyLookup.TryGetValue(id, out assembly)) { // gotta load assembly = DecUtilLib.Compilation.Compile(DecUtilLib.Compress.ReadFromFile(Path.Combine(directory, "Harness.cs")), new Assembly[] { this.GetType().Assembly }); AssemblyLookup[id] = assembly; } var type = assembly.GetType("DecTest.Harness"); type.GetMethod("Setup").Invoke(null, null); var parser = new Dec.Parser(); parser.AddString(DecUtilLib.Compress.ReadFromFile(Path.Combine(directory, "data.xml"))); parser.Finish(); DoBehavior(mode, validation_assemblies: new Assembly[] { assembly }); type.GetMethod("Validate").Invoke(null, null); }
public void AsStringError([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ArrayDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ArrayDec decName=""TestDec""> <dataEmpty>nope</dataEmpty> <dataProvided>nope</dataProvided> </ArrayDec> </Decs>"); ExpectErrors(() => parser.Finish()); DoBehavior(mode); var result = Dec.Database <ArrayDec> .Get("TestDec"); Assert.IsNotNull(result); // error should default to existing data Assert.IsNull(result.dataEmpty); Assert.AreEqual(result.dataProvided, new[] { 10, 20 }); }
public void IndexDerivedList([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(IndexBaseDec), typeof(IndexDerivedDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <IndexDerivedDec decName=""TestDecA"" /> <IndexBaseDec decName=""TestDecB"" /> <IndexDerivedDec decName=""TestDecC"" /> <IndexBaseDec decName=""TestDecD"" /> <IndexDerivedDec decName=""TestDecE"" /> </Decs>"); parser.Finish(); DoBehavior(mode); Assert.AreSame(Dec.Database <IndexBaseDec> .Get("TestDecA"), Dec.Index <IndexBaseDec> .Get(Dec.Database <IndexBaseDec> .Get("TestDecA").index)); Assert.AreSame(Dec.Database <IndexBaseDec> .Get("TestDecB"), Dec.Index <IndexBaseDec> .Get(Dec.Database <IndexBaseDec> .Get("TestDecB").index)); Assert.AreSame(Dec.Database <IndexBaseDec> .Get("TestDecC"), Dec.Index <IndexBaseDec> .Get(Dec.Database <IndexBaseDec> .Get("TestDecC").index)); Assert.AreSame(Dec.Database <IndexBaseDec> .Get("TestDecD"), Dec.Index <IndexBaseDec> .Get(Dec.Database <IndexBaseDec> .Get("TestDecD").index)); Assert.AreSame(Dec.Database <IndexBaseDec> .Get("TestDecE"), Dec.Index <IndexBaseDec> .Get(Dec.Database <IndexBaseDec> .Get("TestDecE").index)); Assert.AreSame(Dec.Database <IndexDerivedDec> .Get("TestDecA"), Dec.Index <IndexDerivedDec> .Get(Dec.Database <IndexDerivedDec> .Get("TestDecA").index)); Assert.AreSame(Dec.Database <IndexDerivedDec> .Get("TestDecC"), Dec.Index <IndexDerivedDec> .Get(Dec.Database <IndexDerivedDec> .Get("TestDecC").index)); Assert.AreSame(Dec.Database <IndexDerivedDec> .Get("TestDecE"), Dec.Index <IndexDerivedDec> .Get(Dec.Database <IndexDerivedDec> .Get("TestDecE").index)); Assert.AreEqual(5, Dec.Index <IndexBaseDec> .Count); Assert.AreEqual(3, Dec.Index <IndexDerivedDec> .Count); }
public void Zero([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ArrayDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ArrayDec decName=""TestDec""> <dataEmpty></dataEmpty> <dataProvided></dataProvided> </ArrayDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <ArrayDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.dataEmpty, new int[] { }); Assert.AreEqual(result.dataProvided, new int[] { }); }
public void ConverterDict([ValuesExcept(BehaviorMode.Validation, BehaviorMode.Null)] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(ConverterDictDec) }, explicitConverters = new Type[] { typeof(ConverterDictTest) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <ConverterDictDec decName=""TestDec""> <payload> <yabba>1</yabba> <dabba>4</dabba> <doo>9</doo> </payload> </ConverterDictDec> </Decs>"); parser.Finish(); DoBehavior(mode); var testDec = Dec.Database <ConverterDictDec> .Get("TestDec"); Assert.AreEqual(1, testDec.payload.Where(kvp => kvp.Key.payload == "yabba").First().Value); Assert.AreEqual(4, testDec.payload.Where(kvp => kvp.Key.payload == "dabba").First().Value); Assert.AreEqual(9, testDec.payload.Where(kvp => kvp.Key.payload == "doo").First().Value); }
public void String([Values] BehaviorMode mode) { Dec.Config.TestParameters = new Dec.Config.UnitTestParameters { explicitTypes = new Type[] { typeof(HashSetStringDec) } }; var parser = new Dec.Parser(); parser.AddString(@" <Decs> <HashSetStringDec decName=""TestDec""> <data> <Hello /> <li>Goodbye</li> </data> </HashSetStringDec> </Decs>"); parser.Finish(); DoBehavior(mode); var result = Dec.Database <HashSetStringDec> .Get("TestDec"); Assert.IsNotNull(result); Assert.AreEqual(result.data, new HashSet <string> { "Hello", "Goodbye" }); }