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