public void TestDecodeTinyInt()
{ //PASSED
Assert.AreEqual(0, PofHelper.DecodeTinyInt(PofConstants.V_INT_0));
Assert.AreEqual(22, PofHelper.DecodeTinyInt(PofConstants.V_INT_22));
Assert.AreEqual(-1, PofHelper.DecodeTinyInt(PofConstants.V_INT_NEG_1));
Assert.AreEqual(17, PofHelper.DecodeTinyInt(PofConstants.V_INT_17));
}
/// <summary>
/// Constructs a year-month interval value.
/// </summary>
/// <param name="years">
/// The number of years in the year-month interval.
/// </param>
/// <param name="months">
/// The number of months in the year-month interval.
/// </param>
public RawYearMonthInterval(int years, int months)
{
PofHelper.CheckYearMonthInterval(years, months);
m_years = years;
m_months = months;
}
public void TestIdFromPofHelper()
{
SimplePofContext context = new SimplePofContext();
context.RegisterUserType(9999, typeof(MyCollection), new MySerializer());
Assert.AreEqual(9999, PofHelper.GetPofTypeId(MyCollection.Instance.GetType(), context));
}
public void TestCheckTimeInterval()
{
PofHelper.CheckTimeInterval(9, 9, 9, 10);
PofHelper.CheckTimeInterval(0, 9, 9, 10);
PofHelper.CheckTimeInterval(0, 0, 9, 10);
PofHelper.CheckTimeInterval(0, 0, 0, 10);
}
public void TestSkipValue()
{
//PASSED
initPOFWriter();
pofwriter.WriteDate(0, new DateTime(2006, 8, 10, 12, 59, 11));
pofwriter.WriteDateTime(0, new DateTime(2006, 8, 10, 12, 59, 11));
pofwriter.WriteUniversalDateTime(0, new DateTime(2006, 8, 10, 12, 59, 11, 1));
pofwriter.WriteCharArray(0, new char[] { 'g', 't', 's' });
pofwriter.WriteArray(0, new object[] { 'g', "Gor", 55 });
pofwriter.WriteArray(0, new object[] { new int[] { 1, 2 }, new int[] { 3, 2, 4 } });
Hashtable ht = new Hashtable();
ht.Add(1, "t"); ht.Add(2, "g");
pofwriter.WriteObject(0, ht);
pofwriter.WriteByte(0, 0x00F0);
pofwriter.WriteInt32(0, 300);
initPOFReader();
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
PofHelper.SkipValue(reader);
Assert.AreEqual(PofConstants.T_INT32, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
Assert.AreEqual(300, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
}
/// <summary>
/// Incorporate one aggregatable value into the result.
/// </summary>
/// <remarks>
/// If the <paramref name="isFinal"/> parameter is <b>true</b>, the
/// given object is a partial result (returned by an individual
/// parallel aggregator) that should be incorporated into the final
/// result; otherwise, the object is a value extracted from an
/// <see cref="IInvocableCacheEntry"/>.
/// </remarks>
/// <param name="o">
/// The value to incorporate into the aggregated result.
/// </param>
/// <param name="isFinal">
/// <b>true</b> to indicate that the given object is a partial
/// result returned by a parallel aggregator.
/// </param>
protected override void Process(object o, bool isFinal)
{
if (o != null)
{
Decimal result = m_result;
if (isFinal)
{
// aggregate partial results packed into a byte array
byte[] buff = (byte[])o;
DataReader reader = new DataReader(new MemoryStream(buff));
int c = reader.ReadInt32();
if (c > 0)
{
Decimal dec = PofHelper.ReadDecimal(reader);
m_count += c;
m_result = Decimal.Add(result, dec);
}
}
else
{
Decimal dec = EnsureDecimal(o);
// collect partial results
m_count++;
m_result = Decimal.Add(result, dec);
}
}
}
public void TestResizeArray()
{
Object[] objArray = new object[] { new DateTime(1999, 1, 1, 12, 0, 0, 100), Int64.MinValue, -0.1F };
Assert.AreEqual(objArray.Length + 10, PofHelper.ResizeArray(objArray, objArray.Length + 10).Length);
Assert.AreEqual(objArray.Length, PofHelper.ResizeArray(objArray, objArray.Length).Length);
// Assert.AreEqual(objArray.Length - 2, PofHelper.ResizeArray(objArray, objArray.Length - 2).Length);
Assert.AreEqual(5, PofHelper.ResizeArray(null, 5).Length);
}
/// <summary>
/// Compute the expected pof type id based on the type.
/// </summary>
/// <param name="ctx">
/// Pof context.
/// </param>
/// <returns>
/// Pof type id or <see cref="PofConstants.T_UNKNOWN"/> if the type
/// is <c>null</c>.
/// </returns>
protected int GetPofTypeId(IPofContext ctx)
{
Type type = m_type;
return(m_type == null
? m_typeId
: PofHelper.GetPofTypeId(type, ctx));
}
/// <summary>
/// Update this PofValue.
/// </summary>
/// <remarks>
/// The changes made using this method will be immediately reflected
/// in the result of <see cref="IPofValue.GetValue()"/> method, but will not be
/// applied to the underlying POF stream until the
/// <see cref="IPofValue.ApplyChanges"/> method is invoked on the root IPofValue.
/// </remarks>
/// <param name="oValue">
/// New deserialized value for this PofValue.
/// </param>
public override void SetValue(object oValue)
{
base.SetValue(oValue);
if (oValue != null)
{
m_nType = PofHelper.GetPofTypeId(oValue.GetType(), PofContext);
}
}
/// <summary>
/// Internal constructor.
/// </summary>
/// <param name="hour">
/// The hours (0 through 23).
/// </param>
/// <param name="minute">
/// The minutes (0 through 59).
/// </param>
/// <param name="second">
/// The seconds (0 through 59).
/// </param>
/// <param name="nanosecond">
/// The nanoseconds (0 through 999999999).
/// </param>
private RawTime(int hour, int minute, int second, int nanosecond)
{
PofHelper.CheckTime(hour, minute, second, nanosecond);
m_hour = hour;
m_minute = minute;
m_second = second;
m_nanosecond = nanosecond;
}
public void TestSkipUniformValue()
{ //PASSED
// PLEASE DO NOTE, the method SkipUniformValue should be used only for Uniform_Arrays/Collections
initPOFWriter();
pofwriter.WriteInt32(0, 100);
pofwriter.WriteInt32(0, 200);
pofwriter.WriteInt32(0, 300);
initPOFReader();
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
Assert.AreEqual(PofConstants.T_INT32, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
Assert.AreEqual(300, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
initPOFWriter();
RawYearMonthInterval ymi = new RawYearMonthInterval(2, 10);
pofwriter.WriteRawYearMonthInterval(0, ymi);
pofwriter.WriteString(0, "skipping to string1");
pofwriter.WriteTimeInterval(0, new TimeSpan(4, 52, 10));
pofwriter.WriteString(0, "skipping to string2");
pofwriter.WriteDayTimeInterval(0, new TimeSpan(11, 12, 13, 14, 50));
pofwriter.WriteString(0, "skipping to string3");
pofwriter.WriteSingle(0, 120.34f);
pofwriter.WriteString(0, "skipping to string4");
pofwriter.WriteDouble(0, 1222.22);
pofwriter.WriteString(0, "skipping to string5");
pofwriter.WriteChar(0, 'A');
pofwriter.WriteString(0, "skipping to string6");
initPOFReader();
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_YEAR_MONTH_INTERVAL);
Assert.AreEqual("skipping to string1", pofreader.ReadString(0));
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_TIME_INTERVAL);
Assert.AreEqual("skipping to string2", pofreader.ReadString(0));
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_DAY_TIME_INTERVAL);
Assert.AreEqual("skipping to string3", pofreader.ReadString(0));
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_FLOAT32);
Assert.AreEqual("skipping to string4", pofreader.ReadString(0));
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_FLOAT64);
Assert.AreEqual("skipping to string5", pofreader.ReadString(0));
PofHelper.SkipUniformValue(reader, PofConstants.T_INT32);
PofHelper.SkipUniformValue(reader, PofConstants.T_CHAR);
Assert.AreEqual("skipping to string6", pofreader.ReadString(0));
}
/// <summary>
/// Construct a raw POF time value with a timezone.
/// </summary>
/// <param name="hour">
/// The hours (0 through 23).
/// </param>
/// <param name="minute">
/// The minutes (0 through 59).
/// </param>
/// <param name="second">
/// The seconds (0 through 59).
/// </param>
/// <param name="nanosecond">
/// The nanoseconds (0 through 999999999).
/// </param>
/// <param name="hourOffset">
/// The timezone offset in hours from UTC, for example 0 for BST, -5
/// for EST and 1 for CET.
/// </param>
/// <param name="minuteOffset">
/// The timezone offset in minutes, for example 0 (in most cases) or
/// 30.
/// </param>
public RawTime(int hour, int minute, int second, int nanosecond,
int hourOffset, int minuteOffset)
: this(hour, minute, second, nanosecond)
{
PofHelper.CheckTimeZone(hourOffset, minuteOffset);
m_timeZoneType = TZ_OFFSET;
m_hourOffset = hourOffset;
m_minuteOffset = minuteOffset;
}
public void TestWriteDate()
{ //PASSED
initPOFWriter();
PofHelper.WriteDate(writer, 2006, 8, 10);
PofHelper.WriteDate(writer, 2006, 8, 11);
initPOFReader();
Assert.AreEqual(new DateTime(2006, 8, 10), PofHelper.ReadDate(reader));
Assert.AreEqual(new DateTime(2006, 8, 11), PofHelper.ReadDate(reader));
}
public void TestConvertNumber()
{
Assert.AreEqual(null, PofHelper.ConvertNumber(null, PofConstants.N_BYTE));
Assert.AreEqual(111, PofHelper.ConvertNumber(111, PofConstants.N_BYTE));
Assert.AreEqual(6, PofHelper.ConvertNumber(6.0001, PofConstants.N_INT16));
Assert.AreEqual(11, PofHelper.ConvertNumber(11, PofConstants.N_INT32));
Assert.AreEqual(Int64.MaxValue, PofHelper.ConvertNumber(Int64.MaxValue, PofConstants.N_INT64));
Assert.AreEqual((Double)Int64.MaxValue, PofHelper.ConvertNumber(Int64.MaxValue, PofConstants.N_DOUBLE));
Assert.AreEqual(-0.1F, PofHelper.ConvertNumber(-0.1, PofConstants.N_SINGLE));
}
/// <summary>
/// Skip a single child value.
/// </summary>
/// <param name="reader">
/// Reader used to read child values.
/// </param>
protected void SkipChild(DataReader reader)
{
if (IsUniformCollection)
{
PofHelper.SkipUniformValue(reader, m_nElementType);
}
else
{
PofHelper.SkipValue(reader);
}
}
public void TestWriteTime()
{ //PASSED
initPOFWriter();
PofHelper.WriteTime(writer, 12, 59, 58, 0, 1, TimeSpan.Zero);
PofHelper.WriteTime(writer, 12, 59, 59, 0, 0, TimeSpan.Zero);
PofHelper.WriteTime(writer, 12, 59, 59, 0, 2, new TimeSpan(1, 0, 0));
initPOFReader();
Assert.AreEqual(new RawTime(12, 59, 58, 0, true), PofHelper.ReadRawTime(reader));
Assert.AreEqual(new RawTime(12, 59, 59, 0, false), PofHelper.ReadRawTime(reader));
Assert.AreEqual(new RawTime(12, 59, 59, 0, 1, 0), PofHelper.ReadRawTime(reader));
}
public void TestReadDate()
{ //PASSED
initPOFWriter();
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(11);
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(12);
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(13);
initPOFReader();
Assert.AreEqual(new DateTime(2006, 8, 11), PofHelper.ReadDate(reader));
Assert.AreEqual(new DateTime(2006, 8, 12), PofHelper.ReadDate(reader));
Assert.AreEqual(new DateTime(2006, 8, 13), PofHelper.ReadDate(reader));
}
public void TestPofTypeID()
{
Assert.AreEqual(PofConstants.T_BOOLEAN, PofHelper.GetPofTypeId(true.GetType(), new SimplePofContext()));
Assert.AreEqual(PofConstants.T_CHAR, PofHelper.GetPofTypeId('t'.GetType(), new SimplePofContext()));
Assert.AreEqual(PofConstants.T_INT16,
PofHelper.GetPofTypeId(Int16.MinValue.GetType(), new SimplePofContext()));
Assert.AreEqual(PofConstants.T_INT32, PofHelper.GetPofTypeId((-1).GetType(), new SimplePofContext()));
Assert.AreEqual(PofConstants.T_INT64,
PofHelper.GetPofTypeId(Int64.MaxValue.GetType(), new SimplePofContext()));
Assert.AreEqual(PofConstants.T_DATETIME,
PofHelper.GetPofTypeId(new DateTime(11, 11, 11, 11, 11, 11).GetType(),
new SimplePofContext()));
Assert.AreEqual(PofConstants.T_CHAR_STRING, PofHelper.GetPofTypeId("test".GetType(), new SimplePofContext()));
double[] uniformArray = new double[] { Double.MaxValue, 0, -1, Double.NegativeInfinity };
Assert.AreEqual(PofConstants.T_UNIFORM_ARRAY,
PofHelper.GetPofTypeId(uniformArray.GetType(), new SimplePofContext()));
Object[] objArray = new object[] { new DateTime(11, 11, 11), 13, Double.NaN };
Assert.AreEqual(PofConstants.T_ARRAY, PofHelper.GetPofTypeId(objArray.GetType(), new SimplePofContext()));
ArrayList al = new ArrayList();
al.Add(new DateTime(11, 11, 11));
al.Add(5.55);
Assert.AreEqual(PofConstants.T_COLLECTION, PofHelper.GetPofTypeId(al.GetType(), new SimplePofContext()));
Hashtable ht = new Hashtable();
ht.Add("now", new DateTime(2006, 8, 11, 12, 49, 0));
Assert.AreEqual(PofConstants.T_MAP, PofHelper.GetPofTypeId(ht.GetType(), new SimplePofContext()));
ICollection ll = new LinkedList <double>();
Assert.AreEqual(PofConstants.T_COLLECTION, PofHelper.GetPofTypeId(ll.GetType(), new SimplePofContext()));
Binary bin = new Binary(new byte[] { 1, 2, 3 });
Assert.AreEqual(PofConstants.T_OCTET_STRING, PofHelper.GetPofTypeId(bin.GetType(), new SimplePofContext()));
SimplePofContext ctx = new SimplePofContext();
Assert.AreEqual(PofConstants.T_OCTET_STRING, PofHelper.GetPofTypeId(typeof(byte[]), ctx));
Assert.AreEqual(PofConstants.T_ARRAY, PofHelper.GetPofTypeId(typeof(object[]), ctx));
Assert.AreEqual(PofConstants.T_ARRAY, PofHelper.GetPofTypeId(typeof(string[]), ctx));
ctx.RegisterUserType(1000, typeof(string[]), new PortableObjectSerializer(1000));
Assert.AreEqual(PofConstants.T_OCTET_STRING, PofHelper.GetPofTypeId(typeof(byte[]), ctx));
Assert.AreEqual(PofConstants.T_ARRAY, PofHelper.GetPofTypeId(typeof(object[]), ctx));
Assert.AreEqual(1000, PofHelper.GetPofTypeId(typeof(string[]), ctx));
}
public void TestSkipPackedInts()
{ //PASSED
initPOFWriter();
writer.WritePackedInt32(100);
writer.WritePackedInt32(200);
writer.WritePackedInt32(300);
initPOFReader();
PofHelper.SkipPackedInts(reader, 2);
Assert.AreEqual(300, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
}
public void TestReadTime()
{ //PASSED
initPOFWriter();
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(57); writer.WritePackedInt32(-100); writer.WritePackedInt32(0);
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(58); writer.WritePackedInt32(-100); writer.WritePackedInt32(0);
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(59); writer.WritePackedInt32(-100); writer.WritePackedInt32(0);
initPOFReader();
Assert.AreEqual(new RawTime(12, 59, 57, 100, false), PofHelper.ReadRawTime(reader));
Assert.AreEqual(new RawTime(12, 59, 58, 100, false), PofHelper.ReadRawTime(reader));
Assert.AreEqual(new RawTime(12, 59, 59, 100, false), PofHelper.ReadRawTime(reader));
}
public void TestToString()
{
DateTime date = new DateTime(1976, 4, 19);
RawTime timeUtc = new RawTime(13, 2, 30, 0, true);
RawTime time = new RawTime(13, 2, 30, 99, false);
RawTime timeOffset = new RawTime(13, 2, 30, 0, -1, 30);
RawDateTime datetimeUtc = new RawDateTime(date, timeUtc);
RawDateTime datetime = new RawDateTime(date, time);
RawDateTime datetimeOffset = new RawDateTime(date, timeOffset);
Assert.IsTrue(datetime.ToString().StartsWith(PofHelper.FormatDate(1976, 4, 19)));
Assert.IsTrue(datetimeUtc.ToString().EndsWith("13:02:30Z"));
Assert.IsTrue(datetime.ToString().EndsWith("13:02:30.000000099"));
Assert.IsTrue(datetimeOffset.ToString().EndsWith("13:02:30-01:30"));
}
public void TestReadAsDouble()
{ //PASSED
initPOFWriter();
writer.Write((double)0.0);
writer.Write((double)Double.MinValue);
writer.Write((double)PofConstants.V_INT_NEG_1);
writer.Write((double)Double.MaxValue);
pofwriter.WriteSingle(0, 11.234f);
initPOFReader();
Assert.AreEqual((double)0.0, PofHelper.ReadAsDouble(reader, PofConstants.T_FLOAT64));
Assert.AreEqual((double)Double.MinValue, PofHelper.ReadAsDouble(reader, PofConstants.T_FLOAT64));
Assert.AreEqual((double)PofConstants.V_INT_NEG_1, PofHelper.ReadAsDouble(reader, PofConstants.T_FLOAT64));
Assert.AreEqual((double)Double.MaxValue, PofHelper.ReadAsDouble(reader, PofConstants.T_FLOAT64));
Assert.AreEqual((Single)11.234, (Single)pofreader.ReadDouble(0));
}
public void TestReadChar()
{ //PASSED
initPOFWriter();
writer.Write('a');
writer.Write(char.MinValue);
writer.Write(char.MaxValue);
writer.Write((char)0x0080);
writer.Write((char)0x0800);
initPOFReader();
Assert.AreEqual('a', PofHelper.ReadChar(reader));
Assert.AreEqual(char.MinValue, PofHelper.ReadChar(reader));
Assert.AreEqual(char.MaxValue, PofHelper.ReadChar(reader));
Assert.AreEqual((char)0x0080, PofHelper.ReadChar(reader));
Assert.AreEqual((char)0x0800, PofHelper.ReadChar(reader));
}
public void TestReadAsChar()
{ //PASSED
initPOFWriter();
writer.Write('A');
writer.Write(char.MinValue);
writer.Write(char.MaxValue);
writer.WritePackedInt32(0x0080);
writer.Write((char)0x0800);
initPOFReader();
Assert.AreEqual('A', PofHelper.ReadAsChar(reader, PofConstants.T_OCTET));
Assert.AreEqual(char.MinValue, PofHelper.ReadAsChar(reader, PofConstants.T_CHAR));
Assert.AreEqual(char.MaxValue, PofHelper.ReadAsChar(reader, PofConstants.T_CHAR));
Assert.AreEqual((char)0x0080, PofHelper.ReadAsChar(reader, PofConstants.T_INT32));
Assert.AreEqual((char)0x0800, PofHelper.ReadAsChar(reader, PofConstants.T_CHAR));
}
/// <summary>
/// Determine if the given type is a user type known to this
/// <b>IPofContext</b>.
/// </summary>
/// <param name="type">
/// The type to test; must not be <c>null</c>.
/// </param>
/// <returns>
/// <b>true</b> iff the specified type is a valid user type.
/// </returns>
public override bool IsUserType(Type type)
{
bool fUserType = base.IsUserType(type);
if (!fUserType)
{
if (!PofHelper.IsIntrinsicPofType(type))
{
fUserType = typeof(IPortableObject).IsAssignableFrom(type) ||
typeof(ISerializable).IsAssignableFrom(type) ||
type.IsDefined(typeof(SerializableAttribute), false);
}
}
return(fUserType);
}
public void TestReadDateTime()
{ //PASSED
initPOFWriter();
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(11);
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(57); writer.WritePackedInt32(100); writer.WritePackedInt32(1);
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(12);
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(58); writer.WritePackedInt32(100); writer.WritePackedInt32(1);
writer.WritePackedInt32(2006); writer.WritePackedInt32(8); writer.WritePackedInt32(13);
writer.WritePackedInt32(12); writer.WritePackedInt32(59); writer.WritePackedInt32(59); writer.WritePackedInt32(100); writer.WritePackedInt32(1);
initPOFReader();
Assert.AreEqual(new DateTime(2006, 8, 11, 12, 59, 57, 100), PofHelper.ReadDateTime(reader));
Assert.AreEqual(new DateTime(2006, 8, 12, 12, 59, 58, 100), PofHelper.ReadDateTime(reader));
Assert.AreEqual(new DateTime(2006, 8, 13, 12, 59, 59, 100), PofHelper.ReadDateTime(reader));
}
public void TestReadAsSingle()
{ //PASSED
initPOFWriter();
writer.Write((float)0.0);
writer.Write((float)Int64.MinValue);
writer.Write((float)PofConstants.V_INT_NEG_1);
writer.Write((float)Int64.MaxValue);
initPOFReader();
Assert.AreEqual((float)0.0, PofHelper.ReadAsSingle(reader, PofConstants.T_FLOAT32));
Assert.AreEqual((float)Int64.MinValue, PofHelper.ReadAsSingle(reader, PofConstants.T_FLOAT32));
Assert.AreEqual((float)PofConstants.V_INT_NEG_1, PofHelper.ReadAsSingle(reader, PofConstants.T_FLOAT32));
Assert.AreEqual((float)Int64.MaxValue, PofHelper.ReadAsSingle(reader, PofConstants.T_FLOAT32));
initPOFWriter();
pofwriter.WriteDouble(0, 3000.123456);
initPOFReader();
Assert.AreEqual(3000.123456f, pofreader.ReadSingle(0));
}
public void TestDotNetTypeID()
{
SimplePofContext ctx = new SimplePofContext();
object o = new byte[0];
Assert.AreEqual(PofConstants.N_BYTE_ARRAY, PofHelper.GetDotNetTypeId(o, ctx));
o = new object[0];
Assert.AreEqual(PofConstants.N_OBJECT_ARRAY, PofHelper.GetDotNetTypeId(o, ctx));
o = new string[0];
Assert.AreEqual(PofConstants.N_OBJECT_ARRAY, PofHelper.GetDotNetTypeId(o, ctx));
ctx.RegisterUserType(1000, o.GetType(), new PortableObjectSerializer(1000));
o = new object[0];
Assert.AreEqual(PofConstants.N_OBJECT_ARRAY, PofHelper.GetDotNetTypeId(o, ctx));
o = new string[0];
Assert.AreEqual(PofConstants.N_USER_TYPE, PofHelper.GetDotNetTypeId(o, ctx));
}
/// <summary>
/// Send the given <b>DataWriter</b> through this Connection.
/// </summary>
/// <param name="writer">
/// The <b>DataWriter</b> to send.
/// </param>
public override void Send(DataWriter writer)
{
base.Send(writer);
var messageStream = (MemoryStream)writer.BaseStream;
int messageLength = (int)messageStream.Length - 5;
// see Connection.Send()
int lengthLength = PofHelper.LengthPackedInt32(messageLength);
int lengthPosition = 5 - lengthLength;
// encode the length
writer.Seek(lengthPosition, SeekOrigin.Begin);
writer.WritePackedInt32(messageLength);
bool secure = IsSecure;
Stream stream = Stream;
if (secure)
{
Monitor.Enter(stream);
}
try
{
stream.Write(messageStream.GetBuffer(),
lengthPosition,
lengthLength + messageLength);
}
catch (Exception e)
{
throw new ConnectionException(e);
}
finally
{
if (secure)
{
Monitor.Exit(stream);
}
}
}
public void TestReadAsInt32()
{ //PASSED
initPOFWriter();
writer.WritePackedInt32((Int32)0);
writer.WritePackedInt32(Int32.MinValue);
writer.WritePackedInt32(PofConstants.V_INT_NEG_1);
writer.WritePackedInt32(Int32.MaxValue);
initPOFReader();
Assert.AreEqual((Int32)0, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
Assert.AreEqual(Int32.MinValue, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
Assert.AreEqual(PofConstants.V_INT_NEG_1, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
Assert.AreEqual(Int32.MaxValue, PofHelper.ReadAsInt32(reader, PofConstants.T_INT32));
initPOFWriter();
pofwriter.WriteSingle(0, 1000.123f);
pofwriter.WriteDouble(0, 3000.123456);
initPOFReader();
Assert.AreEqual(1000, pofreader.ReadInt32(0));
Assert.AreEqual(3000, pofreader.ReadInt32(0));
}
