public void TestPofUniformSparseArray()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
TestValue tv = CreateTestValue(isRefEnabled);
Binary bin = Serialize(tv, isRefEnabled);
IPofValue root = PofValueParser.Parse(bin, GetPofContext(isRefEnabled));
IPofValue pv = root.GetChild(5);
Assert.IsTrue(pv is PofUniformSparseArray);
Assert.AreEqual(pv.GetChild(2).GetValue(), "two");
Assert.AreEqual(pv.GetChild(4).GetValue(), "four");
if (isRefEnabled)
{
break;
}
pv.GetChild(1).SetValue("jedan");
pv.GetChild(3).SetValue("tri");
pv.GetChild(4).SetValue("cetiri");
pv.GetChild(5).SetValue("pet");
Binary binModified = root.ApplyChanges();
TestValue tvModified = (TestValue)Deserialize(binModified);
ILongArray arr = tvModified.m_uniformSparseArray;
Assert.AreEqual(arr[1], "jedan");
Assert.AreEqual(arr[2], "two");
Assert.AreEqual(arr[3], "tri");
Assert.AreEqual(arr[4], "cetiri");
Assert.AreEqual(arr[5], "pet");
isRefEnabled = true;
}
}
public void TestPofValueAccessor()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
PortablePerson person = isRefEnabled ? CreatePersonNoChildren() : CreatePerson();
Binary binPerson = Serialize(person, isRefEnabled);
IPofValue pv = PofValueParser.Parse(binPerson, GetPofContext(isRefEnabled));
Assert.AreEqual(person.Address, pv.GetChild(1).GetValue());
Assert.AreEqual(person.Name, pv.GetChild(0).GetValue());
Assert.AreEqual(person.DOB, pv.GetChild(2).GetValue());
// test NilPofValue
IPofValue nv = pv.GetChild(100);
Assert.IsTrue(nv is PofSparseArray.NilPofValue);
Assert.IsNull(nv.GetValue());
// test PofNavigationException
try
{
pv.GetChild(0).GetChild(0);
Assert.Fail("Should've thrown PofNavigationException");
}
catch (PofNavigationException)
{
}
if (isRefEnabled)
{
break;
}
isRefEnabled = true;
}
}
public void TestGetCollection()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
Stack coll = new Stack();
coll.Push("One");
coll.Push("Two");
coll.Push("Three");
Binary bin = Serialize(coll, isRefEnabled);
IPofValue root = PofValueParser.Parse(bin, GetPofContext(isRefEnabled));
ICollection pv = root.GetCollection(null);
Assert.AreEqual(coll.ToArray(), pv);
Queue res = new Queue();
res.Enqueue("Append");
pv = root.GetCollection(res);
Assert.AreSame(res, pv);
if (isRefEnabled)
{
break;
}
isRefEnabled = true;
}
}
public void TestNestedPofValueAccessor()
{
PortablePerson person = CreatePerson();
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
Binary binPerson = Serialize(person, isRefEnabled);
IPofValue pv = PofValueParser.Parse(binPerson, GetPofContext(isRefEnabled));
Assert.AreEqual(person.Address.Street, pv.GetChild(1).GetChild(0).GetValue());
Assert.AreEqual(person.Address.City, pv.GetChild(1).GetChild(1).GetValue());
Assert.AreEqual(person.Address.State, pv.GetChild(1).GetChild(2).GetValue());
Assert.AreEqual(person.Address.ZIP, pv.GetChild(1).GetChild(3).GetValue());
if (isRefEnabled)
{
// test the case where we try to access an object that contains a
// uniform collection of user defined objects when object reference is enabled
try
{
pv.GetChild(4);
Assert.Fail("Should've thrown NotSupportedException");
}
catch (NotSupportedException)
{
}
break;
}
isRefEnabled = true;
}
}
public void TestPofSparseArray()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
TestValue tv = CreateTestValue(isRefEnabled);
Binary bin = Serialize(tv, isRefEnabled);
IPofValue root = PofValueParser.Parse(bin, GetPofContext(isRefEnabled));
IPofValue pv = root.GetChild(4);
Assert.IsTrue(pv is PofSparseArray);
Assert.AreEqual(pv.GetChild(4).GetValue(), 4);
Assert.AreEqual(pv.GetChild(2).GetValue(), "two");
// Test the case where we try to read a reference id before the object is read.
// We should get an
// IOException: missing identity: 2
// Work around by reading the person object in root.getChild(0) where it first appears
// so that root.getChild(4).getValue(), which references the person object will have it.
if (isRefEnabled)
{
try
{
pv.GetChild(5).GetValue();
Assert.Fail("Should've thrown Exception.");
}
catch (IOException)
{
}
root.GetChild(0).GetChild(2).GetValue();
}
Assert.AreEqual(pv.GetChild(5).GetValue(),
isRefEnabled ? CreatePersonNoChildren() : CreatePerson());
if (isRefEnabled)
{
break;
}
pv.GetChild(1).SetValue(1);
pv.GetChild(2).SetValue("dva");
pv.GetChild(3).SetValue("tri");
pv.GetChild(5).GetChild(0).SetValue("Novak");
Binary binModified = root.ApplyChanges();
TestValue tvModified = (TestValue)Deserialize(binModified);
Assert.AreEqual(tvModified.m_sparseArray[1], 1);
Assert.AreEqual(tvModified.m_sparseArray[2], "dva");
Assert.AreEqual(tvModified.m_sparseArray[3], "tri");
Assert.AreEqual(((PortablePerson)tvModified.m_sparseArray[5]).Name,
"Novak");
isRefEnabled = true;
}
}
public void TestGetDouble()
{
Double d = 0.1234567890123456789d;
Binary bin = Serialize(d);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Double pv = root.GetDouble();
Assert.IsInstanceOf(d.GetType(), pv);
Assert.AreEqual(d, pv);
}
public void TestGetDateTime()
{
DateTime dt = new DateTime((DateTime.Now.Ticks / 10000) * 10000);
Binary bin = Serialize(dt);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
DateTime pv = root.GetDateTime();
Assert.IsInstanceOf(dt.GetType(), pv);
Assert.AreEqual(dt, pv);
}
public void TestGetInt64()
{
Int64 l = 0x1234567812345678;
Binary bin = Serialize(l);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Int64 pv = root.GetInt64();
Assert.IsInstanceOf(l.GetType(), pv);
Assert.AreEqual(l, pv);
}
public void TestGetInt32()
{
Int32 i = 0x12345678;
Binary bin = Serialize(i);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Int32 pv = root.GetInt32();
Assert.IsInstanceOf(i.GetType(), pv);
Assert.AreEqual(i, pv);
}
public void TestPofInt16()
{
Int16 s = 0x1234;
Binary bin = Serialize(s);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Int16 pv = root.GetInt16();
Assert.IsInstanceOf(s.GetType(), pv);
Assert.AreEqual(s, pv);
}
public void TestGetChar()
{
Char c = '\x0041';
Binary bin = Serialize(c);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Char pv = root.GetChar();
Assert.IsInstanceOf(c.GetType(), pv);
Assert.AreEqual(c, pv);
}
public void TestGetDayTimeInterval()
{
TimeSpan ts = new TimeSpan(12, 5, 10, 5);
Binary bin = Serialize(ts);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
TimeSpan pv = root.GetDayTimeInterval();
Assert.IsInstanceOf(ts.GetType(), pv);
Assert.AreEqual(ts, pv);
}
public void TestGetDecimal()
{
Decimal d = Decimal.Parse("28162514264337593543950335.1");
Binary bin = Serialize(d);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Decimal pv = root.GetDecimal();
Assert.IsInstanceOf(d.GetType(), pv);
Assert.AreEqual(d, pv);
}
public void TestGetString()
{
string s = "28162514264337593543950335.1";
Binary bin = Serialize(s);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
string pv = root.GetString();
Assert.IsInstanceOf(s.GetType(), pv);
Assert.AreEqual(s, pv);
}
public void TestReferencesWithComplexObject()
{
var ivan = new PortablePersonReference("Ivan", new DateTime(78, 4, 25));
var goran = new PortablePersonReference("Goran", new DateTime(82, 3, 3));
var anna = new PortablePersonReference("Anna", new DateTime(80, 4, 12));
var tom = new PortablePerson("Tom", new DateTime(103, 7, 5));
var ellen = new PortablePerson("Ellen", new DateTime(105, 3, 15));
ivan.Children = null;
goran.Children = new PortablePerson[2];
goran.Children[0] = tom;
goran.Children[1] = ellen;
anna.Children = new PortablePerson[2];
anna.Children[0] = tom;
anna.Children[1] = ellen;
ivan.Siblings = new PortablePersonReference[1];
ivan.Siblings[0] = goran;
goran.Siblings = new PortablePersonReference[1];
goran.Siblings[0] = ivan;
goran.Spouse = anna;
anna.Spouse = goran;
IDictionary <CompositeKey, IPortableObject> mapPerson = new Dictionary <CompositeKey, IPortableObject>();
String lastName = "Smith";
CompositeKey key1 = new CompositeKey(lastName, "ivan"),
key2 = new CompositeKey(lastName, "goran");
mapPerson.Add(key1, ivan);
mapPerson.Add(key2, goran);
Binary bin = Serialize(mapPerson, true);
IPofValue pv = PofValueParser.Parse(bin, GetPofContext(true));
IDictionary mapResult = pv.GetDictionary(null);
Assert.AreEqual(2, mapResult.Count);
PortablePersonReference ivanR = (PortablePersonReference)mapResult[key1];
PortablePersonReference goranR = (PortablePersonReference)mapResult[key2];
Assert.AreEqual(goran.Name, goranR.Name);
Assert.IsTrue(ivanR.Siblings[0] == goranR);
Assert.IsTrue(goranR.Spouse.Children[0] == goranR.Children[0]);
bin = Serialize(ivan, true);
pv = PofValueParser.Parse(bin, GetPofContext(true));
ivanR = (PortablePersonReference)pv.Root.GetValue();
goranR = ivanR.Siblings[0];
Assert.IsTrue(goranR.Siblings[0] == ivanR);
ivanR = (PortablePersonReference)pv.GetValue(PofConstants.T_UNKNOWN);
goranR = ivanR.Siblings[0];
Assert.IsTrue(goranR.Siblings[0] == ivanR);
}
public void TestGetSingle()
{
Single f = 0.12345678f;
f = 0.1234567890123456789f;
Binary bin = Serialize(f);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Single pv = root.GetSingle();
Assert.IsInstanceOf(f.GetType(), pv);
Assert.AreEqual(f, pv);
}
public void TestCOH5231()
{
var holder = new BooleanHolder {
Boolean1 = false, Boolean2 = true
};
Binary bin = Serialize(holder);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
IPofValue bool1 = new SimplePofPath(0).Navigate(root);
IPofValue bool2 = new SimplePofPath(1).Navigate(root);
Assert.IsFalse(bool1.GetBoolean());
Assert.IsTrue((bool)bool2.GetValue());
}
public void TestGetDate()
{
DateTime dt = DateTime.Now;
Binary bin = Serialize(dt);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
DateTime pv = root.GetDate();
Assert.IsInstanceOf(dt.GetType(), pv);
Assert.AreEqual(dt.Date, pv.Date);
Assert.AreEqual(pv.Hour, 0);
Assert.AreEqual(pv.Minute, 0);
Assert.AreEqual(pv.Second, 0);
Assert.AreEqual(pv.Millisecond, 0);
}
public void TestPofCollection()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
TestValue tv = CreateTestValue(isRefEnabled);
Binary bin = Serialize(tv, isRefEnabled);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
IPofValue pv = root.GetChild(2);
Assert.AreEqual(((PofCollection)pv).Length, 3);
Assert.AreEqual(pv.GetChild(0).GetValue(), 1);
Assert.AreEqual(pv.GetChild(1).GetValue(), "two");
if (isRefEnabled)
{
IPofValue pv2 = root.GetChild(0).GetChild(2);
pv2.GetValue();
}
Assert.AreEqual(pv.GetChild(2).GetValue(), isRefEnabled ? CreatePersonNoChildren() : CreatePerson());
try
{
pv.GetChild(100);
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException)
{
}
if (isRefEnabled)
{
break;
}
pv.GetChild(1).SetValue("dva");
pv.GetChild(2).GetChild(0).SetValue("Novak");
Binary binModified = root.ApplyChanges();
TestValue tvModified = (TestValue)Deserialize(binModified);
Assert.AreEqual(tvModified.m_col[1], "dva");
Assert.AreEqual(((PortablePerson)tvModified.m_col[2]).Name,
"Novak");
isRefEnabled = true;
}
}
public void TestGetDoubleArray()
{
Double[] tv = new Double[] { 0, 1.1d, 2.2d, 3.3f, 4.4d };
Binary bin = Serialize(tv);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Double[] pv = root.GetDoubleArray();
Assert.AreEqual(tv, pv);
try
{
pv[5] = pv[5];
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException) { }
}
public void TestGetInt64Array()
{
Int64[] tv = new Int64[] { 0, 0xf0f0f0f0, 0xffffffff, 0x7fffffffffffffff };
Binary bin = Serialize(tv);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Int64[] pv = root.GetInt64Array();
Assert.AreEqual(tv, pv);
try
{
pv[5] = pv[5];
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException) { }
}
public void TestGetCharArray()
{
Char[] tv = new char[] { '\x0041', '\x0042', '\x0043', '\x0044' };
Binary bin = Serialize(tv);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Char[] pv = root.GetCharArray();
Assert.AreEqual(tv, pv);
try
{
pv[5] = pv[5];
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException) { }
}
public void TestGetByteArray()
{
Byte[] tv = new byte[] { 1, 2, 3, 4 };
Binary bin = Serialize(tv);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Byte[] pv = root.GetByteArray();
Assert.AreEqual(tv, pv);
try
{
pv[5] = pv[5];
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException) { }
}
public void TestPofValueMutator()
{
PortablePerson person = CreatePerson();
Binary binPerson = Serialize(person);
IPofValue pv = PofValueParser.Parse(binPerson, GetPofContext());
pv.GetChild(0).SetValue("Seovic Aleksandar");
Assert.AreEqual(pv.GetChild(0).GetValue(), "Seovic Aleksandar");
pv.GetChild(0).SetValue("Marija Seovic");
pv.GetChild(1).GetChild(0).SetValue("456 Main St");
pv.GetChild(1).GetChild(1).SetValue("Lutz");
pv.GetChild(1).GetChild(3).SetValue("33549");
pv.GetChild(2).SetValue(new DateTime(1978, 2, 20));
pv.GetChild(3).SetValue(new PortablePerson("Aleksandar Seovic", new DateTime(1974, 8, 24)));
pv.GetChild(4).SetValue(person.Children);
binPerson = pv.ApplyChanges();
PortablePerson p2 = (PortablePerson)Deserialize(binPerson);
Assert.AreEqual("Marija Seovic", p2.Name);
Assert.AreEqual("456 Main St", p2.Address.Street);
Assert.AreEqual("Lutz", p2.Address.City);
Assert.AreEqual("33549", p2.Address.ZIP);
Assert.AreEqual(new DateTime(1978, 2, 20), p2.DOB);
Assert.AreEqual("Aleksandar Seovic", p2.Spouse.Name);
Assert.AreEqual(person.Children, p2.Children);
pv = PofValueParser.Parse(binPerson, GetPofContext());
pv.GetChild(0).SetValue("Ana Maria Seovic");
pv.GetChild(2).SetValue(new DateTime(2004, 8, 14));
pv.GetChild(3).SetValue(null);
pv.GetChild(4).SetValue(null);
binPerson = pv.ApplyChanges();
PortablePerson p3 = (PortablePerson)Deserialize(binPerson);
Assert.AreEqual("Ana Maria Seovic", p3.Name);
Assert.AreEqual(p2.Address, p3.Address);
Assert.AreEqual(new DateTime(2004, 8, 14), p3.DOB);
Assert.IsNull(p3.Spouse);
Assert.IsNull(p3.Children);
}
public void TestPofValueInitialization()
{
PortablePerson person = CreatePerson();
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
Binary binPerson = Serialize(person, isRefEnabled);
IPofValue pv = PofValueParser.Parse(binPerson, GetPofContext(isRefEnabled));
Assert.AreEqual(101, pv.TypeId);
Assert.AreEqual(person, pv.GetValue());
if (isRefEnabled)
{
break;
}
isRefEnabled = true;
}
}
public void TestGetBoolean()
{
Boolean bt = true;
Boolean bf = false;
Binary binTrue = Serialize(bt);
Binary binFalse = Serialize(bf);
IPofValue rootTrue = PofValueParser.Parse(binTrue, GetPofContext());
IPofValue rootFalse = PofValueParser.Parse(binFalse, GetPofContext());
Boolean pvTrue = rootTrue.GetBoolean();
Boolean pvFalse = rootFalse.GetBoolean();
Assert.IsTrue(pvTrue);
Assert.IsFalse(pvFalse);
pvTrue = (Boolean)rootTrue.GetValue();
pvFalse = (Boolean)rootFalse.GetValue();
Assert.IsTrue(pvTrue);
Assert.IsFalse(pvFalse);
}
public void TestPofUniformArray()
{
// perform the test twice, once with references disable, once with them enabled
for (bool isRefEnabled = false; ;)
{
TestValue tv = CreateTestValue(isRefEnabled);
Binary bin = Serialize(tv, isRefEnabled);
IPofValue root = PofValueParser.Parse(bin, GetPofContext(isRefEnabled));
IPofValue pv = root.GetChild(1);
Assert.AreEqual(((PofArray)pv).Length, 4);
Assert.AreEqual(pv.GetChild(0).GetValue(), "one");
Assert.AreEqual(pv.GetChild(1).GetValue(), "two");
Assert.AreEqual(pv.GetChild(2).GetValue(), "three");
Assert.AreEqual(pv.GetChild(3).GetValue(), "four");
try
{
pv.GetChild(100);
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException)
{
}
if (isRefEnabled)
{
break;
}
pv.GetChild(0).SetValue("jedan");
pv.GetChild(3).SetValue("cetiri");
Binary binModified = root.ApplyChanges();
TestValue tvModified = (TestValue)Deserialize(binModified);
Assert.AreEqual(tvModified.m_sArray[0], "jedan");
Assert.AreEqual(tvModified.m_sArray[3], "cetiri");
isRefEnabled = true;
}
}
public void TestGetBooleanArray()
{
Boolean[] tv = new Boolean[] { true, false, true, false };
Binary bin = Serialize(tv);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
Boolean[] pv = root.GetBooleanArray();
Assert.AreEqual(pv.Length, 4);
Assert.IsTrue(pv[0]);
Assert.IsFalse(pv[1]);
Assert.IsTrue(pv[2]);
Assert.IsFalse(pv[3]);
try
{
pv[5] = pv[5];
Assert.Fail("Should've thrown IndexOutOfRangeException.");
}
catch (IndexOutOfRangeException) { }
}
public void TestGetDictionaryT()
{
IDictionary <string, Int32> dict = new Dictionary <string, Int32> {
{ "One", 1 }, { "Two", 2 }, { "Three", 3 }
};
Binary bin = Serialize(dict);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
IDictionary <string, Int32> pv = root.GetDictionary <string, Int32>(null);
Assert.AreEqual(dict.Count, pv.Count);
foreach (KeyValuePair <string, Int32> entry in pv)
{
Assert.AreEqual(dict[entry.Key], pv[entry.Key]);
}
IDictionary <string, Int32> res = new Dictionary <string, Int32> {
{ "Append", 0 }
};
pv = root.GetDictionary <string, Int32>(res);
Assert.AreSame(res, pv);
}
public void TestGetDictionary()
{
IDictionary dict = new Hashtable {
{ "One", 1 }, { "Two", 2 }, { "Three", 3 }
};
Binary bin = Serialize(dict);
IPofValue root = PofValueParser.Parse(bin, GetPofContext());
IDictionary pv = root.GetDictionary(null);
Assert.AreEqual(dict.Count, pv.Count);
foreach (DictionaryEntry dentry in pv)
{
Assert.AreEqual(dict[dentry.Key], pv[dentry.Key]);
}
IDictionary res = new Hashtable {
{ "Append", 0 }
};
pv = root.GetDictionary(res);
Assert.AreSame(res, pv);
}