public void IdentifyCommand()
{
var c = LobbyCommandMock.IdentifyCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareIdentifyCommand(c, dc);
}
public void CheckUserExistCommand()
{
var c = LobbyCommandMock.CheckUserExistCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareCheckUserExistCommand(c, dc);
}
public void CreateTableCommand()
{
var c = LobbyCommandMock.CreateTableCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareCreateTableCommand(c, dc);
}
public void AuthenticateUserCommand()
{
var c = LobbyCommandMock.AuthenticateUserCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareAuthenticateUserCommand(c, dc);
}
public void GetUserCommand()
{
var c = LobbyCommandMock.GetUserCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareGetUserCommand(c, dc);
}
public void JoinTableCommand()
{
var c = LobbyCommandMock.JoinTableCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareJoinTableCommand(c, dc);
}
public void CheckCompatibilityCommand()
{
var c = LobbyCommandMock.CheckCompatibilityCommand();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
CompareCheckCompatibilityCommand(c, dc);
}
public void JoinTableResponse()
{
var c = LobbyCommandMock.JoinTableResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Success, dc.Success);
CompareJoinTableCommand(c.Command, dc.Command);
}
public void IdentifyResponse()
{
var c = LobbyCommandMock.IdentifyResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Success, dc.Success);
CompareIdentifyCommand(c.Command, dc.Command);
}
public void CreateTableResponse()
{
var c = LobbyCommandMock.CreateTableResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.IdTable, dc.IdTable);
CompareCreateTableCommand(c.Command, dc.Command);
}
public void CheckUserExistResponse()
{
var c = LobbyCommandMock.CheckUserExistResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Exist, dc.Exist);
CompareCheckUserExistCommand(c.Command, dc.Command);
}
public void CreateUserResponse()
{
var c = LobbyCommandMock.CreateUserResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Success, dc.Success);
CompareCreateUserCommand(c.Command, dc.Command);
}
public void GetUserResponse()
{
var c = LobbyCommandMock.GetUserResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Email, dc.Email);
Assert.AreEqual(c.DisplayName, dc.DisplayName);
Assert.AreEqual(c.Money, dc.Money);
CompareGetUserCommand(c.Command, dc.Command);
}
public void ListTableResponse()
{
var c = LobbyCommandMock.ListTableResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Tables.Count, dc.Tables.Count);
for (int i = 0; i < c.Tables.Count; ++i)
{
CompareTupleTable.Compare(c.Tables[i], dc.Tables[i]);
}
CompareListTableCommand(c.Command, dc.Command);
}
public void CheckCompatibilityResponse()
{
var c = LobbyCommandMock.CheckCompatibilityResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.ImplementedProtocolVersion, dc.ImplementedProtocolVersion);
Assert.IsFalse(c.SupportedLobbyTypes.Except(dc.SupportedLobbyTypes).Any());
Assert.AreEqual(c.Rules.Length, dc.Rules.Length);
for (int i = 0; i < c.Rules.Length; ++i)
{
CompareRuleInfo.Compare(c.Rules[i], dc.Rules[i]);
}
CompareCheckCompatibilityCommand(c.Command, dc.Command);
}
public void JoinTableResponse()
{
var c = LobbyCommandMock.JoinTableResponse();
var dc = EncodeDecodeHelper.GetDecodedCommand(c);
Assert.AreEqual(c.Success, dc.Success);
CompareJoinTableCommand(c.Command, dc.Command);
CompareTableParams.Compare(c.Params, dc.Params);
//Assert.AreEqual(c.TotalPotAmount, dc.TotalPotAmount);
//Assert.AreEqual(c.PotsAmount.Count, dc.PotsAmount.Count);
//Assert.IsFalse(c.PotsAmount.Except(dc.PotsAmount).Any());
//Assert.AreEqual(c.BoardCards.Length, dc.BoardCards.Length);
//Assert.IsFalse(c.BoardCards.Except(dc.BoardCards).Any());
Assert.AreEqual(c.Seats.Count, dc.Seats.Count);
for (int i = 0; i < c.Seats.Count; ++i)
{
CompareSeatInfo.Compare(c.Seats[i], dc.Seats[i]);
}
Assert.AreEqual(c.GameHasStarted, dc.GameHasStarted);
}
public void AuthenticateUserCommand()
{
CheckIfResponseIs <AuthenticateUserResponse>(LobbyCommandMock.AuthenticateUserCommand());
}
public void CreateTableCommand()
{
CheckIfResponseIs <CreateTableResponse>(LobbyCommandMock.CreateTableCommand());
}
public void CreateUserCommand()
{
CheckIfResponseIs <CreateUserResponse>(LobbyCommandMock.CreateUserCommand());
}
public void GetUserCommand()
{
CheckIfResponseIs <GetUserResponse>(LobbyCommandMock.GetUserCommand());
}
public void IdentifyCommand()
{
CheckIfResponseIs <IdentifyResponse>(LobbyCommandMock.IdentifyCommand());
}
public void JoinTableCommand()
{
CheckIfResponseIs <JoinTableResponse>(LobbyCommandMock.JoinTableCommand());
}
public void ListTableCommand()
{
CheckIfResponseIs <ListTableResponse>(LobbyCommandMock.ListTableCommand());
}
public void CheckCompatibilityCommand()
{
CheckIfResponseIs <CheckCompatibilityResponse>(LobbyCommandMock.CheckCompatibilityCommand());
}
public void CheckUserExistCommand()
{
CheckIfResponseIs <CheckUserExistResponse>(LobbyCommandMock.CheckUserExistCommand());
}
