public void testExpression()
{
var args = new Type[1];
args[0] = typeof(TestMsg);
var mi = GetType().GetMethod("handle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
ParameterExpression pe = Expression.Parameter(typeof(TestMsg), "msgIn");
var exConvert = Expression.Convert(pe, args[0]);
var exParams = new Expression[1];
exParams[0] = exConvert;
var exThis = Expression.Constant(this);
var exCall = Expression.Call(exThis, mi, exParams);
var fn = Expression.Lambda <Action <TestMsg> >(exCall, pe).Compile();
var o = new TestMsg();
var timer = new lib.Timer();
timer.Start();
for (int i = 0; i < m_runCount; ++i)
{
fn(o);
}
var endMs = timer.Current;
log.info($"testExpression: {endMs}");
}
public void testInvoke()
{
var argTypes = new Type[1];
argTypes[0] = typeof(TestMsg);
var mi = GetType().GetMethod("handle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, argTypes, null);
var o = new TestMsg();
var timer = new lib.Timer();
var args = new object[1];
args[0] = o;
timer.Start();
for (int i = 0; i < m_runCount; ++i)
{
mi.Invoke(this, args);
}
var endMs = timer.Current;
log.info($"testInvoke: {endMs}");
}
public async Task Publish_invalid_channel()
{
// arrange
_fayeServerProcess.StartThinServer();
var socket = new WebSocketClient(uri: TEST_SERVER_URL);
SetupWebSocket(socket);
InstantiateFayeClient();
_connection = await _fayeClient.Connect();
const string invalidChannel = "/*";
var messageToSendObj = new TestMsg {
Stuff = "the message"
};
var messageToSend = JsonConvert.SerializeObject(messageToSendObj);
// act + assert
var exception = await _connection.InvokingAsync(c => c.Publish(channel: invalidChannel,
message: messageToSend))
.ShouldThrow <PublishException>();
exception.Message
.Should()
.Be("405:/*:Invalid channel");
}
void SendData()
{
TestMsg msg = new TestMsg();
msg.msgType = 1;
msg.msgContent = "Client";
GameEntity.Instance.gNetManager.PushMsg(msg, SendCallBack);
}
public async Task Subscribe_twice()
{
// arrange
_fayeServerProcess.StartThinServer();
var socket = new WebSocketClient(uri: TEST_SERVER_URL);
SetupWebSocket(socket);
InstantiateFayeClient();
_connection = await _fayeClient.Connect();
var secondClient = GetFayeClient(new WebSocketClient(uri: TEST_SERVER_URL));
_connection2 = await secondClient.Connect();
var tcs = new TaskCompletionSource <string>();
var tcs2 = new TaskCompletionSource <string>();
const string channelName = "/somechannel";
var messageToSend = new TestMsg {
Stuff = "the message"
};
var json = JsonConvert.SerializeObject(messageToSend);
var task = tcs.Task;
// act
await _connection.Subscribe(channelName,
tcs.SetResult);
await _connection.Subscribe(channelName,
tcs2.SetResult);
await _connection2.Publish(channel : channelName,
message : json);
// assert
var result = await task.Timeout(5.Seconds());
if (result == Result.Timeout)
{
Assert.Fail("Timed out waiting for pub/sub to work");
}
var jsonReceived = task.Result;
var objectReceived = JsonConvert.DeserializeObject <TestMsg>(jsonReceived);
objectReceived
.ShouldBeEquivalentTo(messageToSend);
task = tcs2.Task;
result = await task.Timeout(5.Seconds());
if (result == Result.Timeout)
{
Assert.Fail("Timed out waiting for pub/sub to work");
}
jsonReceived = task.Result;
objectReceived = JsonConvert.DeserializeObject <TestMsg>(jsonReceived);
objectReceived
.ShouldBeEquivalentTo(messageToSend);
}
public void Implements_IReason()
{
// Arrange
// Act
var result = new TestMsg();
// Assert
Assert.IsAssignableFrom <IMsg>(result);
}
public void Returns_Type_String()
{
// Arrange
var msg = new TestMsg();
// Act
var result = msg.GetTypeName();
// Assert
Assert.Equal(typeof(TestMsg).ToString(), result);
}
public void Returns_Value()
{
// Arrange
var msg = new TestMsg(Rnd.Str);
// Act
var result = msg.Name;
// Assert
Assert.Equal(nameof(TestMsg.Value), result);
}
public void Returns_DefaultLevel()
{
// Arrange
var msg = new TestMsg();
// Act
var result = msg.Level;
// Assert
Assert.Equal(Msg.DefaultLevel, result);
}
public void Implements_IWithValueMsg()
{
// Arrange
var value = Rnd.Str;
// Act
var result = new TestMsg(value);
// Assert
Assert.IsAssignableFrom <IWithValueMsg <string> >(result);
}
public void Empty_Format_Returns_Type_Name()
{
// Arrange
var msg = new TestMsg();
// Act
var result = msg.ToString();
// Assert
Assert.Equal(typeof(TestMsg).ToString(), result);
}
Message ParsePlayerAction(Message m)
{
return(m switch
{
MoveMsg _ => DecideMove((MoveMsg)m),
PickUpMsg _ => DecideTake((PickUpMsg)m),
TestMsg _ => DecideTest((TestMsg)m),
PlaceMsg _ => DecidePlace((PlaceMsg)m),
DiscoverMsg _ => DecideDiscover((DiscoverMsg)m),
_ => new Message("Unknown"),
});
public void Returns_MsgType_When_Empty()
{
// Arrange
var msg = new TestMsg();
// Act
var result = msg.FormatWithType;
// Assert
Assert.Equal("{MsgType}", result);
}
public void Implements_INotFoundMsg()
{
// Arrange
var value = Rnd.Str;
// Act
var result = new TestMsg(value);
// Assert
Assert.IsAssignableFrom <INotFoundMsg>(result);
}
public override Task <TestResponse> TestWithTestMsg(TestMsg request, ServerCallContext context)
{
var response = new TestResponse();//new List<int>();
var randon = new Random(DateTime.Now.Millisecond);
for (var i = 0; i < 10; i++)
{
response.Values.Add(request.Data + randon.Next(0, 100).ToString());
}
return(Task.FromResult(response));
}
public Task Handle(TestMsg message, IMessageHandlerContext context)
{
var ravenSession = context.SynchronizedStorageSession.RavenSession();
if (ravenSession is InMemoryDocumentSessionOperations ravenSessionOps)
{
var dbName = ravenSessionOps.DatabaseName;
testCtx.ObservedDbs.Add(dbName);
}
Interlocked.Increment(ref testCtx.MessagesReceived);
return(Task.FromResult(0));
}
public void Trims_Format()
{
// Arrange
var format = Rnd.Str;
var msg = new TestMsg($"{format} ");
// Act
var result = msg.FormatWithType;
// Assert
Assert.Equal($"{{MsgType}} {format}", result);
}
public async Task OnStart()
{
var ping = new Ping();
ping.Name = "Tom";
var response = await _mediator.Send(ping);
//Console.WriteLine(response); // "Pong"
var msg = new TestMsg();
msg.Name = "Jack";
await _mediator.Publish(msg);
}
public void Returns_Empty_Object_When_Value_Is_Null()
{
// Arrange
var msg = new TestMsg(null);
// Act
var result = msg.Args;
// Assert
Assert.Collection(result,
x => Assert.NotNull(x)
);
}
public void Msg_Passes_Text_With_Type()
{
// Arrange
var log = Substitute.ForPartsOf <Log>();
var format = Rnd.Str;
var msg = new TestMsg(format);
// Act
log.Msg(msg);
// Assert
log.Received().Vrb($"{{MsgType}} {format}", Arg.Any <object[]>());
}
public void Uses_Name()
{
// Arrange
var name = Rnd.Str;
var msg = new TestMsg(name, Rnd.Int);
var expected = $"{name} = {{Value}}";
// Act
var result = msg.Format;
// Assert
Assert.Equal(expected, result);
}
public void Returns_TypeName_When_Null()
{
// Arrange
var msg = new TestMsg();
// Act
var result = msg.ArgsWithType;
// Assert
Assert.Collection(result,
x => Assert.Equal(msg.GetTypeName(), x)
);
}
public void Returns_Value()
{
// Arrange
var value = Rnd.Str;
var msg = new TestMsg(value);
// Act
var result = msg.Args;
// Assert
Assert.Collection(result,
x => Assert.Equal(value, x)
);
}
public void Returns_Name_And_Value()
{
// Arrange
var name = Rnd.Str;
var value = Rnd.Int;
var msg = new TestMsg(name, value);
var expected = $"{typeof(TestMsg)} {name} = {value}";
// Act
var result = msg.ToString();
// Assert
Assert.Equal(expected, result);
}
// Test MSG
private TestMsg GetTMSG(byte[] msg, Int64 msgSize)
{
Int32 type = ByteInt32(msg[8]);
byte[] seq_num = new byte[4];
byte[] vars = new byte[msgSize - 13];
Array.Copy(msg, 9, seq_num, 0, 4);
Array.Copy(msg, 13, vars, 0, msgSize - 13);
TestMsg TMSG = TMSGVars(vars);
TMSG.msgType = type;
return(TMSG);
}
public void Returns_Formatted_String()
{
// Arrange
var format = "{0} = {1}";
var a0 = Rnd.Str;
var a1 = Rnd.Int;
var msg = new TestMsg(format, a0, a1);
var expected = $"{typeof(TestMsg)} {a0} = {a1}";
// Act
var result = msg.ToString();
// Assert
Assert.Equal(expected, result);
}
private TestMsg TMSGVars(byte[] vars) //needs testing
{
byte[][] stuff = new byte[vars.Length / 4][];
//Console.WriteLine(vars.Length);
for (int index = 0; index < vars.Length / 4; index += 4)
{
Array.Copy(vars, index, stuff[index], 0, 4);
}
TestMsg msg = new TestMsg();
msg.stuff = ByteInt32(stuff);
return(msg);
}
public void testDirect()
{
var o = new TestMsg();
var timer = new lib.Timer();
timer.Start();
for (int i = 0; i < m_runCount; ++i)
{
handle(o);
}
var endMs = timer.Current;
log.info($"testDirect: {endMs}");
}
//**********************************************************************
public void ExecuteTx(CmdLineCmd aCmd)
{
aCmd.setArgDefault(1, 1);
int tMsgType = aCmd.argInt(1);
switch (tMsgType)
{
case 1:
{
TestMsg tMsg = new TestMsg();
Helper.initialize(tMsg);
Global.mNetworkThread.sendMsg(tMsg);
break;
}
case 2:
{
FirstMessageMsg tMsg = new FirstMessageMsg();
Helper.initialize(tMsg);
Global.mNetworkThread.sendMsg(tMsg);
break;
}
case 3:
{
StatusRequestMsg tMsg = new StatusRequestMsg();
Helper.initialize(tMsg);
Global.mNetworkThread.sendMsg(tMsg);
break;
}
case 4:
{
StatusResponseMsg tMsg = new StatusResponseMsg();
Helper.initialize(tMsg);
Global.mNetworkThread.sendMsg(tMsg);
break;
}
case 5:
{
DataMsg tMsg = new DataMsg();
Helper.initialize(tMsg);
Global.mNetworkThread.sendMsg(tMsg);
break;
}
}
}
//**********************************************************************
public void ExecuteGo3(CmdLineCmd aCmd)
{
ByteBuffer tBuffer = new ByteBuffer(1000);
TestMsg tTxMsg = new TestMsg();
TestMsg tRxMsg = null;
Helper.initialize(tTxMsg);
MsgMonkey tMonkey = new MsgMonkey();
tMonkey.putMsgToBuffer(tBuffer, tTxMsg);
tBuffer.rewind();
tRxMsg = (TestMsg)tMonkey.makeMsgFromBuffer(tBuffer);
Helper.show(tRxMsg);
}
