public static void RunCollectionApplyTest()
{
var start = new CollectionHolder();
start.dict["foo1"] = "bar1";
start.dict["foo2"] = "bar2";
start.list = new List <int> {
1, 2
};
start.arr = new[] { true, false };
var end = new CollectionHolder();
end.dict["foo1"] = "baz";
end.list = new List <int> {
1, 3, 4
};
end.arr = new bool[] { };
// Compute in-memory representation.
var startModel = new SavedObject(start);
var endModel = new SavedObject(end);
// Compute differental.
var delta = new SavedObjectDelta(startModel, endModel);
// Apply differental.
delta.ApplyChanges(ref end);
// Compare.
CollectionAssert.AreEqual(start.dict, end.dict);
CollectionAssert.AreEqual(start.list, end.list);
CollectionAssert.AreEqual(start.arr, end.arr);
}
public virtual void Test()
{
CollectionHolder h1 = Subject();
StoreNewAndCommit(A().Provider(), h1);
ReplicateAll(A().Provider(), B().Provider());
IEnumerator it = B().Provider().GetStoredObjects(typeof(CollectionHolder)).GetEnumerator
();
Assert.IsTrue(it.MoveNext());
CollectionHolder replica = (CollectionHolder)it.Current;
B().Provider().Activate(replica);
AssertSameClassIfDb4o(h1.Map(), replica.Map());
foreach (object key in h1.Map().Keys)
{
B().Provider().Activate(replica.Map());
Assert.AreEqual(h1.Map()[key], replica.Map()[key]);
}
AssertSameClassIfDb4o(h1.Set(), replica.Set());
foreach (object element in h1.Set())
{
Assert.IsTrue(replica.Set().Contains(element));
}
AssertSameClassIfDb4o(h1.List(), replica.List());
Assert.AreEqual(h1.List().Count, replica.List().Count);
CollectionAssert.AreEqual(h1.List(), replica.List());
}
public static void RunCollectionTest()
{
var obj = new CollectionHolder();
obj.dict["foo1"] = "bar1";
obj.dict["foo2"] = "bar2";
obj.list.Add(1);
obj.list.Add(2);
obj.arr = new[] { true, false };
obj.nested = new CollectionHolder();
obj.nested.dict["nested1"] = "ack1";
obj.nested.arr = new[] { true };
Dictionary <ObjectDataPath[], object> model = new SavedObject(obj).state;
Dictionary <string, object> readableModel = SavedObjectDelta.ReadableModel(model);
// TODO: If list is null, we will include it, but if it is empty we will
// not
Assert.AreEqual(11, readableModel.Count);
Assert.AreEqual(obj.GetType(), readableModel["GetType()"]);
Assert.AreEqual("bar1", readableModel["dict.foo1"]);
Assert.AreEqual("bar2", readableModel["dict.foo2"]);
Assert.AreEqual(1, readableModel["list.0"]);
Assert.AreEqual(2, readableModel["list.1"]);
Assert.AreEqual(true, readableModel["arr.0"]);
Assert.AreEqual(false, readableModel["arr.1"]);
Assert.AreEqual(obj.nested.GetType(), readableModel["nested:GetType()"]);
Assert.AreEqual("ack1", readableModel["nested:dict.nested1"]);
Assert.AreEqual(true, readableModel["nested:arr.0"]);
Assert.AreEqual(null, readableModel["nested:nested"]);
}
private static void AssertCollectionIsNull(CollectionHolder <Item> holder, string collectionFieldName)
{
FieldInfo field = holder.GetType().GetField(collectionFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
Object fieldValue = field.GetValue(holder);
Assert.IsNull(fieldValue);
}
private static CollectionHolder <Item> RetrieveHolder(IObjectContainer db)
{
IObjectSet result = db.Query(typeof(CollectionHolder <Item>));
CollectionHolder <Item> holder = (CollectionHolder <Item>)result[0];
return(holder);
}
private CollectionHolder Initialize(CollectionHolder h1)
{
h1.Map()["1"] = "one";
h1.Map()["2"] = "two";
h1.Set().Add("two");
h1.List().Add("three");
return(h1);
}
private void AssertCollectionHolder(CollectionHolder holder)
{
var result = _serializer.Deserialize <CollectionHolder>(_serializer.Serialize(holder));
Assert.That(result.List, Is.EqualTo(holder.List));
Assert.That(result.Collection, Is.EqualTo(holder.Collection));
Assert.That(result.Enumerable, Is.EqualTo(holder.Enumerable));
}
public BasicCollectionProperty(Type type, PropertyFactory modelFactory)
{
CollectionValue = new CollectionHolder(type, modelFactory);
Value = CollectionValue.Value.Cast <object>().ToReactiveProperty();
CollectionValue.OnError.Subscribe(x => OnErrorSubject.OnNext(x));
Collection = CollectionValue.Collection.ToReadOnlyReactiveCollection(x => x.model);
}
//[Ignored("MapTypeHandler doesn't store comparer information")]
public void _TestComparerProperty()
{
Store(new CollectionHolder <ActivatableDictionary <string, int> >(new ActivatableDictionary <string, int>(new MyStringComparer("foo.comparer"))));
Reopen();
CollectionHolder <ActivatableDictionary <string, int> > instance = (CollectionHolder <ActivatableDictionary <string, int> >)RetrieveOnlyInstance(typeof(CollectionHolder <ActivatableDictionary <string, int> >));
Assert.AreEqual(new MyStringComparer("foo.comparer"), instance.Collection.Comparer);
}
private void CheckH1(CollectionHolder holder)
{
Assert.AreEqual("value", holder.Map()["key"]);
Assert.AreEqual(holder, holder.Map()["key2"]);
Assert.AreEqual("value2", holder.Map()[holder]);
Assert.AreEqual("one", holder.List()[0]);
Assert.AreEqual(holder, holder.List()[1]);
Assert.IsTrue(holder.Set().Contains("one"));
Assert.IsTrue(holder.Set().Contains(holder));
}
public ReferenceByIntCollectionProperty(ReferencableMasterInfo source, string idPropertyName, PropertyFactory factory)
{
Source = source;
IdPropertyName = idPropertyName;
CollectionValue = new CollectionHolder(typeof(int[]), factory);
Value = CollectionValue.Value
.Cast <object>()
.ToReactiveProperty();
CollectionValue.OnError.Subscribe(x => OnErrorSubject.OnNext(x));
Collection = CollectionValue.Collection.ToReadOnlyReactiveCollection(x => x.model);
}
private void CheckH2(CollectionHolder holder)
{
Assert.AreEqual("h1", ((CollectionHolder)holder.Map()["key"]).Name());
Assert.AreEqual("h1", ((CollectionHolder)holder.Map()[holder]).Name());
Assert.AreEqual("two", holder.List()[0]);
Assert.AreEqual("h1", ((CollectionHolder)holder.List()[1]).Name());
Assert.AreEqual(holder, holder.List()[2]);
Assert.IsTrue(holder.Set().Remove("two"));
Assert.IsTrue(holder.Set().Remove(holder));
CollectionHolder remaining = NextCollectionHolder(holder.Set().GetEnumerator());
Assert.AreEqual("h1", remaining.Name());
}
public void SelectMethodsReturnsEmptyEnumerableWhenOwnerDoesNotHaveMethod()
{
// Arrange
var owner = new CollectionHolder <string>().Collection;
var methodName = string.Empty;
var sut = new InstanceMethodQuery(owner, methodName);
// Act
var result = sut.SelectMethods();
// Assert
Assert.Empty(result);
}
private static void StoreTestData(IObjectContainer container)
{
for (int i = 0; i < NumberOfItems; i++)
{
Item item = new Item(i);
container.Store(ObjectHolder.Create(item));
container.Store(
CollectionHolder.Create(
item,
new Item(NumberOfItems + i),
new Item(2 * NumberOfItems + i)));
}
}
private void Check(CollectionHolder holder, CollectionHolder original1, CollectionHolder
original2)
{
Assert.IsTrue(holder != original1);
Assert.IsTrue(holder != original2);
if (holder.Name().Equals("h1"))
{
CheckH1(holder);
}
else
{
CheckH2(holder);
}
}
private void StoreTestData(IObjectContainer container)
{
for (int i = 0; i < NumberOfItems; i++)
{
var item = new Item(i);
container.Store(ItemHolder.Create(item));
container.Store(GenericHolder.Create(item));
container.Store(
CollectionHolder.Create(
item,
new Item(NumberOfItems + i),
new Item(2 * NumberOfItems + i)));
}
container.Commit();
}
public void ExecuteFillsReadonlyCollectionProperty()
{
// Arrange
var sut = new ReadonlyCollectionPropertiesCommand();
var specimen = new CollectionHolder <string>();
var container = new DelegatingSpecimenContext
{
OnResolve = r => new Fixture().CreateMany <string>()
};
// Act
sut.Execute(specimen, container);
// Assert
Assert.NotEmpty(specimen.Collection);
}
public ProtocolsControl()
{
this.ProtocolHolder = new ValueHolder <Protocol>();
this.AllProtocolsHolder = new CollectionHolder <Protocol>();
this.AllProtocolsHolder.CollectionChanged += new CollectionChangedEventHandler(this.AllProtocolsChanged);
InitializeComponent();
this.protocolDefinitionControl.ProtocolHolder = this.ProtocolHolder;
this.protocolDefinitionControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.protocolGlobalControl.ProtocolHolder = this.ProtocolHolder;
this.protocolMessagesControl.ProtocolHolder = this.ProtocolHolder;
this.conformingProtocolsControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.conformingProtocolsControl.ProtocolHolder = this.ProtocolHolder;
this.conformsToProtocolsControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.conformsToProtocolsControl.ProtocolHolder = this.ProtocolHolder;
this.FillView();
}
public ProtocolsControl()
{
this.ProtocolHolder = new ValueHolder<Protocol>();
this.AllProtocolsHolder = new CollectionHolder<Protocol>();
this.AllProtocolsHolder.CollectionChanged += new CollectionChangedEventHandler(this.AllProtocolsChanged);
InitializeComponent();
this.protocolDefinitionControl.ProtocolHolder = this.ProtocolHolder;
this.protocolDefinitionControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.protocolGlobalControl.ProtocolHolder = this.ProtocolHolder;
this.protocolMessagesControl.ProtocolHolder = this.ProtocolHolder;
this.conformingProtocolsControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.conformingProtocolsControl.ProtocolHolder = this.ProtocolHolder;
this.conformsToProtocolsControl.AllProtocolsHolder = this.AllProtocolsHolder;
this.conformsToProtocolsControl.ProtocolHolder = this.ProtocolHolder;
this.FillView();
}
private void TestTransparentPersistence()
{
WithDatabase(delegate(IObjectContainer db)
{
AssertActivationCount(typeof(ActivatableList <Item>), 0);
CollectionHolder <Item> holder = RetrieveHolder(db);
holder.List.Clear();
AssertActivationCount(typeof(ActivatableList <Item>), 1);
});
WithDatabase(delegate(IObjectContainer db)
{
AssertActivationCount(typeof(ActivatableList <Item>), 0);
CollectionHolder <Item> holder = RetrieveHolder(db);
Assert.AreEqual(0, holder.List.Count);
});
}
public void SelectMethodsReturnsMethodFromOwner()
{
// Arrange
var owner = new CollectionHolder <string>().Collection;
var methodName = nameof(CollectionHolder <string> .Collection.Add);
var expectedContents = string.Empty;
var sut = new InstanceMethodQuery(owner, methodName);
// Act
var result = sut.SelectMethods();
var enumerable = result.ToArray();
enumerable.Single().Invoke(new[] { expectedContents });
// Assert
Assert.Single(enumerable);
Assert.Single(owner, expectedContents);
}
protected virtual void ActualTest()
{
if (!A().Provider().SupportsHybridCollection())
{
return;
}
if (!B().Provider().SupportsHybridCollection())
{
return;
}
CollectionHolder h1 = new CollectionHolder("h1");
CollectionHolder h2 = new CollectionHolder("h2");
h1.Map()["key"] = "value";
h1.Map()["key2"] = h1;
h1.Map()[h1] = "value2";
h2.Map()["key"] = h1;
h2.Map()[h2] = h1;
h1.List().Add("one");
h1.List().Add(h1);
h2.List().Add("two");
h2.List().Add(h1);
h2.List().Add(h2);
h1.Set().Add("one");
h1.Set().Add(h1);
h2.Set().Add("two");
h2.Set().Add(h1);
h2.Set().Add(h2);
B().Provider().StoreNew(h2);
B().Provider().StoreNew(h1);
IReplicationSession replication = new GenericReplicationSession(A().Provider(), B
().Provider());
replication.Replicate(h2);
//Traverses to h1.
replication.Commit();
IEnumerator objects = A().Provider().GetStoredObjects(typeof(CollectionHolder)).GetEnumerator
();
Check(NextCollectionHolder(objects), h1, h2);
Check(NextCollectionHolder(objects), h1, h2);
}
private void AssertItemActivation(
CollectionHolder <Item> holder,
Func <CollectionHolder <Item>, object> collectionExtractor,
Func <object, Item> itemExtractor,
Type collectionType)
{
Reset();
AssertNoActivation(typeof(List <Item>), typeof(Dictionary <string, Item>));
AssertActivationCount(typeof(Item), 0);
AssertActivationCount(collectionType, 0);
Item item = itemExtractor(collectionExtractor(holder));
AssertActivationCount(collectionType, 1);
AssertActivationCount(typeof(Item), 0);
Assert.AreEqual(ItemName, item.Name);
AssertActivationCount(typeof(Item), 1);
}
public static void RunCollectionTest()
{
var obj = new CollectionHolder();
obj.dict["foo1"] = "bar1";
obj.dict["foo2"] = "bar2";
obj.list.Add(1);
obj.list.Add(2);
obj.arr = new[] { true, false };
obj.nested = new CollectionHolder();
obj.nested.dict["nested1"] = "ack1";
obj.nested.arr = new[] { true };
Dictionary<ObjectDataPath[], object> model = new SavedObject(obj).state;
Dictionary<string, object> readableModel = SavedObjectDelta.ReadableModel(model);
// TODO: If list is null, we will include it, but if it is empty we will
// not
Assert.AreEqual(11, readableModel.Count);
Assert.AreEqual(obj.GetType(), readableModel["GetType()"]);
Assert.AreEqual("bar1", readableModel["dict.foo1"]);
Assert.AreEqual("bar2", readableModel["dict.foo2"]);
Assert.AreEqual(1, readableModel["list.0"]);
Assert.AreEqual(2, readableModel["list.1"]);
Assert.AreEqual(true, readableModel["arr.0"]);
Assert.AreEqual(false, readableModel["arr.1"]);
Assert.AreEqual(obj.nested.GetType(), readableModel["nested:GetType()"]);
Assert.AreEqual("ack1", readableModel["nested:dict.nested1"]);
Assert.AreEqual(true, readableModel["nested:arr.0"]);
Assert.AreEqual(null, readableModel["nested:nested"]);
}
private static void AssertCollectionsAreNull(CollectionHolder<Item> holder)
{
AssertCollectionIsNull(holder, "_list");
AssertCollectionIsNull(holder, "_dictionary");
}
private void AssertItemActivation(
CollectionHolder<Item> holder,
Func<CollectionHolder<Item>, object> collectionExtractor,
Func<object, Item> itemExtractor,
Type collectionType)
{
Reset();
AssertNoActivation(typeof(List<Item>), typeof(Dictionary<string, Item>));
AssertActivationCount(typeof(Item), 0);
AssertActivationCount(collectionType, 0);
Item item = itemExtractor(collectionExtractor(holder));
AssertActivationCount(collectionType, 1);
AssertActivationCount(typeof(Item), 0);
Assert.AreEqual(ItemName, item.Name);
AssertActivationCount(typeof(Item), 1);
}
private void Run()
{
DeleteDatabaseFile();
try
{
WithDatabase(delegate(IObjectContainer db)
{
db.Store(new CollectionHolder <Item>("Holder", new Item(ItemName)));
});
WithDatabase(delegate(IObjectContainer db)
{
CollectionHolder <Item> holder = RetrieveHolder(db);
AssertCollectionsAreNull(holder);
AssertItemActivation(
holder,
delegate(CollectionHolder <Item> collectionHolder)
{
return(collectionHolder.List);
},
delegate(object obj)
{
IList <Item> list = (IList <Item>)obj;
return(list[0]);
},
typeof(ActivatableList <Item>));
});
WithDatabase(delegate(IObjectContainer db)
{
CollectionHolder <Item> holder = RetrieveHolder(db);
AssertCollectionsAreNull(holder);
AssertItemActivation(
holder,
delegate(CollectionHolder <Item> collectionHolder)
{
return(collectionHolder.Dictionary);
},
delegate(object obj)
{
IDictionary <string, Item> dictionary = (IDictionary <string, Item>)obj;
return(dictionary[new Item(ItemName).ToString()]);
},
typeof(ActivatableDictionary <string, Item>));
});
TestTransparentPersistence();
}
catch (Exception ex)
{
Assert.Fail("Test failed.", ex);
}
DeleteDatabaseFile();
}
private static void AssertCollectionIsNull(CollectionHolder<Item> holder, string collectionFieldName)
{
FieldInfo field = holder.GetType().GetField(collectionFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
Object fieldValue = field.GetValue(holder);
Assert.IsNull(fieldValue);
}
private static void AssertCollectionsAreNull(CollectionHolder <Item> holder)
{
AssertCollectionIsNull(holder, "_list");
AssertCollectionIsNull(holder, "_dictionary");
}
public static void RunCollectionApplyTest()
{
var start = new CollectionHolder();
start.dict["foo1"] = "bar1";
start.dict["foo2"] = "bar2";
start.list = new List<int> { 1, 2 };
start.arr = new[] { true, false };
var end = new CollectionHolder();
end.dict["foo1"] = "baz";
end.list = new List<int> { 1, 3, 4 };
end.arr = new bool[] { };
// Compute in-memory representation.
var startModel = new SavedObject(start);
var endModel = new SavedObject(end);
// Compute differental.
var delta = new SavedObjectDelta(startModel, endModel);
// Apply differental.
delta.ApplyChanges(ref end);
// Compare.
CollectionAssert.AreEqual(start.dict, end.dict);
CollectionAssert.AreEqual(start.list, end.list);
CollectionAssert.AreEqual(start.arr, end.arr);
}
protected override IList <ICollectionElement> SingleCollection()
{
CollectionHolder <IList <ICollectionElement> > holder = (CollectionHolder <IList <ICollectionElement> >)RetrieveOnlyInstance(typeof(CollectionHolder <IList <ICollectionElement> >));
return(holder.Collection);
}
private void StoreNewAndCommit(ITestableReplicationProviderInside provider, CollectionHolder
h1)
{
provider.StoreNew(h1);
provider.Activate(h1);
provider.Commit();
}
