public void TestWriteObject()
{
try
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
message.ClearBody();
message.WriteObject("test");
message.WriteObject((Char)'a');
message.WriteObject((Boolean)false);
message.WriteObject((Byte)((byte)2));
message.WriteObject((Int16)((short)2));
message.WriteObject((Int32)2);
message.WriteObject((Int64)2L);
message.WriteObject((Single)2.0f);
message.WriteObject((Double)2.0);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
try
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
message.ClearBody();
message.WriteObject(new Object());
Assert.Fail("should throw an exception");
}
catch (MessageFormatException)
{
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void TestReset()
{
ActiveMQStreamMessage streamMessage = new ActiveMQStreamMessage();
try
{
streamMessage.WriteDouble(24.5);
streamMessage.WriteInt64(311);
}
catch (MessageNotWriteableException)
{
Assert.Fail("should be writeable");
}
streamMessage.Reset();
try
{
Assert.IsTrue(streamMessage.ReadOnlyBody);
Assert.AreEqual(streamMessage.ReadDouble(), 24.5, 0);
Assert.AreEqual(streamMessage.ReadInt64(), 311);
}
catch (MessageNotReadableException)
{
Assert.Fail("should be readable");
}
try
{
streamMessage.WriteInt32(33);
Assert.Fail("should throw exception");
}
catch (MessageNotWriteableException)
{
}
}
protected override IStreamMessage DoCreateStreamMessage()
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
message.Connection = this.connection;
return(message);
}
public void TestCommand()
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
Assert.IsNull(message.Content);
Assert.IsTrue(!message.ReadOnlyBody);
Assert.IsTrue(!message.ReadOnlyProperties);
}
//
// Write the booleans that this object uses to a BooleanStream
//
public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs)
{
ActiveMQStreamMessage info = (ActiveMQStreamMessage)o;
int rc = base.TightMarshal1(wireFormat, info, bs);
return(rc + 0);
}
public void TestReadBigString()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
// Test with a 1Meg String
StringBuilder bigSB = new StringBuilder(1024 * 1024);
for (int i = 0; i < 1024 * 1024; i++)
{
bigSB.Append((char)'a' + i % 26);
}
String bigString = bigSB.ToString();
msg.WriteString(bigString);
msg.Reset();
Assert.AreEqual(bigString, msg.ReadString());
}
public void TestClearBody()
{
ActiveMQStreamMessage streamMessage = new ActiveMQStreamMessage();
try
{
streamMessage.WriteObject((Int64)2);
streamMessage.ClearBody();
Assert.IsFalse(streamMessage.ReadOnlyBody);
streamMessage.WriteObject((Int64)2);
streamMessage.ReadObject();
Assert.Fail("should throw exception");
}
catch (MessageNotReadableException)
{
}
catch (MessageNotWriteableException)
{
Assert.Fail("should be writeable");
}
}
public void TestReadOnlyBody()
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
try
{
message.WriteBoolean(true);
message.WriteByte((byte)1);
message.WriteBytes(new byte[1]);
message.WriteBytes(new byte[3], 0, 2);
message.WriteChar('a');
message.WriteDouble(1.5);
message.WriteSingle((float)1.5);
message.WriteInt32(1);
message.WriteInt64(1);
message.WriteObject("stringobj");
message.WriteInt16((short)1);
message.WriteString("string");
}
catch (MessageNotWriteableException)
{
Assert.Fail("Should be writeable");
}
message.Reset();
try
{
message.ReadBoolean();
message.ReadByte();
Assert.AreEqual(1, message.ReadBytes(new byte[10]));
Assert.AreEqual(-1, message.ReadBytes(new byte[10]));
Assert.AreEqual(2, message.ReadBytes(new byte[10]));
Assert.AreEqual(-1, message.ReadBytes(new byte[10]));
message.ReadChar();
message.ReadDouble();
message.ReadSingle();
message.ReadInt32();
message.ReadInt64();
message.ReadString();
message.ReadInt16();
message.ReadString();
}
catch (MessageNotReadableException)
{
Assert.Fail("Should be readable");
}
try
{
message.WriteBoolean(true);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteByte((byte)1);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteBytes(new byte[1]);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteBytes(new byte[3], 0, 2);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try {
message.WriteChar('a');
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteDouble(1.5);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteSingle((float)1.5);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteInt32(1);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteInt64(1);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteObject("stringobj");
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteSingle((short)1);
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
try
{
message.WriteString("string");
Assert.Fail("Should have thrown exception");
}
catch (MessageNotWriteableException)
{
}
}
public void TestReadObject()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
byte testByte = (byte)2;
msg.WriteByte(testByte);
msg.Reset();
Assert.IsTrue((byte)msg.ReadObject() == testByte);
msg.ClearBody();
short testShort = 3;
msg.WriteInt16(testShort);
msg.Reset();
Assert.IsTrue((short)msg.ReadObject() == testShort);
msg.ClearBody();
int testInt = 4;
msg.WriteInt32(testInt);
msg.Reset();
Assert.IsTrue((int)msg.ReadObject() == testInt);
msg.ClearBody();
long testLong = 6L;
msg.WriteInt64(testLong);
msg.Reset();
Assert.IsTrue((long)msg.ReadObject() == testLong);
msg.ClearBody();
float testFloat = 6.6f;
msg.WriteSingle(testFloat);
msg.Reset();
Assert.IsTrue((float)msg.ReadObject() == testFloat);
msg.ClearBody();
double testDouble = 7.7d;
msg.WriteDouble(testDouble);
msg.Reset();
Assert.IsTrue((double)msg.ReadObject() == testDouble);
msg.ClearBody();
char testChar = 'z';
msg.WriteChar(testChar);
msg.Reset();
Assert.IsTrue((char)msg.ReadObject() == testChar);
msg.ClearBody();
byte[] data = new byte[50];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
msg.WriteBytes(data);
msg.Reset();
byte[] valid = (byte[])msg.ReadObject();
Assert.IsTrue(valid.Length == data.Length);
for (int i = 0; i < valid.Length; i++)
{
Assert.IsTrue(valid[i] == data[i]);
}
msg.ClearBody();
msg.WriteBoolean(true);
msg.Reset();
Assert.IsTrue((bool)msg.ReadObject());
}
public void TestReadBytes()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
byte[] test = new byte[50];
for (int i = 0; i < test.Length; i++)
{
test[i] = (byte)i;
}
msg.WriteBytes(test);
msg.Reset();
byte[] valid = new byte[test.Length];
msg.ReadBytes(valid);
for (int i = 0; i < valid.Length; i++)
{
Assert.IsTrue(valid[i] == test[i]);
}
msg.Reset();
try
{
msg.ReadByte();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt16();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt32();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt64();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadSingle();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadChar();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadString();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
}
public void TestReadString()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
byte testByte = (byte)2;
msg.WriteString(((Byte)testByte).ToString());
msg.Reset();
Assert.IsTrue(msg.ReadByte() == testByte);
msg.ClearBody();
short testShort = 3;
msg.WriteString(((Int16)testShort).ToString());
msg.Reset();
Assert.IsTrue(msg.ReadInt16() == testShort);
msg.ClearBody();
int testInt = 4;
msg.WriteString(((Int32)testInt).ToString());
msg.Reset();
Assert.IsTrue(msg.ReadInt32() == testInt);
msg.ClearBody();
long testLong = 6L;
msg.WriteString(((Int64)testLong).ToString());
msg.Reset();
Assert.IsTrue(msg.ReadInt64() == testLong);
msg.ClearBody();
float testFloat = 6.6f;
msg.WriteString(((Single)testFloat).ToString());
msg.Reset();
Assert.IsTrue(msg.ReadSingle() == testFloat);
msg.ClearBody();
double testDouble = 7.7d;
msg.WriteString(((Double)testDouble).ToString());
msg.Reset();
Assert.AreEqual(testDouble, msg.ReadDouble(), 0.05);
msg.ClearBody();
msg.WriteString("true");
msg.Reset();
Assert.IsTrue(msg.ReadBoolean());
msg.ClearBody();
msg.WriteString("a");
msg.Reset();
try
{
msg.ReadChar();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.ClearBody();
msg.WriteString("777");
msg.Reset();
try
{
msg.ReadBytes(new byte[3]);
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
}
public void TestReadDouble()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
double test = 4.4;
msg.WriteDouble(test);
msg.Reset();
Assert.IsTrue(msg.ReadDouble() == test);
msg.Reset();
Assert.IsTrue(msg.ReadString() == (test).ToString());
msg.Reset();
try
{
msg.ReadBoolean();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadByte();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt16();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt32();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt64();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadSingle();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadChar();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadBytes(new byte[1]);
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
}
public void TestReadLong()
{
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
long test = 4L;
msg.WriteInt64(test);
msg.Reset();
Assert.IsTrue(msg.ReadInt64() == test);
msg.Reset();
Assert.IsTrue(msg.ReadString() == (test).ToString());
msg.Reset();
try
{
msg.ReadBoolean();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadByte();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt16();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadInt32();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadSingle();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadDouble();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadChar();
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg.Reset();
try
{
msg.ReadBytes(new byte[1]);
Assert.Fail("Should have thrown exception");
}
catch (MessageFormatException)
{
}
msg = new ActiveMQStreamMessage();
msg.WriteObject((Int64)1);
// Reset so it's readable now
msg.Reset();
Assert.AreEqual((Int64)1, msg.ReadObject());
}
public void TestStreamMessageTransformation()
{
ActiveMQStreamMessage message = new ActiveMQStreamMessage();
Assert.AreSame(message, transformer.TransformMessage <ActiveMQMessage>(message));
}
