public void PermissionsRoNo()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(Decs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""SimpleComponent"">
<type>SimpleComponent</type>
</ComponentDec>
<ComponentDec decName=""StringComponent"">
<type>StringComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>SimpleComponent</li>
<li>StringComponent</li>
</components>
</EntityDec>
<SystemDec decName=""TestSystem"">
<type>ComponentPermissionRoSystem</type>
<iterate>
<StringComponent>ReadWrite</StringComponent>
</iterate>
</SystemDec>
<ProcessDec decName=""TestProcess"">
<order>
<li>TestSystem</li>
</order>
</ProcessDec>
</Decs>
");
parser.Finish();
Environment.Startup();
Environment.Add(new Entity(Decs.EntityModel));
Environment.Add(new Entity(Decs.EntityModel));
ComponentPermissionRoSystem.Executions = 0;
ExpectErrors(() => Environment.Process(Decs.TestProcess));
Assert.AreEqual(2, ComponentPermissionRoSystem.Executions);
}
public void Missing([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(MissingDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
</Decs>");
ExpectErrors(() => parser.Finish());
DoBehavior(mode, rewrite_expectParseErrors: true);
}
public void LoadFile([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(IntDec) }
};
var parser = new Dec.Parser();
parser.AddFile("data/Parser.LoadFile.xml");
parser.Finish();
DoBehavior(mode);
Assert.AreEqual(55, Dec.Database <IntDec> .Get("TestDec").value);
}
public void LoadFileError([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(IntDec) }
};
var parser = new Dec.Parser();
parser.AddFile("data/Parser.LoadFileError.xml");
ExpectErrors(() => parser.Finish(), str => str.Contains("Parser.LoadFileError"));
DoBehavior(mode);
Assert.IsNotNull(Dec.Database <IntDec> .Get("TestDec"));
}
public void ProperStringName([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
ExpectErrors(() => parser.AddString(@"
<Decs>
<StubDec decName=""TestDecA"" />
</Decs>", "TestStringName"), str => str.StartsWith("TestStringName"));
parser.Finish();
DoBehavior(mode);
}
public void Basic()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(Decs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""Component"">
<type>SimpleComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>Component</li>
</components>
</EntityDec>
<SystemDec decName=""TestSystem"">
<type>IterationSystem</type>
<iterate>
<Component>ReadWrite</Component>
</iterate>
</SystemDec>
<ProcessDec decName=""TestProcess"">
<order>
<li>TestSystem</li>
</order>
</ProcessDec>
</Decs>
");
parser.Finish();
Environment.Startup();
Environment.Add(new Entity(Decs.EntityModel));
Environment.Add(new Entity(Decs.EntityModel));
IterationSystem.Executions = 0;
Environment.Process(Decs.TestProcess);
Assert.AreEqual(2, IterationSystem.Executions);
Entity[] entities = Environment.List.OrderBy(e => e.Component <SimpleComponent>().number).ToArray();
Assert.AreEqual(1, entities[0].Component <SimpleComponent>().number);
Assert.AreEqual(2, entities[1].Component <SimpleComponent>().number);
}
public void Integration()
{
Directory.SetCurrentDirectory(new DirectoryInfo(TestContext.CurrentContext.TestDirectory).Parent.Parent.Parent.FullName);
Dec.Config.UsingNamespaces = new string[] { "DecTestIntegration" };
var parser = new Dec.Parser();
parser.AddDirectory("data");
parser.Finish();
Assert.IsNotNull(Dec.Database <IntegrationDec> .Get("ItemAlpha"));
Assert.IsNotNull(Dec.Database <IntegrationDec> .Get("ItemBeta"));
Assert.AreSame(IntegrationDecs.ItemAlpha, Dec.Database <IntegrationDec> .Get("ItemAlpha"));
}
public void MissingDecName([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 />
</Decs>"));
parser.Finish();
DoBehavior(mode);
}
public void RootPrimitive([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
int value = 4;
// gonna be honest, this feels kind of like overkill
var deserialized = DoRecorderRoundTrip(value, mode);
Assert.AreEqual(value, deserialized);
}
public void LoadDirectoryRecursive([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(IntDec) }
};
var parser = new Dec.Parser();
parser.AddDirectory("data/Parser.LoadDirectoryRecursive");
parser.Finish();
DoBehavior(mode);
Assert.AreEqual(40, Dec.Database <IntDec> .Get("TestDec1").value);
Assert.AreEqual(80, Dec.Database <IntDec> .Get("TestDec2").value);
}
public void RecursiveSquaredRoot([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var root = new RecursiveSquaredRecorder();
var a = new RecursiveSquaredRecorder();
var b = new RecursiveSquaredRecorder();
var c = new RecursiveSquaredRecorder();
root.left = a;
root.right = a;
a.left = b;
a.right = b;
b.left = c;
b.right = c;
c.left = root;
c.right = root;
var deserialized = DoRecorderRoundTrip(root, mode);
Assert.AreSame(deserialized.left, deserialized.right);
Assert.AreSame(deserialized.left.left, deserialized.right.right);
Assert.AreSame(deserialized.left.left.left, deserialized.right.right.right);
Assert.AreSame(deserialized.left.left.left.left, deserialized.right.right.right.right);
Assert.AreSame(deserialized, deserialized.right.right.right.right);
Assert.AreNotSame(deserialized, deserialized.left);
Assert.AreNotSame(deserialized, deserialized.left.left);
Assert.AreNotSame(deserialized, deserialized.left.left.left);
Assert.AreNotSame(deserialized.left, deserialized.left.left);
Assert.AreNotSame(deserialized.left, deserialized.left.left.left);
Assert.AreNotSame(deserialized.left, deserialized.left.left.left.left);
Assert.AreNotSame(deserialized.left.left, deserialized.left.left.left);
Assert.AreNotSame(deserialized.left.left.left, deserialized.left.left.left.left);
Assert.AreNotSame(deserialized.left.left.left, deserialized.left.left.left.left);
}
public void Clear()
{
ExpectWarnings(() => Assert.IsNull(Dec.Database <StubDec> .Get("TestDec")));
// we don't test StubDecs.TestDec here because if we do, we'll kick off the detection
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(StubDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<StubDec decName=""TestDec"" />
</Decs>");
parser.Finish();
}
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
Assert.AreEqual(StubDecs.TestDec, Dec.Database <StubDec> .Get("TestDec"));
Dec.Database.Clear();
ExpectWarnings(() => Assert.IsNull(Dec.Database <StubDec> .Get("TestDec")));
Assert.IsNull(StubDecs.TestDec);
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(StubDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<StubDec decName=""TestDec"" />
</Decs>");
parser.Finish();
}
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
Assert.AreEqual(StubDecs.TestDec, Dec.Database <StubDec> .Get("TestDec"));
Dec.Database.Clear();
ExpectWarnings(() => Assert.IsNull(Dec.Database <StubDec> .Get("TestDec")));
Assert.IsNull(StubDecs.TestDec);
}
public void Unicode([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(UnicodeDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<StubDec decName=""Brød"" />
<StubDec decName=""ขนมปัง"" />
<StubDec decName=""パン"" />
<StubDec decName=""餧"" />
<StubDec decName=""麵包"" />
<StubDec decName=""خبز"" />
<StubDec decName=""빵"" />
<StubDec decName=""לחם"" />
<StubDec decName=""ပေါင်မုန့်"" />
<StubDec decName=""ബ്രെഡ്"" />
</Decs>");
parser.Finish();
DoBehavior(mode);
Assert.IsNotNull(Dec.Database <StubDec> .Get("Brød"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("ขนมปัง"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("パン"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("餧"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("麵包"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("خبز"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("빵"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("לחם"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("ပေါင်မုန့်"));
Assert.IsNotNull(Dec.Database <StubDec> .Get("ബ്രെഡ്"));
Assert.AreSame(Dec.Database <StubDec> .Get("Brød"), UnicodeDecs.Brød);
Assert.AreSame(Dec.Database <StubDec> .Get("ขนมปัง"), UnicodeDecs.ขนมปัง);
Assert.AreSame(Dec.Database <StubDec> .Get("パン"), UnicodeDecs.パン);
Assert.AreSame(Dec.Database <StubDec> .Get("餧"), UnicodeDecs.餧);
Assert.AreSame(Dec.Database <StubDec> .Get("麵包"), UnicodeDecs.麵包);
Assert.AreSame(Dec.Database <StubDec> .Get("خبز"), UnicodeDecs.خبز);
Assert.AreSame(Dec.Database <StubDec> .Get("빵"), UnicodeDecs.빵);
Assert.AreSame(Dec.Database <StubDec> .Get("לחם"), UnicodeDecs.לחם);
Assert.AreSame(Dec.Database <StubDec> .Get("ပေါင်မုန့်"), UnicodeDecs.ပေါင်မုန့်);
Assert.AreSame(Dec.Database <StubDec> .Get("ബ്രെഡ്"), UnicodeDecs.ബ്രെഡ്);
}
public void LateTouch()
{
// We avoid BehaviorMode here because the StaticReference error event can happen at most once, which means that we can't run the test twice without the second (and later) tests failing.
// This also means that test success would depend on test order run, which, no.
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
</Decs>");
parser.Finish();
ExpectErrors(() => LateTouchDecs.TestDec = null);
}
private static void Init()
{
// Configure Dec's error reporting
Dec.Config.InfoHandler = str => Dbg.Inf(str);
Dec.Config.WarningHandler = str => Dbg.Wrn(str);
Dec.Config.ErrorHandler = str => Dbg.Err(str);
Dec.Config.ExceptionHandler = e => Dbg.Ex(e);
// Configure Dec's namespaces
Dec.Config.UsingNamespaces = new string[] { "Fuzzgen" };
// In most cases, you'll just want to read all the XML files in your data directory, which is easy
var parser = new Dec.Parser();
parser.AddDirectory("data/dec");
parser.Finish();
}
public void Core()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var deserialized = Dec.Recorder.Read <int>(@"
<Record>
<recordFormatVersion>1</recordFormatVersion>
<data>4</data>
</Record>");
Assert.AreEqual(deserialized, 4);
}
public void HashSetReplace([Values] BehaviorMode mode, [Values] ParseModesToTest parseMode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(HashSetDec) }
};
var parser = new Dec.Parser();
parser.AddString($@"
<Decs>
<HashSetDec decName=""TestDec"">
<filled {GenerateParseModeTag(parseMode)}>
<li>4</li>
<li>5</li>
<li>6</li>
<li>7</li>
</filled>
</HashSetDec>
</Decs>");
if (parseMode == ParseModesToTest.Default || parseMode == ParseModesToTest.Replace || parseMode == ParseModesToTest.Patch)
{
parser.Finish();
}
else
{
ExpectErrors(() => parser.Finish());
}
DoBehavior(mode);
Assert.IsNull(Dec.Database <HashSetDec> .Get("TestDec").empty);
if (parseMode == ParseModesToTest.Append || parseMode == ParseModesToTest.Patch)
{
Assert.AreEqual(new HashSet <int> {
1, 2, 3, 4, 5, 6, 7
}, Dec.Database <HashSetDec> .Get("TestDec").filled);
}
else
{
Assert.AreEqual(new HashSet <int> {
4, 5, 6, 7
}, Dec.Database <HashSetDec> .Get("TestDec").filled);
}
}
public void DepthSingleLinked([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
// This test verifies that we can serialize and/or read an extremely deep structure without blowing the stack.
// We use single links so we don't generate refs, we actually embed objects.
const int depth = 10_000;
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var root = new DoubleLinkedRecorder();
{
var current = root;
for (int i = 1; i < depth; ++i)
{
var next = new DoubleLinkedRecorder();
current.a = next;
current = next;
}
}
var deserialized = DoRecorderRoundTrip(root, mode, testSerializedResult: serialized =>
{
// This verifies we haven't done an n^2 monstrosity by letting the depth get too far.
// With 10_000 items, this generates a 300_000_000 byte file before depth controlling!
Assert.Less(serialized.Length, 2_000_000);
});
{
var seen = new HashSet <DoubleLinkedRecorder>();
var current = deserialized;
while (current != null && !seen.Contains(current))
{
seen.Add(current);
current = current.a;
}
Assert.AreEqual(depth, seen.Count);
}
}
public void Misparse([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var misparse = new MisparseRecordable();
var deserialized = DoRecorderRoundTrip(misparse, mode, expectWriteErrors: true, expectReadErrors: true);
Assert.IsNotNull(deserialized);
// should just leave this alone
Assert.IsNotNull(deserialized.unparseable);
}
public void ConverterUnsupplied([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitConverters = new Type[] { typeof(ConverterUnsuppliedConverter) }
};
var parser = new Dec.Parser();
parser.Finish();
var root = new ConverterUnsuppliedClass();
root.x = 42;
var deserialized = DoRecorderRoundTrip(root, mode, expectWriteErrors: true);
Assert.IsNotNull(deserialized); // even if we don't know how to store it and deserialize it, we should at least be able to create it
}
public void ExtraAttribute([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=""TestDec"" invalidAttribute=""hello"" />
</Decs>");
ExpectErrors(() => parser.Finish());
DoBehavior(mode);
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
}
public void Internal([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }, explicitStaticRefs = new Type[] { typeof(InternalDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<StubDec decName=""TestDec"" />
</Decs>");
parser.Finish();
DoBehavior(mode);
Assert.IsNotNull(InternalDecs.TestDec);
}
public void LooseMatchCamelToSnake([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(LooseMatchDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<LooseMatchDec decName=""TestDec"">
<camel_case>words</camel_case>
</LooseMatchDec>
</Decs>");
ExpectErrors(() => parser.Finish(), err => err.Contains("camelCase"));
DoBehavior(mode);
}
public void TrivialEmptyParse([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=""TestDec"" />
</Decs>");
parser.Finish();
DoBehavior(mode);
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
}
public void ConstructorTouch()
{
// We avoid BehaviorMode here because the StaticReference error event can happen at most once, which means that we can't run the test twice without the second (and later) tests failing.
// This also means that test success would depend on test order run, which, no.
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(ConstructorTouchDec) }, explicitStaticRefs = new Type[] { typeof(ConstructorTouchDecs) }
};
var parser = new Dec.Parser();
ExpectErrors(() => parser.AddString(@"
<Decs>
<ConstructorTouchDec decName=""TestDec"" />
</Decs>"));
ExpectErrors(() => parser.Finish());
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
}
public void IncorrectRoot([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(StubDec) }
};
var parser = new Dec.Parser();
ExpectWarnings(() => parser.AddString(@"
<NotDecs>
<StubDec decName=""TestDec"" />
</NotDecs>"));
parser.Finish();
DoBehavior(mode);
Assert.IsNotNull(Dec.Database <StubDec> .Get("TestDec"));
}
public void ConstructorParameter([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(ConstructorParameterDec) }
};
var parser = new Dec.Parser();
ExpectErrors(() => parser.AddString(@"
<Decs>
<ConstructorParameterDec decName=""TestDec"" />
</Decs>"));
parser.Finish();
DoBehavior(mode);
Assert.IsNull(Dec.Database <ConstructorParameterDec> .Get("TestDec"));
}
public void BulkParse([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(BulkParseDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<BulkParseDec decName=""TestDec"">
<testIntA>35</testIntA>
<testIntB>-20</testIntB>
<testFloatA>0.1234</testFloatA>
<testFloatB>-8000000000000000</testFloatB>
<testStringA>Hello</testStringA>
<testStringB>Data, data, data</testStringB>
<testStringC>Forsooth</testStringC>
<testBoolA>true</testBoolA>
<testBoolB>false</testBoolB>
</BulkParseDec>
</Decs>");
parser.Finish();
DoBehavior(mode);
var result = Dec.Database <BulkParseDec> .Get("TestDec");
Assert.IsNotNull(result);
Assert.AreEqual(35, result.testIntA);
Assert.AreEqual(-20, result.testIntB);
Assert.AreEqual(3, result.testIntC);
Assert.AreEqual(0.1234f, result.testFloatA);
Assert.AreEqual(-8000000000000000f, result.testFloatB);
Assert.AreEqual(3, result.testFloatC);
Assert.AreEqual("Hello", result.testStringA);
Assert.AreEqual("Data, data, data", result.testStringB);
Assert.AreEqual("Forsooth", result.testStringC);
Assert.AreEqual("four", result.testStringD);
Assert.AreEqual(true, result.testBoolA);
Assert.AreEqual(false, result.testBoolB);
Assert.AreEqual(false, result.testBoolC);
}
public void DictionaryReplace([Values] BehaviorMode mode, [Values] ParseModesToTest parseMode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(DictionaryDec) }
};
var parser = new Dec.Parser();
parser.AddString($@"
<Decs>
<DictionaryDec decName=""TestDec"">
<filled {GenerateParseModeTag(parseMode)}>
<three>-3</three>
<four>4</four>
<five>5</five>
</filled>
</DictionaryDec>
</Decs>");
if (parseMode == ParseModesToTest.Default || parseMode == ParseModesToTest.Replace || parseMode == ParseModesToTest.Patch)
{
parser.Finish();
}
else
{
ExpectErrors(() => parser.Finish());
}
DoBehavior(mode);
Assert.IsNull(Dec.Database <DictionaryDec> .Get("TestDec").empty);
if (parseMode == ParseModesToTest.Patch || parseMode == ParseModesToTest.Append)
{
Assert.AreEqual(new Dictionary <string, int> {
{ "one", 1 }, { "two", 2 }, { "three", -3 }, { "four", 4 }, { "five", 5 }
}, Dec.Database <DictionaryDec> .Get("TestDec").filled);
}
else
{
Assert.AreEqual(new Dictionary <string, int> {
{ "three", -3 }, { "four", 4 }, { "five", 5 }
}, Dec.Database <DictionaryDec> .Get("TestDec").filled);
}
}
public void FromNonAbstract([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(SimpleDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<SimpleDec decName=""Base"">
<defaulted>3</defaulted>
<overridden>42</overridden>
<subObject>
<defaulted>12</defaulted>
<overridden>80</overridden>
</subObject>
</SimpleDec>
<SimpleDec decName=""Thing"" parent=""Base"">
<overridden>60</overridden>
<subObject>
<overridden>90</overridden>
</subObject>
</SimpleDec>
</Decs>");
parser.Finish();
DoBehavior(mode);
var bas = Dec.Database <SimpleDec> .Get("Base");
Assert.AreEqual(3, bas.defaulted);
Assert.AreEqual(42, bas.overridden);
Assert.AreEqual(12, bas.subObject.defaulted);
Assert.AreEqual(80, bas.subObject.overridden);
var thing = Dec.Database <SimpleDec> .Get("Thing");
Assert.AreEqual(3, thing.defaulted);
Assert.AreEqual(60, thing.overridden);
Assert.AreEqual(12, thing.subObject.defaulted);
Assert.AreEqual(90, thing.subObject.overridden);
}
