public void ShouldSerializeSingleAndSetOfOrids()
{
string recordString = "Something@single:#10:12345,set:<#11:123,#22:1234,#33:1234567>,singleSet:<#44:44>";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("single"), true);
Assert.AreEqual(document.HasField("set"), true);
// check for fields values
Assert.AreEqual(document.GetField <ORID>("single"), new ORID(10, 12345));
HashSet <ORID> collection = document.GetField <HashSet <ORID> >("set");
Assert.AreEqual(collection.Count, 3);
Assert.IsTrue(collection.Contains(new ORID(11, 123)));
Assert.IsTrue(collection.Contains(new ORID(22, 1234)));
Assert.IsTrue(collection.Contains(new ORID(33, 1234567)));
HashSet <ORID> singleSet = document.GetField <HashSet <ORID> >("singleSet");
Assert.AreEqual(singleSet.Count, 1);
Assert.IsTrue(singleSet.Contains(new ORID(44, 44)));
var serialized = document.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void ShouldSerializeNumbers()
{
string recordString = "TestClass@ByteNumber:123b,ShortNumber:1234s,IntNumber:123456,LongNumber:12345678901l,FloatNumber:3.14f,DoubleNumber:3.14d,DecimalNumber:1234567.8901c,embedded:(ByteNumber:123b,ShortNumber:1234s,IntNumber:123456,LongNumber:12345678901l,FloatNumber:3.14f,DoubleNumber:3.14d,DecimalNumber:1234567.8901c)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("ByteNumber", byte.Parse("123"))
.SetField("ShortNumber", short.Parse("1234"))
.SetField("IntNumber", 123456)
.SetField("LongNumber", 12345678901)
.SetField("FloatNumber", 3.14f)
.SetField("DoubleNumber", 3.14)
.SetField("DecimalNumber", new Decimal(1234567.8901))
.SetField("embedded.ByteNumber", byte.Parse("123"))
.SetField("embedded.ShortNumber", short.Parse("1234"))
.SetField("embedded.IntNumber", 123456)
.SetField("embedded.LongNumber", 12345678901)
.SetField("embedded.FloatNumber", 3.14f)
.SetField("embedded.DoubleNumber", 3.14)
.SetField("embedded.DecimalNumber", new Decimal(1234567.8901));
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeNumbers()
{
string recordString = "TestClass@ByteNumber:123b,ShortNumber:1234s,IntNumber:123456,LongNumber:12345678901l,FloatNumber:3.14f,DoubleNumber:3.14d,DecimalNumber:1234567.8901c,embedded:(ByteNumber:123b,ShortNumber:1234s,IntNumber:123456,LongNumber:12345678901l,FloatNumber:3.14f,DoubleNumber:3.14d,DecimalNumber:1234567.8901c)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("ByteNumber", byte.Parse("123"))
.SetField("ShortNumber", short.Parse("1234"))
.SetField("IntNumber", 123456)
.SetField("LongNumber", 12345678901)
.SetField("FloatNumber", 3.14f)
.SetField("DoubleNumber", 3.14)
.SetField("DecimalNumber", new Decimal(1234567.8901))
.SetField("embedded.ByteNumber", byte.Parse("123"))
.SetField("embedded.ShortNumber", short.Parse("1234"))
.SetField("embedded.IntNumber", 123456)
.SetField("embedded.LongNumber", 12345678901)
.SetField("embedded.FloatNumber", 3.14f)
.SetField("embedded.DoubleNumber", 3.14)
.SetField("embedded.DecimalNumber", new Decimal(1234567.8901));
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeNull()
{
string recordString = "TestClass@null:,embedded:(null:)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField<object>("null", null)
.SetField<object>("embedded.null", null);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeNull()
{
string recordString = "TestClass@null:,embedded:(null:)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField <object>("null", null)
.SetField <object>("embedded.null", null);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public Request Request(int sessionID)
{
Request request = new Request();
if (_document.ORID != null)
{
throw new InvalidOperationException();
}
CorrectClassName();
var clusterId = _database.GetClusterIdFor(_document.OClassName);
_document.ORID = new ORID(clusterId, -1);
// standard request fields
request.DataItems.Add(new RequestDataItem()
{
Type = "byte", Data = BinarySerializer.ToArray((byte)OperationType.RECORD_CREATE)
});
request.DataItems.Add(new RequestDataItem()
{
Type = "int", Data = BinarySerializer.ToArray(sessionID)
});
if (OClient.ProtocolVersion < 24)
{
request.DataItems.Add(new RequestDataItem()
{
Type = "int", Data = BinarySerializer.ToArray((int)-1)
}); // data segment id
}
request.DataItems.Add(new RequestDataItem()
{
Type = "short", Data = BinarySerializer.ToArray((short)-1)
});
request.DataItems.Add(new RequestDataItem()
{
Type = "string", Data = BinarySerializer.ToArray(_document.Serialize())
});
request.DataItems.Add(new RequestDataItem()
{
Type = "byte", Data = BinarySerializer.ToArray((byte)'d')
});
request.DataItems.Add(new RequestDataItem()
{
Type = "byte", Data = BinarySerializer.ToArray((byte)0)
});
return(request);
}
public void ShouldNotSerializeFieldsWithAtCharacter()
{
string recordString = "TestClass@foo:true";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("@ClassId", 123)
.SetField("@Foo", "bar")
.SetField("@ORID", new ORID(8, 0))
.SetField <bool>("foo", true);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldNotSerializeFieldsWithAtCharacter()
{
string recordString = "TestClass@foo:true";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("@ClassId", 123)
.SetField("@Foo", "bar")
.SetField("@ORID", new ORID(8, 0))
.SetField<bool>("foo", true);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeBoolean()
{
string recordString = "TestClass@isTrue:true,isFalse:false,embedded:(isTrue:true,isFalse:false),array:[true,false]";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("isTrue", true)
.SetField("isFalse", false)
.SetField("embedded.isTrue", true)
.SetField("embedded.isFalse", false)
.SetField<List<bool>>("array", new List<bool> { true, false });
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeBoolean()
{
string recordString = "TestClass@isTrue:true,isFalse:false,embedded:(isTrue:true,isFalse:false),array:[true,false]";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("isTrue", true)
.SetField("isFalse", false)
.SetField("embedded.isTrue", true)
.SetField("embedded.isFalse", false)
.SetField <List <bool> >("array", new List <bool> {
true, false
});
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeSetOfORIDs()
{
string recordString = "TestClass@Single:#8:0,Set:<#8:1,#8:2>,embedded:(Set:<#9:1,#9:2>)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("Single", new ORID(8, 0))
.SetField("Set", new HashSet <ORID> {
new ORID(8, 1), new ORID(8, 2)
})
.SetField("embedded.Set", new HashSet <ORID> {
new ORID(9, 1), new ORID(9, 2)
});
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
public void ShouldSerializeListOfORIDs()
{
string recordString = "TestClass@Single:#8:0,Array:[#8:1,#8:2],embedded:(Array:[#9:1,#9:2])";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("Single", new ORID(8, 0))
.SetField("Array", new List <ORID> {
new ORID(8, 1), new ORID(8, 2)
})
.SetField("embedded.Array", new List <ORID> {
new ORID(9, 1), new ORID(9, 2)
});
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
public void ShouldSerializeDateTime()
{
DateTime dateTime = DateTime.Now;
// get Unix time version
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
string timeString = ((long)((DateTime)dateTime - unixEpoch).TotalMilliseconds).ToString();
string recordString = "TestClass@DateTime:" + timeString + "t,embedded:(DateTime:" + timeString + "t)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("DateTime", dateTime)
.SetField("embedded.DateTime", dateTime);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeStrings()
{
string recordString = "TestClass@String:\"Bra\\" + "\"vo \\\\ asdf\",Array:[\"foo\",\"bar\"],embedded:(String:\"Bra\\" + "\"vo \\\\ asdf\",Array:[\"foo\",\"bar\"])";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("String", "Bra\"vo \\ asdf")
.SetField("Array", new List <string> {
"foo", "bar"
})
.SetField("embedded.String", "Bra\"vo \\ asdf")
.SetField("embedded.Array", new List <string> {
"foo", "bar"
});
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
public void TestSerializeEmptySubObjectArray()
{
string recordString = "TestHasThings@TheThings:[]";
ODocument document = ODocument.Deserialize(recordString);
TypeMapper <TestHasThings> tm = TypeMapper <TestHasThings> .Instance;
var t = new TestHasThings();
tm.ToObject(document, t);
Assert.IsNotNull(t.TheThings, "much easier for consumers to have a consistent behaviour - collections always created but empty, rather than having to test for nullness");
Assert.AreEqual(0, t.TheThings.Length);
ODocument newODocument = ODocument.ToDocument(t);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void TestSerializeArray()
{
string recordString = "TestArray@values:[1,2,3,4,5]";
ODocument document = ODocument.Deserialize(recordString);
TypeMapper <TestArray> tm = TypeMapper <TestArray> .Instance;
var t = new TestArray();
tm.ToObject(document, t);
Assert.IsNotNull(t.values);
Assert.AreEqual(5, t.values.Length);
Assert.AreEqual(3, t.values[2]);
ODocument newODocument = ODocument.ToDocument(t);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void TestSerializeSingleSubObjectList()
{
string recordString = "TestHasListThings@TheThings:[(Value:18,Text:\"foo\")]";
ODocument document = ODocument.Deserialize(recordString);
TypeMapper <TestHasListThings> tm = TypeMapper <TestHasListThings> .Instance;
var t = new TestHasListThings();
tm.ToObject(document, t);
Assert.IsNotNull(t.TheThings);
Assert.AreEqual(1, t.TheThings.Count);
ODocument newODocument = ODocument.ToDocument(t);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void TestSerializeSubObject()
{
string recordString = "TestHasAThing@TheThing:(Value:17,Text:\"blah\")";
ODocument document = ODocument.Deserialize(recordString);
TypeMapper <TestHasAThing> tm = TypeMapper <TestHasAThing> .Instance;
var t = new TestHasAThing();
tm.ToObject(document, t);
Assert.IsNotNull(t.TheThing);
Assert.AreEqual(17, t.TheThing.Value);
Assert.AreEqual("blah", t.TheThing.Text);
ODocument newODocument = ODocument.ToDocument(t);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void TestSerializationMapping()
{
// important if you use ordered edges, since if more than 1 they appear as a list, if only one then as a single object, ie
// db.Create.Class<Person>().Extends("V").Run();
// db.Command("create property Person.in_FriendOf ANY");
// db.Command("alter property Person.in_FriendOf custom ordered=true");
string recordString = "TestObject@Value:17,Text:\"some text\",Link:#11:123,single:[#10:12345],list:[#11:123,#22:1234,#33:1234567]";
ODocument document = ODocument.Deserialize(recordString);
document.ORID = new ORID("#123:45");
Assert.AreEqual(document.HasField("single"), true);
Assert.AreEqual(document.HasField("Link"), true);
Assert.AreEqual(document.HasField("Value"), true);
Assert.AreEqual(document.HasField("Text"), true);
TypeMapper <TestObject> tm = TypeMapper <TestObject> .Instance;
var testObj = new TestObject();
tm.ToObject(document, testObj);
Assert.AreEqual("#123:45", testObj.ORID.RID);
Assert.AreEqual(17, testObj.Value);
Assert.AreEqual("some text", testObj.Text);
Assert.IsNotNull(testObj.Link);
Assert.AreEqual("#11:123", testObj.Link.RID);
Assert.IsNotNull(testObj);
Assert.IsNotNull(testObj.single);
Assert.IsNotNull(testObj.list);
Assert.AreEqual(1, testObj.single.Count);
Assert.AreEqual(3, testObj.list.Count);
ODocument newODocument = ODocument.ToDocument(testObj);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void TestSerializeSubObjectArray()
{
string recordString = "TestHasThings@TheThings:[(Value:17,Text:\"blah\"),(Value:18,Text:\"foo\")]";
ODocument document = ODocument.Deserialize(recordString);
TypeMapper <TestHasThings> tm = TypeMapper <TestHasThings> .Instance;
var t = new TestHasThings();
tm.ToObject(document, t);
Assert.IsNotNull(t.TheThings);
Assert.AreEqual(2, t.TheThings.Length);
Assert.AreEqual(18, t.TheThings[1].Value);
Assert.AreEqual("foo", t.TheThings[1].Text);
ODocument newODocument = ODocument.ToDocument(t);
var serialized = newODocument.Serialize();
Assert.AreEqual(recordString, serialized);
}
public void ShouldSerializeDateTime()
{
DateTime dateTime = DateTime.Now;
// get Unix time version
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
string timeString = ((long)((DateTime)dateTime - unixEpoch).TotalMilliseconds).ToString();
string recordString = "TestClass@DateTime:" + timeString + "t,embedded:(DateTime:" + timeString + "t)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("DateTime", dateTime)
.SetField("embedded.DateTime", dateTime);
string serializedRecord = document.Serialize();
Assert.AreEqual(serializedRecord, recordString);
}
public void ShouldSerializeStrings()
{
string recordString = "TestClass@String:\"Bra\\" + "\"vo \\\\ asdf\",Array:[\"foo\",\"bar\"],embedded:(String:\"Bra\\" + "\"vo \\\\ asdf\",Array:[\"foo\",\"bar\"])";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("String", "Bra\"vo \\ asdf")
.SetField("Array", new List<string> { "foo", "bar" })
.SetField("embedded.String", "Bra\"vo \\ asdf")
.SetField("embedded.Array", new List<string> { "foo", "bar" });
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
public void ShouldSerializeSetOfORIDs()
{
string recordString = "TestClass@Single:#8:0,Set:<#8:1,#8:2>,embedded:(Set:<#9:1,#9:2>)";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("Single", new ORID(8, 0))
.SetField("Set", new HashSet<ORID> { new ORID(8, 1), new ORID(8, 2) })
.SetField("embedded.Set", new HashSet<ORID> { new ORID(9, 1), new ORID(9, 2) });
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
public void ShouldSerializeListOfORIDs()
{
string recordString = "TestClass@Single:#8:0,Array:[#8:1,#8:2],embedded:(Array:[#9:1,#9:2])";
ODocument document = new ODocument()
.SetField("@ClassName", "TestClass")
.SetField("Single", new ORID(8, 0))
.SetField("Array", new List<ORID> { new ORID(8, 1), new ORID(8, 2) })
.SetField("embedded.Array", new List<ORID> { new ORID(9, 1), new ORID(9, 2) });
string serializedString = document.Serialize();
Assert.AreEqual(serializedString, recordString);
}
