public void GenericDependencies() { var subject = new TrivialSimulator(); // Can't get Gen because it depends on AssertMeasurement Assert.Throws <MemberAccessException>(() => { subject.Get <Gen <string> >(); }); // TODO: because we can't check dependencies, this // is not throwing an Exception, even though Gen depends on AssertMeasurement: var gen1 = subject.Get <DependsOnGen>(); Assert.NotNull(gen1); // Add an implementation of X: subject.Register(typeof(Diagnostics.AssertMeasurement), typeof(DummyAssertMeasurement)); var gen2 = subject.Get <Gen <int> >(); Assert.NotNull(gen1); // Asking for same T, should give same op, but asking for different T should not: var gen2a = subject.Get <Gen <int> >(); var gen2b = subject.Get <Gen <string> >(); Assert.Same(gen2, gen2a); Assert.NotSame(gen2, gen2b); }
public void QuantumTestSuiteSelfTests(TestOperation op) { var sim = new TrivialSimulator(); //these tests do not do anything quantum sim.OnLog += (msg) => { output.WriteLine(msg); }; op.TestOperationRunner(sim); }
public void OverrideWithNoInheritance() { var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); // If providing an interface, the original gate must implement that interface Assert.Throws <ArgumentException>(() => { subject.Register(typeof(Intrinsic.CNOT), typeof(LikeX), typeof(IUnitary <Qubit>)); }); // If providing an interface, the replacement gate must implement that interface Assert.Throws <ArgumentException>(() => { subject.Register(typeof(Intrinsic.CNOT), typeof(LikeX), typeof(IUnitary <(Qubit, Qubit)>)); }); // You can override without inheritance, as long as both implement the same interface: subject.Register(typeof(Intrinsic.X), typeof(LikeX), typeof(IUnitary <Qubit>)); // Verify the replacement work var x = subject.Get <IUnitary <Qubit>, Intrinsic.X>(); Assert.NotNull(x); Assert.Equal(typeof(LikeX), x.GetType()); }
public void OperationWithNotImplementedDependency() { var subject = new TrivialSimulator(); Assert.Throws <MemberAccessException>(() => { subject.Get <DependsOnAssertMeasurement>(); }); }
public void OperationWithNoBody() { var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); Assert.Throws <MemberAccessException>(() => { subject.Get <Diagnostics.AssertMeasurement>(); }); }
public void OperationsCache() { var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); var allocate1 = subject.Get <Intrinsic.Allocate>(); var allocate2 = subject.Get <Intrinsic.Allocate>(); Assert.Same(allocate1, allocate2); }
public void OperationWithNoBody() { var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); Assert.Throws <MemberAccessException>(() => { subject.Get <Intrinsic.X>(); }); }
public void UserDefinedOperations() { var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); Assert.Throws <MemberAccessException>(() => { subject.Get <Intrinsic.X>(); }); try { subject.Register(null, typeof(DummyX)); } catch (ArgumentNullException e) { Assert.Equal("original", e.ParamName); } try { subject.Register(typeof(Intrinsic.Allocate), null); } catch (ArgumentNullException e) { Assert.Equal("replace", e.ParamName); } // You can only register an override of a class that extends Operation: Assert.Throws <ArgumentException>(() => { subject.Register(typeof(Nothing), typeof(NothingSquared)); }); // By default, you can only register a Gate that is a subclass of the gate it's overriding: Assert.Throws <ArgumentException>(() => { subject.Register(typeof(Intrinsic.Allocate), typeof(DummyX)); }); subject.Register(typeof(Intrinsic.X), typeof(DummyX)); var customX = subject.Get <Intrinsic.X>(); Assert.Equal(typeof(DummyX), customX.GetType()); subject.Register(typeof(Intrinsic.M), typeof(DummyM)); var customM = subject.Get <Intrinsic.M>(); Assert.Equal(typeof(DummyM), customM.GetType()); }
public void TextRecursion() { var sim = new TrivialSimulator(); var res1 = Tests.Circuits.Factorial.Run(sim, 4L).Result; var res2 = Tests.Circuits.OpFactorial.Run(sim, 4L).Result; var res3 = Tests.Circuits.GenRecursion <long> .Run(sim, 6L, 2L).Result; var res4 = Tests.Circuits.GenRecursion <long> .Run(sim, 6L, 2L).Result; Assert.Equal(24L, res1); Assert.Equal(24L, res2); Assert.Equal(6L, res3); Assert.Equal(6L, res4); }
public void OperationWithRecursiveDependencies() { var subject = new TrivialSimulator(); var a = subject.Get <A>(); var b = subject.Get <B>(); // Make sure the last instance is correctly cached. var a2 = subject.Get <A>(); var b2 = subject.Get <B>(); Assert.Same(a, a2); Assert.Same(b, b2); Assert.Same(a, b.A); Assert.Same(b, a.B); }
public void TestQubitCounts() { var sim = new TrivialSimulator(); var baseCount = 32L; var allocCount = 10L; var(initialUse, initialBorrow, afterUse, afterBorrow, subBorrow, innerBorrow) = Circuits.GetAvailableTest.Run(sim, allocCount).Result; Assert.Equal(baseCount, initialUse); Assert.Equal(baseCount, initialBorrow); Assert.Equal(baseCount - allocCount, afterUse); Assert.Equal(baseCount - allocCount, afterBorrow); Assert.Equal(baseCount, subBorrow); Assert.Equal(baseCount - 1, innerBorrow); }
public void CheckQubits() { var sim = new TrivialSimulator(); var allocate = sim.Get <Intrinsic.Allocate>(); var release = sim.Get <Intrinsic.Release>(); var qubits = allocate.Apply(1); var name = "foo"; // This should work: sim.CheckQubits(qubits, name); // Calling with null will throw an Exception Assert.Throws <ArgumentNullException>(name, () => sim.CheckQubits(null, name)); // Calling after release will throw an Exception sim.CheckQubits(qubits, name); release.Apply(qubits); Assert.Throws <ArgumentException>($"{name}[0]", () => sim.CheckQubits(qubits, name)); }
public void SimulatorBuiltInOperations() { // The SimulatorBase class only implements operations for Qubit management, // i.e. Allocate/Release: var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); var allocate = subject.Get <Intrinsic.Allocate>(); var release = subject.Get <Intrinsic.Release>(); // Try the operations var qubits = allocate.Apply(3); Assert.Equal(3, qubits.Length); release.Apply(qubits); subject.CheckNoQubitLeak(); }
public void CatchFail() { int exceptionCount = 0; System.Action <System.Runtime.ExceptionServices.ExceptionDispatchInfo> inc = (System.Runtime.ExceptionServices.ExceptionDispatchInfo e) => exceptionCount++; var sim = new TrivialSimulator(); sim.OnFail += inc; // increment exception counter when exception is caught var inst = sim.Get <Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail>(); try { inst.Apply(QVoid.Instance); Assert.True(false); // make sure that exception actually happened } catch (System.Exception e) { Assert.True(true); // make sure that exception actually happened } Assert.Equal(1, exceptionCount); // check that we cought exception once }
public void SimulatorBuiltInOperations() { // The SimulatorBase class only implements operations for Qubit management, // i.e. Allocate/Release: var subject = new TrivialSimulator(); Assert.Equal(typeof(TrivialSimulator).Name, subject.Name); // Check whether our events for allocation and deallocation // are actually called. var calledOnAllocate = false; var calledOnRelease = false; subject.BeforeAllocateQubits += count => { output.WriteLine($"Allocate count = {count}"); calledOnAllocate = true; }; subject.BeforeReleaseQubits += register => { output.WriteLine($"Release qubits = {register}"); calledOnRelease = true; }; var allocate = subject.Get <Intrinsic.Allocate>(); var release = subject.Get <Intrinsic.Release>(); // Try the operations var qubits = allocate.Apply(3); Assert.True(calledOnAllocate); Assert.Equal(3, qubits.Length); release.Apply(qubits); Assert.True(calledOnRelease); subject.CheckNoQubitLeak(); }