public void LoggerActorTest()
{
const string logFilename = "testLog";
TestLauncherActor.Test(() =>
{
var logger = new LoggerActor(logFilename)
{
MessageTracerService = new MemoryMessageTracerService()
};
logger.SendMessage("Test Message");
var msgList = logger.MessageTracerService.CopyAllMessages();
Assert.IsTrue(msgList.Contains("Test Message"));
Task.Delay(1000).Wait();
msgList = logger.MessageTracerService.CopyAllMessages();
Assert.IsTrue(msgList.Any(s => s.Contains("HeartBeatAction")));
Task.Delay(1000).Wait();
});
var file = Path.Combine(Environment.CurrentDirectory, logFilename);
List <string> strings = new List <string>();
using (var stream = new StreamReader(file))
{
while (!stream.EndOfStream)
{
strings.Add(stream.ReadLine());
}
}
Assert.IsTrue(strings.Any(t => t.Contains("Test Message")));
}
public void TestShardRun()
{
TestLauncherActor.Test(() =>
{
ActorServer.Start(ActorConfigManager.CastForTest());
new ShardDirectoryClientTest();
});
}
public void TestNullBehavior()
{
TestLauncherActor.Test(() =>
{
var actor = new BaseActor(new NullBehavior());
actor.SendMessage("delta");
});
}
public void EnumerableActorTest()
{
TestLauncherActor.Test(() =>
{
var act = new EnumerableActor <string>();
Assert.IsNotNull(act);
});
}
public void AddElementTest()
{
TestLauncherActor.Test(() =>
{
var act = new EnumerableActor <string>
{
"test"
};
});
}
public void TestADecoratedActor()
{
TestLauncherActor.Test(() =>
{
var actor = new TestActorBehaviorDecorated();
var future = actor.GetAnswer();
actor.SendMessage("Test Decorated");
Assert.AreEqual("Test Decorated", future.Result());
});
}
public void TestADecoratedActorWith2Args()
{
TestLauncherActor.Test(() =>
{
var actor = new TestActorBehaviorDecorated();
var future = new Future <string>();
actor.PostAnswer(future, "Test Decorated");
Assert.AreEqual("Test Decorated", future.Result());
});
}
public void TestADecoratedActor()
{
TestLauncherActor.Test(() =>
{
var actor = new TestActorActionBehaviorDecorated();
var future = new Future <string>();
actor.SendDecoratedMessage(future, "Test Decorated");
Assert.AreEqual("Test Decorated", future.Result());
});
}
public void Sequencing1Test()
{
TestLauncherActor.Test(
() =>
{
var future = new Future <string>();
var sequenceActor = new SequenceActor(future);
var result = future.Result();
Assert.AreEqual("Test Done", result);
});
}
public void ActorStateTest()
{
TestLauncherActor.Test(
() =>
{
var stateActor = new StateFullActor <string>();
string strTest = "Test actStateFullActor";
stateActor.SetState(strTest);
Assert.AreEqual(strTest, stateActor.GetState().Result());
});
}
public void ActorStatServerTest()
{
TestLauncherActor.Test(() =>
{
var stat = new ActorStatServer();
var future = new Future <string>();
stat.SendMessage(future);
var result = future.Result();
Assert.IsTrue(result.Contains("Task"));
});
}
public void EchoActorTest2()
{
TestLauncherActor.Test(() =>
{
var actor = new EchoTest();
new EchoActor <string>(actor, "Test Echo");
IFuture <string> future = new Future <string>();
actor.SendMessage(future);
Assert.AreEqual("Test Echo", future.ResultAsync().Result);
});
}
public void RemoveElementTest()
{
TestLauncherActor.Test(() =>
{
var act = new EnumerableActor <string>
{
"test"
};
act.Remove("test");
});
}
public void TestADecoratedActorWith3Args()
{
TestLauncherActor.Test(() =>
{
var actor = new TestActorBehaviorDecorated();
var future = new Future <string, int>();
actor.PostAnswer(future, "Test Decorated", 1);
var result = future.Result();
Assert.AreEqual("Test Decorated", result.Item1);
Assert.AreEqual(1, result.Item2);
});
}
public void FutureFilteredAsyncTest()
{
TestLauncherActor.Test(() =>
{
Future <string> future = new Future <string>();
FutureAsyncActorTest actor = new FutureAsyncActorTest();
actor.SendMessage("Test Data");
Task <string> result = future.ResultAsync(o => (string)o == "Test Data");
actor.SendMessage(future);
Assert.AreEqual("Test Data", result.Result);
});
}
public void ParserServerTest()
{
ParserServer parser = new ParserServer();
TestParserActor receive = new TestParserActor();
TestLauncherActor.Test(() =>
{
parser.SendMessage((IActor)receive, "A B C D E");
var result = receive.GetList().Result;
Assert.IsTrue(result.Any());
Assert.IsTrue(result.Count() == 5);
Assert.IsTrue(result.Count(c => c == "C") == 1);
});
}
public void EchoActorTest()
{
var launcher = new TestLauncherActor();
launcher.SendAction(() =>
{
var actor = new EchoTest();
new EchoActor(actor, "Test Echo");
IFuture <string> future = new Future <string>();
actor.SendMessage(future);
Assert.AreEqual("Test Echo", future.ResultAsync().Result);
launcher.Finish();
});
Assert.IsTrue(launcher.Wait());
}
public void WorkerActorTest()
{
TestLauncherActor.Test(
() =>
{
EnumerableActor <string> memLogger = new EnumerableActor <string>();
IActor worker = new WorkerActorTestString(memLogger);
IActor dummyBroker = new BaseActor();
ActorTag tag = new ActorTag();
worker.SendMessage(dummyBroker, tag, "Worker on stage");
Task.Delay(1000).Wait();
Assert.AreEqual(1, memLogger.Count);
Assert.AreEqual("Worker on stage", memLogger.First());
});
}
public void SimpleAndReceiveTest()
{
TestLauncherActor.Test(() =>
{
List <string> list = new List <string>();
var bhv = new Behavior <IActor, string>((i, s1) => i.SendMessage(i, s1));
var simple = new SimpleActor(bhv);
var bhv2 = new Behavior <IActor, string>((i, s2) => list.Add(s2));
var receiver = new SimpleActor(bhv2);
simple.SendMessage(receiver, "Simple works");
Task.Delay(5000).Wait();
var s = list.FirstOrDefault();
Assert.AreEqual("Simple works", s);
});
}
public void HeartBeatActorTest()
{
var heartBeat = new HeartBeatActor(5000);
TestHeartBeatActor actor = new TestHeartBeatActor();
TestLauncherActor.Test(
() =>
{
heartBeat.SendMessage(actor);
Task.Delay(5100).Wait();
Assert.IsTrue(actor.fHeartBeatReceive);
actor.fHeartBeatReceive = false;
Assert.IsFalse(actor.fHeartBeatReceive);
Task.Delay(5100).Wait();
Assert.IsTrue(actor.fHeartBeatReceive);
});
}
public void TestActorExtension()
{
TestLauncherActor.Test(() =>
{
var receiver = new ExtensionTestActor();
var future = new Future <IEnumerable <string> >();
receiver.SendMessage("test1");
receiver.SendMessage("test1", "test2");
receiver.SendMessage("test1", "test2", "test3");
receiver.SendMessage("test1", "test2", "test3", "test4");
receiver.SendMessage(future);
var result = future.Result();
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Count());
Assert.IsTrue(result.Contains("test4"));
});
}
public void ProcessActorTest()
{
TestLauncherActor.Test(() =>
{
var futurePing = new Future <string>();
var futurePong = new Future <string>();
ping = new ProcessActor <string>(msg => futurePing.SendMessage(msg));
pong = new ProcessActor <string>(msg =>
{
futurePong.SendMessage(msg);
ping.SendMessage("ping");
});
pong.SendMessage("pong");
Assert.AreEqual("ping", futurePing.Result());
Assert.AreEqual("pong", futurePong.Result());
});
}
public void GetEnumeratorTest()
{
TestLauncherActor.Test(() =>
{
var act = new EnumerableActor <string>
{
"test1",
"test2"
};
var list = new List <string>();
foreach (var item in act)
{
list.Add(item);
}
Assert.AreEqual(2, list.Count);
Assert.AreEqual(2, act.Count);
});
}
public void StressEnumeratorWithLinqTest()
{
TestLauncherActor.Test(() =>
{
var act = new EnumerableActor <string>();
foreach (var item in Enumerable.Range(0, 100))
{
act.Add($"{item}");
}
Assert.AreEqual(100, act.Count());
var query =
from s in act
where s.StartsWith("1", StringComparison.InvariantCulture)
select s;
Assert.AreEqual(11, query.Count());
Assert.IsTrue(query.Contains("11"));
});
}
public void RegisterUnregisterTestV2()
{
TestLauncherActor.Test(() =>
{
ActorServer.Start(ActorConfigManager.CastForTest());
var actor = new StateFullActor <string>();
HostDirectoryActor.Register(actor);
Task.Delay(5000).Wait();
var stat = HostDirectoryActor.GetInstance().GetEntries();
Assert.IsTrue(stat.Count(t => t == actor.Tag.Key()) == 1);
HostDirectoryActor.Unregister(actor);
Task.Delay(5000).Wait();
var stat2 = HostDirectoryActor.GetInstance().GetEntries();
#pragma warning disable CA1827 // Do not use Count() or LongCount() when Any() can be used
Assert.IsTrue(stat2.Count(t => t == actor.Tag.Key()) == 0); // don't touch
#pragma warning restore CA1827 // Do not use Count() or LongCount() when Any() can be used
});
}
public void ReceiveLineTest()
{
BehaviorReceiveLine brl = new BehaviorReceiveLine();
TestParserActor receive = new TestParserActor();
string testLine = "A B CD E F";
IMessageParam <IActor, string> msg = new MessageParam <IActor, string>(receive, testLine);
TestLauncherActor.Test(() =>
{
// call behavior directly
if (brl.DefaultPattern()(msg.Item1, msg.Item2))
{
brl.StandardApply(msg);
var result = receive.GetList().Result;
Assert.IsTrue(result.Any());
Assert.IsTrue(result.Count() == 5);
Assert.IsTrue(result.Count(c => c == "CD") == 1);
}
});
}
public void RegisterUnregisterTest()
{
TestLauncherActor.Test(() =>
{
ActorServer.Start(ActorConfigManager.CastForTest());
var actor = new StateFullActor <string>();
HostDirectoryActor.Register(actor);
SerialObject so = new SerialObject(new MessageParam <StateAction, string>(StateAction.Set, "Test"), actor.Tag);
HostDirectoryActor.GetInstance().SendMessage(so);
Task.Delay(5000).Wait();
var result = actor.GetStateAsync(5000).Result;
Assert.AreEqual(result, "Test");
HostDirectoryActor.Unregister(actor);
SerialObject so2 = new SerialObject(new MessageParam <StateAction, string>(StateAction.Set, "Test2"), actor.Tag);
HostDirectoryActor.GetInstance().SendMessage(so2);
Task.Delay(5000).Wait();
var result2 = actor.GetStateAsync(5000).Result;
Assert.AreEqual("Test", result2, string.Format(CultureInfo.InvariantCulture, "Expected {0} Found {1}", "Test", result2));
});
}
public void TestActorQueue()
{
TestLauncherActor.Test(() =>
{
var actorqueue = new QueueActor <string>();
actorqueue.Queue("a");
actorqueue.Queue("b");
actorqueue.Queue("c");
var a = actorqueue.TryDequeueAsync();
var b = actorqueue.TryDequeueAsync();
var c = actorqueue.TryDequeueAsync();
Assert.IsTrue(a.Result.Result);
Assert.IsTrue(b.Result.Result);
Assert.IsTrue(c.Result.Result);
string s = a.Result.Data + b.Result.Data + c.Result.Data;
Assert.AreEqual(3, s.Length);
Assert.IsTrue(s.Contains("a"));
Assert.IsTrue(s.Contains("b"));
Assert.IsTrue(s.Contains("c"));
});
}
public void TraceActorTest()
{
TestLauncherActor.Test(() =>
{
var trace = new TraceActor();
trace.Start();
trace.Stop("Test End Trace");
Task.Delay(1000).Wait();
});
var filename = Path.Combine(Environment.CurrentDirectory, "TraceLogger");
List <string> strings = new List <string>();
using (var stream = new StreamReader(filename))
{
while (!stream.EndOfStream)
{
strings.Add(stream.ReadLine());
}
}
Assert.IsTrue(strings.Any(t => t.Contains("Test End Trace")));
}
public void BrokerActorTest()
{
TestLauncherActor.Test(
() =>
{
EnumerableActor <string> memLogger = new EnumerableActor <string>();
IActor broker = new BrokerActor <string>();
Enumerable.Range(1, 10).All((t) =>
{
IActor worker = new WorkerActorTestString(memLogger);
broker.SendMessage(BrokerAction.RegisterWorker, worker);
return(true);
});
Enumerable.Range(1, 10).All(t =>
{
IActor client = new BaseActor();
string s = string.Format(CultureInfo.InvariantCulture, "Test range {0}", t);
broker.SendMessage(s);
return(true);
});
Task.Delay(5000).Wait();
Assert.AreEqual(10, memLogger.Count);
});
}
