public void TestPromotionForStorage()
{
string test
= @"integer g() { return 0; }
f() {
integer i;
float f = 1;
float h = g();
float j = i;
float l = i++;
float k = i - 5;
f = 1;
h = g();
j = i;
l = i++;
k = i - 5;
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 10);
}
public void TestDoGenerateBooleanEval()
{
string test
= @"string strfunc() { return """"; }
f() {
if (strfunc()) {
}
while (0.0) {
}
for (;"""";) {
}
key k;
do {
} while (k);
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"), true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int evalCount = new Regex("booleval").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(evalCount, 4);
}
public MessageHandlingTests()
{
listener = new TestListener();
node = new Node(NodeId.Create(), new IPEndPoint(IPAddress.Any, 0));
engine = new DhtEngine(listener);
//engine.Add(node);
}
IEnumerable<KeyValuePair<string, bool?>> RunTestsCore(string runnerAssemblyPath, string runnerTypeName, IEnumerable<string> assembliesToTest)
{
var runnerAssembly = Assembly.LoadFrom(runnerAssemblyPath);
var runnerType = runnerAssembly.GetType(runnerTypeName);
var runner = Activator.CreateInstance(runnerType) as TestDriven.Framework.ITestRunner;
if (runner == null)
yield break;
var testListener = new TestListener();
foreach (var asm in assembliesToTest)
{
bool success = true;
try
{
var assemblyToTest = Assembly.LoadFrom(Path.Combine(_tempDirectory, Path.GetFileName(asm)));
runner.RunAssembly(testListener, assemblyToTest);
}
catch
{
success = false;
}
if (!success)
{
yield return new KeyValuePair<string, bool?>("An error occured while executing tests.", false);
continue;
}
foreach (var result in testListener.Results)
yield return new KeyValuePair<string, bool?>(ToMessage(result), ToSuccess(result));
}
}
public void TestBroadcaster()
{
var test = new Broadcaster();
var listener = new TestListener();
var listener2 = new TestListener();
test.AddListener(listener);
Assert.AreEqual(1, test.listeners.Count);
test.RemoveListener(listener);
Assert.AreEqual(0, test.listeners.Count);
test.AddListener(listener);
test.AddListener(listener2);
test.Broadcast(new Event("hello"));
Assert.AreEqual("hello", listener.lastMessage);
Assert.AreEqual("hello", listener2.lastMessage);
test.RemoveListener(listener);
test.Broadcast(new Event("goodbye"));
Assert.AreEqual("hello", listener.lastMessage);
Assert.AreEqual("goodbye", listener2.lastMessage);
test.Clear();
Assert.AreEqual(0, test.listeners.Count);
}
public void TestClearSymbols()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
string candleSymbolString = "XBT/USD{=d}";
string aaplSymbolString = "AAPL{=d,price=mark}";
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(defaultDateTime, listener))
{
s.AddSymbol(CandleSymbol.ValueOf(candleSymbolString));
listener.WaitEvents <IDxCandle>(candleSymbolString);
s.Clear();
listener.ClearEvents <IDxCandle>();
Thread.Sleep(10000);
Assert.AreEqual(0, listener.GetEventCount <IDxCandle>());
//try to restore symbols
s.AddSymbol(CandleSymbol.ValueOf(candleSymbolString));
listener.WaitEvents <IDxCandle>(candleSymbolString);
//set other symbol
s.Clear();
listener.ClearEvents <IDxCandle>();
s.AddSymbol(CandleSymbol.ValueOf(aaplSymbolString));
listener.WaitEvents <IDxCandle>(aaplSymbolString);
Assert.AreEqual(listener.GetEventCount <IDxCandle>(), listener.GetEventCount <IDxCandle>(aaplSymbolString));
}
}
}
public void TestGetSymbols()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
EventType events = EventType.Order;
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(events, listener))
{
List <string> symbols = new List <string>(new string[] { "AAPL", "IBM" });
s.AddSymbols(symbols.ToArray());
IList <string> returnedSymbolList = s.GetSymbols();
Assert.AreEqual(symbols.Count, returnedSymbolList.Count);
foreach (string symbol in returnedSymbolList)
{
Assert.True(symbols.Contains(symbol));
}
s.Clear();
returnedSymbolList = s.GetSymbols();
Assert.AreEqual(0, returnedSymbolList.Count);
}
}
}
public void TestPromotionForFunctionCalls()
{
string test
= @"g(float parm) { }
integer intfunc() { return 0; }
f() {
integer i;
g(1);
g(i);
g(i++);
g(i - 3);
g(intfunc());
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"), true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 5);
}
public void TestSetSymbolsCandle()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
EventType events = EventType.Order;
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(events, listener))
{
s.AddSymbols("AAPL", "IBM");
listener.WaitEvents <IDxOrder>("AAPL", "IBM");
CandleSymbol[] candleSymbols = new CandleSymbol[] {
CandleSymbol.ValueOf("XBT/USD{=d}"),
CandleSymbol.ValueOf("AAPL{=d}"),
CandleSymbol.ValueOf("IBM{=d}")
};
s.SetSymbols(candleSymbols);
listener.ClearEvents <IDxOrder>();
Assert.AreEqual(2, s.GetSymbols().Count);
listener.WaitEvents <IDxOrder>("AAPL", "IBM");
}
}
}
public void TestClearSymbols()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
EventType events = EventType.Order;
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(events, listener))
{
s.AddSymbols("AAPL", "IBM");
listener.WaitEvents <IDxOrder>("AAPL", "IBM");
s.Clear();
listener.ClearEvents <IDxOrder>();
Thread.Sleep(10000);
Assert.AreEqual(0, listener.GetEventCount <IDxOrder>("AAPL", "IBM"));
//add another symbol
s.AddSymbols("XBT/USD");
listener.WaitEvents <IDxOrder>("XBT/USD");
}
}
}
public void TestGazeDataStream()
{
try
{
ActivateServer();
TestListener listener = new TestListener();
Assert.IsFalse(GazeManager.Instance.HasGazeListener(listener));
GazeManager.Instance.AddGazeListener(listener);
Assert.IsTrue(GazeManager.Instance.HasGazeListener(listener));
Assert.IsTrue(GazeManager.Instance.GetNumGazeListeners() == 1);
lock (SyncRoot)
{
Monitor.Wait(SyncRoot, (int)DEFAULT_TIMEOUT_MILLIS);
}
Assert.IsTrue(listener.hasRecievedGazeData);
}
finally
{
DeactivateServer();
}
}
public void TestCalibrationStart()
{
try
{
ActivateServer();
TestListener listener = new TestListener();
GazeManager.Instance.CalibrationAbort();
GazeManager.Instance.AddCalibrationStateListener(listener);
Assert.IsTrue(GazeManager.Instance.CalibrationStart(9, null));
Assert.IsFalse(GazeManager.Instance.CalibrationStart(9, null));
lock (SyncRoot)
{
Monitor.Wait(SyncRoot, 1000);
}
Assert.IsTrue(listener.hasRecievedCalibrationStateChange);
Assert.IsTrue(GazeManager.Instance.CalibrationAbort());
Assert.IsTrue(GazeManager.Instance.CalibrationStart(9, null));
Assert.IsTrue(GazeManager.Instance.CalibrationAbort());
}
finally
{
DeactivateServer();
}
}
public void Setup()
{
_compiler = new CompilerFrontend(System.IO.Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"));
_listener = new TestListener();
_compiler.Listener = _listener;
_compiler.TraceDestination = Console.Error;
}
public void TestJumpDifferentSymbolSameName()
{
string test = @"
f() {
@a;
jump a;
}
g() {
@a;
jump a;
}
default
{
touch_start(integer num) {
}
}";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"), true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(new Regex("a_usrlbl__0").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("a_usrlbl__1").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("jmp a_usrlbl__0").Matches(byteCode).Count, 1);
Assert.AreEqual(new Regex("jmp a_usrlbl__1").Matches(byteCode).Count, 1);
}
public void TestSetSource3()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
EventType events = EventType.Order;
string source = "NTV";
string[] sources2 = new string[] { "DEX", "DEA" };
string[] allSource = new string[] { "NTV", "DEX", "DEA" };
string[] symbols = new string[] { "AAPL", "IBM", "XBT/USD" };
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(events, listener))
{
s.AddSymbols(symbols);
listener.WaitOrders(allSource);
listener.WaitEvents <IDxOrder>(symbols);
s.SetSource(source);
Thread.Sleep(12000);
listener.ClearEvents <IDxOrder>();
Thread.Sleep(3000);
listener.WaitOrders(source);
listener.WaitEvents <IDxOrder>(symbols);
Assert.AreEqual(0, listener.GetOrderCount(sources2));
s.AddSource(sources2);
Thread.Sleep(1000);
listener.ClearEvents <IDxOrder>();
Thread.Sleep(3000);
listener.WaitOrders(allSource);
listener.WaitEvents <IDxOrder>(symbols);
}
}
}
public void TestPromotionForStorage()
{
string test
= @"integer g() { return 0; }
f() {
integer i;
float f = 1;
float h = g();
float j = i;
float l = i++;
float k = i - 5;
f = 1;
h = g();
j = i;
l = i++;
k = i - 5;
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"), true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 10);
}
protected virtual void Run(TestResult result, TestListener listener)
{
IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(method, typeof(IgnoreAttribute));
if (this.RunState == RunState.NotRunnable)
{
result.Failure(this.ignoreReason);
}
else if (ignore != null)
{
result.NotRun(ignore.Reason);
}
else
{
try
{
RunBare();
result.Success();
}
catch (NUnitLiteException nex)
{
result.RecordException(nex.InnerException);
}
#if !NETCF_1_0
catch (System.Threading.ThreadAbortException)
{
throw;
}
#endif
catch (Exception ex)
{
result.RecordException(ex);
}
}
}
public void Setup()
{
_compiler = new CompilerFrontend();
_listener = new TestListener();
_compiler.Listener = _listener;
_compiler.TraceDestination = Console.Error;
}
public void testPublish()
{
var listener = new TestListener();
new QTopic(TOPIC_NAME).register(FieldsReceiver.receiver(listener));
IDictionary <string, object> message = new Dictionary <string, object> {
{ "foo", 123.45 }
};
var topic = new Topic(TOPIC_NAME);
topic.send(message);
Objects.sleep(100);
AreEqual(123.45, listener.received.numeric("foo"));
topic.send("bar", "string initializedValue");
Objects.sleep(100);
AreEqual("string initializedValue", listener.received.get("bar"));
var data = new string[3, 2];
data[0, 0] = "key1";
data[0, 1] = "value1";
data[1, 0] = "key2";
data[1, 1] = "value2";
data[2, 0] = "key3";
data[2, 1] = "value3";
topic.send(data);
Objects.sleep(100);
AreEqual("value1", listener.received.get("key1"));
AreEqual("value2", listener.received.get("key2"));
AreEqual("value3", listener.received.get("key3"));
}
public void TestSetSymbolsCandle()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
string candleSymbolString = "XBT/USD{=d}";
string aaplSymbolString = "AAPL{=d,price=mark}";
string ibmSymbolString = "IBM{=d,price=mark}";
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(defaultDateTime, listener))
{
//add candle symbol
s.AddSymbols(new CandleSymbol[] {
CandleSymbol.ValueOf(aaplSymbolString),
CandleSymbol.ValueOf(ibmSymbolString)
});
IList <string> returnedSymbolList = s.GetSymbols();
Assert.AreEqual(2, returnedSymbolList.Count);
listener.WaitEvents <IDxCandle>(aaplSymbolString, ibmSymbolString);
//try to set other non-candle symbols
s.SetSymbols(CandleSymbol.ValueOf(candleSymbolString));
returnedSymbolList = s.GetSymbols();
Assert.AreEqual(1, returnedSymbolList.Count);
Assert.AreEqual(candleSymbolString, returnedSymbolList[0]);
listener.ClearEvents <IDxCandle>();
listener.WaitEvents <IDxCandle>(candleSymbolString);
}
}
}
public void CreateTimeSeriesSubscriptionTest()
{
var symbol = "SYMA";
var s = DXEndpoint.Create().Feed.CreateTimeSeriesSubscription <IDxCandle>();
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
var playedCandle = new PlayedCandle(symbol, Tools.DateToUnixTime(DateTime.Now), 123, 100, 12.34, 56.78, 9.0, 43.21, 1000, 999, 1001, 1002, 1, 777, 888, EventFlag.RemoveSymbol);
EventPlayer <IDxCandle> eventPlayer = new EventPlayer <IDxCandle>(s as DXFeedSubscription <IDxCandle>);
eventPlayer.PlayEvents(symbol, playedCandle);
Assert.AreEqual(eventListener.GetEventCount <IDxCandle>(symbol), 1);
IDxCandle receivedCandle = eventListener.GetLastEvent <IDxCandle>().Event;
Assert.AreEqual(symbol, receivedCandle.EventSymbol.ToString());
CompareCandles(playedCandle, receivedCandle);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXEndpoint.GetInstance().Feed.CreateTimeSeriesSubscription <IDxCandle>();
});
});
}
public void TestAddSymbols()
{
TestListener listener = new TestListener(eventsTimeout, eventsSleepTime, IsConnected);
string candleSymbolString = "XBT/USD{=d}";
using (var con = new NativeConnection(address, OnDisconnect))
{
Interlocked.Exchange(ref isConnected, 1);
using (IDxSubscription s = con.CreateSubscription(defaultDateTime, listener))
{
//add candle symbol
s.AddSymbol(CandleSymbol.ValueOf(candleSymbolString));
IList <string> returnedSymbolList = s.GetSymbols();
Assert.AreEqual(1, returnedSymbolList.Count);
Assert.AreEqual(candleSymbolString, returnedSymbolList[0]);
//try to add other non-candle symbols
s.AddSymbols("AAPL", "IBM");
returnedSymbolList = s.GetSymbols();
Assert.AreEqual(1, returnedSymbolList.Count);
Assert.AreEqual(candleSymbolString, returnedSymbolList[0]);
listener.WaitEvents <IDxCandle>(candleSymbolString);
}
}
}
public override void RunAsync (TestListener listener)
{
this.listener = listener;
OnStarted (null);
listener.TestStarted (this);
Result = new TestResult (this);
queue = new Queue<AsyncTestCase> (Tests.Count);
switch (RunState) {
case RunState.NotRunnable:
Result.Error (IgnoreReason);
break;
case RunState.Ignored:
Result.NotRun (IgnoreReason);
break;
case RunState.Runnable:
foreach (AsyncTestCase @case in Tests)
queue.Enqueue (@case);
break;
}
}
public virtual void TestPropagation()
{
ChemFile cf = new ChemFile();
ChemSequence cs = new ChemSequence();
ChemModel cm = new ChemModel();
IChemObjectSet <IAtomContainer> som = new ChemObjectSet <IAtomContainer>();
var mol = new AtomContainer();
Atom a1 = new Atom("C");
Atom a2 = new Atom("C");
Bond b1 = new Bond(a1, a2);
mol.Atoms.Add(a1);
mol.Atoms.Add(a2);
mol.Bonds.Add(b1);
som.Add(mol);
cm.MoleculeSet = som;
cs.Add(cm);
cf.Add(cs);
TestListener ts = new TestListener();
cf.Listeners.Add(ts);
a2.Symbol = "N";
Assert.IsInstanceOfType(ts.ChangedObject, typeof(Atom));
Assert.AreEqual("N", ((Atom)ts.ChangedObject).Symbol);
}
public void TestImplicitCastForSubscriptAssignment()
{
string test
= @"g(float parm) { }
integer intfunc() { return 0; }
f() {
vector v;
v.x = intfunc();
float f = (v.y = 1);
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, Path.Combine(TestContext.CurrentContext.TestDirectory, "..", "grammar"), true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 2);
}
public void Disconnected_MultipleSubscribedEvents_AllCalledAndInOrder()
{
bool event1Called = false;
bool event2Called = false;
var listener = new TestListener(LoggerTests.BlackHole);
listener.Disconnected += (sender, eventArgs) =>
{
Assert.IsFalse(event1Called);
Assert.IsFalse(event2Called);
event1Called = true;
};
listener.Disconnected += (sender, eventArgs) =>
{
Assert.IsTrue(event1Called);
Assert.IsFalse(event2Called);
event2Called = true;
};
listener.Test_OnDisconnected(new DisconnectedEventArgs(null, null));
Assert.IsTrue(event1Called);
Assert.IsTrue(event2Called);
}
public void Setup()
{
_compiler = new CompilerFrontend();
_listener = new TestListener();
_compiler.Listener = _listener;
_compiler.TraceDestination = Console.Error;
}
private void PrintEvents <TE>(TestListener listener, params string[] symbols)
{
Console.WriteLine(string.Format("Event {0}: Total data count: {1}", typeof(TE), listener.GetEventCount <TE>()));
foreach (string symbol in symbols)
{
Console.WriteLine(" symbol {0}: data count: {1}", symbol, listener.GetEventCount <TE>(symbol));
}
}
private void Awake()
{
listeners = new TestListener[listenersCount];
for (var i = 0; i < listenersCount; i++)
{
listeners[i] = new TestListener();
}
}
public void DefaultMessageInstancesAreSent()
{
var agg = new EventAggregator();
var tester = new TestListener(agg);
agg.SendMessage <TestEvent3>();
Assert.That(tester.Result, Is.EqualTo("TestEvent3()"));
}
public static void WillBeMain()
{
string[] testClassesToLaunch = { "SHOULD_BE_REPLACED" };
var listener = new TestListener();
var assembly = Assembly.GetExecutingAssembly();
ReportOnNonexistentTestClasses(assembly, testClassesToLaunch);
RunAllTests(listener, assembly, testClassesToLaunch);
}
public void CreateSubscriptionTypesTest()
{
//create default endpoint
DXEndpoint.Create();
//try to create subscription with invalid event types parameters
//all attempts to create subscription in this block must be failed with exception
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxOrder>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxIndexedEvent>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxLastingEvent>(typeof(IDxOrder), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(IDxCandle));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(string));
});
var symbol = "SYMA";
var s = DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
EventPlayer <IDxEventType> eventPlayer = new EventPlayer <IDxEventType>(s as DXFeedSubscription <IDxEventType>);
var playedOrder = new PlayedOrder(symbol, 0, 0x4e54560000000006, 0, 0, 0, 0, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA");
eventPlayer.PlayEvents(symbol, playedOrder);
var playedTrade = new PlayedTrade(symbol, 0, 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional);
eventPlayer.PlayEvents(symbol, playedTrade);
Assert.AreEqual(eventListener.GetEventCount <IDxOrder>(symbol), 1);
Assert.AreEqual(eventListener.GetEventCount <IDxTrade>(symbol), 1);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
});
});
}
public TestResult Run(TestListener listener)
{
int count = 0, failures = 0, errors = 0;
listener.TestStarted(this);
TestResult result = new TestResult(this);
switch (this.RunState)
{
case RunState.NotRunnable:
result.Error(this.IgnoreReason);
break;
case RunState.Ignored:
result.NotRun(this.IgnoreReason);
break;
case RunState.Runnable:
foreach (ITest test in tests)
{
++count;
TestResult r = test.Run(listener);
result.AddResult(r);
switch (r.ResultState)
{
case ResultState.Error:
++errors;
break;
case ResultState.Failure:
++failures;
break;
default:
break;
}
}
if (count == 0)
{
result.NotRun("Class has no tests");
}
else if (errors > 0 || failures > 0)
{
result.Failure("One or more component tests failed");
}
else
{
result.Success();
}
break;
}
listener.TestFinished(result);
return(result);
}
public void ListenersAreRemoved()
{
var agg = new EventAggregator();
var tester = new TestListener(agg, _testDispatcherFrame.Dispatcher);
Assert.That(agg.GetMessageTypesHandled(tester).Any(), Is.True);
agg.RemoveListener(tester);
Assert.That(agg.GetMessageTypesHandled(tester).Any(), Is.False);
}
public void Dont_log_if_logging_is_not_enabled()
{
TestListener Listener = new TestListener();
Trace.Listeners.Add(Listener);
Logging.DebugLogger.WriteLine(this, LoggingLevel.Normal, () => "Test");
Assert.AreEqual("", Listener.ToString());
}
public IEnumerable<TestResult> Run(RunSettings settings)
{
_results = new List<TestResult>();
var listener = new TestListener(_feedback, settings.Assembly.Assembly);
var assembly = getAssembly(settings.Assembly.Assembly);
var runner = new AppDomainRunner(listener, Machine.Specifications.Runner.RunOptions.Default);
runTests(settings, assembly, runner);
_results.AddRange(listener.Results);
return _results;
}
public void TestLauksLarrowScript()
{
string test;
using (StreamReader rdr = File.OpenText("..\\..\\..\\..\\grammar\\test_files\\Lauks_Larrow_Main.lsl"))
{
test = rdr.ReadToEnd();
}
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar");
CompiledScript script = testFrontend.Compile(test);
Assert.IsTrue(listener.HasErrors() == false);
}
public override void RunAsync (TestListener listener)
{
this.listener = listener;
queue = new Queue<AsyncTestFixture> (Tests.Count);
Result = new TestResult (this);
OnStarted (null);
listener.TestStarted (this);
foreach (AsyncTestFixture fixture in Tests)
queue.Enqueue (fixture);
RunIterate ();
}
public void TestMultiParamEvent()
{
string test
= @"default
{
listen(integer chan, string name, key id, string text)
{
llSay(0, ""Script Running"");
}
timer()
{
}
}";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar");
CompiledScript script = testFrontend.Compile(test);
Assert.AreEqual(0, listener.ErrorCount);
}
public override void RunAsync (TestListener listener)
{
IgnoreAttribute ignore = (IgnoreAttribute) Reflect.GetAttribute (Method, typeof (IgnoreAttribute));
this.listener = listener;
tasks = new Queue<ConditionalHandler> ();
Result = new TestResult (this);
OnStarted (null);
listener.TestStarted (this);
is_async = Method.IsDefined (typeof (AsynchronousAttribute), false);
Current = this;
if (RunState == RunState.NotRunnable) {
Result.Failure (IgnoreReason);
} else if (ignore != null) {
Result.NotRun (ignore.Reason);
} else {
SetUp ();
try {
RunTest ();
if (is_async) {
Suite.BeginInvoke (ProcessTasks);
} else {
Result.Success ();
RunEnd ();
}
} catch (NUnitLiteException nex) {
Result.RecordException (nex.InnerException);
RunEnd ();
} catch (Exception ex) {
Result.RecordException (ex);
RunEnd ();
}
}
}
public void Timer_SingleCommandMultipleIntervals()
{
HystrixTimer timer = HystrixTimer.Instance;
TestListener l1 = new TestListener(100, "A");
timer.AddTimerListener(l1);
TestListener l2 = new TestListener(10, "B");
timer.AddTimerListener(l2);
TestListener l3 = new TestListener(25, "C");
timer.AddTimerListener(l3);
try
{
Thread.Sleep(500);
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e.ToString());
}
// we should have 3 or more 100ms ticks within 500ms
Console.WriteLine("l1 ticks: " + l1.TickCount.Value);
Assert.IsTrue(l1.TickCount.Value >= 3);
// but it can't be more than 6
Assert.IsTrue(l1.TickCount.Value < 6);
// we should have 30 or more 10ms ticks within 500ms
Console.WriteLine("l2 ticks: " + l2.TickCount);
Assert.IsTrue(l2.TickCount.Value > 28);
Assert.IsTrue(l2.TickCount.Value < 550);
// we should have 15-20 25ms ticks within 500ms
Console.WriteLine("l3 ticks: " + l3.TickCount);
Assert.IsTrue(l3.TickCount.Value > 12);
Assert.IsTrue(l3.TickCount.Value < 25);
}
public void Timer_SingleCommandSingleInterval()
{
HystrixTimer timer = HystrixTimer.Instance;
TestListener l1 = new TestListener(50, "A");
timer.AddTimerListener(l1);
TestListener l2 = new TestListener(50, "B");
timer.AddTimerListener(l2);
try
{
Thread.Sleep(500);
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e.ToString());
}
// we should have 7 or more 50ms ticks within 500ms
Console.WriteLine("l1 ticks: " + l1.TickCount.Value);
Console.WriteLine("l2 ticks: " + l2.TickCount.Value);
Assert.IsTrue(l1.TickCount.Value > 7);
Assert.IsTrue(l2.TickCount.Value > 7);
}
/// <summary>
/// Removes a listener from the TestRunner.
/// </summary>
/// <param name="listener">The listener.</param>
public void RemoveListener(TestListener listener)
{
listeners.Remove(listener);
}
/// <summary>
/// Adds a listener to the TestRunner.
/// </summary>
/// <param name="listener">The listener.</param>
public void AddListener(TestListener listener)
{
listeners.Add(listener);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
if (this.dispatcher == null)
{
this.dispatcher = this.Dispatcher;
}
//获取本窗体的句柄
WindowInteropHelper wndHelper = new WindowInteropHelper(this);
_wpfHwnd = wndHelper.Handle;
_keyboardDriver = new RawKeyboard(_wpfHwnd);
_keyboardDriver.CaptureOnlyIfTopMostWindow = false;
_keyboardDriver.EnumerateDevices();
//之所以不在 WndProc 进行消息的拦截，是因为···在 WPF 中，消息到 WndProc 的时候，都已经显示在界面上了
//当然，在 WinForm 程序上还是有效的，所以在这里，就 在这个消息中截取
System.Windows.Interop.ComponentDispatcher.ThreadFilterMessage +=
new System.Windows.Interop.ThreadMessageEventHandler(ComponentDispatcher_ThreadFilterMessage);
DisplayMemory();
Console.WriteLine();
for (int i = 0; i < 5; i++)
{
Console.WriteLine("--- New Listener #{0} ---", i + 1);
var listener = new TestListener(new TestClassHasEvent());
////listener = null; //可有可无
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
DisplayMemory();
}
byte[] b = new byte[10];
b[11] = 1;
for (int i = 0; i < 11; i++ )
{
b[i] = (byte)i;
}
var file = new FileStream("DeviceAudit.txt", FileMode.Create, FileAccess.Write);
var sw = new StreamWriter(file);
sw.WriteLine("1234-----");
sw.WriteLine(Marshal.GetLastWin32Error());
// sw.Flush();
// sw.Close();
// file.Close();
}
public void Timer_SingleCommandRemoveListener()
{
HystrixTimer timer = HystrixTimer.Instance;
TestListener l1 = new TestListener(50, "A");
timer.AddTimerListener(l1);
TestListener l2 = new TestListener(50, "B");
TimerReference l2ref = timer.AddTimerListener(l2);
try
{
Thread.Sleep(500);
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e.ToString());
}
// we should have 7 or more 50ms ticks within 500ms
Console.WriteLine("l1 ticks: " + l1.TickCount);
Console.WriteLine("l2 ticks: " + l2.TickCount);
Assert.IsTrue(l1.TickCount.Value > 7);
Assert.IsTrue(l2.TickCount.Value > 7);
// remove l2
l2ref.Clear();
// reset counts
l1.TickCount.Value = 0;
l2.TickCount.Value = 0;
// wait for time to pass again
try
{
Thread.Sleep(500);
}
catch (ThreadInterruptedException e)
{
Console.WriteLine(e.ToString());
}
// we should have 7 or more 50ms ticks within 500ms
Console.WriteLine("l1 ticks: " + l1.TickCount);
Console.WriteLine("l2 ticks: " + l2.TickCount);
// l1 should continue ticking
Assert.IsTrue(l1.TickCount.Value > 7);
// we should have no ticks on l2 because we removed it
Console.WriteLine("tickCount.get(): " + l2.TickCount + " on l2: " + l2);
Assert.AreEqual(0, l2.TickCount);
}
public void TestGenerationOutputForTypePromotion()
{
string test
= @"string strfunc() { return """"; }
f() {
integer i;
float f;
if (i < f) {}
if (i > f) {}
if (f > i) {}
if (f < i) {}
if (i >= f) {}
if (i <= f) {}
if (i < i) {}
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(new Regex("flt(?!e)").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("fgt(?!e)").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("fgte").Matches(byteCode).Count, 1);
Assert.AreEqual(new Regex("flte").Matches(byteCode).Count, 1);
Assert.AreEqual(new Regex("ilt").Matches(byteCode).Count, 1);
}
public TestResult Run(TestListener listener)
{
int count = 0, failures = 0, errors = 0;
listener.TestStarted(this);
TestResult result = new TestResult(this);
switch (this.RunState)
{
case RunState.NotRunnable:
result.Error(this.IgnoreReason);
break;
case RunState.Ignored:
result.NotRun(this.IgnoreReason);
break;
case RunState.Runnable:
foreach (ITest test in tests)
{
++count;
TestResult r = test.Run(listener);
result.AddResult(r);
switch (r.ResultState)
{
case ResultState.Error:
++errors;
break;
case ResultState.Failure:
++failures;
break;
default:
break;
}
}
if (count == 0)
result.NotRun("Class has no tests");
else if (errors > 0 || failures > 0)
result.Failure("One or more component tests failed");
else
result.Success();
break;
}
listener.TestFinished(result);
return result;
}
public void TestImplicitCastForSubscriptAssignment()
{
string test
= @"g(float parm) { }
integer intfunc() { return 0; }
f() {
vector v;
v.x = intfunc();
float f = (v.y = 1);
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 2);
}
/**
* example from
* http://msdn.microsoft.com/en-us/library/bb412179(v=vs.110).aspx
* */
public void testDataMemberSimple()
{
Person p = new Person();
p.name = "John";
p.age = 42;
p.title = "Mr";
MemoryStream stream1 = new MemoryStream();
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
ser.WriteObject(stream1, p);
StreamReader sr = new StreamReader(stream1);
stream1.Position=0;
string strBuiltInJson = sr.ReadToEnd();
//Console.WriteLine(sr.ReadToEnd());
Console.WriteLine("inbuilt json=" + strBuiltInJson);
Object2Json o2j = new Object2Json();
o2j.NodeExpander = new DataContractFieldNodeExpander();
string strJson = o2j.toJson(p);
System.Console.WriteLine("json:" + strJson);
// analyze with JsonExplorer
JSONExplorerImpl jsonExplorer = new JSONExplorerImpl();
TestListener inbuiltListener = new TestListener();
TestListener listener = new TestListener();
jsonExplorer.explore(strBuiltInJson, inbuiltListener);
jsonExplorer.explore(strJson, listener);
Assert.AreEqual(inbuiltListener.leaves.Keys.Count, listener.leaves.Keys.Count, "leaf count");
compareMaps(inbuiltListener.leaves, "inbuilt", listener.leaves, "local");
compareMaps(listener.leaves, "local", inbuiltListener.leaves, "inbuilt");
}
async void RunTests(CategoryFilter filter = null)
{
if (!startButton.Enabled)
return;
startButton.Enabled = false;
var keywords = search.Text;
Log.Write(null, "Starting tests...");
var testPlatform = useTestPlatform.Checked == true ? new TestPlatform() : Platform;
try
{
await Task.Run(() =>
{
using (Platform.ThreadStart())
{
try
{
var listener = new TestListener { Application = Application.Instance }; // use running application for logging
var builder = new DefaultTestAssemblyBuilder();
var runner = new NUnitTestAssemblyRunner(builder);
var settings = new Dictionary<string, object>();
var result = new MultipleTestResult();
if (filter != null)
filter.SkipCount = 0;
foreach (var assembly in ((TestApplication)TestApplication.Instance).TestAssemblies)
{
runner.Load(assembly, settings);
filter = filter ?? new CategoryFilter();
filter.Application = Application.Instance;
filter.ExecutingAssembly = assembly;
if (testPlatform is TestPlatform)
filter.IncludeCategories.Add(UnitTests.TestUtils.TestPlatformCategory);
else
filter.IncludeCategories.RemoveAll(r => r == UnitTests.TestUtils.TestPlatformCategory);
filter.Keyword = keywords;
using (testPlatform.Context)
{
result.Results.Add(runner.Run(listener, filter));
}
}
var writer = new StringWriter();
writer.WriteLine(result.FailCount > 0 ? "FAILED" : "PASSED");
writer.WriteLine("\tPass: {0}, Fail: {1}, Skipped: {2}, Inconclusive: {3}", result.PassCount, result.FailCount, result.SkipCount + filter.SkipCount, result.InconclusiveCount);
writer.Write("\tDuration: {0}", result.Duration);
Application.Instance.Invoke(() => Log.Write(null, writer.ToString()));
}
catch (Exception ex)
{
Application.Instance.Invoke(() => Log.Write(null, "Error running tests: {0}", ex));
}
finally
{
Application.Instance.Invoke(() => startButton.Enabled = true);
}
}
});
}
catch (Exception ex)
{
Log.Write(null, "Error running tests\n{0}", ex);
}
}
public TestResult Run(TestListener listener)
{
listener.TestStarted(this);
TestResult result = new TestResult(this);
Run(result, listener);
listener.TestFinished(result);
return result;
}
public void TestNoGenerateBooleanEval()
{
string test
= @"integer intfunc() { return 0; }
f() {
if (intfunc()) {
}
if (1) {
}
if (1 && 2 && 3) {
}
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int evalCount = new Regex("booleval").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(evalCount, 0);
}
protected virtual void Run(TestResult result, TestListener listener)
{
IgnoreAttribute ignore = (IgnoreAttribute)Reflect.GetAttribute(method, typeof(IgnoreAttribute));
if (this.RunState == RunState.NotRunnable)
result.Failure(this.ignoreReason);
else if ( ignore != null )
result.NotRun(ignore.Reason);
else
{
try
{
RunBare();
result.Success();
}
catch (NUnitLiteException nex)
{
result.RecordException(nex.InnerException);
}
#if !NETCF_1_0
catch (System.Threading.ThreadAbortException)
{
throw;
}
#endif
catch (Exception ex)
{
result.RecordException(ex);
}
}
}
public void TestDoGenerateBooleanEval()
{
string test
= @"string strfunc() { return """"; }
f() {
if (strfunc()) {
}
while (0.0) {
}
for (;"""";) {
}
key k;
do {
} while (k);
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int evalCount = new Regex("booleval").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(evalCount, 4);
}
public void TestCalibrationStartAsync()
{
try
{
ActivateServer();
TestListener listener = new TestListener();
GazeManager.Instance.CalibrationAbort();
GazeManager.Instance.AddCalibrationStateListener(listener);
Task<Boolean> task = GazeManager.Instance.CalibrationStartAsync(9, null);
Assert.IsNotNull(task);
Assert.IsTrue(task.Result);
task = GazeManager.Instance.CalibrationStartAsync(9, null);
Assert.IsNotNull(task);
Assert.IsFalse(task.Result);
lock (SyncRoot)
{
Monitor.Wait(SyncRoot, 1000);
}
Assert.IsTrue(listener.hasRecievedCalibrationStateChange);
Assert.IsTrue(GazeManager.Instance.CalibrationAbort());
task = GazeManager.Instance.CalibrationStartAsync(9, null);
Assert.IsNotNull(task);
Assert.IsTrue(task.Result);
Assert.IsTrue(GazeManager.Instance.CalibrationAbort());
}
finally
{
DeactivateServer();
}
}
public void TestJumpDifferentSymbolSameName()
{
string test = @"
f() {
@a;
jump a;
}
g() {
@a;
jump a;
}
default
{
touch_start(integer num) {
}
}";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(new Regex("a_usrlbl__0").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("a_usrlbl__1").Matches(byteCode).Count, 2);
Assert.AreEqual(new Regex("jmp a_usrlbl__0").Matches(byteCode).Count, 1);
Assert.AreEqual(new Regex("jmp a_usrlbl__1").Matches(byteCode).Count, 1);
}
public void TestGazeDataStream()
{
try
{
ActivateServer();
TestListener listener = new TestListener();
Assert.IsFalse(GazeManager.Instance.HasGazeListener(listener));
GazeManager.Instance.AddGazeListener(listener);
Assert.IsTrue(GazeManager.Instance.HasGazeListener(listener));
Assert.IsTrue(GazeManager.Instance.GetNumGazeListeners() == 1);
lock (SyncRoot)
{
Monitor.Wait(SyncRoot, (int)DEFAULT_TIMEOUT_MILLIS);
}
Assert.IsTrue(listener.hasRecievedGazeData);
}
finally
{
DeactivateServer();
}
}
public void TestPromotionForFunctionCalls()
{
string test
= @"g(float parm) { }
integer intfunc() { return 0; }
f() {
integer i;
g(1);
g(i);
g(i++);
g(i - 3);
g(intfunc());
}
default { state_entry() {} }
";
TestListener listener = new TestListener();
MCompilerFrontend testFrontend = new MCompilerFrontend(listener, "..\\..\\..\\..\\grammar", true);
CompiledScript script = testFrontend.Compile(test);
string byteCode = testFrontend.GeneratedByteCode;
Console.WriteLine(byteCode);
int castCount = new Regex("fcast").Matches(byteCode).Count;
Assert.IsTrue(listener.HasErrors() == false);
Assert.AreEqual(castCount, 5);
}
public TestResult Run(TestListener listener)
{
int count = 0, failures = 0, errors = 0;
listener.TestStarted(this);
TestResult result = new TestResult(this);
switch (this.RunState)
{
case RunState.NotRunnable:
result.Error(this.IgnoreReason);
break;
case RunState.Ignored:
result.NotRun(this.IgnoreReason);
break;
case RunState.Runnable:
if(TestFixtureSetUpMethod != null)
{
NUnitLite.Reflect.InvokeMethod(TestFixtureSetUpMethod, TestObject);
}
foreach (ITest test in tests)
{
++count;
TestResult r = test.Run(listener);
result.AddResult(r);
switch (r.ResultState)
{
case ResultState.Error:
++errors;
break;
case ResultState.Failure:
++failures;
break;
default:
break;
}
}
if (TestFixtureTearDownMethod != null)
{
NUnitLite.Reflect.InvokeMethod(TestFixtureTearDownMethod, TestObject);
}
if (count == 0)
{
result.NotRun("Class has no tests");
}
else if (errors > 0 || failures > 0)
{
result.Failure("One or more component tests failed");
}
else
{
result.Success();
}
break;
}
listener.TestFinished(result);
return result;
}
