public void RenameDeleted([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(IntDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<IntDec decName=""One""><value>1</value></IntDec>
<IntDec decName=""Two""><value>2</value></IntDec>
<IntDec decName=""Three""><value>3</value></IntDec>
</Decs>");
parser.Finish();
var three = Dec.Database <IntDec> .Get("Three");
Dec.Database.Delete(three);
ExpectErrors(() => Dec.Database.Rename(three, "ThreePhoenix"));
DoBehavior(mode);
Assert.AreEqual(1, Dec.Database <IntDec> .Get("One").value);
Assert.AreEqual(2, Dec.Database <IntDec> .Get("Two").value);
Assert.IsNull(Dec.Database <IntDec> .Get("Three"));
Assert.IsNull(Dec.Database <IntDec> .Get("ThreePhoenix"));
}
public void ContainerRecursive([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var parent = new RecursiveParent();
parent.children.Add(new RecursiveNode());
parent.children.Add(new RecursiveNode());
parent.children.Add(new RecursiveNode());
parent.children[0].childB = parent.children[1];
parent.children[1].childA = parent.children[0];
// look on my works, ye mighty, and despair
parent.children[2].childA = parent.children[2];
parent.children[2].childB = parent.children[2];
var deserialized = DoRecorderRoundTrip(parent, mode);
Assert.IsNull(deserialized.children[0].childA);
Assert.AreSame(deserialized.children[1], deserialized.children[0].childB);
Assert.AreSame(deserialized.children[0], deserialized.children[1].childA);
Assert.IsNull(deserialized.children[1].childB);
Assert.AreSame(deserialized.children[2], deserialized.children[2].childA);
Assert.AreSame(deserialized.children[2], deserialized.children[2].childB);
Assert.AreEqual(3, deserialized.children.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 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 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 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 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 Containers([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var containers = new ContainersRecordable();
containers.intList.Add(42);
containers.intList.Add(1234);
containers.intList.Add(-105);
containers.stringDict["Key"] = "Value";
containers.stringDict["Info"] = "Data";
containers.intArray = new int[] { 10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82, 91 };
var deserialized = DoRecorderRoundTrip(containers, mode);
Assert.AreEqual(containers.intList, deserialized.intList);
Assert.AreEqual(containers.stringDict, deserialized.stringDict);
Assert.AreEqual(containers.intArray, deserialized.intArray);
}
public void ToStringExistent()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(EntityTemplateDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""Component"">
<type>SimpleComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>Component</li>
</components>
</EntityDec>
</Decs>
");
parser.Finish();
Environment.Startup(toString: e => "ToStringTest");
Environment.Add(new Ghi.Entity(EntityTemplateDecs.EntityModel));
var ents = Environment.List.ToArray();
Assert.AreEqual("ToStringTest", ents[0].ToString());
}
public void Creation()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(EntityTemplateDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""Component"">
<type>SimpleComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>Component</li>
</components>
</EntityDec>
</Decs>
");
parser.Finish();
Environment.Startup();
Environment.Add(new Ghi.Entity(EntityTemplateDecs.EntityModel));
var ents = Environment.List.ToArray();
Assert.AreEqual(1, ents.Length);
Assert.IsTrue(ents[0].Component <SimpleComponent>() != null);
}
public void ToStringNonexistent()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(EntityTemplateDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""Component"">
<type>SimpleComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>Component</li>
</components>
</EntityDec>
</Decs>
");
parser.Finish();
Environment.Startup();
Environment.Add(new Ghi.Entity(EntityTemplateDecs.EntityModel));
var ents = Environment.List.ToArray();
ents[0].ToString(); // we're just checking to make sure it doesn't crash, we actually don't care what it outputs
}
public void ExplicitComponentDerived()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(EntityTemplateDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""EntityComponent"">
<type>SimpleComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>EntityComponent</li>
</components>
</EntityDec>
</Decs>
");
parser.Finish();
Environment.Startup();
var comp = new DerivedComponent();
var entity = new Entity(EntityTemplateDecs.EntityModel, comp);
Assert.AreSame(comp, entity.Component <SimpleComponent>());
}
public void ExplicitComponentWrong()
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitStaticRefs = new System.Type[] { typeof(EntityTemplateDecs) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<ComponentDec decName=""EntityComponent"">
<type>SimpleComponent</type>
</ComponentDec>
<ComponentDec decName=""NonEntityComponent"">
<type>StringComponent</type>
</ComponentDec>
<EntityDec decName=""EntityModel"">
<components>
<li>EntityComponent</li>
</components>
</EntityDec>
</Decs>
");
parser.Finish();
Environment.Startup();
var comp = new StringComponent();
ExpectErrors(() => new Entity(EntityTemplateDecs.EntityModel, comp));
}
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 Primitives([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var primitives = new PrimitivesRecordable();
primitives.intValue = 42;
primitives.floatValue = 0.1234f;
primitives.boolValue = true;
primitives.stringValue = "<This is a test string value with some XML-sensitive characters.>";
primitives.typeValue = typeof(Dec.Dec);
var deserialized = DoRecorderRoundTrip(primitives, mode);
Assert.AreEqual(primitives.intValue, deserialized.intValue);
Assert.AreEqual(primitives.floatValue, deserialized.floatValue);
Assert.AreEqual(primitives.boolValue, deserialized.boolValue);
Assert.AreEqual(primitives.stringValue, deserialized.stringValue);
Assert.AreEqual(primitives.typeValue, typeof(Dec.Dec));
}
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 Enum([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var enums = new EnumRecordable();
enums.alph = EnumRecordable.Enum.Alpha;
enums.bet = EnumRecordable.Enum.Beta;
enums.gam = EnumRecordable.Enum.Gamma;
var deserialized = DoRecorderRoundTrip(enums, mode, testSerializedResult: serialized =>
{
Assert.IsTrue(serialized.Contains("Alpha"));
Assert.IsTrue(serialized.Contains("Beta"));
Assert.IsTrue(serialized.Contains("Gamma"));
Assert.IsFalse(serialized.Contains("__value"));
});
Assert.AreEqual(enums.alph, deserialized.alph);
Assert.AreEqual(enums.bet, deserialized.bet);
Assert.AreEqual(enums.gam, deserialized.gam);
}
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 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"
});
}
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 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 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 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 Refs([Values] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
};
var parser = new Dec.Parser();
parser.Finish();
var refs = new RefsRootRecordable();
refs.childAone = new RefsChildRecordable();
refs.childAtwo = refs.childAone;
refs.childB = new RefsChildRecordable();
refs.childEmpty = null;
var deserialized = DoRecorderRoundTrip(refs, mode);
Assert.IsNotNull(deserialized.childAone);
Assert.IsNotNull(deserialized.childAtwo);
Assert.IsNotNull(deserialized.childB);
Assert.IsNull(deserialized.childEmpty);
Assert.AreEqual(deserialized.childAone, deserialized.childAtwo);
Assert.AreNotEqual(deserialized.childAone, deserialized.childB);
}
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 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 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 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 Rename([Values] BehaviorMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitTypes = new Type[] { typeof(IntDec) }
};
var parser = new Dec.Parser();
parser.AddString(@"
<Decs>
<IntDec decName=""One""><value>1</value></IntDec>
<IntDec decName=""Two""><value>2</value></IntDec>
<IntDec decName=""Three""><value>3</value></IntDec>
</Decs>");
parser.Finish();
Dec.Database.Rename(Dec.Database <IntDec> .Get("One"), "OneBeta");
Dec.Database.Rename(Dec.Database <IntDec> .Get("OneBeta"), "OneGamma");
// yes okay this is confusing
Dec.Database.Rename(Dec.Database <IntDec> .Get("Two"), "One");
DoBehavior(mode);
Assert.AreEqual(1, Dec.Database <IntDec> .Get("OneGamma").value);
Assert.AreEqual(2, Dec.Database <IntDec> .Get("One").value);
Assert.AreEqual(3, Dec.Database <IntDec> .Get("Three").value);
}