public void FilterByKeyword_Test()
{
VisualRxSettings.ClearFilters();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create());
VisualRxSettings.AddFilter((marble, channelKey) =>
marble.Keywords.Contains("Key1"));
VisualRxInitResult infos = info.Result;
Trace.WriteLine(infos);
var xs = Observable.Interval(TimeSpan.FromSeconds(0.5))
.Take(10);
xs = xs.Monitor("Stream A", 1, "Key1", "Key3", "Key4");
var ys = Observable.Interval(TimeSpan.FromSeconds(1))
.Take(10);
ys = ys.Monitor("Stream B", 2, "Key2", "Key3");
//xs.Subscribe();
ys.Subscribe();
xs.Wait();
GC.KeepAlive(xs);
}
public void LateInitializaqtion()
{
const int SIZE = 1000;
//arrange
var proxy = new CustomCountdownMonitorProxy("test", 2 /* value + On Completed */);
var xs = Observable.Return(1)
.Monitor("Source", 0);
Task <VisualRxInitResult> info = VisualRxSettings.Initialize();
info.Wait();
// act
xs.Wait();
int countBefore = proxy.Data.Count();
info = VisualRxSettings.AddProxies(proxy);
info.Wait();
xs.Wait();
bool completed = proxy.Wait(500);
Assert.IsTrue(completed, "Wait");
int countAfter = proxy.Data.Count();
// verify
Assert.AreEqual(0, countBefore, "Count before proxy attachment");
Assert.AreEqual(2, countAfter, "Count after proxy attachment"); // OnNext + OnComplete
}
static async Task Main(string[] args)
{
Console.WriteLine("Start");
IObservable <PerformanceSample> performanceCounterObservable =
PerfCounterObservable.FromRealTime(
TimeSpan.FromSeconds(1),
new[]
{
@"\Processor(_Total)\% Processor Time",
@"\Memory(_Total)\% Committed Bytes In Use",
@"\Memory(_Total)\Available MBytes"
});
VisualRxInitResult info = await VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create());
Console.WriteLine(info);
performanceCounterObservable
.Monitor("Step 1", 1)
.Where(v => v.CounterName == "% Processor Time")
.Monitor("Step 2", 1)
.Select(m => (int)(m.Value / 10))
.Select(m => new string('-', m))
.Subscribe(
v => Console.WriteLine(v));
Console.ReadKey();
}
public void TestInitialize()
{
VisualRxSettings.ClearFilters();
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
Thread.Sleep(1);
}
public void ProxyFilterMessagesByKeywordsTest()
{
const int SIZE = 10;// 00;
//arrange
var proxyX = new CustomCountdownMonitorProxy("testX", SIZE + 1 /* + 1 = On Completed */);
var proxyY = new CustomCountdownMonitorProxy("testY", SIZE + 1 /* + 1 = On Completed */);
var proxyAll = new CustomCountdownMonitorProxy("testAll", (SIZE * 3) + 3 /* + 1 = On Completed */);
var xs = Observable.Range(1, SIZE)
.Monitor("X", 0, "Category1", "Category2");
var ys = Observable.Range(1, SIZE)
.Monitor("Y", 1, "Category1", "Category3");
var zs = Observable.Range(1, SIZE)
.Monitor("Z", 2);
Task <VisualRxInitResult> info =
VisualRxSettings.Initialize(proxyX, proxyY, proxyAll);
VisualRxSettings.AddFilter((marble, proxyKind) =>
{
if (proxyKind == "testX")
{
return(marble.Keywords.Contains("Category2"));
}
if (proxyKind == "testY")
{
return(marble.Keywords.Contains("Category3"));
}
return(true);
});
info.Wait();
// act
xs.Subscribe();
ys.Subscribe();
zs.Subscribe();
//Assert.IsTrue(VisualRxSettings.WaitForProxiesCompletion(
// 3 /* (streams) */,
// TimeSpan.FromSeconds(1)), "WaitForProxiesCompletion");
Assert.IsTrue(proxyX.Wait(), "Wait");
Assert.IsTrue(proxyY.Wait(), "Wait");
Assert.IsTrue(proxyAll.Wait(), "Wait");
// validate
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxyX.Data.Count(), "proxyX");
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxyY.Data.Count(), "proxyY");
Assert.AreEqual((SIZE * 3) + 3 /* + 1 = On Completed */, proxyAll.Data.Count(), "proxyAll");
Assert.IsFalse(proxyX.Data.Any(marble =>
!marble.Keywords.Contains("Category2")));
Assert.IsFalse(proxyY.Data.Any(marble =>
!marble.Keywords.Contains("Category3")));
GC.KeepAlive(xs);
GC.KeepAlive(ys);
GC.KeepAlive(zs);
}
static void Main(string[] args)
{
var info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create());
Console.WriteLine(info.Result);
Console.ReadKey();
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
VisualRxSettings.ClearFilters();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create());
VisualRxInitResult infos = info.Result;
Trace.WriteLine(infos);
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Application.Startup"/> event.
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.StartupEventArgs"/> that contains the event data.</param>
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
Task <VisualRxInitResult> info =
VisualRxSettings.Initialize(
LocalProxy.Create());
info.ContinueWith(inf => Trace.WriteLine(inf));
UIPluginHelper.SetDispatcher();
MarbleController.Init(Resources);
}
static async Task Main(string[] args)
{
var info = await VisualRxSettings.Initialize(VisualRxWcfDiscoveryProxy.Create());
Console.WriteLine(info);
var xs = Observable.Interval(TimeSpan.FromSeconds(1))
.Monitor("Before", 1)
.Select(v => new string('*', (int)(v + 1)))
.Monitor("After", 2)
.Subscribe(v => Console.Write($"{v},"));
Console.ReadKey();
}
public virtual void TestInitialize()
{
VisualRxSettings.ClearFilters();
ScopeFactory = new TestScopeFactory();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create(),
//VisualRxWcfQueuedProxy.Create(),
//VisualRxTraceSourceProxy.Create(),
ScopeFactory);
VisualRxInitResult infos = info.Result;
Trace.WriteLine(infos);
}
public void SplitToDifferentChannel_ByDatumType_Test()
{
VisualRxSettings.ClearFilters();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create(),
VisualRxWcfQueuedProxy.Create(),
VisualRxTraceSourceProxy.Create());
VisualRxSettings.AddFilter((marble, channelKey) =>
{
bool enable = false;
switch (marble.Name)
{
case "Stream A":
enable = channelKey == VisualRxWcfDiscoveryProxy.KIND;
break;
case "Stream B":
enable = channelKey == VisualRxTraceSourceProxy.KIND;
break;
default:
enable = channelKey == VisualRxWcfQueuedProxy.KIND;
break;
}
return(enable);
});
VisualRxInitResult infos = info.Result;
Trace.WriteLine(infos);
var xs = Observable.Interval(TimeSpan.FromSeconds(0.5))
.Take(10);
xs = xs.Monitor("Stream A", 1);
var ys = Observable.Interval(TimeSpan.FromSeconds(1))
.Take(10);
ys = ys.Monitor("Stream B", 2);
xs.Subscribe();
//ys.Subscribe();
ys.Wait();
GC.KeepAlive(xs);
}
public void ProxyFilterChangeProxiesTest()
{
const int SIZE = 1000;
//arrange
var proxyX = new CustomCountdownMonitorProxy("testX", SIZE + 1 /* + 1 = On Completed */);
var proxyY = new CustomCountdownMonitorProxy("testY", SIZE + 1 /* + 1 = On Completed */);
// Init
Task <VisualRxInitResult> info =
VisualRxSettings.Initialize(proxyX);
info.Wait();
// produce values
var xs = Observable.Range(1, SIZE)
.Monitor("X", 0)
.Subscribe();
// wait for completion
//Assert.IsTrue(VisualRxSettings.WaitForProxiesCompletion(
// 1 /* (streams) */,
// TimeSpan.FromSeconds(1)), "WaitForProxiesCompletion");
// Init
info = VisualRxSettings.Initialize(proxyY);
info.Wait();
// produce values
var ys = Observable.Range(1, SIZE)
.Monitor("Y", 1)
.Subscribe();
// wait for completion
//Assert.IsTrue(VisualRxSettings.WaitForProxiesCompletion(
// 1,
// TimeSpan.FromSeconds(1)), "WaitForProxiesCompletion");
Assert.IsTrue(proxyX.Wait(), "Wait");
Assert.IsTrue(proxyY.Wait(), "Wait");
// validate
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxyX.Data.Count(), "proxyX.Data.Count = " + proxyX.Data.Count());
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxyY.Data.Count(), "proxyY.Data.Count = " + proxyY.Data.Count());
GC.KeepAlive(xs);
GC.KeepAlive(ys);
}
private static void Main(string[] args)
{
TryToOpenViewer();
var bc = new BlockingCollection <string>();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create()//,
//MonitorWcfQueuedProxy.Create(),
//VisualRxTraceSourceProxy.Create()
);
#region Loaded Proxies Log
VisualRxInitResult infos = info.Result;
Console.WriteLine(infos);
#endregion Loaded Proxies Log
var surrogate = new MonitorSurrogate <IList <double> >(MarbleSerializationOptions.Serializable);
var xs = StockProvider()
.Buffer(2, 1)
.Monitor("Stock", 100, surrogate);
for (int i = 0; i < 4; i++)
{
int local = i;
var ys = StockProvider(_rnd.Value.Next(50, 150))
.Buffer(2, 1)
.Monitor("StockGraph " + local, local, surrogate);
xs = xs.Merge(ys);
}
xs.Subscribe(_ => bc.Add("."));
foreach (var item in bc.GetConsumingEnumerable())
{
Console.Write(item);
}
GC.KeepAlive(xs);
}
public void WaitForProxiesCompletionTest()
{
const int SIZE = 10;
//arrange
var proxy = new CustomCountdownMonitorProxy("test", SIZE + 1 /* + 1 = On Completed */);
var xs = Observable.Range(1, SIZE)
.Monitor("A", 0);
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(proxy);
info.Wait();
// act
xs.Delay(TimeSpan.FromMilliseconds(100)).Subscribe();
//Assert.IsTrue(VisualRxSettings.WaitForProxiesCompletion(
// 1 /* (streams) */,
// TimeSpan.FromSeconds(1)), "WaitForProxiesCompletion");
Assert.IsTrue(proxy.Wait(), "Wait");
// validate
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxy.Data.Count());
GC.KeepAlive(xs);
}
public void ProxyHandleAllMonitordMessagesTest()
{
const int SIZE = 1000;
//arrange
var proxy = new CustomCountdownMonitorProxy("test", SIZE + 1 /* + 1 = On Completed */);
var xs = Observable.Range(1, SIZE)
.Monitor("Source", 0);
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(proxy);
info.Wait();
// act
xs.Subscribe();
//VisualRxSettings.WaitForProxiesCompletion(
// 1, // number of proxies * number of streams
// TimeSpan.FromSeconds(0.5));
Assert.IsTrue(proxy.Wait(), "Wait");
// validate
Assert.AreEqual(SIZE + 1 /* + 1 = On Completed */, proxy.Data.Count());
GC.KeepAlive(xs);
}
public void EnableDisableTest()
{
var sync = new ManualResetEventSlim();
VisualRxSettings.ClearFilters();
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create());
VisualRxInitResult infos = info.Result;
Trace.WriteLine(infos);
var xs = Observable.Interval(TimeSpan.FromSeconds(0.5))
.Take(10);
xs = xs.Monitor("Enable / Disable", 1);
xs.Subscribe(
v => VisualRxSettings.Enable = v < 3 || v > 6,
() => sync.Set());
sync.Wait();
GC.KeepAlive(xs);
}
private static void Main(string[] args)
{
TryToOpenViewer();
Thread.Sleep(1200);
Console.WriteLine("Initialize");
/* Create a ConsoleTraceListener and add it to the trace listeners. */
var testProxy = MonitorTestProxy.Create();
VisualRxSettings.CollectMachineInfo = true;
Task <VisualRxInitResult> info = VisualRxSettings.Initialize(
VisualRxWcfDiscoveryProxy.Create(),
//VisualRxWcfFixedAddressProxy.CreateDefaultHttp(Environment.MachineName),
//VisualRxWcfQueuedProxy.Create(),
//VisualRxTraceSourceProxy.Create(),
testProxy);
#region Loaded Proxies Log
VisualRxInitResult infos = info.Result;
Console.WriteLine(infos);
#endregion Loaded Proxies Log
// the test proxy will publish only items with "Interval" keyword
VisualRxSettings.AddFilter((marble, proxyKind) =>
proxyKind != MonitorTestProxy.KIND ||
proxyKind == MonitorTestProxy.KIND &&
marble.Keywords.Contains("Interval"));
IObservable <string> stream1 = Observable.Return("** 42 **").Monitor("Return", 0.1);
IObservable <string> stream2 = Observable.Empty <string>().Monitor("Empty", 0.2);
IObservable <string> stream3 = Observable.Never <string>().Monitor("Never", 0.3);
IObservable <string> stream4 = Observable.Throw <string>(new Exception()).Monitor("Throw", 0.4);
IObservable <int> stream5 = Observable.Generate(0, i => i < 5, i => i + 1, i => i, i => TimeSpan.FromSeconds(i))
.Monitor("Generate", 0.4);
stream1.Subscribe(Console.WriteLine);
stream2.Subscribe(Console.WriteLine);
stream3.Subscribe(Console.WriteLine);
stream4.Subscribe(Console.WriteLine, ex => Console.WriteLine(ex));
Thread.Sleep(3000);
stream5.Subscribe(Console.WriteLine);
#region Observable.Range
var rengeStream = Observable.Range(1, 3)
.Monitor("Range 3", orderingIndex: 1);
rengeStream.Subscribe(item => Console.Write("{0},", item), () => Console.WriteLine("Complete"));
#endregion Observable.Range
#region 1 sec Interval Take 50
var srm1 = Observable.Interval(TimeSpan.FromSeconds(1)).Take(50)
.Monitor("Sec 1", 2, "Interval", "Merge");
//srm1.Subscribe(Console.WriteLine);
#endregion 1 sec Interval Take 50
#region 3 sec Interval Take 14
var srm2 = Observable.Interval(TimeSpan.FromSeconds(3))
.Take(14)
.Monitor("Sec 3", 2, "Interval", "Merge");
//srm2.Subscribe(Console.WriteLine);
#endregion 3 sec Interval Take 14
#region 0.5 sec Interval With befor and after where
var srm3 = Observable.Interval(TimeSpan.FromSeconds(0.5))
.Take(19)
.Monitor("Sec 0.5 Before Where", 4, "Interval", "Where")
.Where(v => v % 3 == 0)
.Monitor("After Where", 5, "Merge", "Where");
//srm3.Subscribe(Console.WriteLine);
#endregion 0.5 sec Interval With befor and after where
#region Merge 1 sec, 3 sec and 0.5 sec Intervals
Observable.Merge(srm1, srm2, srm3)
.Monitor("After Merge", 6, "Merge")
.Subscribe(Console.WriteLine);
#endregion Merge 1 sec, 3 sec and 0.5 sec Intervals
#region Observable.Throw
var srm4 = Observable.Throw <NullReferenceException>(new NullReferenceException())
.Monitor("Error", 7);
srm4.Subscribe(Console.WriteLine, ex => Console.WriteLine("Handle Error: {0}", ex.Message));
#endregion Observable.Throw
Thread.Sleep(8000);
#region Filter test
bool isIntervalOnly = !testProxy.Data.Any(
marble => !marble.Keywords.Contains("Interval"));
if (!isIntervalOnly)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
}
Console.WriteLine("Test proxy is interval only = {0} / Count = {1}",
isIntervalOnly, testProxy.Data.Count());
Console.ResetColor();
#endregion Filter test
#region Stress Test
for (int i = 0; i < STRESS_MILLISECOND_ITERATIONS; i++)
{
var srm5 = Observable.Interval(
TimeSpan.FromMilliseconds(STRESS_MILLISECOND),
NewThreadScheduler.Default)
.Take(STRESS_COUNT)
.Monitor("Stress " + i.ToString(), 100 + (i * 0.01), "Stress");
srm5.Subscribe(Console.WriteLine);
}
#endregion Stress Test
Console.ReadKey();
}
