public void TestIntTaskReturnValue() { var subject = new Mock <IReturnsIntTask>(); Task <int> innerTask = null; subject.Setup(x => x.DoStuff()).Returns(() => { innerTask = new Task <int>(() => 42); innerTask.Start(); return(innerTask); }); IServant servant = _creator.CreateServant(_endPoint.Object, _channel.Object, 1, subject.Object); var output = new MemoryStream(); servant.Invoke("DoStuff", null, new BinaryWriter(output)); innerTask.Should().NotBeNull(); innerTask.Status.Should().Be(TaskStatus.RanToCompletion); output.Position = 0; var reader = new BinaryReader(output); reader.ReadInt32().Should().Be(42); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
private T CreateServantAndProxy <T>(T subject) { var objectId = (ulong)_random.Next(); _servant = _servantCreator.CreateServant(_endPoint, _channel, objectId, subject); return(_proxyCreator.CreateProxy <T>(_endPoint, _channel, objectId)); }
public void TestEventInt32() { var subject = new Mock <IEventInt32>(); IServant servant = TestGenerate(subject.Object); bool callRemoteMethodInvoked = false; _channel.Setup( x => x.CallRemoteMethod(It.IsAny <ulong>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MemoryStream>())) .Callback((ulong id, string interfaceName, string methodName, MemoryStream stream) => { id.Should().Be(servant.ObjectId); methodName.Should().Be("Foobar"); stream.Should().NotBeNull(); var reader = new BinaryReader(stream); reader.ReadInt32().Should().Be(42); callRemoteMethodInvoked = true; }); subject.Raise(x => x.Foobar += null, 42); callRemoteMethodInvoked.Should().BeTrue(); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void TestGetTaskScheduler6() { var subject = new Mock <IInvokeAttributeMethods>(); IServant servant = TestGenerate(subject.Object); new Action(() => servant.GetTaskScheduler("DoesntExist")) .Should().Throw <ArgumentException>(); }
public bool TryGetServant(ulong servantId, out IServant servant, out int numServants) { lock (_syncRoot) { numServants = _servantsById.Count; return(_servantsById.TryGetValue(servantId, out servant)); } }
public void TestGetTaskScheduler2() { var subject = new Mock <IInvokeAttributeMethods>(); IServant servant = TestGenerate(subject.Object); servant.GetTaskScheduler("DoNotSerialize") .Should().BeNull(); }
public void TestGetTaskScheduler4() { var subject = new Mock <IInvokeAttributeMethods>(); IServant servant = TestGenerate(subject.Object); var scheduler = servant.GetTaskScheduler("SerializePerObject1"); scheduler.Should().NotBeNull(); scheduler.Should().BeOfType <SerialTaskScheduler>(); scheduler.Should().BeSameAs(servant.GetTaskScheduler("SerializePerObject2")); }
public void TestIntMethodTypeParameters() { var subject = new Mock <ISubjectHost>(); bool disposed = false; subject.Setup(x => x.Dispose()) .Callback(() => disposed = true); ulong?actualId = null; Type @interface = null; Type @impl = null; subject.Setup(x => x.CreateSubject1(It.IsAny <ulong>(), It.IsAny <Type>(), It.IsAny <Type>())) .Callback((ulong id, Type a, Type b) => { actualId = id; @interface = a; @impl = b; }); IServant servant = TestGenerate(subject.Object); var arguments = new MemoryStream(); var writer = new BinaryWriter(arguments); writer.Write((ulong)42); writer.Write(true); writer.Write(typeof(IGetStringProperty).AssemblyQualifiedName); writer.Write(true); writer.Write(typeof(GetStringPropertyImplementation).AssemblyQualifiedName); arguments.Position = 0; var output = new MemoryStream(); servant.Invoke("CreateSubject1", new BinaryReader(arguments), new BinaryWriter(output)); actualId.Should().Be(42ul); @interface.Should().Be <IGetStringProperty>(); @impl.Should().Be <GetStringPropertyImplementation>(); servant.Invoke("Dispose", null, new BinaryWriter(new MemoryStream())); disposed.Should().BeTrue(); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void TestGetTaskScheduler5() { var subject = new Mock <IInvokeAttributeMethods>(); IServant servant1 = TestGenerate(subject.Object); IServant servant2 = TestGenerate(subject.Object); var scheduler = servant1.GetTaskScheduler("SerializePerMethod1"); scheduler.Should().NotBeNull(); scheduler.Should().BeOfType <SerialTaskScheduler>(); scheduler.Should() .NotBeSameAs(servant1.GetTaskScheduler("SerializePerMethod2"), "because Dispatch.SerializePerMethod shall behave exactly like Java's synchronized statement"); scheduler.Should() .NotBeSameAs(servant2.GetTaskScheduler("SerializePerMethod1"), "because Dispatch.SerializePerMethod shall behave exactly like Java's synchronized statement"); }
public void TestRaiseEmptyEvent() { var subject = new Mock <IEventInt32>(); const int servantId = 4; IServant servant = _server.CreateServant(servantId, subject.Object); var proxy = (IProxy)_client.CreateProxy <IEventInt32>(servantId); new Action(() => subject.Raise(x => x.Foobar += null, 42)) .ExecutionTime().ShouldNotExceed(TimeSpan.FromSeconds(1)); servant.ObjectId.Should().Be(servantId); proxy.ObjectId.Should().Be(servantId); // This line exists to FORCE the GC to NOT collect the subject, which // in turn would unregister the servant from the server, thus making the test // fail sporadically. GC.KeepAlive(subject); }
public void TestCreateServant2() { using (var endPoint = CreateClient()) { var subject = new Mock <IEventInt32>(); IServant servant = null; const string reason = "because a servant can always be created - its usage may however not work depending on the endpoint's connection status"; new Action(() => servant = endPoint.CreateServant(0, subject.Object)) .Should().NotThrow(reason); servant.Should().NotBeNull(reason); new Action(() => subject.Raise(x => x.Foobar += null, 42)) .Should().Throw <NotConnectedException>( "because the endpoint is not connected to any other endpoint and thus there cannot be a proxy on which the event can ever be executed"); } }
private IServant TestGenerate <T>(T subject) { Type type = null; new Action(() => type = _creator.GenerateServant <T>()) .Should().NotThrow(); type.Should().NotBeNull(); _objectId = (ulong)_random.Next(); IServant servant = _creator.CreateServant(_endPoint.Object, _channel.Object, _objectId, subject); servant.Should().NotBeNull(); servant.ObjectId.Should().Be(_objectId); servant.Subject.Should().BeSameAs(subject); return(servant); }
public void TestWatchdog() { var subject = new Mock <IReturnComplexType>(); var app = new InstalledApplication(new ApplicationDescriptor { Name = "SharpRemote/0.1" }); app.Files.Add(new InstalledFile { Id = 1, Filename = "SharpRemote.dll", FileLength = 212345, Folder = Environment.SpecialFolder.CommonProgramFiles }); app.Files.Add(new InstalledFile { Id = 2, Filename = "SharpRemote.Host.exe", FileLength = 1234, Folder = Environment.SpecialFolder.CommonProgramFiles }); subject.Setup(x => x.CommitInstallation(It.IsAny <long>())) .Returns((long id) => app); IServant servant = TestGenerate(subject.Object); var arguments = new MemoryStream(); var writer = new BinaryWriter(arguments); writer.Write((long)42); arguments.Position = 0; var output = new MemoryStream(); servant.Invoke("CommitInstallation", new BinaryReader(arguments), new BinaryWriter(output)); output.Position = 0; output.Length.Should().BeInRange(342, 344); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void TestGetProperty() { var subject = new Mock <IGetDoubleProperty>(); IServant servant = TestGenerate(subject.Object); subject.Setup(x => x.Value).Returns(Math.PI); var outStream = new MemoryStream(); var @out = new BinaryWriter(outStream); servant.Invoke("get_Value", null, @out); outStream.Position = 0; var reader = new BinaryReader(outStream); reader.ReadDouble().Should().BeApproximately(Math.PI, 0); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void TestByReferenceParameter() { IVoidMethodStringParameter actualListener = null; var subject = new Mock <IByReferenceParemeterMethodInterface>(); subject.Setup(x => x.AddListener(It.IsAny <IVoidMethodStringParameter>())) .Callback((IVoidMethodStringParameter l) => actualListener = l); var listener = new Mock <IVoidMethodStringParameter>(); IServant servant = _creator.CreateServant(_endPoint.Object, _channel.Object, 1, subject.Object); _endPoint.Setup(x => x.GetExistingOrCreateNewProxy <IVoidMethodStringParameter>(It.IsAny <ulong>())) .Returns((ulong objectId) => { objectId.Should().Be(12345678912345678912); return(listener.Object); }); var inStream = new MemoryStream(); var writer = new BinaryWriter(inStream); writer.Write(true); writer.Write((byte)ByReferenceHint.CreateProxy); writer.Write(12345678912345678912); inStream.Position = 0; var @in = new BinaryReader(inStream); var outStream = new MemoryStream(); servant.Invoke("AddListener", @in, new BinaryWriter(outStream)); actualListener.Should() .BeSameAs(listener.Object, "because the compiled code should've retrieved the existing proxy by its id"); outStream.Length.Should().Be(0, "because nothing needed to be written to the outstream"); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void TestAddByReference1() { const ulong servantId = 30; var processor = new Processor(); processor.Listeners.Should().BeEmpty(); _server.CreateServant(servantId, (IProcessor)processor); var proxy = _client.CreateProxy <IProcessor>(servantId); var listener1 = new Listener(); proxy.AddListener(listener1); IServant listenerServant = Servants(_client).First(x => x.InterfaceType == typeof(IListener)); IProxy listenerProxy = _server.Proxies.First(x => x.InterfaceType == typeof(IListener)); listenerServant.ObjectId.Should() .Be(listenerProxy.ObjectId, "Because both proxy and servant must have been created for that specific listener instance because of the remote method call"); processor.Listeners.Count.Should().Be(1, "Because AddListener() should have added a listener to the processor"); processor.Listeners[0].Should() .NotBe(listener1, "Because not the real listener has been added, but a proxy representing it"); processor.Listeners[0].Should() .BeSameAs(listenerProxy, "Because not the real listener has been added, but a proxy representing it"); proxy.Report("Foobar"); listener1.Messages.Should() .Equal(new[] { "Foobar" }, "Because Processor.Report() method should have invoked the Report() method on the proxy which in turn would've called the real listener implementation"); // This line exists to FORCE the GC to NOT collect the subject, which // in turn would unregister the servant from the server, thus making the test // fail sporadically. GC.KeepAlive(processor); }
public void TestVoidMethodTypeParameter() { var subject = new Mock <IVoidMethodTypeParameter>(); Type actualType = null; subject.Setup(x => x.Do(It.IsAny <Type>())).Callback((Type t) => { actualType = t; }); IServant servant = TestGenerate(subject.Object); var arguments = new MemoryStream(); var writer = new BinaryWriter(arguments); writer.Write(true); writer.Write(typeof(string).AssemblyQualifiedName); arguments.Position = 0; servant.Invoke("Do", new BinaryReader(arguments), new BinaryWriter(new MemoryStream())); actualType.Should().Be <string>(); // Servants hold a weak reference to their subjects, so in order for this test to run 100% of the time, // we need to keep the subject alive. GC.KeepAlive(subject.Object); }
public void Add(string servantName, IServant servant) { this.servantsByName.Add(servantName, servant); servant.Die += OnServantDead; }
public void TestEmpty() { var subject = new Mock <IEmpty>(); IServant servant = TestGenerate(subject.Object); }