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 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 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 PolymorphicRoot([Values] RecorderMode mode)
{
BaseType root = new DerivedType();
var deserialized = DoRecorderRoundTrip(root, mode);
Assert.AreEqual(root.GetType(), deserialized.GetType());
}
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 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 DotNet21FloatIssue([Values] RecorderMode mode)
{
// Intended to verify that this test doesn't stop working somehow, so we actually test both codepaths . . .
bool floatSuccess = -8.22272715124268E-63 == double.Parse("-8.22272715124268E-63");
int[] assemblyVersion = typeof(float)
.Assembly
.CustomAttributes
.Where(ca => ca.AttributeType == typeof(System.Reflection.AssemblyFileVersionAttribute))
.Single()
.ConstructorArguments[0]
.ToString()
.Trim('"')
.Split('.')
.Select(n => int.Parse(n))
.ToArray();
bool bugShouldBeFixed =
assemblyVersion[0] > 4 ||
(assemblyVersion[0] == 4 && assemblyVersion[1] > 7);
Assert.IsTrue(floatSuccess == bugShouldBeFixed);
var mr = new DoubleRec();
mr.a = -8.22272715124268E-63;
mr.b = -2.30119041724042E-247;
mr.c = -30984198100f;
var deserialized = DoRecorderRoundTrip(mr, mode);
Assert.AreEqual(mr.a, deserialized.a);
Assert.AreEqual(mr.b, deserialized.b);
Assert.AreEqual(mr.c, deserialized.c);
}
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 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 Private([Values] RecorderMode mode)
{
var item = new RecordablePrivate();
var output = DoRecorderRoundTrip(item, mode);
Assert.IsNotNull(output);
}
public void Pretty([Values(RecorderMode.Bare, RecorderMode.Pretty)] RecorderMode mode)
{
var item = new StubRecordable();
var output = Dec.Recorder.Write(item, pretty: mode == RecorderMode.Pretty);
Assert.AreEqual(mode == RecorderMode.Pretty, output.Contains("\n"));
}
public void Parameter([Values] RecorderMode mode)
{
var item = new RecordableParameter(3);
var output = DoRecorderRoundTrip(item, mode, expectReadErrors: true);
Assert.IsNull(output);
}
public void Null([Values] RecorderMode mode)
{
var element = new NullCore();
// Need to create these otherwise the factory won't even be triggered
element.element = new Factoried();
var deserialized = DoRecorderRoundTrip(element, mode);
Assert.IsNotNull(deserialized.element);
}
public void Sidestep([Values] RecorderMode mode)
{
var element = new SidestepCore();
element.one = new FactoriedDerivedSibling();
var deserialized = DoRecorderRoundTrip(element, mode);
Assert.IsInstanceOf(typeof(FactoriedDerivedSibling), element.one);
Assert.AreEqual(0, deserialized.one.value);
}
public void MultiRecord([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
var mr = new MultiRecordRec();
mr.x = 3;
mr.y = 5;
var deserialized = DoRecorderRoundTrip(mr, mode, expectWriteErrors: true);
Assert.AreEqual(mr.x, deserialized.x);
// y's value is left undefined
}
public void RecursiveRemoval([Values] RecorderMode mode)
{
var element = new RecursiveRoot();
element.element = new Recursive();
element.element.element = new Recursive();
var deserialized = DoRecorderRoundTrip(element, mode);
Assert.AreEqual(42, deserialized.element.value);
Assert.AreEqual(4, deserialized.element.element.value);
}
public void Basic([Values] RecorderMode mode)
{
var element = new BasicCore();
// Need to create these otherwise the factory won't even be triggered
element.one = new Factoried();
element.two = new Factoried();
var deserialized = DoRecorderRoundTrip(element, mode);
Assert.AreEqual(1, deserialized.one.value);
Assert.AreEqual(2, deserialized.two.value);
}
public void AsThis([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
var lat = new ListAsThisRecordable();
lat.data = new List <int>()
{
1, 1, 2, 3, 5, 8, 13, 21
};
var deserialized = DoRecorderRoundTrip(lat, mode);
Assert.AreEqual(lat.data, deserialized.data);
}
public void Stop()
{
if (mode == RecorderMode.IsRecording)
{
for (int i = 0; i < m_RecorderList.Count; i++)
{
m_RecorderList[i].Record(currentClip);
m_RecorderList[i].Save();
}
}
mode = RecorderMode.None;
}
public void ParameterOverride([Values] RecorderMode mode)
{
var element = new ParameterOverrideCore();
// Need to create these dynamically otherwise the factory won't even be triggered
element.one = new Factoried();
element.two = new Factoried();
var deserialized = DoRecorderRoundTrip(element, mode, expectWriteErrors: true, expectReadErrors: true);
Assert.AreEqual(-1, deserialized.one.value);
Assert.AreEqual(-2, deserialized.two.value);
}
public void ParameterReuse([Values] RecorderMode mode)
{
var element = new ParameterReuseCore();
// Need to create these dynamically otherwise the factory won't even be triggered
element.one = new Factoried();
element.two = new Factoried();
var deserialized = DoRecorderRoundTrip(element, mode);
Assert.AreEqual(42, deserialized.one.value);
Assert.AreEqual(42, deserialized.two.value);
}
public void RecursiveKiller([Values] RecorderMode mode)
{
bool gotRef = false;
for (int depth = 15; depth < 25; ++depth)
{
// Make sure we get a ref mode eventually
{
var testbed = new RecursiveKillerItem(depth, false);
var result = DoRecorderRoundTrip(testbed, mode, testSerializedResult: serialized => gotRef |= serialized.Contains("<refs>"));
int detectedDepth = 0;
while (result != null)
{
++detectedDepth;
result = result.element;
}
Assert.AreEqual(depth + 11, detectedDepth);
}
// Make sure we deserialize without error
{
var testbed = new RecursiveKillerItem(depth, true);
var result = DoRecorderRoundTrip(testbed, mode);
int detectedDepth = 0;
int foundFactory = 0;
while (result != null)
{
++detectedDepth;
if (result.makeFactory)
{
Assert.IsTrue(result.element.usedFactory);
foundFactory++;
}
else
{
Assert.IsTrue(result.element == null || !result.element.usedFactory);
}
result = result.element;
}
Assert.AreEqual(depth + 11, detectedDepth);
Assert.AreEqual(1, foundFactory);
}
}
}
public void AsThisPost([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
var lat = new ListAsThisPostRecordable();
lat.data = new List <int>()
{
1, 1, 2, 3, 5, 8, 13, 21
};
lat.data2 = 19;
var deserialized = DoRecorderRoundTrip(lat, mode, expectReadErrors: true, expectWriteErrors: true);
Assert.AreEqual(lat.data, deserialized.data);
}
public void DerivedConverterTest([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
Dec.Config.TestParameters = new Dec.Config.UnitTestParameters {
explicitConverters = new Type[] { typeof(DerivedConverter) }
};
// we're only doing this to kick off the converter init
new Dec.Parser().Finish();
BaseType root = new DerivedType();
var deserialized = DoRecorderRoundTrip(root, mode);
Assert.AreEqual(root.GetType(), deserialized.GetType());
}
public void StringEmptyNull([Values] RecorderMode mode)
{
var senr = new StringEmptyNullRecordable();
senr.stringContains = "Contains";
senr.stringEmpty = "";
senr.stringNull = null;
var deserialized = DoRecorderRoundTrip(senr, mode);
Assert.AreEqual(senr.stringContains, deserialized.stringContains);
Assert.AreEqual(senr.stringEmpty, deserialized.stringEmpty);
Assert.AreEqual(senr.stringNull, deserialized.stringNull);
}
public void DictionaryKeyRef([ValuesExcept(RecorderMode.Validation)] RecorderMode mode)
{
var dict = new DictionaryKeyRefDec();
dict.referenceA = new StubRecordable();
dict.referenceB = new StubRecordable();
dict.dict[dict.referenceA] = "Hello";
dict.dict[dict.referenceB] = "Goodbye";
var deserialized = DoRecorderRoundTrip(dict, mode);
Assert.AreNotSame(deserialized.referenceA, deserialized.referenceB);
Assert.AreEqual("Hello", deserialized.dict[deserialized.referenceA]);
Assert.AreEqual("Goodbye", deserialized.dict[deserialized.referenceB]);
}
public TResult Invoke <TResult>(Expression <Func <TResult> > expression, RecorderMode mode)
{
switch (mode)
{
case RecorderMode.Bypass:
return(expression.Compile().Invoke());
case RecorderMode.Record:
return(Record(expression));
case RecorderMode.Playback:
return(Playback(expression));
}
return(default(TResult));
}
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 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 ObjectRefs([Values] RecorderMode mode)
{
var obj = new ObjectRefsRecordable();
obj.intRef = 42;
obj.enumRef = GenericEnum.Gamma;
obj.stringRef = "Hello, I am a string";
obj.typeRef = typeof(Recorder);
obj.nullRef = null; // redundant, obviously
obj.classRef = new IntContainerClass()
{
value = 10
};
obj.structRef = new IntContainerStruct()
{
value = -10
};
obj.arrayRef = new int[] { 1, 1, 2, 3, 5, 8, 11 };
obj.listRef = new List <int>()
{
2, 3, 5, 7, 11, 13, 17
};
obj.dictRef = new Dictionary <int, string>()
{
{ 1, "one" }, { 2, "two" }, { 4, "four" }, { 8, "eight" }
};
obj.hashRef = new HashSet <int>()
{
1, 6, 21, 107
};
var deserialized = DoRecorderRoundTrip(obj, mode);
Assert.AreEqual(obj.intRef, deserialized.intRef);
Assert.AreEqual(obj.enumRef, deserialized.enumRef);
Assert.AreEqual(obj.stringRef, deserialized.stringRef);
Assert.AreEqual(obj.typeRef, deserialized.typeRef);
Assert.AreEqual(obj.nullRef, deserialized.nullRef);
Assert.AreEqual(obj.classRef.GetType(), deserialized.classRef.GetType());
Assert.AreEqual(((IntContainerClass)obj.classRef).value, ((IntContainerClass)deserialized.classRef).value);
Assert.AreEqual(obj.structRef.GetType(), deserialized.structRef.GetType());
Assert.AreEqual(((IntContainerStruct)obj.structRef).value, ((IntContainerStruct)deserialized.structRef).value);
Assert.AreEqual(obj.arrayRef, deserialized.arrayRef);
Assert.AreEqual(obj.listRef, deserialized.listRef);
Assert.AreEqual(obj.dictRef, deserialized.dictRef);
Assert.AreEqual(obj.hashRef, deserialized.hashRef);
}
public void StopSelection()
{
if (this.recorderMode != RecorderMode.SELECTION_MODE)
{
// Not in selection mode.
return;
}
this.recorderMode = RecorderMode.STOP_MODE;
this.win32MouseHook.UnInstall();
RemoveHighlight();
}
public void StopRec()
{
if (this.recorderMode != RecorderMode.RECORDING_MODE)
{
// Not recording.
return;
}
this.recorderMode = RecorderMode.STOP_MODE;
if (RecStopped != null)
{
RecStopped(this, EventArgs.Empty);
}
}
public void StartSelection()
{
if (this.recorderMode == RecorderMode.RECORDING_MODE)
{
StopRec();
}
Debug.Assert(this.recorderMode == RecorderMode.STOP_MODE);
this.recorderMode = RecorderMode.SELECTION_MODE;
this.win32MouseHook.Install();
}
public void StartRec()
{
if (this.recorderMode == RecorderMode.RECORDING_MODE)
{
// Already recording.
return;
}
else if (this.recorderMode == RecorderMode.SELECTION_MODE)
{
StopSelection();
}
Debug.Assert(this.recorderMode == RecorderMode.STOP_MODE);
this.recorderMode = RecorderMode.RECORDING_MODE;
if (RecStarted != null)
{
RecStarted(this, EventArgs.Empty);
}
}
