static void Main(string[] args)
{
// legend:
// [something physical to be stored in buffer] (something to be translated to/from the byte array)
// <<description of item>> (no physical storaged.. just to make reading the structure easier!)
//
// overall layout of byte buffer:
//
// [unsigned int number_of_elements ]
// [element]
// [element]
// ...
//
// element =
// <<ItemIdentity>>
// [ushort typeField]
// [ushort referenceTypeField]
// <<embedded ary>>
// [unsigned int namefield_length]
// [bytes nameField_strdata 0..n]
// <<embedded ary>>
// [unsigned int contextNameField_length]
// [bytes contextNameField_strdata 0..n]
// [ulong idField]
// [bool idFieldSpecified]
// <<RuntimeValue>>
// [DateTime timestampField] (??)
// [bool timestampFieldSpecified]
// <<Variant>>
// [ushort typeField]
// [int lengthField]
// <embedded ary>
// [unsigned int payloadField_length]
// [bytes payloadField_bytes 0..n]
//
// <<ASBStatus>>
// [sbyte countField]
// <<embedded ary>>
// [unsigned int payloadfield_length]
// [bytes payloadField_bytes 0..n]
//
// <<Variant>>
// [ushort typeField]
// [int lengthField]
// <<embedded ary>>
// [unsigned int payloadField_length]
// [bytes payloadField_bytes 0..n]
// hand marshal the structures..
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
MonitoredItemValue [] mivs = new MonitoredItemValue[3];
for ( uint currOfst = 0;
currOfst < 3;
currOfst++)
{
mivs[currOfst].itemField.Type = (ushort) (currOfst + 1);
mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
mivs[currOfst].itemField.Name = String.Format("testing name string #{0}",currOfst + 3);
mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
mivs[currOfst].itemField.IdSpecified = false;
mivs[currOfst].valueField.timestampField = DateTime.Now;
mivs[currOfst].valueField.timestampFieldSpecified = true;
mivs[currOfst].valueField.valueField.typeField = (ushort) (currOfst + 6);
mivs[currOfst].valueField.valueField.lengthField = (int) (currOfst + 7);
byte [] tmpBytes = new byte[currOfst+2];
for(int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
{
tmpBytes[aryOfst] = (byte) (aryOfst + currOfst);
}
mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
mivs[currOfst].valueField.statusField.countField = (sbyte) (currOfst + 8);
mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
mivs[currOfst].userDataField.typeField = (ushort) (currOfst + 9);
mivs[currOfst].userDataField.lengthField = (int) (currOfst + 10);
mivs[currOfst].userDataField.payloadField = tmpBytes;
}
MonitoredItemConverter cnvrtr = new MonitoredItemConverter();
byte [] buf = cnvrtr.ConvertMIVToBytes(mivs);
MonitoredItemValue[] mivs2;
// this makes a copy.. which is probably ok given what we are doing..
// GetBuffer is more efficient here.. but returns more than what we
// need to transfer (its highly likely to have unused slop-over bytes at the
// end of the buffer), which is highly wasteful of network resources, which
// is the efficiency we are tracking here..
DumpString(buf);
cnvrtr.ConvertBytesToMIV(buf, out mivs2);
}
public void LargerScale_20K()
{
MonitoredItemConverter cnvrtr = new MonitoredItemConverter();
for (int x = 0; x < 10; x++)
{
int countToTest = 20000;
MIVContainer mivc = new MIVContainer();
mivc.mivs = new MonitoredItemValue[countToTest];
// status addition
mivc.statuses = new ItemStatus[countToTest];
for (uint currOfst = 0;
currOfst < countToTest;
currOfst++)
{
mivc.mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
mivc.mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
mivc.mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
mivc.mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
mivc.mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
mivc.mivs[currOfst].itemField.IdSpecified = false;
mivc.mivs[currOfst].valueField.timestampField = DateTime.Now;
mivc.mivs[currOfst].valueField.timestampFieldSpecified = true;
mivc.mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
mivc.mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
byte[] tmpBytes = new byte[10];
for (int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
{
tmpBytes[aryOfst] = (byte)(aryOfst + currOfst);
}
mivc.mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
mivc.mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
mivc.mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
mivc.mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
mivc.mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
mivc.mivs[currOfst].userDataField.payloadField = tmpBytes;
// ///////////////////////////////////////
// status addition
// ///////////////////////////////////////
mivc.statuses[currOfst].itemField.Type = (ushort)(currOfst + 11);
mivc.statuses[currOfst].itemField.ReferenceType = (ushort)(currOfst + 12);
mivc.statuses[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 13);
mivc.statuses[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 14);
mivc.statuses[currOfst].itemField.Id = (ulong)(currOfst + 15);
mivc.statuses[currOfst].itemField.IdSpecified = false;
mivc.statuses[currOfst].errorCodeField = (ushort)(currOfst + 16);
mivc.statuses[currOfst].errorCodeFieldSpecified = true;
}
TestBigStructParam(mivc.mivs);
byte[] buf = cnvrtr.ConvertMIVToBytes(mivc.mivs);
// ///////////////////////////////////////
// status addition
// ///////////////////////////////////////
byte[] statusBuf = cnvrtr.ConvertItemStatusToBytes(mivc.statuses);
MIVContainer mivc2 = new MIVContainer();
// this makes a copy.. which is probably ok given what we are doing..
// GetBuffer is more efficient here.. but returns more than what we
// need to transfer (its highly likely to have unused slop-over bytes at the
// end of the buffer), which is highly wasteful of network resources, which
// is the efficiency we are tracking here..
//DumpString(buf);
cnvrtr.ConvertBytesToMIV(buf, out mivc2.mivs);
// ///////////////////////////////////////
// status addition
// ///////////////////////////////////////
cnvrtr.ConvertBytesToItemStatus(statusBuf, out mivc2.statuses);
Assert.AreEqual(mivc.mivs.Length, mivc2.mivs.Length);
Assert.AreEqual(mivc2.mivs.Length, countToTest);
// ///////////////////////////////////////
// status addition
// ///////////////////////////////////////
Assert.AreEqual(mivc.statuses.Length, mivc2.statuses.Length);
Assert.AreEqual(mivc2.statuses.Length, countToTest);
int len = mivc.mivs.Length;
for (int currmiv = 0;
currmiv < len;
currmiv++)
{
//mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
Assert.AreEqual(mivc.mivs[currmiv].itemField.Type, mivc2.mivs[currmiv].itemField.Type);
//mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
Assert.AreEqual(mivc.mivs[currmiv].itemField.ReferenceType, mivc2.mivs[currmiv].itemField.ReferenceType);
//mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
Assert.AreEqual(mivc.mivs[currmiv].itemField.Name, mivc2.mivs[currmiv].itemField.Name);
//mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
Assert.AreEqual(mivc.mivs[currmiv].itemField.ContextName, mivc2.mivs[currmiv].itemField.ContextName);
//mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
Assert.AreEqual(mivc.mivs[currmiv].itemField.Id, mivc2.mivs[currmiv].itemField.Id);
//mivs[currOfst].itemField.IdSpecified = false;
Assert.AreEqual(mivc.mivs[currmiv].itemField.IdSpecified, mivc2.mivs[currmiv].itemField.IdSpecified);
//mivs[currOfst].valueField.timestampField = DateTime.Now;
Assert.AreEqual(mivc.mivs[currmiv].valueField.timestampField, mivc2.mivs[currmiv].valueField.timestampField);
//mivs[currOfst].valueField.timestampFieldSpecified = true;
Assert.AreEqual(mivc.mivs[currmiv].valueField.timestampFieldSpecified, mivc2.mivs[currmiv].valueField.timestampFieldSpecified);
//mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
Assert.AreEqual(mivc.mivs[currmiv].valueField.valueField.typeField, mivc2.mivs[currmiv].valueField.valueField.typeField);
//mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
Assert.AreEqual(mivc.mivs[currmiv].valueField.valueField.lengthField, mivc2.mivs[currmiv].valueField.valueField.lengthField);
//byte[] tmpBytes = new byte[currOfst + 2];
//for (int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
//{
// tmpBytes[aryOfst] = (byte)(aryOfst + currOfst);
//}
//mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
int len1 = mivc.mivs[currmiv].valueField.valueField.payloadField.Length;
int len2 = mivc2.mivs[currmiv].valueField.valueField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivc.mivs[currmiv].valueField.valueField.payloadField[currByteOfst],
mivc2.mivs[currmiv].valueField.valueField.payloadField[currByteOfst]);
}
//mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
Assert.AreEqual(mivc.mivs[currmiv].valueField.statusField.countField, mivc2.mivs[currmiv].valueField.statusField.countField);
//mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
len1 = mivc.mivs[currmiv].valueField.statusField.payloadField.Length;
len2 = mivc2.mivs[currmiv].valueField.statusField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivc.mivs[currmiv].valueField.statusField.payloadField[currByteOfst],
mivc2.mivs[currmiv].valueField.statusField.payloadField[currByteOfst]);
}
//mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
Assert.AreEqual(mivc.mivs[currmiv].userDataField.typeField, mivc2.mivs[currmiv].userDataField.typeField);
//mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
Assert.AreEqual(mivc.mivs[currmiv].userDataField.lengthField, mivc2.mivs[currmiv].userDataField.lengthField);
//mivs[currOfst].userDataField.payloadField = tmpBytes;
len1 = mivc.mivs[currmiv].userDataField.payloadField.Length;
len2 = mivc2.mivs[currmiv].userDataField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivc.mivs[currmiv].userDataField.payloadField[currByteOfst],
mivc2.mivs[currmiv].userDataField.payloadField[currByteOfst]);
}
// ///////////////////////////////////////
// status addition
// ///////////////////////////////////////
Assert.AreEqual(mivc.statuses[currmiv].itemField.Type, mivc2.statuses[currmiv].itemField.Type);
Assert.AreEqual(mivc.statuses[currmiv].itemField.ReferenceType, mivc2.statuses[currmiv].itemField.ReferenceType);
Assert.AreEqual(mivc.statuses[currmiv].itemField.Name, mivc2.statuses[currmiv].itemField.Name);
Assert.AreEqual(mivc.statuses[currmiv].itemField.ContextName, mivc2.statuses[currmiv].itemField.ContextName);
Assert.AreEqual(mivc.statuses[currmiv].itemField.Id, mivc2.statuses[currmiv].itemField.Id);
Assert.AreEqual(mivc.statuses[currmiv].itemField.IdSpecified, mivc2.statuses[currmiv].itemField.IdSpecified);
Assert.AreEqual(mivc.statuses[currmiv].errorCodeField, mivc2.statuses[currmiv].errorCodeField);
Assert.AreEqual(mivc.statuses[currmiv].itemField.IdSpecified, mivc2.statuses[currmiv].itemField.IdSpecified);
}
}
}
public void SimpleEndToEnd()
{
// this has been supercede by the bulk test.. but is left here
// for completeness.. it does NOT have the ItemStatus portion
// in it because the Bulk test takes that into account.
int countToTest = 100;
MonitoredItemValue[] mivs = new MonitoredItemValue[countToTest];
for (uint currOfst = 0;
currOfst < countToTest;
currOfst++)
{
mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
mivs[currOfst].itemField.IdSpecified = false;
mivs[currOfst].valueField.timestampField = DateTime.Now;
mivs[currOfst].valueField.timestampFieldSpecified = true;
mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
byte[] tmpBytes = new byte[currOfst + 2];
for (int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
{
tmpBytes[aryOfst] = (byte)(aryOfst + currOfst);
}
mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
mivs[currOfst].userDataField.payloadField = tmpBytes;
}
MonitoredItemConverter cnvrtr = new MonitoredItemConverter();
byte[] buf = cnvrtr.ConvertMIVToBytes(mivs);
MonitoredItemValue[] mivs2;
// this makes a copy.. which is probably ok given what we are doing..
// GetBuffer is more efficient here.. but returns more than what we
// need to transfer (its highly likely to have unused slop-over bytes at the
// end of the buffer), which is highly wasteful of network resources, which
// is the efficiency we are tracking here..
DumpString(buf);
cnvrtr.ConvertBytesToMIV(buf, out mivs2);
Assert.AreEqual(mivs.Length, mivs2.Length);
Assert.AreEqual(mivs2.Length, countToTest);
int len = mivs.Length;
for (int currmiv = 0;
currmiv < len;
currmiv++)
{
//mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
Assert.AreEqual(mivs[currmiv].itemField.Type, mivs2[currmiv].itemField.Type);
//mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
Assert.AreEqual(mivs[currmiv].itemField.ReferenceType, mivs2[currmiv].itemField.ReferenceType);
//mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
Assert.AreEqual(mivs[currmiv].itemField.Name, mivs2[currmiv].itemField.Name);
//mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
Assert.AreEqual(mivs[currmiv].itemField.ContextName, mivs2[currmiv].itemField.ContextName);
//mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
Assert.AreEqual(mivs[currmiv].itemField.Id, mivs2[currmiv].itemField.Id);
//mivs[currOfst].itemField.IdSpecified = false;
Assert.AreEqual(mivs[currmiv].itemField.IdSpecified, mivs2[currmiv].itemField.IdSpecified);
//mivs[currOfst].valueField.timestampField = DateTime.Now;
Assert.AreEqual(mivs[currmiv].valueField.timestampField, mivs2[currmiv].valueField.timestampField);
//mivs[currOfst].valueField.timestampFieldSpecified = true;
Assert.AreEqual(mivs[currmiv].valueField.timestampFieldSpecified, mivs2[currmiv].valueField.timestampFieldSpecified);
//mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
Assert.AreEqual(mivs[currmiv].valueField.valueField.typeField, mivs2[currmiv].valueField.valueField.typeField);
//mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
Assert.AreEqual(mivs[currmiv].valueField.valueField.lengthField, mivs2[currmiv].valueField.valueField.lengthField);
//byte[] tmpBytes = new byte[currOfst + 2];
//for (int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
//{
// tmpBytes[aryOfst] = (byte)(aryOfst + currOfst);
//}
//mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
int len1 = mivs[currmiv].valueField.valueField.payloadField.Length;
int len2 = mivs2[currmiv].valueField.valueField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivs[currmiv].valueField.valueField.payloadField[currByteOfst],
mivs2[currmiv].valueField.valueField.payloadField[currByteOfst]);
}
//mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
Assert.AreEqual(mivs[currmiv].valueField.statusField.countField, mivs2[currmiv].valueField.statusField.countField);
//mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
len1 = mivs[currmiv].valueField.statusField.payloadField.Length;
len2 = mivs2[currmiv].valueField.statusField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivs[currmiv].valueField.statusField.payloadField[currByteOfst],
mivs2[currmiv].valueField.statusField.payloadField[currByteOfst]);
}
//mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
Assert.AreEqual(mivs[currmiv].userDataField.typeField, mivs2[currmiv].userDataField.typeField);
//mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
Assert.AreEqual(mivs[currmiv].userDataField.lengthField, mivs2[currmiv].userDataField.lengthField);
//mivs[currOfst].userDataField.payloadField = tmpBytes;
len1 = mivs[currmiv].userDataField.payloadField.Length;
len2 = mivs2[currmiv].userDataField.payloadField.Length;
Assert.AreEqual(len1, len2);
for (int currByteOfst = 0;
currByteOfst < len1;
currByteOfst++)
{
Assert.AreEqual(mivs[currmiv].userDataField.payloadField[currByteOfst],
mivs2[currmiv].userDataField.payloadField[currByteOfst]);
}
}
}
public void NullArrayTest()
{
int countToTest = 2;
MonitoredItemValue[] mivs = new MonitoredItemValue[countToTest];
ItemStatus[] statuses = new ItemStatus[countToTest];
for (uint currOfst = 0;
currOfst < countToTest;
currOfst++)
{
mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
//mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
mivs[currOfst].itemField.Name = null;
mivs[currOfst].itemField.ContextName = null;
mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
mivs[currOfst].itemField.IdSpecified = false;
mivs[currOfst].valueField.timestampField = DateTime.Now;
mivs[currOfst].valueField.timestampFieldSpecified = true;
mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
mivs[currOfst].valueField.valueField.payloadField = null;
mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
mivs[currOfst].valueField.statusField.payloadField = null;
mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
mivs[currOfst].userDataField.payloadField = null;
statuses[currOfst].itemField.Type = (ushort)(currOfst + 11);
statuses[currOfst].itemField.ReferenceType = (ushort)(currOfst + 12);
statuses[currOfst].itemField.Name = null;
statuses[currOfst].itemField.ContextName = null;
statuses[currOfst].itemField.Id = (ulong)(currOfst + 13);
statuses[currOfst].itemField.IdSpecified = false;
statuses[currOfst].errorCodeField = (ushort)(currOfst + 14);
statuses[currOfst].errorCodeFieldSpecified = true;
}
MonitoredItemConverter cnvrtr = new MonitoredItemConverter();
byte[] buf = cnvrtr.ConvertMIVToBytes(mivs);
byte[] statusesBuf = cnvrtr.ConvertItemStatusToBytes(statuses);
MonitoredItemValue[] mivs2;
ItemStatus[] statuses2;
// this makes a copy.. which is probably ok given what we are doing..
// GetBuffer is more efficient here.. but returns more than what we
// need to transfer (its highly likely to have unused slop-over bytes at the
// end of the buffer), which is highly wasteful of network resources, which
// is the efficiency we are tracking here..
Console.WriteLine("MIV buf dump:");
DumpString(buf);
Console.WriteLine("ItemStatus buf dump:");
DumpString(statusesBuf);
cnvrtr.ConvertBytesToMIV(buf, out mivs2);
cnvrtr.ConvertBytesToItemStatus(statusesBuf, out statuses2);
Assert.AreEqual(mivs.Length, mivs2.Length);
Assert.AreEqual(statuses.Length, statuses2.Length);
Assert.AreEqual(mivs2.Length,statuses2.Length);
int len = mivs.Length;
for (int currmiv = 0;
currmiv < len;
currmiv++)
{
//mivs[currOfst].itemField.Type = (ushort)(currOfst + 1);
Assert.AreEqual(mivs[currmiv].itemField.Type, mivs2[currmiv].itemField.Type);
//mivs[currOfst].itemField.ReferenceType = (ushort)(currOfst + 2);
Assert.AreEqual(mivs[currmiv].itemField.ReferenceType, mivs2[currmiv].itemField.ReferenceType);
//mivs[currOfst].itemField.Name = String.Format("testing name string #{0}", currOfst + 3);
Assert.AreEqual(mivs[currmiv].itemField.Name, null);
Assert.AreEqual(mivs2[currmiv].itemField.Name,"");
//mivs[currOfst].itemField.ContextName = String.Format("testing contextname string #{0}", currOfst + 4);
Assert.AreEqual(mivs[currmiv].itemField.ContextName, null);
Assert.AreEqual(mivs2[currmiv].itemField.ContextName, "" );
//mivs[currOfst].itemField.Id = (ulong)(currOfst + 5);
Assert.AreEqual(mivs[currmiv].itemField.Id, mivs2[currmiv].itemField.Id);
//mivs[currOfst].itemField.IdSpecified = false;
Assert.AreEqual(mivs[currmiv].itemField.IdSpecified, mivs2[currmiv].itemField.IdSpecified);
//mivs[currOfst].valueField.timestampField = DateTime.Now;
Assert.AreEqual(mivs[currmiv].valueField.timestampField, mivs2[currmiv].valueField.timestampField);
//mivs[currOfst].valueField.timestampFieldSpecified = true;
Assert.AreEqual(mivs[currmiv].valueField.timestampFieldSpecified, mivs2[currmiv].valueField.timestampFieldSpecified);
//mivs[currOfst].valueField.valueField.typeField = (ushort)(currOfst + 6);
Assert.AreEqual(mivs[currmiv].valueField.valueField.typeField, mivs2[currmiv].valueField.valueField.typeField);
//mivs[currOfst].valueField.valueField.lengthField = (int)(currOfst + 7);
Assert.AreEqual(mivs[currmiv].valueField.valueField.lengthField, mivs2[currmiv].valueField.valueField.lengthField);
//byte[] tmpBytes = new byte[currOfst + 2];
//for (int aryOfst = 0; aryOfst < tmpBytes.Length; aryOfst++)
//{
// tmpBytes[aryOfst] = (byte)(aryOfst + currOfst);
//}
//mivs[currOfst].valueField.valueField.payloadField = tmpBytes;
Assert.AreEqual(mivs[currmiv].valueField.valueField.payloadField, null);
Assert.AreEqual(mivs2[currmiv].valueField.valueField.payloadField, null);
//mivs[currOfst].valueField.statusField.countField = (sbyte)(currOfst + 8);
Assert.AreEqual(mivs[currmiv].valueField.statusField.countField, mivs2[currmiv].valueField.statusField.countField);
//mivs[currOfst].valueField.statusField.payloadField = tmpBytes;
Assert.AreEqual(mivs[currmiv].valueField.statusField.payloadField,null);
Assert.AreEqual(mivs2[currmiv].valueField.statusField.payloadField,null);
//mivs[currOfst].userDataField.typeField = (ushort)(currOfst + 9);
Assert.AreEqual(mivs[currmiv].userDataField.typeField, mivs2[currmiv].userDataField.typeField);
//mivs[currOfst].userDataField.lengthField = (int)(currOfst + 10);
Assert.AreEqual(mivs[currmiv].userDataField.lengthField, mivs2[currmiv].userDataField.lengthField);
//mivs[currOfst].userDataField.payloadField = tmpBytes;
Assert.AreEqual(mivs[currmiv].userDataField.payloadField,null);
Assert.AreEqual(mivs2[currmiv].userDataField.payloadField,null);
Assert.AreEqual(statuses[currmiv].itemField.Type, statuses2[currmiv].itemField.Type);
Assert.AreEqual(statuses[currmiv].itemField.ReferenceType, statuses2[currmiv].itemField.ReferenceType);
Assert.AreEqual(statuses[currmiv].itemField.Name, null);
Assert.AreEqual(statuses2[currmiv].itemField.Name, "");
Assert.AreEqual(statuses[currmiv].itemField.ContextName, null);
Assert.AreEqual(statuses2[currmiv].itemField.ContextName, "");
Assert.AreEqual(statuses[currmiv].itemField.Id, statuses2[currmiv].itemField.Id);
Assert.AreEqual(statuses[currmiv].itemField.IdSpecified, statuses2[currmiv].itemField.IdSpecified);
Assert.AreEqual(statuses[currmiv].errorCodeField, statuses2[currmiv].errorCodeField);
Assert.AreEqual(statuses[currmiv].errorCodeFieldSpecified, statuses2[currmiv].errorCodeFieldSpecified);
}
}
