public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out this class id first
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
base.Encode(bytes); // Encode the part of the object defined
// by the base class
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void WhiningSpinner_CheckEncodeAndDecode()
{
Tick t1 = new Tick();
Tick t2 = new Tick();
Tick t3 = new Tick();
Tick t4 = new Tick();
List<Tick> ticks = new List<Tick> { t1, t2, t3 };
WhiningTwine e1 = new WhiningTwine(10, ticks, t4);
Assert.AreEqual(10, e1.CreatorId);
Assert.IsNotNull(e1.Ticks);
Assert.AreEqual(3, e1.Ticks.Count);
Assert.AreSame(t1, e1.Ticks[0]);
Assert.AreSame(t2, e1.Ticks[1]);
Assert.AreSame(t3, e1.Ticks[2]);
Assert.AreSame(t4, e1.RequestTick);
ByteList bytes = new ByteList();
e1.Encode(bytes);
WhiningTwine e2 = WhiningTwine.Create(bytes);
Assert.AreEqual(e1.CreatorId, e2.CreatorId);
Assert.AreEqual(e1.Ticks.Count, e2.Ticks.Count);
Assert.AreEqual(e1.Ticks[0].LogicalClock, e2.Ticks[0].LogicalClock);
Assert.AreEqual(e1.Ticks[0].HashCode, e2.Ticks[0].HashCode);
Assert.AreEqual(e1.Ticks[1].LogicalClock, e2.Ticks[1].LogicalClock);
Assert.AreEqual(e1.Ticks[1].HashCode, e2.Ticks[1].HashCode);
Assert.AreEqual(e1.Ticks[2].LogicalClock, e2.Ticks[2].LogicalClock);
Assert.AreEqual(e1.Ticks[2].HashCode, e2.Ticks[2].HashCode);
Assert.AreEqual(e1.RequestTick.LogicalClock, e2.RequestTick.LogicalClock);
Assert.AreEqual(e1.RequestTick.HashCode, e2.RequestTick.HashCode);
bytes.Clear();
e1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
e2 = WhiningTwine.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
e1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
e2 = WhiningTwine.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
bytes.Add(CreatorId); // Write out Creator's Id
if (Ticks == null)
{
Ticks = new List <Tick>(); // Write out the ticks that made up this whining twine
}
bytes.Add(Convert.ToInt16(Ticks.Count));
foreach (Tick tick in Ticks)
{
bytes.Add(tick);
}
bytes.Add(RequestTick);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
base.Encode(bytes);
if (ANumber == null)
{
ANumber = string.Empty;
}
if (FirstName == null)
{
FirstName = string.Empty;
}
if (LastName == null)
{
LastName = string.Empty;
}
bytes.AddObjects((byte)AgentType,
(byte)AgentStatus,
ANumber,
FirstName,
LastName,
Strength,
Speed,
Points,
Location);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
lock (myLock)
{
bytes.Add(Convert.ToInt16(agents.Count));
foreach (AgentInfo component in agents)
{
bytes.Add(component);
}
}
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void TickTester_CheckEncodeDecode()
{
Tick tick1 = new Tick(10);
tick1.LogicalClock = 100;
ByteList bytes = new ByteList();
tick1.Encode(bytes);
Tick tick2 = Tick.Create(bytes);
Assert.AreEqual(10, tick1.ForAgentId);
Assert.AreEqual(tick1.LogicalClock, tick2.LogicalClock);
tick1.LogicalClock = 0;
bytes = new ByteList();
tick1.Encode(bytes);
tick2 = Tick.Create(bytes);
Assert.AreEqual(tick1.LogicalClock, tick2.LogicalClock);
tick1.LogicalClock = Int32.MaxValue;
bytes = new ByteList();
tick1.Encode(bytes);
tick2 = Tick.Create(bytes);
Assert.AreEqual(tick1.ForAgentId, tick1.ForAgentId);
Assert.AreEqual(tick1.LogicalClock, tick2.LogicalClock);
bytes.Clear();
tick1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
tick2 = Tick.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
tick1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
tick2 = Tick.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
public void Bomb_CheckEncodeAndDecode()
{
Tick t1 = new Tick();
List<Excuse> eList = new List<Excuse> { CreateExcuse(10), CreateExcuse(11), CreateExcuse(12) };
List<WhiningTwine> wtList = new List<WhiningTwine> { CreateTwine(20), CreateTwine(21), CreateTwine(22) };
Bomb b1 = new Bomb(1, eList, wtList, t1);
Assert.AreEqual(1, b1.CreatorId);
Assert.AreSame(eList, b1.Excuses);
Assert.AreSame(wtList, b1.Twine);
Assert.AreSame(t1, b1.BuiltOnTick);
ByteList bytes = new ByteList();
b1.Encode(bytes);
Bomb b2 = Bomb.Create(bytes);
Assert.AreEqual(b1.CreatorId, b2.CreatorId);
Assert.AreEqual(b1.Excuses.Count, b2.Excuses.Count);
Assert.AreEqual(b1.Twine.Count, b2.Twine.Count);
Assert.AreEqual(b1.BuiltOnTick.LogicalClock, b2.BuiltOnTick.LogicalClock);
Assert.AreEqual(b1.BuiltOnTick.HashCode, b2.BuiltOnTick.HashCode);
bytes.Clear();
b1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
b2 = Bomb.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
b1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
b2 = Bomb.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
public void AgentList_CheckEncodeAndDecode()
{
AgentInfo info1 = new AgentInfo(10, AgentInfo.PossibleAgentType.ExcuseGenerator);
AgentInfo info2 = new AgentInfo(11, AgentInfo.PossibleAgentType.WhiningSpinner);
AgentInfo info3 = new AgentInfo(12, AgentInfo.PossibleAgentType.BrilliantStudent);
AgentList list1 = new AgentList();
list1.Add(info1);
list1.Add(info2);
list1.Add(info3);
ByteList bytes = new ByteList();
list1.Encode(bytes);
AgentList list2 = AgentList.Create(bytes);
Assert.AreEqual(3, list2.Count);
Assert.AreEqual(10, list2[0].Id);
Assert.AreEqual(11, list2[1].Id);
Assert.AreEqual(12, list2[2].Id);
bytes.Clear();
list1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
list2 = AgentList.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
list1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
list2 = AgentList.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.AddObjects(Width, Height); // Write out Width and Height
Int16 SidewalkCount = (SidewalkSquares == null) ? (Int16) 0 : Convert.ToInt16(SidewalkSquares.Count);
bytes.Add(SidewalkCount);
if (SidewalkSquares!=null)
foreach (FieldLocation loc in SidewalkSquares)
bytes.Add(loc);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.Add(CreatorId); // Write out Creator's Id
if (Ticks == null) Ticks = new List<Tick>(); // Write out the ticks that made up this whining twine
bytes.Add(Convert.ToInt16(Ticks.Count));
foreach (Tick tick in Ticks)
bytes.Add(tick);
bytes.Add(RequestTick);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
bytes.Add(CreatorId); // Write out Creator's Id
if (Excuses == null)
{
Excuses = new List <Excuse>();
}
bytes.Add(Convert.ToInt16(Excuses.Count));
foreach (Excuse excuse in Excuses)
{
bytes.Add(excuse);
}
if (Twine == null)
{
Twine = new List <WhiningTwine>();
}
bytes.Add(Convert.ToInt16(Twine.Count));
foreach (WhiningTwine twine in Twine)
{
bytes.Add(twine);
}
bytes.Add(BuiltOnTick);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void JoinGame_EncodingAndDecoding()
{
AgentInfo agentInfo = new AgentInfo(1001, AgentInfo.PossibleAgentType.BrilliantStudent) { ANumber = "A0001", FirstName = "Joe", LastName = "Jone" };
JoinGame jg1 = new JoinGame(10, agentInfo);
Assert.AreEqual(10, jg1.GameId);
Assert.AreSame(agentInfo, jg1.AgentInfo);
ByteList bytes = new ByteList();
jg1.Encode(bytes);
JoinGame jg2 = JoinGame.Create(bytes);
Assert.AreEqual(jg1.GameId, jg2.GameId);
bytes.Clear();
jg1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
jg2 = JoinGame.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
jg1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
jg2 = JoinGame.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.Add(CreatorId); // Write out Creator's Id
if (Excuses == null) Excuses = new List<Excuse>();
bytes.Add(Convert.ToInt16(Excuses.Count));
foreach (Excuse excuse in Excuses)
bytes.Add(excuse);
if (Twine == null) Twine = new List<WhiningTwine>();
bytes.Add(Convert.ToInt16(Twine.Count));
foreach (WhiningTwine twine in Twine)
bytes.Add(twine);
bytes.Add(BuiltOnTick);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes
/// </summary>
/// <param name="bytes"></param>
public virtual void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.AddObjects(MessageNr, ConversationId);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void ByteList_WriteAndAddMethods()
{
ByteList myBytes = new ByteList();
// Case: Write out a boolean of True
myBytes.Clear();
myBytes.Add(true);
Assert.IsNotNull(myBytes);
Assert.AreEqual(1, myBytes.Length);
Assert.AreEqual(1, myBytes[0]);
// Case: Write out a boolean of False
myBytes.Clear();
myBytes.Add(false);
Assert.IsNotNull(myBytes);
Assert.AreEqual(1, myBytes.Length);
Assert.AreEqual(0, myBytes[0]);
// Case: Write out a Byte
myBytes.Clear();
myBytes.Add((byte)4);
Assert.IsNotNull(myBytes);
Assert.AreEqual(1, myBytes.Length);
Assert.AreEqual((byte) 4, myBytes[0]);
// Case: Write out a Char
myBytes.Clear();
myBytes.Add('A');
Assert.IsNotNull(myBytes);
Assert.AreEqual(2, myBytes.Length);
Assert.AreEqual(65, myBytes[0]);
Assert.AreEqual(0, myBytes[1]);
// Case: Write out a Int16
myBytes.Clear();
myBytes.Add((Int16) 7);
Assert.IsNotNull(myBytes);
Assert.AreEqual(2, myBytes.Length);
Assert.AreEqual(0, myBytes[0]);
Assert.AreEqual(7, myBytes[1]);
// Case: Write out a Int16
myBytes.Clear();
myBytes.Add(Int16.MaxValue);
Assert.IsNotNull(myBytes);
Assert.AreEqual(2, myBytes.Length);
Assert.AreEqual(127, myBytes[0]);
Assert.AreEqual(255, myBytes[1]);
// Case: Write out a Int32
myBytes.Clear();
myBytes.Add((Int32) 7);
Assert.IsNotNull(myBytes);
Assert.AreEqual(4, myBytes.Length);
for (int i = 0; i < 3; i++) Assert.AreEqual(0, myBytes[i]);
Assert.AreEqual(7, myBytes[3]);
// Case: Write out a Int32
myBytes.Clear();
myBytes.Add(Int32.MaxValue);
Assert.IsNotNull(myBytes);
Assert.AreEqual(4, myBytes.Length);
Assert.AreEqual(127, myBytes[0]);
for (int i = 1; i < 4; i++) Assert.AreEqual(255, myBytes[i]);
// Case: Write out a Int64
myBytes.Clear();
myBytes.Add((Int64) 7);
Assert.IsNotNull(myBytes);
Assert.AreEqual(8, myBytes.Length);
for (int i=0; i<7; i++) Assert.AreEqual(0, myBytes[i]);
Assert.AreEqual(7, myBytes[7]);
// Case 7: Write out a Int64
myBytes.Clear();
myBytes.Add(Int64.MaxValue);
Assert.IsNotNull(myBytes);
Assert.AreEqual(8, myBytes.Length);
Assert.AreEqual(127, myBytes[0]);
for (int i = 1; i < 8; i++) Assert.AreEqual(255, myBytes[i]);
// Case: Write out a Single Precision Real
myBytes.Clear();
myBytes.Add((float) 7.7 );
Assert.IsNotNull(myBytes);
Assert.AreEqual(4, myBytes.Length);
// Case: Write out a Double Precision Real
myBytes.Clear();
myBytes.Add((float)7.7);
Assert.IsNotNull(myBytes);
Assert.AreEqual(4, myBytes.Length);
// Case: Write out a Byte Array
myBytes.Clear();
myBytes.Add(new byte[] { 1, 2, 3, 4, 5, 6 });
Assert.AreEqual(6, myBytes.Length);
for (int i = 0; i < 6; i++) Assert.AreEqual(i+1, myBytes[i]);
// Case: Write out a string
myBytes.Clear();
myBytes.Add((string) null);
Assert.AreEqual(2, myBytes.Length);
Assert.AreEqual(0, myBytes[0]);
Assert.AreEqual(0, myBytes[1]);
// Case: Write out a string
myBytes.Clear();
myBytes.Add(string.Empty);
Assert.AreEqual(2, myBytes.Length);
Assert.AreEqual(0, myBytes[0]);
Assert.AreEqual(0, myBytes[1]);
// Case 11: Write out a string
myBytes = new ByteList("abc");
Assert.AreEqual(2 + 2*3, myBytes.Length);
Assert.AreEqual(0, myBytes[0]);
Assert.AreEqual(2*3, myBytes[1]);
// Note AddObjects and AddObject methods were tested with constructors
}
public void PlayingFieldLayout_CheckEncodeAndDecode()
{
PlayingFieldLayout pfl1 = new PlayingFieldLayout(20, 30);
Assert.AreEqual(20, pfl1.Width);
Assert.AreEqual(30, pfl1.Height);
Assert.IsNotNull(pfl1.SidewalkSquares);
List<FieldLocation> flList = new List<FieldLocation> { new FieldLocation(1, 1), new FieldLocation(2, 1) };
pfl1.SidewalkSquares = flList;
Assert.AreSame(flList, pfl1.SidewalkSquares);
ByteList bytes = new ByteList();
pfl1.Encode(bytes);
PlayingFieldLayout pfl2 = PlayingFieldLayout.Create(bytes);
Assert.AreEqual(pfl1.Width, pfl2.Width);
Assert.AreEqual(pfl1.Height, pfl2.Height);
Assert.IsNotNull(pfl2.SidewalkSquares);
Assert.AreEqual(pfl1.SidewalkSquares.Count, pfl1.SidewalkSquares.Count);
bytes.Clear();
pfl1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
pfl2 = PlayingFieldLayout.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
pfl1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
pfl2 = PlayingFieldLayout.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
pfl1 = new PlayingFieldLayout(100, 100);
SetUpSidewalks(pfl1);
Assert.AreEqual(100, pfl1.Width);
Assert.AreEqual(100, pfl1.Height);
Assert.IsNotNull(pfl1.SidewalkSquares);
bytes = new ByteList();
pfl1.Encode(bytes);
pfl2 = PlayingFieldLayout.Create(bytes);
Assert.AreEqual(pfl1.Width, pfl2.Width);
Assert.AreEqual(pfl1.Height, pfl2.Height);
Assert.IsNotNull(pfl2.SidewalkSquares);
Assert.AreEqual(pfl1.SidewalkSquares.Count, pfl1.SidewalkSquares.Count);
pfl1 = new PlayingFieldLayout(200, 300);
SetUpSidewalks(pfl1);
Assert.AreEqual(200, pfl1.Width);
Assert.AreEqual(300, pfl1.Height);
Assert.IsNotNull(pfl1.SidewalkSquares);
bytes = new ByteList();
pfl1.Encode(bytes);
pfl2 = PlayingFieldLayout.Create(bytes);
Assert.AreEqual(pfl1.Width, pfl2.Width);
Assert.AreEqual(pfl1.Height, pfl2.Height);
Assert.IsNotNull(pfl2.SidewalkSquares);
Assert.AreEqual(pfl1.SidewalkSquares.Count, pfl1.SidewalkSquares.Count);
}
public void AgentInfo_CheckEncodeAndDecode()
{
EndPoint ep = new EndPoint("129.123.7.24:1345");
AgentInfo info1 = new AgentInfo(20, AgentInfo.PossibleAgentType.WhiningSpinner, ep)
{
ANumber = "A00001",
FirstName = "Joe",
LastName = "Jones",
Location = new FieldLocation(10, 20, false),
Strength = 1200.5,
Speed = 1500.0
};
ByteList bytes = new ByteList();
info1.Encode(bytes);
AgentInfo info2 = AgentInfo.Create(bytes);
Assert.AreEqual(info1.Id, info2.Id);
Assert.AreEqual(info1.AgentType, info2.AgentType);
Assert.AreEqual(info1.ANumber, info2.ANumber);
Assert.AreEqual(info1.FirstName, info2.FirstName);
Assert.AreEqual(info1.LastName, info2.LastName);
Assert.AreEqual(info1.Strength, info2.Strength);
Assert.AreEqual(info1.Speed, info2.Speed);
Assert.AreEqual(info1.Points, info2.Points);
Assert.AreEqual(info1.Location.X, info2.Location.X);
Assert.AreEqual(info1.Location.Y, info2.Location.Y);
Assert.AreEqual(info1.CommunicationEndPoint.Address, info2.CommunicationEndPoint.Address);
Assert.AreEqual(info1.CommunicationEndPoint.Port, info2.CommunicationEndPoint.Port);
bytes.Clear();
info1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
info2 = AgentInfo.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
info1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
info2 = AgentInfo.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
/// <summary>
/// This method encodes
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out this class id first
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
base.Encode(bytes); // Encode stuff from base class
bytes.Add(Convert.ToByte(ReplyType)); // Write out a place holder for the length
bytes.Add(Convert.ToByte(Status)); // Write out a place holder for the length
if (Note == null) Note = string.Empty;
bytes.Add(Note);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.Add(ProcessId); // Write out a place holder for the length
bytes.Add(SeqNumber);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
base.Encode(bytes);
if (ANumber == null)
ANumber = string.Empty;
if (FirstName == null)
FirstName = string.Empty;
if (LastName == null)
LastName = string.Empty;
bytes.AddObjects( (byte) AgentType,
(byte) AgentStatus,
ANumber,
FirstName,
LastName,
Strength,
Speed,
Points,
Location);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void EndPoint_CheckEncodeAndDecode()
{
Common.EndPoint ep1 = new Common.EndPoint(3255420, 3004);
Assert.AreEqual(3255420, ep1.Address);
Assert.AreEqual(3004, ep1.Port);
ByteList bytes = new ByteList();
ep1.Encode(bytes);
Common.EndPoint ep2 = Common.EndPoint.Create(bytes);
Assert.AreEqual(ep1.Address, ep2.Address);
Assert.AreEqual(ep1.Port, ep2.Port);
bytes.Clear();
ep1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
ep2 = Common.EndPoint.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
ep1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
ep2 = Common.EndPoint.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.AddObjects(X, Y, Immutable); // Write out X, Y, and Immutable properties
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.AddObjects(ForAgentId, LogicalClock, HashCode); // Write out Address and Port
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
public void GameConfiguration_CheckEncodeAndDecode()
{
GameConfiguration gc1 = new GameConfiguration();
gc1.PlayingFieldWidth = 50;
gc1.PlayingFieldHeight = 51;
gc1.BrilliantStudentRegistrationMin = 10;
gc1.BrilliantStudentRegistrationMax = 11;
gc1.BrilliantStudentInitialStrength = 2.1F;
gc1.BrilliantStudentBaseSpeed = 2.2F;
gc1.BrilliantStudentSidewalkSpeedMultiplier = 2.3F;
gc1.BrilliantStudentDeathToZombieDelay = 2.4F;
gc1.ExcuseGeneratorRegistrationMin = 12;
gc1.ExcuseGeneratorRegistrationMax = 13;
gc1.ExcuseGeneratorInitialStrength = 2.5F;
gc1.NumberOfTicksRequiredToBuildTwine = 3;
gc1.WhiningSpinnerRegistrationMin = 14;
gc1.WhiningSpinnerRegistrationMax = 15;
gc1.WhiningSpinnerInitialStrength = 2.8F;
gc1.NumberOfTicksRequiredToBuildTwine = 2;
gc1.ZombieInitialStrengthMin = 16;
gc1.ZombieInitialStrengthMax = 17;
gc1.ZombieInitialSpeedMax = 3.1F;
gc1.ZombieInitialSpeedMin = 3.2F;
gc1.ZombieSidewalkSpeedMultiplier = 3.3F;
gc1.ZombieCreationRate = 3.4F;
gc1.ZombieCreationAcceleration = 3.5F;
gc1.ZombieEatingRate = 3.6F;
gc1.ZombieStrengthIncreaseForEatingStudent = 3.7F;
gc1.ZombieStrengthIncreaseForExcuseGenerator = 3.8F;
gc1.ZombieStrengthIncreaseForWhiningSpinner = 3.9F;
gc1.MaxEatingDistance = 0.5F;
gc1.MaxEatingDistance = 4.5F;
gc1.RefereeRegistrationMin = 22;
gc1.RefereeRegistrationMax = 23;
gc1.BombExcuseDamage = 18;
gc1.BombTwinePerSquareOfDistance = 4.0F;
gc1.BombDamageDiffusionFactor = 4.1F;
gc1.TickLifetime = 19;
gc1.TicksToStrengthRatio = 4.2F;
ByteList bytes = new ByteList();
gc1.Encode(bytes);
GameConfiguration gc2 = GameConfiguration.Create(bytes);
Assert.AreEqual(gc1.PlayingFieldWidth, gc2.PlayingFieldWidth);
Assert.AreEqual(gc1.PlayingFieldHeight, gc2.PlayingFieldHeight);
Assert.AreEqual(gc1.BrilliantStudentRegistrationMin, gc2.BrilliantStudentRegistrationMin);
Assert.AreEqual(gc1.BrilliantStudentRegistrationMax, gc2.BrilliantStudentRegistrationMax);
Assert.AreEqual(gc1.BrilliantStudentInitialStrength, gc2.BrilliantStudentInitialStrength);
Assert.AreEqual(gc1.BrilliantStudentBaseSpeed, gc2.BrilliantStudentBaseSpeed);
Assert.AreEqual(gc1.BrilliantStudentSidewalkSpeedMultiplier, gc2.BrilliantStudentSidewalkSpeedMultiplier);
Assert.AreEqual(gc1.BrilliantStudentDeathToZombieDelay, gc2.BrilliantStudentDeathToZombieDelay);
Assert.AreEqual(gc1.ExcuseGeneratorRegistrationMin, gc2.ExcuseGeneratorRegistrationMin);
Assert.AreEqual(gc1.ExcuseGeneratorRegistrationMax, gc2.ExcuseGeneratorRegistrationMax);
Assert.AreEqual(gc1.ExcuseGeneratorInitialStrength, gc2.ExcuseGeneratorInitialStrength);
Assert.AreEqual(gc1.NumberOfTicksRequiredToBuildAnExcuse, gc2.NumberOfTicksRequiredToBuildAnExcuse);
Assert.AreEqual(gc1.WhiningSpinnerRegistrationMin, gc2.WhiningSpinnerRegistrationMin);
Assert.AreEqual(gc1.WhiningSpinnerRegistrationMax, gc2.WhiningSpinnerRegistrationMax);
Assert.AreEqual(gc1.WhiningSpinnerInitialStrength, gc2.WhiningSpinnerInitialStrength);
Assert.AreEqual(gc1.NumberOfTicksRequiredToBuildTwine, gc2.NumberOfTicksRequiredToBuildTwine);
Assert.AreEqual(gc1.ZombieInitialStrengthMin, gc2.ZombieInitialStrengthMin);
Assert.AreEqual(gc1.ZombieInitialStrengthMax, gc2.ZombieInitialStrengthMax);
Assert.AreEqual(gc1.ZombieInitialSpeedMax, gc2.ZombieInitialSpeedMax);
Assert.AreEqual(gc1.ZombieInitialSpeedMin, gc2.ZombieInitialSpeedMin);
Assert.AreEqual(gc1.ZombieSidewalkSpeedMultiplier, gc2.ZombieSidewalkSpeedMultiplier);
Assert.AreEqual(gc1.ZombieCreationRate, gc2.ZombieCreationRate);
Assert.AreEqual(gc1.ZombieCreationAcceleration, gc2.ZombieCreationAcceleration);
Assert.AreEqual(gc1.ZombieEatingRate, gc2.ZombieEatingRate);
Assert.AreEqual(gc1.ZombieStrengthIncreaseForEatingStudent, gc2.ZombieStrengthIncreaseForEatingStudent);
Assert.AreEqual(gc1.ZombieStrengthIncreaseForExcuseGenerator, gc2.ZombieStrengthIncreaseForExcuseGenerator);
Assert.AreEqual(gc1.ZombieStrengthIncreaseForWhiningSpinner, gc2.ZombieStrengthIncreaseForWhiningSpinner);
Assert.AreEqual(gc1.MinEatingDistance, gc2.MinEatingDistance);
Assert.AreEqual(gc1.MaxEatingDistance, gc2.MaxEatingDistance);
Assert.AreEqual(gc1.RefereeRegistrationMin, gc2.RefereeRegistrationMin);
Assert.AreEqual(gc1.RefereeRegistrationMax, gc2.RefereeRegistrationMax);
Assert.AreEqual(gc1.BombExcuseDamage, gc2.BombExcuseDamage);
Assert.AreEqual(gc1.BombTwinePerSquareOfDistance, gc2.BombTwinePerSquareOfDistance);
Assert.AreEqual(gc1.BombDamageDiffusionFactor, gc2.BombDamageDiffusionFactor);
Assert.AreEqual(gc1.TickLifetime, gc2.TickLifetime);
Assert.AreEqual(gc1.TicksToStrengthRatio, gc2.TicksToStrengthRatio);
bytes.Clear();
gc1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
gc2 = GameConfiguration.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
gc1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
gc2 = GameConfiguration.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
public void AckNak_CheckEncodeDecode()
{
Tick t1 = new Tick();
AckNak m1 = new AckNak(Reply.PossibleStatus.Success, 10, t1, "Test Message", "Test Note");
Assert.AreEqual(Reply.PossibleTypes.AckNak, m1.ReplyType);
Assert.AreEqual(Reply.PossibleStatus.Success, m1.Status);
Assert.AreEqual(10, m1.IntResult);
Assert.AreSame(t1, m1.ObjResult);
Assert.AreEqual("Test Message", m1.Message);
Assert.AreEqual("Test Note", m1.Note);
ByteList bytes = new ByteList();
m1.Encode(bytes);
AckNak m2 = AckNak.Create(bytes);
Assert.AreEqual(m1.Status, m2.Status);
Assert.AreEqual(m1.IntResult, m2.IntResult);
Assert.AreEqual(((Tick)m1.ObjResult).LogicalClock, ((Tick)m2.ObjResult).LogicalClock);
Assert.AreEqual(m1.Message, m2.Message);
Assert.AreEqual(m1.Note, m2.Note);
bytes.Clear();
m1.Encode(bytes);
bytes.GetByte(); // Read one byte, which will throw the length off
try
{
m2 = AckNak.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
bytes.Clear();
m1.Encode(bytes);
bytes.Add((byte)100); // Add a byte
bytes.GetByte(); // Read one byte, which will make the ID wrong
try
{
m2 = AckNak.Create(bytes);
Assert.Fail("Expected an exception to be thrown");
}
catch (ApplicationException)
{
}
}
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out this class id first
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16)0); // Write out a place holder for the length
base.Encode(bytes); // Encode the part of the object defined
// by the base class
bytes.AddObjects(ThrowingBrilliantStudentId, Bomb, TowardsSquare, EnablingTick);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}
/// <summary>
/// This method encodes an object of this class into a byte list
/// </summary>
/// <param name="bytes"></param>
public override void Encode(ByteList bytes)
{
bytes.Add(ClassId); // Write out the class type
Int16 lengthPos = bytes.CurrentWritePosition; // Get the current write position, so we
// can write the length here later
bytes.Add((Int16) 0); // Write out a place holder for the length
bytes.AddObjects(
PlayingFieldWidth,
PlayingFieldHeight,
BrilliantStudentRegistrationMin,
BrilliantStudentRegistrationMax,
BrilliantStudentInitialStrength,
BrilliantStudentBaseSpeed,
BrilliantStudentSidewalkSpeedMultiplier,
BrilliantStudentDeathToZombieDelay,
ExcuseGeneratorRegistrationMin,
ExcuseGeneratorRegistrationMax,
ExcuseGeneratorInitialStrength,
NumberOfTicksRequiredToBuildAnExcuse,
WhiningSpinnerRegistrationMin,
WhiningSpinnerRegistrationMax,
WhiningSpinnerInitialStrength,
NumberOfTicksRequiredToBuildTwine,
ZombieInitialStrengthMin,
ZombieInitialStrengthMax,
ZombieInitialSpeedMax,
ZombieInitialSpeedMin,
ZombieSidewalkSpeedMultiplier,
ZombieCreationRate,
ZombieCreationAcceleration,
ZombieEatingRate,
ZombieStrengthIncreaseForEatingStudent,
ZombieStrengthIncreaseForExcuseGenerator,
ZombieStrengthIncreaseForWhiningSpinner,
MinEatingDistance,
MaxEatingDistance,
RefereeRegistrationMin,
RefereeRegistrationMax,
BombExcuseDamage,
BombTwinePerSquareOfDistance,
BombDamageDiffusionFactor,
TickInterval,
TickLifetime,
TicksToStrengthRatio);
Int16 length = Convert.ToInt16(bytes.CurrentWritePosition - lengthPos - 2);
bytes.WriteInt16To(lengthPos, length); // Write out the length of this object
}