private void ClientForm_FormClosed(object sender, FormClosedEventArgs e)
{
ExitPacket exitPacket = new ExitPacket("bitch");
m_client.SendMessage(exitPacket);
Console.WriteLine("Yeet");
}
private void ProcessServerResponce()
{
Console.Write(">>>");
Packet packet;
while ((packet = Read()) != null)
{
switch (packet.m_packetType)
{
case (PacketType.CHATMESSAGE):
{
ChatMessagePacket chatMessage = (ChatMessagePacket)packet;
clientForm.UpdateChatWindow(chatMessage.m_message);
break;
}
case (PacketType.CHATLOG):
{
ChatLog chatLog = (ChatLog)packet;
clientForm.UpdateChatWindow(chatLog.m_ChatLog);
break;
}
case (PacketType.CLIENTLISTUPDATE):
{
ClientListUpdate clientList = (ClientListUpdate)packet;
//clientForm.UpdateClientList(clientList.m_clientName);
break;
}
case (PacketType.EXIT):
{
ExitPacket exitPacket = (ExitPacket)packet;
Console.WriteLine(exitPacket.m_message);
break;
}
default:
{
break;
}
}
}
}
public Packet Read()
{
int numberOfBytes;
lock (m_readLock)
{
if ((numberOfBytes = m_reader.ReadInt32()) != -1)
{
byte[] buffer = m_reader.ReadBytes(numberOfBytes);
MemoryStream memStream = new MemoryStream(buffer);
return(m_formatter.Deserialize(memStream) as Packet);
}
else
{
ExitPacket packet = new ExitPacket("User: "******"Disconnected");
return(packet);
}
}
}
public async Task <bool> TryTest()
{
int stateVar = 0;
int testStep = 0;
firstStart = true;
ExitTest = false;
PassedTest = false;
testTimedOut = false;
try
{
WD_Timer = new System.Threading.Timer(WD_TimerCallback, testTimedOut, msTimeOut, 10);
StdOutArrays = new List <List <byte> >();
StdErrArrays = new List <List <byte> >();
StdInArrays = new List <List <byte> >();
using (Process myProcess = new Process())
{
myProcess.StartInfo.UseShellExecute = false;
myProcess.StartInfo.CreateNoWindow = true;
myProcess.StartInfo.StandardInputEncoding = Encoding.UTF8;
myProcess.StartInfo.RedirectStandardInput = true;
myProcess.StartInfo.StandardOutputEncoding = Encoding.UTF8;
myProcess.StartInfo.RedirectStandardOutput = true;
myProcess.StartInfo.StandardErrorEncoding = Encoding.UTF8;
myProcess.StartInfo.RedirectStandardError = true;
myProcess.StartInfo.FileName = TestAppExePathString;
myProcess.StartInfo.Arguments = argsIn;
do
{
switch (stateVar)
{
case 0:
{
if (myProcess.Start())
{
StdInputStream = myProcess.StandardInput.BaseStream;
StdOutputStream = myProcess.StandardOutput.BaseStream;
StdErrorStream = myProcess.StandardError.BaseStream;
if (firstStart)
{
// close stream
StdInputStream.Close();
System.Threading.Thread.Sleep(BaseClass_Sys_ExecutionPolicy.default_msSleep_APIProc_PostInputDelay);
await ReadStandardResponseAsync();
// ensure starts with title string and ends with argIn string
if (StdOutArrays.Count > 0)
{
if (!(Encoding.UTF8.GetString(StdOutArrays[0].ToArray())).StartsWith(titleString))
{
throw new Exception("Fail - Preamble received doesn't match title string.");
}
if (!(Encoding.UTF8.GetString(StdOutArrays[0].ToArray())).EndsWith(argsIn))
{
throw new Exception("Fail - Preamble received doesn't match argument string.");
}
}
else if (StdErrArrays.Count > 0)
{
throw new Exception("Std Error: " + Encoding.UTF8.GetString(StdErrArrays[0].ToArray()));
}
firstStart = false;
break;
}
// write test packet
TestConversation[testStep].CommandPacket.ToByteStreamAndLog(DefaultSerializationType, StdInputStream, StdInArrays);
// close stream
StdInputStream.Close();
System.Threading.Thread.Sleep(BaseClass_Sys_ExecutionPolicy.default_msSleep_APIProc_PostInputDelay);
// read packets from standard streams
// process response packet(s)
// compare expected response packet to actual response packet
foreach (BaseClass_Packet bc in await ReadStandardPacketsAsync(DefaultSerializationType))
{
if (testStep == 0)
{
PassedTest = bc.Equals(TestConversation[testStep].ResponsePacket);
}
else
{
PassedTest &= bc.Equals(TestConversation[testStep].ResponsePacket);
}
}
if (++testStep >= TestConversation.Count)
{
ExitTest = true;
}
}
else if (firstStart)
{
throw new Exception("Failed to Start: " + myProcess.StartInfo.FileName + "\\" + myProcess.StartInfo.Arguments);
}
else
{
throw new Exception("Failed to Re-Start: " + myProcess.StartInfo.FileName);
}
}
if (ExitTest)
{
goto case 1;
}
else
{
break;
}
case 1:
{
if (myProcess.Start())
{
// write exit packet
ExitPacket exPack = new ExitPacket
{
ShouldExitWillExit = true
};
exPack.ToByteStreamAndLog(DefaultSerializationType, StdInputStream, StdInArrays);
// close stream
StdInputStream.Close();
System.Threading.Thread.Sleep(BaseClass_Sys_ExecutionPolicy.default_msSleep_APIProc_PostInputDelay);
// read packets from standard streams
// process response packet(s)
// compare expected response packet to actual response packet
bool gotexRsp = false;
foreach (BaseClass_Packet bc in await ReadStandardPacketsAsync(DefaultSerializationType))
{
if (exPack.MatchesPacket(bc))
{
gotexRsp = true;
}
}
if (!gotexRsp)
{
throw new Exception("Failed to Read Exit Response.");
}
// wait for process to exit
myProcess.WaitForExit(BaseClass_Sys_ExecutionPolicy.default_msSleep_APIProc_ExitDelay);
}
else
{
throw new Exception("Failed to Re-Start for Exit: " + myProcess.StartInfo.FileName);
}
}
break;
}
if (testTimedOut)
{
throw new Exception("Test Timed Out!");
}
} while (!ExitTest);
if (!myProcess.HasExited)
{
myProcess.Kill();
throw new Exception("Test Process did not Exit!");
}
}
return(PassedTest);
}
catch (Exception e)
{
throw e;
}
finally
{
WD_Timer.Dispose();
}
}
public static Packet RenderPacket(PacketType type, string payload)
{
switch (type)
{
case PacketType.Exit:
{
ExitPacket p = JsonConvert.DeserializeObject <ExitPacket>(payload);
return(p);
}
case PacketType.Error:
{
ErrorPacket p = JsonConvert.DeserializeObject <ErrorPacket>(payload);
return(p);
}
case PacketType.VersionRequest:
{
VersionPacket p = JsonConvert.DeserializeObject <VersionPacket>(payload);
return(p);
}
case PacketType.VersionResponse:
{
VersionPacket p = JsonConvert.DeserializeObject <VersionPacket>(payload);
return(p);
}
case PacketType.LoginRequest:
{
LoginRequestPacket p = JsonConvert.DeserializeObject <LoginRequestPacket>(payload);
return(p);
}
case PacketType.LoginResponse:
{
LoginResponsePacket p = JsonConvert.DeserializeObject <LoginResponsePacket>(payload);
return(p);
}
case PacketType.PlayerListRequest:
{
PlayerListRequestPacket p = JsonConvert.DeserializeObject <PlayerListRequestPacket>(payload);
return(p);
}
case PacketType.PlayerListResponse:
{
LoginResponsePacket p = JsonConvert.DeserializeObject <LoginResponsePacket>(payload);
return(p);
}
case PacketType.CreateLobbyRequest:
{
CreateLobbyRequestPacket p = JsonConvert.DeserializeObject <CreateLobbyRequestPacket>(payload);
return(p);
}
case PacketType.CreateLobbyResponse:
{
CreateLobbyResponsePacket p = JsonConvert.DeserializeObject <CreateLobbyResponsePacket>(payload);
return(p);
}
default:
Console.WriteLine("packet type not found.");
return(new Packet());
}
}
