public void CircuitProjectSaveLoadTest() { string dir = Path.Combine(this.TestContext.TestRunDirectory, this.TestContext.TestName + DateTime.UtcNow.Ticks, "Some Test Sub Directory"); string file = Path.Combine(dir, "My Test File.CircuitProject"); // save in inexistent folder CircuitProject project1 = CircuitProject.Create(null); project1.InTransaction(() => { LogicalCircuit main = project1.ProjectSet.Project.LogicalCircuit; CircuitButton button = project1.CircuitButtonSet.Create("b", false, PinSide.Right); CircuitSymbol buttonSymbol = project1.CircuitSymbolSet.Create(button, main, 1, 2); Gate led = project1.GateSet.Gate(GateType.Led, 1, false); project1.CircuitSymbolSet.Create(led, main, 6, 2); Wire wire = project1.WireSet.Create(main, new GridPoint(3, 3), new GridPoint(6, 3)); }); Assert.IsTrue(!Directory.Exists(dir)); project1.Save(file); Assert.IsTrue(File.Exists(file)); CircuitProject project2 = CircuitProject.Create(file); Assert.IsTrue(ProjectTester.Equal(project1, project2)); // save in existing folder and existing file. CircuitProject project3 = ProjectTester.Load(this.TestContext, Properties.Resources.Digital_Clock, null); Assert.IsTrue(File.Exists(file)); project3.Save(file); CircuitProject project4 = CircuitProject.Create(file); File.Delete(file); Assert.IsTrue(ProjectTester.Equal(project3, project4)); }
private void AssertTestable(CircuitProject project, string circuitName, bool isTestable) { ProjectTester.SwitchTo(project, circuitName); Assert.AreEqual(isTestable, CircuitTestSocket.IsTestable(project.ProjectSet.Project.LogicalCircuit), "{0} should {1}be testable", project.ProjectSet.Project.LogicalCircuit.Name, isTestable ? "" : "not " ); }
public void CircuitTestSocketBuildTruthTable1Test() { ProjectTester.SwitchTo(this.CircuitProject, "1 Bit Wire"); CircuitTestSocket s1 = new CircuitTestSocket(this.CircuitProject.ProjectSet.Project.LogicalCircuit); ExpressionParser parser = new ExpressionParser(s1); Predicate <TruthState> predicate = parser.Parse("q=x", true); double progress = -1; bool truncated; IList <TruthState> table1 = s1.BuildTruthTable( p => { Assert.IsTrue(0 <= p && p <= 100); progress = p; }, () => true, null, 2, out truncated ); Assert.IsTrue(Math.Abs(progress - 100) < 2); Assert.IsTrue(!truncated); Assert.IsTrue(table1 != null && table1.Count == 2); Assert.IsTrue(table1[0].Input[0] == 0 && table1[0].Output[0] == 0); Assert.IsTrue(table1[1].Input[0] == 1 && table1[1].Output[0] == 1); IList <TruthState> table2 = s1.BuildTruthTable( p => { Assert.IsTrue(0 <= p && p <= 100); progress = p; }, () => true, predicate, 2, out truncated ); Assert.IsTrue(Math.Abs(progress - 100) < 2); Assert.IsTrue(!truncated); Assert.IsTrue(table2 != null && table2.Count == 0); }
public void CircuitStateEndDefinitionTest() { ProjectTester.InitResources(); CircuitProject project = CircuitProject.Create(null); CircuitButton button = null; CircuitSymbol buttonSymbol = null; Gate led = null; CircuitSymbol ledSymbol = null; project.InTransaction(() => { button = project.CircuitButtonSet.Create("b", false, PinSide.Right); buttonSymbol = project.CircuitSymbolSet.Create(button, project.ProjectSet.Project.LogicalCircuit, 1, 1); led = project.GateSet.Gate(GateType.Led, 1, false); ledSymbol = project.CircuitSymbolSet.Create(led, project.ProjectSet.Project.LogicalCircuit, 5, 1); }); CircuitState target = new CircuitState(3); int buttonResult = target.ReserveState(); FunctionButton functionButton = new FunctionButton(target, new CircuitSymbol[] { buttonSymbol }, buttonResult); FunctionLed functionLed = new FunctionLed(target, new CircuitSymbol[] { ledSymbol }, buttonResult); target.EndDefinition(); Assert.IsTrue(functionButton.Dependent != null && functionButton.Dependent.Length == 1 && functionButton.Dependent[0] == functionLed); Assert.IsTrue(functionLed.Dependent == null); }
public void ExpressionParserVariableParseTest() { CircuitProject project = ProjectTester.Load(this.TestContext, Properties.Resources.Digital_Clock, "4 bit adder"); CircuitTestSocket socket = new CircuitTestSocket(project.ProjectSet.Project.LogicalCircuit); ExpressionParser parser = new ExpressionParser(socket); TruthState state = new TruthState(socket.Inputs.Count(), socket.Outputs.Count()); for (int i = 0; i < state.Result.Length; i++) { state.Result[i] = 0x5555555555555555L; } bool success = state.Unpack(socket.Outputs.Select(o => o.Function.ParameterCount).ToArray()); Assert.IsTrue(success); state.Input[this.InputIndex(socket, "c")] = 1; state.Input[this.InputIndex(socket, "x1")] = 5; state.Input[this.InputIndex(socket, "x2")] = 4; state.Output[this.OutputIndex(socket, "s")] = 9; state.Output[this.OutputIndex(socket, "c'")] = 1; this.Valid(parser, state, 1, "c"); this.Valid(parser, state, 5, "x1"); this.Valid(parser, state, 4, "x2"); this.Valid(parser, state, 9, "s"); this.Valid(parser, state, 1, "\"c'\""); this.Invalid(parser, state, "d"); this.Invalid(parser, state, "\"c'"); this.Invalid(parser, state, "\"c'\\"); this.Invalid(parser, state, "\"c'\\\"\""); }
public void ExpressionParserVariableCaseParseTest() { CircuitProject project = ProjectTester.Load(this.TestContext, Properties.Resources.Digital_Clock, "4 bit adder"); Pin x1 = null, x2 = null, s = null, c = null; foreach (Pin pin in project.PinSet.SelectByCircuit(project.ProjectSet.Project.LogicalCircuit)) { switch (pin.Name) { case "x1": x1 = pin; break; case "x2": x2 = pin; break; case "s": s = pin; break; case "c'": c = pin; break; } } Assert.IsNotNull(x1); Assert.IsNotNull(x2); Assert.IsNotNull(s); Assert.IsNotNull(c); project.InTransaction(() => { x1.Name = "variant"; x2.Name = "vaRIAnt"; s.Name = "VAriaNT"; c.Name = "VARIANT"; }); CircuitTestSocket socket = new CircuitTestSocket(project.ProjectSet.Project.LogicalCircuit); ExpressionParser parser = new ExpressionParser(socket); TruthState state = new TruthState(socket.Inputs.Count(), socket.Outputs.Count()); for (int i = 0; i < state.Result.Length; i++) { state.Result[i] = 0x5555555555555555L; } state.Unpack(socket.Outputs.Select(o => o.Function.ParameterCount).ToArray()); state.Input[this.InputIndex(socket, "c")] = 1; state.Input[this.InputIndex(socket, "variant")] = 5; state.Input[this.InputIndex(socket, "vaRIAnt")] = 4; state.Output[this.OutputIndex(socket, "VAriaNT")] = 9; state.Output[this.OutputIndex(socket, "VARIANT")] = 1; this.Valid(parser, state, 1, "c"); this.Valid(parser, state, 5, "variant"); this.Valid(parser, state, 4, "vaRIAnt"); this.Valid(parser, state, 9, "VAriaNT"); this.Valid(parser, state, 1, "VARIANT"); }
private void CircuitMapCleanUpTest(CircuitProject circuitProject, string logicalCircuitName, int expectedFunctions) { ProjectTester.SwitchTo(circuitProject, logicalCircuitName); CircuitMap map = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit); CircuitState state = map.Apply(CircuitRunner.HistorySize); Assert.AreEqual(expectedFunctions, state.Functions.Count(), "wrong number of functions"); }
public void ConvertDescription2NoteTest() { string projectText = Properties.Resources.From2_0_0_6Conversion; this.AssertFileVersion(projectText, "http://LogicCircuit.net/2.0.0.6/CircuitProject.xsd"); ProjectTester tester = new ProjectTester(this.TestContext, projectText, "Test Circuit"); Assert.AreEqual("Project Description\n<xml>text</xml>", tester.Project.Note); Assert.AreEqual("Test Circuit description\n<xml>node</xml>", tester.Project.LogicalCircuit.Note); }
public void SensorSeriesTest() { ProjectTester tester = new ProjectTester(this.TestContext, Properties.Resources.SensorTests, "Series Test"); OutputSocket target = new OutputSocket(tester.Output[0]); for (int i = 0; i < 2000; i++) { Assert.IsTrue(tester.CircuitState.Evaluate(true)); int result = target.BinaryInt(); Assert.AreEqual(i < 0x14 ? i * 2 + 1 : 0x27, result); } }
public static LogicalCircuit SwitchTo(CircuitProject circuitProject, string logicalCircuitName) { Assert.IsNotNull(logicalCircuitName); LogicalCircuit circuit = circuitProject.LogicalCircuitSet.FindByName(logicalCircuitName); Assert.IsNotNull(circuit, "Circuit {0} not found in the project", logicalCircuitName); if (circuitProject.ProjectSet.Project.LogicalCircuit != circuit) { circuitProject.InOmitTransaction(() => circuitProject.ProjectSet.Project.LogicalCircuit = circuit); } ProjectTester.GuaranteeGlyph(circuitProject); return(circuit); }
public void ProbeConvertionTest() { string projectText = Properties.Resources.ProbeConvertTest; this.AssertFileVersion(projectText); ProjectTester tester = new ProjectTester(this.TestContext, projectText, null); Assert.AreEqual <int>(3, tester.CircuitProject.CircuitProbeSet.Count(), "Expecting 3 probes"); Assert.AreEqual(3, tester.CircuitProject.CircuitSymbolSet.Where(symbol => symbol.Circuit is CircuitProbe).Count(), "Expecting 3 probe symbols"); List <CircuitSymbol> symbols = tester.CircuitProject.CircuitProbeSet.Select(probe => tester.CircuitProject.CircuitSymbolSet.SelectByCircuit(probe).First()).ToList(); Assert.AreEqual(3, symbols.Count); Assert.AreEqual(2, symbols.Where(symbol => symbol.LogicalCircuit == tester.CircuitProject.ProjectSet.Project.LogicalCircuit).Count(), "Expecting 2 symbols on main diagram"); }
public void CircuitMapCleanUpTest() { CircuitProject circuitProject = ProjectTester.Load(this.TestContext, Properties.Resources.CircuitMapCleanUpTest, null); this.CircuitMapCleanUpTest(circuitProject, "1. Empty 1", 0); Assert.AreEqual(0, circuitProject.ProjectSet.Project.LogicalCircuit.CircuitSymbols().Count()); this.CircuitMapCleanUpTest(circuitProject, "2. Empty 2", 0); Assert.AreEqual(7, circuitProject.ProjectSet.Project.LogicalCircuit.CircuitSymbols().Count()); this.CircuitMapCleanUpTest(circuitProject, "3. Single Out", 3); Assert.AreEqual(4, circuitProject.ProjectSet.Project.LogicalCircuit.CircuitSymbols().Count()); this.CircuitMapCleanUpTest(circuitProject, "4. Chain Out", 8); Assert.AreEqual(11, circuitProject.ProjectSet.Project.LogicalCircuit.CircuitSymbols().Count()); }
private static bool Equal <T>(TableSnapshot <T> x, TableSnapshot <T> y) where T : struct { return(ProjectTester.EqualCount(x, y) && x.Zip(y, (RowId xr, RowId yr) => { T xd, yd; x.GetData(xr, out xd); y.GetData(yr, out yd); foreach (IField <T> field in x.Fields) { if (field.Compare(ref xd, ref yd) != 0) { return false; } } return true; }).All(r => r)); }
public ClockSocket(ProjectTester tester) { this.Tester = tester; Assert.AreEqual(5, this.Tester.Input.Length); Assert.AreEqual(3, this.Tester.Output.Length); this.clock = new InputSocket(tester.Input[0]); this.mPlus = new InputSocket(tester.Input[1]); this.hPlus = new InputSocket(tester.Input[2]); this.s0 = new InputSocket(tester.Input[2]); this.clr = new InputSocket(tester.Input[3]); this.h = new OutputSocket(tester.Output[0]); this.m = new OutputSocket(tester.Output[1]); this.s = new OutputSocket(tester.Output[2]); }
private void CircuitMapPerfTest(string project, string initialCircuit, int maxCount, int maxSeconds) { CircuitProject circuitProject = ProjectTester.Load(this.TestContext, project, initialCircuit); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < maxCount; i++) { CircuitMap circuitMap = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit); CircuitState circuitState = circuitMap.Apply(CircuitRunner.HistorySize); Assert.IsNotNull(circuitState); circuitMap.TurnOn(); } stopwatch.Stop(); this.TestContext.WriteLine("{0} CircuitMap(s) created and applied in {1} - {2:N2} sec per each map", maxCount, stopwatch.Elapsed, stopwatch.Elapsed.TotalSeconds / maxCount); Assert.IsTrue(stopwatch.Elapsed < new TimeSpan(0, 0, maxSeconds), "CircuitMap was created and applied successfully but too slow"); }
public void SensorRandomTest() { ProjectTester tester = new ProjectTester(this.TestContext, Properties.Resources.SensorTests, "Random Test"); OutputSocket target = new OutputSocket(tester.Output[0]); HashSet <int> values = new HashSet <int>(); for (int i = 0; i < 5000; i++) { Assert.IsTrue(tester.CircuitState.Evaluate(true)); values.Add(target.BinaryInt()); } Assert.IsTrue(1 < values.Count); int max = 1 << target.BitWidth; // If this fail, it is possible to ignore. Assert.AreEqual(max, values.Count); }
public static CircuitProject Load(TestContext testContext, string projectText, string initialCircuit) { // First save project text to test directory string path = Path.Combine(testContext.TestRunDirectory, string.Format("{0}.{1}.{2}.xml", testContext.FullyQualifiedTestClassName, testContext.TestName, DateTime.UtcNow.Ticks)); File.WriteAllText(path, projectText, Encoding.UTF8); // Load it from test directory CircuitProject circuitProject = CircuitProject.Create(path); File.Delete(path); ProjectTester.InitResources(); if (initialCircuit != null) { ProjectTester.SwitchTo(circuitProject, initialCircuit); } ProjectTester.GuaranteeGlyph(circuitProject); return(circuitProject); }
public void CircuitMapDeepWireLoopTest() { ProjectTester tester = new ProjectTester(this.TestContext, Properties.Resources.CircuitMapTests, "DeepWireLoopTest"); InputSocket input = new InputSocket(tester.Input[0]); OutputSocket target = new OutputSocket(tester.Output[0]); Action <int> test = value => { input.Value = value; tester.CircuitState.Evaluate(true); Assert.AreEqual(value, target.BinaryInt()); }; tester.CircuitProject.InOmitTransaction(() => { for (int i = 0; i < 10; i++) { test(i & 1); } }); }
public void VisualElementLoadProjectTesterTest() { ProjectTester tester = new ProjectTester(this.TestContext, Properties.Resources.VisualElementLoadTest, null); Assert.AreEqual(1, tester.Input.Length); Assert.AreEqual(1, tester.Output.Length); Assert.IsTrue(tester.Input.All(f => f != null)); Assert.IsTrue(tester.Output.All(f => f != null)); Assert.IsTrue(tester.CircuitState.Evaluate(true)); Assert.AreEqual(1, tester.Input[0].Value); Assert.AreEqual(2, tester.Output[0].Pack()); tester.CircuitProject.InTransaction(() => tester.Input[0].Value = 0); Assert.IsTrue(tester.CircuitState.Evaluate(true)); Assert.AreEqual(0, tester.Input[0].Value); Assert.AreEqual(1, tester.Output[0].Pack()); }
public void XmlLoadReadElementTextTest() { string text = Properties.Resources.XmlLoadReadElementTextTest; XmlDocument xml = new XmlDocument(); xml.LoadXml(text); Assert.AreEqual(@"http://LogicCircuit.net/1.0.0.2/CircuitProject.xsd", xml.DocumentElement.NamespaceURI); CircuitProject circuitProject = ProjectTester.Load(this.TestContext, text, null); Assert.IsNotNull(circuitProject); Assert.AreEqual(1, circuitProject.CircuitButtonSet.Count()); CircuitButton button = circuitProject.CircuitButtonSet.First(); Assert.AreEqual(@"<a>", button.Notation); Assert.AreEqual(@"<a>b</a>", button.Note); Assert.AreEqual(1, circuitProject.CircuitSymbolSet.SelectByCircuit(button).Count()); CircuitSymbol buttonSymbol = circuitProject.CircuitSymbolSet.SelectByCircuit(button).First(); Assert.AreEqual(3, buttonSymbol.X); Assert.AreEqual(8, buttonSymbol.Y); Assert.AreEqual(2, circuitProject.CircuitSymbolSet.Count()); CircuitSymbol ledSymbol = circuitProject.CircuitSymbolSet.First(s => s != buttonSymbol); Assert.IsNotNull(ledSymbol); Assert.AreEqual(9, ledSymbol.X); Assert.AreEqual(8, ledSymbol.Y); Assert.AreEqual(1, circuitProject.WireSet.Count()); Wire wire = circuitProject.WireSet.First(); Assert.IsNotNull(wire); Assert.AreEqual(5, wire.X1); Assert.AreEqual(9, wire.Y1); Assert.AreEqual(9, wire.X2); Assert.AreEqual(9, wire.Y1); }
public ProjectTester(TestContext testContext, string projectText, string initialCircuit) { this.CircuitProject = ProjectTester.Load(testContext, projectText, initialCircuit); // Create map and state this.CircuitMap = new CircuitMap(this.CircuitProject.ProjectSet.Project.LogicalCircuit); this.CircuitState = this.CircuitMap.Apply(CircuitRunner.HistorySize); // Init controlling points of the main circuit: constants and probes List <CircuitSymbol> inputSymbol = new List <CircuitSymbol>(); foreach (CircuitSymbol symbol in this.Project.LogicalCircuit.CircuitSymbols()) { if (symbol.Circuit is Constant) { inputSymbol.Add(symbol); } } CircuitSymbolComparer circuitSymbolComparer = new CircuitSymbolComparer(true); inputSymbol.Sort(circuitSymbolComparer); this.Input = inputSymbol.Select(s => this.CircuitMap.FunctionConstant(s)).ToArray(); List <CircuitSymbol> outputSymbol = new List <CircuitSymbol>(); foreach (CircuitSymbol symbol in this.Project.LogicalCircuit.CircuitSymbols()) { if (symbol.Circuit is CircuitProbe) { outputSymbol.Add(symbol); } } outputSymbol.Sort(circuitSymbolComparer); this.Output = outputSymbol.Select(s => this.CircuitMap.FunctionProbe(s)).ToArray(); this.CircuitMap.TurnOn(); }
public static bool Equal(CircuitProject x, CircuitProject y) { Assert.IsNotNull(x); Assert.IsNotNull(y); return( ProjectTester.Equal(x.ProjectSet.Table, y.ProjectSet.Table) && ProjectTester.Equal(x.CollapsedCategorySet.Table, y.CollapsedCategorySet.Table) && ProjectTester.EqualCount(x.CircuitSet.Table, y.CircuitSet.Table) && ProjectTester.EqualCount(x.DevicePinSet.Table, y.DevicePinSet.Table) && ProjectTester.EqualCount(x.GateSet.Table, y.GateSet.Table) && ProjectTester.Equal(x.LogicalCircuitSet.Table, y.LogicalCircuitSet.Table) && ProjectTester.Equal(x.PinSet.Table, y.PinSet.Table) && ProjectTester.Equal(x.ConstantSet.Table, y.ConstantSet.Table) && ProjectTester.Equal(x.ConstantSet.Table, y.ConstantSet.Table) && ProjectTester.Equal(x.CircuitButtonSet.Table, y.CircuitButtonSet.Table) && ProjectTester.Equal(x.MemorySet.Table, y.MemorySet.Table) && ProjectTester.Equal(x.LedMatrixSet.Table, y.LedMatrixSet.Table) && ProjectTester.Equal(x.SplitterSet.Table, y.SplitterSet.Table) && ProjectTester.Equal(x.CircuitSymbolSet.Table, y.CircuitSymbolSet.Table) && ProjectTester.Equal(x.WireSet.Table, y.WireSet.Table) && ProjectTester.Equal(x.TextNoteSet.Table, y.TextNoteSet.Table) ); }
public void CircuitTestSocketBuildTruthTable5Test() { ProjectTester.SwitchTo(this.CircuitProject, "8 bit adder"); CircuitTestSocket s1 = new CircuitTestSocket(this.CircuitProject.ProjectSet.Project.LogicalCircuit); ExpressionParser parser = new ExpressionParser(s1); Predicate <TruthState> predicate = parser.Parse("outC << 8 | s = inC + a + b && v = !(a & 0x80 != b & 0x80 || a & 0x80 == s & 0x80)", true); double progress = -1; bool truncated; int maxSize = 128; IList <TruthState> table1 = s1.BuildTruthTable( p => { Assert.IsTrue(0 <= p && p <= 100); progress = p; }, () => true, null, maxSize, out truncated ); Assert.IsTrue(truncated); Assert.IsTrue(table1 != null && table1.Count == maxSize); foreach (TruthState state in table1) { Assert.IsFalse(predicate(state)); } IList <TruthState> table2 = s1.BuildTruthTable( p => { Assert.IsTrue(0 <= p && p <= 100); progress = p; }, () => true, predicate, 1, out truncated ); Assert.IsTrue(Math.Abs(progress - 100) < 2); Assert.IsTrue(!truncated); Assert.IsTrue(table2 != null && table2.Count == 0); }
public void CircuitTestSocketConstructorTest() { ProjectTester.SwitchTo(this.CircuitProject, "Unconnected"); CircuitTestSocket s1 = new CircuitTestSocket(this.CircuitProject.ProjectSet.Project.LogicalCircuit); Assert.AreEqual(0, s1.Inputs.Count()); Assert.AreEqual(0, s1.Outputs.Count()); ProjectTester.SwitchTo(this.CircuitProject, "1 Bit Wire"); CircuitTestSocket s2 = new CircuitTestSocket(this.CircuitProject.ProjectSet.Project.LogicalCircuit); Assert.AreEqual(1, s2.Inputs.Count()); Assert.AreEqual(1, s2.Outputs.Count()); Assert.AreEqual(1, s2.Inputs.Sum(i => i.Pin.BitWidth)); Assert.AreEqual(1, s2.Outputs.Sum(i => i.Pin.BitWidth)); ProjectTester.SwitchTo(this.CircuitProject, "8 bit adder"); CircuitTestSocket s3 = new CircuitTestSocket(this.CircuitProject.ProjectSet.Project.LogicalCircuit); Assert.AreEqual(3, s3.Inputs.Count()); Assert.AreEqual(3, s3.Outputs.Count()); Assert.AreEqual(17, s3.Inputs.Sum(i => i.Pin.BitWidth)); Assert.AreEqual(10, s3.Outputs.Sum(i => i.Pin.BitWidth)); }
public TestSocket(ProjectTester tester) { this.Tester = tester; Assert.IsTrue(this.Tester.Input.Length == this.Tester.Output.Length); }
public FunctionSocket(ProjectTester tester) { this.Tester = tester; Assert.IsTrue(this.Tester.Input.Length <= 32); }