public void VerifyCanPerformFunctionCallAfterBulk()
{
int numberKiloBytes = 1024 * 1024 * 1;
var buffer = new byte[numberKiloBytes];
for (int i = 0; i < numberKiloBytes; ++i)
{
buffer[i] = (byte)(i % 2);
}
var bulkDataStub = new BulkDataStub(buffer);
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var ipcServer = new IpcServer <IBulkData>(bulkDataStub, dispatcherThread.Dispatcher, IPAddress.Loopback, 62000, new MsDataContractJsonSerializer());
ipcServer.Listen();
var ipcClient = new IpcClient <IBulkData>(IPAddress.Loopback, 62000, new MsDataContractJsonSerializer());
ipcClient.Proxy.GetBulkyData();
var fooResult = ipcClient.Proxy.Foo();
Assert.AreEqual("Bar", fooResult);
ipcClient.Dispose();
ipcServer.Dispose();
bulkDataStub.Dispose();
dispatcherThread.Shutdown();
}
private static void Main(string[] args)
{
var calculatorImp = new CalculatorImp();
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var server = new IpcServer <ICalculator>(calculatorImp, dispatcherThread.Dispatcher, IPAddress.Any, 62005, new JsonDotNetSerializer());
server.ClientConnected += OnClientConnected;
server.ClientDisconnected += OnClientDisconnected;
server.Listen();
var multiCastAddress = IPAddress.Parse("239.0.0.222");
var advertiser = new ServiceAdvertiser <ICalculator>(multiCastAddress, 2222, TimeSpan.FromMilliseconds(1000));
advertiser.OnAdvertisement += dt => Console.WriteLine("[{0}]", dt);
Console.ReadLine();
server.ClientDisconnected -= OnClientDisconnected;
server.ClientConnected -= OnClientConnected;
advertiser.Dispose();
}
public void VerifyBasicSendReceive()
{
var fooStub = new FooStub();
fooStub.ReturnValueOfBar = "Bar";
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var ipcServer = new IpcServer <IFoo>(fooStub, dispatcherThread.Dispatcher, IPAddress.Loopback, 62000, new JsonDotNetSerializer());
ipcServer.Listen();
var ipcClient = new IpcClient <IFoo>(IPAddress.Loopback, 62000, new JsonDotNetSerializer());
object response;
ipcClient.Proxy.Foo();
Assert.AreEqual(1, fooStub.NumberOfFooCalls);
response = ipcClient.Proxy.Bar();
Assert.AreEqual(fooStub.ReturnValueOfBar, response);
Assert.AreEqual(1, fooStub.NumberOfBarCalls);
ipcClient.Dispose();
ipcServer.Dispose();
dispatcherThread.Shutdown();
}
public static void Main(string[] args)
{
var ipAddress = IPAddress.Loopback;
if (args.Length == 1)
{
ipAddress = IPAddress.Parse(args[0]);
}
var fileTransferImpl = new FileTransferImp();
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var server = new IpcServer <IFileTransfer>(fileTransferImpl, dispatcherThread.Dispatcher, ipAddress, 63000, new JsonDotNetSerializer());
server.ClientConnected += OnClientConnected;
server.ClientDisconnected += OnClientDisconnected;
server.Listen();
Console.WriteLine("FileTransferServer service running, press any key to exit.");
Console.ReadLine();
server.ClientDisconnected -= OnClientDisconnected;
server.ClientConnected -= OnClientConnected;
server.Dispose();
fileTransferImpl.Dispose();
dispatcherThread.Join();
}
public void VerifyPerformance()
{
var fooStub = new FooStub();
fooStub.ReturnValueOfBar = "Bar";
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var ipcServer = new IpcServer <IFoo>(fooStub, dispatcherThread.Dispatcher, IPAddress.Loopback, 62000, new JsonDotNetSerializer());
ipcServer.Listen();
var ipcClient = new IpcClient <IFoo>(IPAddress.Loopback, 62000, new JsonDotNetSerializer());
var numberOfCalls = 1000;
var nanoSecs = Performance.MeasureMs(() =>
{
for (var i = 0; i < numberOfCalls; i++)
{
ipcClient.Proxy.Foo();
}
});
var fooAverageMs = nanoSecs / numberOfCalls;
Console.WriteLine("Foo call took: {0}ms", fooAverageMs);
Assert.AreEqual(numberOfCalls, fooStub.NumberOfFooCalls);
Assert.LessOrEqual(TimeSpan.FromMilliseconds(fooAverageMs), TimeSpan.FromMilliseconds(10));
nanoSecs = Performance.MeasureMs(() =>
{
for (var i = 0; i < numberOfCalls; i++)
{
ipcClient.Proxy.Bar();
}
});
var barAverageMs = nanoSecs / numberOfCalls;
Console.WriteLine("Bar call took: {0}ms", barAverageMs);
Assert.AreEqual(numberOfCalls, fooStub.NumberOfBarCalls);
Assert.LessOrEqual(TimeSpan.FromMilliseconds(barAverageMs), TimeSpan.FromMilliseconds(10));
ipcClient.Dispose();
ipcServer.Dispose();
dispatcherThread.Shutdown();
}
internal Dispatcher(Context context, Handler mainThreadHandler, IExecutorService service, ICache <Bitmap> cache, IDownloader <Bitmap> downloader)
{
m_DipatcherThread = new DispatcherThread();
m_DipatcherThread.Start();
m_Handler = new DispatcherHandler(m_DipatcherThread.Looper, this);
m_Context = context;
m_MainThreadHandler = mainThreadHandler;
m_Cache = cache;
m_Downloader = downloader;
m_Service = service;
m_AirplaneMode = AndroidUtils.IsAirplaneModeOn(m_Context);
m_Receiver = new NetworkBroadcastReceiver(this);
m_Receiver.Register();
}
public void ShouldDispatchOnDispatcherThreadForDispatcherObjects()
{
using (var dt = new DispatcherThread())
{
var root = dt.Invoke(() => new DispatcherRoot());
var dispatcher = DispatcherFactory.CreateDispatcher(root, _endpoint.Object, false);
dispatcher.Execute("GetIntValue", new Dictionary <string, string>()).Result.ShouldBe("1");
dispatcher.Execute("GetIntValueAsync", new Dictionary <string, string>()).Result.ShouldBe("1");
dispatcher.Execute("Invoke", new Dictionary <string, string>()).Result.ShouldBe("");
dispatcher.Execute("InvokeAsync", new Dictionary <string, string>()).Result.ShouldBe("");
_endpoint.Setup(x => x.RegisterInstance(It.IsAny <object>())).Returns("i1");
dispatcher.Execute("Clone", new Dictionary <string, string>()).Result.ShouldBe("i1");
dispatcher.Execute("CloneAsync", new Dictionary <string, string>()).Result.ShouldBe("i1");
}
}
public void VerifyBulkyData_using_Json_dot_NET_serializer(int mb)
{
int numberKiloBytes = 1024 * 1024 * mb;
var buffer = new byte[numberKiloBytes];
for (int i = 0; i < numberKiloBytes; ++i)
{
buffer[i] = (byte)(i % 2);
}
var bulkDataStub = new BulkDataStub(buffer);
var bulkDataHash = ComputeHash(bulkDataStub.GetBulkyData());
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var ipcServer = new IpcServer <IBulkData>(bulkDataStub, dispatcherThread.Dispatcher, IPAddress.Loopback, 62000, new JsonDotNetSerializer());
ipcServer.Listen();
var ipcClient = new IpcClient <IBulkData>(IPAddress.Loopback, 62000, new JsonDotNetSerializer());
Stream receivingStream = null;
double ms = Performance.MeasureMs(() =>
{
receivingStream = ipcClient.Proxy.GetBulkyData();
});
var receivingHash = ComputeHash(receivingStream);
Assert.That(receivingHash, Is.EqualTo(bulkDataHash));
Console.WriteLine("Sending of {0}MB took {1}ms", mb, ms);
ipcClient.Dispose();
ipcServer.Dispose();
bulkDataStub.Dispose();
receivingStream.Dispose();
dispatcherThread.Shutdown();
}
static NuGetLockServiceTests()
{
// ThreadHelper in VS requires a persistent dispatcher thread. Because
// each unit test executes on a new thread, we create our own
// persistent thread that acts like a UI thread. This will be invoked just
// once for the module.
DispatcherThread = new DispatcherThread();
DispatcherThread.Invoke(() =>
{
// Internally this calls ThreadHelper.SetUIThread(), which
// causes ThreadHelper to remember this thread for the
// lifetime of the process as the dispatcher thread.
var serviceProvider = ServiceProvider.GlobalProvider;
});
JoinableTaskContext = new JoinableTaskContextNode(
new JoinableTaskContext(DispatcherThread.Thread, DispatcherThread.SyncContext));
}
public static void Main(string[] args)
{
var calculatorImp = new CalculatorImp();
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var server = new IpcServer <ICalculator>(calculatorImp, dispatcherThread.Dispatcher, IPAddress.Loopback, 62001, new JsonDotNetSerializer());
server.ClientConnected += OnClientConnected;
server.ClientDisconnected += OnClientDisconnected;
server.Listen();
Console.WriteLine("Calculator service running, press any key to exit.");
Console.ReadLine();
server.ClientDisconnected -= OnClientDisconnected;
server.ClientConnected -= OnClientConnected;
server.Dispose();
dispatcherThread.Shutdown();
}
public void VerifyServerExceptionsAreForwardedToClientAndServerRemainsAlive()
{
var fooStub = new FooStubThrowsException();
var dispatcherThread = new DispatcherThread(Dispatcher.Run);
dispatcherThread.Start();
var ipcServer = new IpcServer <IFoo>(fooStub, dispatcherThread.Dispatcher, IPAddress.Loopback, 62000, new JsonDotNetSerializer());
ipcServer.Listen();
var ipcClient = new IpcClient <IFoo>(IPAddress.Loopback, 62000, new JsonDotNetSerializer());
var caughtException = false;
try
{
ipcClient.Proxy.Foo();
}
catch (Exception)
{
caughtException = true;
}
Assert.IsTrue(caughtException);
//See if server survives failed method call
ipcClient.Proxy.Bar();
Assert.IsTrue(fooStub.NumberOfBarCalls == 1);
ipcClient.Dispose();
ipcServer.Dispose();
dispatcherThread.Shutdown();
}
public WebBrowser()
{
//TODO: Register this object for SkraprContext.ensureDisposal
DispatcherThread = new DispatcherThread();
}
