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