public void PersistAndFind()
{
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(eb1.RowKey.Equals(Guid.Empty));
em.Persist(eb2);
Assert.IsFalse(eb2.RowKey.Equals(Guid.Empty));
Assert.IsFalse(eb2.A.RowKey.Equals(Guid.Empty));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.RowKey);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.RowKey);
Assert.AreEqual(eb2, _eb2);
}
}
public void PersistChildren()
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC {
A = new EntityA(), B = new EntityB()
};
TestBase.TestSerialization(ec2);
var ec3 = new EntityC {
X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
Assert.IsFalse(ec2.A.Id.Equals(Guid.Empty));
Assert.IsFalse(ec2.B.Id.Equals(Guid.Empty));
em.Persist(ec3);
Assert.IsFalse(string.IsNullOrEmpty(ec3.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.X.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.Y.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ea2 = em.Find <EntityA>(ec2.A.Id);
Assert.AreEqual(ec2.A, _ea2);
var _eb2 = em.Find <EntityB>(ec2.B.Id);
Assert.AreEqual(ec2.B, _eb2);
var _ec2 = em.Find <EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
var _ex3 = em.Find <EntityX>(ec3.X.Id);
Assert.AreEqual(ec3.X, _ex3);
var _ey3 = em.Find <EntityY>(ec3.Y.Id);
Assert.AreEqual(ec3.Y, _ey3);
var _ec3 = em.Find <EntityC>(ec3.Id);
Assert.AreEqual(ec3, _ec3);
}
}
public void PersistAndFind()
{
var p = new Parent("0");
p.Children.Add(new Child("X"));
p.Children.Add(new Child("Y"));
p.Children.Add(new Child("Z"));
TestBase.TestSerialization(p);
using (var em = Emf.CreateEntityManager())
{
em.Persist(p, Behaviors.CreateNew);
Assert.AreEqual("0", p.Id);
Assert.AreEqual("X", p.Children[0].Id);
Assert.AreEqual("Y", p.Children[1].Id);
Assert.AreEqual("Z", p.Children[2].Id);
}
using (var em = Emf.CreateEntityManager())
{
var _p = em.Find <Parent>(p.Id);
Assert.AreEqual(p, _p);
}
using (var em = Emf.CreateEntityManager())
{
var _b = em.Fetch <Base>(new[] { typeof(Parent), typeof(Child) });
var _p = _b.OfType <Parent>().First();
Assert.AreEqual(p, _p);
var i = 0;
foreach (var c in _b.OfType <Child>().OrderBy(c => c.Id))
{
Assert.AreEqual(p.Children[i], c);
Assert.AreSame(_p.Children[i++], c);
}
}
}
public void PersistBehaviors()
{
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
var _ea1 = em.Find <EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(ea1, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
}
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(2, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
var _ea1 = em.Find <EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch <EntityA>().Count());
Assert.AreEqual(4, em.Fetch <EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch <EntityA>().Count());
Assert.AreEqual(4, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
}
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsFalse(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityB), new KeyBindingEntityB()));
{
var cb = new ColumnBinding("e");
Assert.IsTrue(bindings.RegisterColumnBinding(typeof(EntityC), cb));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityC), new KeyBinding <EntityC>(e => e.Name)));
}
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier));
Assert.IsTrue(eb1.Key.Row.StartsWith(typeof(EntityB).Name));
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier));
Assert.IsTrue(eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
Assert.IsTrue(_eb1.Key.Row.StartsWith(_eb1.GetType().Name));
var _ea2 = em.Find <EntityA>(eb2.A.Name); // EntityA key binding uses the Name property as row key
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
Assert.IsTrue(_eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.AreEqual(eb2.A.Name, _eb2.A.Name);
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
var ec1 = new EntityC {
Name = "11", A = new EntityA()
};
TestBase.TestSerialization(ec1);
var ec2 = new EntityC {
Name = "222", A = new EntityA(), B = new EntityB()
};
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.AreEqual(ec1.Id, ec1.Name);
em.Persist(ec2);
Assert.AreEqual(ec2.Id, ec2.Name);
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>("11");
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find <EntityC>(ec2);
Assert.AreEqual(ec2, _ec2);
}
bindings.UnregisterBinding(typeof(EntityA));
bindings.UnregisterBinding(typeof(EntityB));
bindings.UnregisterBinding(typeof(EntityC));
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsFalse(bindings.StrictExplicitColumnBinding);
Assert.IsFalse(bindings.StrictExplicitKeyBinding);
Assert.IsFalse(bindings.StrictExplicitTableBinding);
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsFalse(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityB), new TableBindingEntityB()));
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
Assert.IsTrue(em.IsTypeDeclared <EntityA>());
Assert.IsTrue(em.IsTypeDeclared <EntityB>());
em.Configuration.Binding.StrictExplicitTableBinding = true;
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier));
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier));
Assert.IsNotNull(eb2.A.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.A.Key.ColumnQualifier));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.Key);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
}
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsFalse(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityB)));
}
void WriteRectL(Emf.RectL r)
{
byte[] data = RawSerialize(r);
ms.Write(data, 0, data.Length);
}
void WriteRecordHeader(Emf.RecordType record, uint size)
{
Emf.RecordHeader r;
r.Type = (uint)record;
r.Size = size;
byte[] buf = RawSerialize(r);
ms.Write(buf, 0, buf.Length);
// need this for Emf.Header
numRecords++;
}
