public void ReloadSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
// Creates a second dictionnary to load previous data (with skippedFragments)
string path = TestBase.GetTestFilePath("SharedDic", "ReloadSkippedFragments");
SharedDicTestContext.Write("Test", path, dic, this);
IList <ReadElementObjectInfo> errors;
ISharedDictionary dic2 = SharedDicTestContext.Read("Test", path, this, d => d.Ensure(uid1), out errors);
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(implDic2.Fragments.Count, Is.EqualTo(1));
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
// Now we have skippedFragments. Let's try to reload it.
dic2.Ensure(uid2);
Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1"));
Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2"));
Assert.That(implDic2.Fragments.Count, Is.EqualTo(0));
}
public void CreateSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
string path = TestBase.GetTestFilePath("SharedDic", "SkippedFragments");
SharedDicTestContext.Write("Test", path, dic, this);
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(dic.Fragments.Count, Is.EqualTo(0), "There is no skipped fragments for this dic.");
// Creates a second dictionnary to load previous data (with skippedFragments)
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dic2 = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
dic2.Ensure(uid1);
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(dic2.Fragments.Count, Is.EqualTo(1));
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
}
public void Setup()
{
_lastConfigChangedEventArgs = null;
_lastSender = null;
_dic = new SharedDictionaryImpl(null);
_dic.Changed += (o, e) => { _lastSender = o; _lastConfigChangedEventArgs = e; };
}
SharedDictionaryImpl CreateDummySharedDic(object dataHolder, params INamedVersionedUniqueId[] identifiers)
{
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
foreach (INamedVersionedUniqueId id in identifiers)
{
dic[dataHolder, id, "key1"] = "value1";
dic[dataHolder, id, "key2"] = "value2";
}
return(dic);
}
public void None()
{
SharedDictionaryImpl source = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
source[this, SharedDicTestContext.Plugins[0], "key1"] = "value1";
source[this, SharedDicTestContext.Plugins[0], "key2"] = "value2";
source[this, SharedDicTestContext.Plugins[0], "key3"] = "value3";
object key = new object();
SharedDictionaryImpl target = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
target[key, SharedDicTestContext.Plugins[1], "previousKey"] = "previousValue";
target.Import(source, MergeMode.None);
Assert.IsNull(target[key, SharedDicTestContext.Plugins[1], "previousKey"]);
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key1"] == "value1");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key2"] == "value2");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key3"] == "value3");
}
public void ImportReloadedSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", "ImportReloadedSkippedFragments");
#region Creates actual fragments
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
SharedDicTestContext.Write("Test", path, dic, this);
// Creates a second dictionnary to load previous data (with skippedFragments).
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(dicFrag.GetSkippedFragments(this).Count == 2);
Assert.That(dicFrag[this, uid1, "key1"], Is.Null);
Assert.That(dicFrag[this, uid2, "key2"], Is.Null);
#endregion
ISharedDictionary dic2 = SharedDictionary.Create(SharedDicTestContext.ServiceProvider);
dic2[this, uid1, "key1"] = "value1";
dic2[this, uid1, "key2"] = "value2";
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
dic2.Ensure(uid2);
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
implDic2.ImportFragments(dicFrag.Fragments, MergeMode.None);
Assert.That(implDic2.GetSkippedFragments(this) == null);
Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1"));
Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2"));
}
public void ReplaceExisting()
{
object key = new object();
SharedDictionaryImpl source = new SharedDictionaryImpl(null);
source[this, SharedDicTestContext.Plugins[0], "key1"] = "value1";
source[this, SharedDicTestContext.Plugins[0], "key2"] = "value2";
source[this, SharedDicTestContext.Plugins[0], "key3"] = "value3";
source[key, SharedDicTestContext.Plugins[1], "previousKey"] = "value";
SharedDictionaryImpl target = new SharedDictionaryImpl(null);
target[key, SharedDicTestContext.Plugins[1], "previousKey"] = "previousValue";
target.Import(source, MergeMode.ReplaceExisting);
Assert.That((string)target[key, SharedDicTestContext.Plugins[1], "previousKey"] == "value");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key1"] == "value1");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key2"] == "value2");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key3"] == "value3");
}
public void MergeFragments_PreserveExisting()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
INamedVersionedUniqueId uid3 = SharedDicTestContext.Plugins[2];
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
dic[this, uid1, "key1"] = "value1";
dic[this, uid1, "key2"] = "value2";
dic[this, uid2, "key1"] = "value1";
dic[this, uid2, "key2"] = "value2";
dic[this, uid3, "key1"] = "value1";
dic[this, uid3, "key2"] = "value2";
string path = TestBase.GetTestFilePath("SharedDic", "MergeFragments");
SharedDicTestContext.Write("Test", path, dic, this);
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, d => { d.Ensure(uid1); d.Ensure(uid2); }, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
int hashCode = dicFrag.GetSkippedFragments(this)[0].GetHashCode();
dicFrag.ImportFragments(dicFullFrag.Fragments, MergeMode.PreserveExisting);
Assert.That(dicFrag.GetSkippedFragments(this) != null);
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
Assert.That(dicFrag.GetSkippedFragments(this)[0].GetHashCode() == hashCode);
}
public void MergeFragments_ErrorDuplicate()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
INamedVersionedUniqueId uid3 = SharedDicTestContext.Plugins[2];
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
dic[this, uid1, "key1"] = "value1";
dic[this, uid1, "key2"] = "value2";
dic[this, uid2, "key1"] = "value1";
dic[this, uid2, "key2"] = "value2";
dic[this, uid3, "key1"] = "value1";
dic[this, uid3, "key2"] = "value2";
Assert.That(dic.Contains(uid1) && dic.Contains(uid2) && dic.Contains(uid3));
string path = TestBase.GetTestFilePath("SharedDic", "ErrorDuplicate");
SharedDicTestContext.Write("Test", path, dic, this);
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, d => { d.Ensure(uid1); d.Ensure(uid2); }, out errors);
Assert.That(errors.Count == 0);
Assert.That(dic.GetSkippedFragments(this) == null);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
Assert.Throws <CKException>(() => dicFrag.ImportFragments(dicFullFrag.Fragments, MergeMode.ErrorOnDuplicate));
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
}
public void ReplaceExistingTryMerge()
{
object key = new object();
SharedDictionaryImpl source = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
source[this, SharedDicTestContext.Plugins[0], "key1"] = "value1";
source[this, SharedDicTestContext.Plugins[0], "key2"] = "value2";
source[this, SharedDicTestContext.Plugins[0], "key3"] = "value3";
source[this, SharedDicTestContext.Plugins[0], "key4"] = "newValue";
MergeableObject mergeableObj = new MergeableObject()
{
Property = 10
};
source[key, SharedDicTestContext.Plugins[1], "mergeableObject"] = mergeableObj;
SharedDictionaryImpl target = new SharedDictionaryImpl(null);
MergeableObject newMergeableObj = new MergeableObject()
{
Property = 20
};
target[key, SharedDicTestContext.Plugins[1], "mergeableObject"] = newMergeableObj;
target[this, SharedDicTestContext.Plugins[0], "key4"] = "value4";
target.Import(source, MergeMode.ReplaceExistingTryMerge);
Assert.That(((MergeableObject)target[key, SharedDicTestContext.Plugins[1], "mergeableObject"]).GetHashCode() == newMergeableObj.GetHashCode());
Assert.That(((MergeableObject)target[key, SharedDicTestContext.Plugins[1], "mergeableObject"]).Property == 30);
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key1"] == "value1");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key2"] == "value2");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key3"] == "value3");
Assert.That((string)target[this, SharedDicTestContext.Plugins[0], "key4"] == "newValue");
}
private static void CheckAllDataLoaded(object rootObject, ITestObject complexObject, SimpleNamedVersionedUniqueId p1, SimpleNamedVersionedUniqueId p2, SharedDictionaryImpl dic)
{
ITestObject obj = (ITestObject)dic[rootObject, p1, "complexObject"];
Assert.That(obj != null);
Assert.That(obj.Value == complexObject.Value);
string value = (string)dic[obj, p2, "subKey"];
Assert.That(value == "subValue");
}
void TryReloadNestedSkippedFragments(ITestObject complexObject)
{
object rootObject = new object();
SimpleNamedVersionedUniqueId p1 = new SimpleNamedVersionedUniqueId(Guid.NewGuid(), new Version(1, 0, 0), "plugin1");
SimpleNamedVersionedUniqueId p2 = new SimpleNamedVersionedUniqueId(Guid.NewGuid(), new Version(1, 0, 0), "plugin2");
string path = TestBase.GetTestFilePath("SharedDic", "NestedSkippedFragments");
// Write !
{
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
dic[rootObject, p1, "complexObject"] = complexObject;
dic[complexObject, p2, "subKey"] = "subValue";
SharedDicTestContext.Write("Test", path, dic, rootObject);
TestBase.DumpFileToConsole(path);
}
// Read nothing then p1 and p2
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, out errors);
dic.Ensure(p1);
dic.Ensure(p2);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
// Read nothing then p2 and p1
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, out errors);
dic.Ensure(p2);
dic.Ensure(p1);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
// Ensure p1 then read p2
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, d => d.Ensure(p1), out errors);
dic.Ensure(p2);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
// Ensure p2 then read p1
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, d => d.Ensure(p2), out errors);
dic.Ensure(p1);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
// Ensure p1 and p2 then read nothing
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, d => { d.Ensure(p1); d.Ensure(p2); }, out errors);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
// Ensure p2 and p1 then read nothing
{
IList <ReadElementObjectInfo> errors = new List <ReadElementObjectInfo>();
SharedDictionaryImpl dic = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, rootObject, d => { d.Ensure(p2); d.Ensure(p1); }, out errors);
CheckAllDataLoaded(rootObject, complexObject, p1, p2, dic);
}
}
public void SyncDestroyObject()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
INamedVersionedUniqueId uid3 = SharedDicTestContext.Plugins[2];
string path = TestBase.GetTestFilePath("SharedDic", "MergeFragments");
SharedDictionaryImpl dicFullFrag;
// Create fragments file.
{
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
dic[this, uid1, "key1"] = "value1";
dic[this, uid1, "key2"] = "value2";
dic[this, uid2, "key1"] = "value1";
dic[this, uid2, "key2"] = "value2";
dic[this, uid3, "key1"] = "value1";
dic[this, uid3, "key2"] = "value2";
SharedDicTestContext.Write("Test", path, dic, this);
}
{
IList <ReadElementObjectInfo> errors;
dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
dicFullFrag.Destroy(this);
Assert.That(dicFullFrag.GetSkippedFragments(this) == null, "Destroying the object destroyed the fragments.");
}
{
IList <ReadElementObjectInfo> errors;
dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
// If we Ensure() the id, then the fragment will be restored.
// We test here the ClearFragments internal.
dicFullFrag.ClearFragments(uid1);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 2, "Destroying the fragment explicitely.");
dicFullFrag.Destroy(uid2);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 1, "Destroying the fragment explicitely.");
dicFullFrag.Destroy(uid3);
Assert.That(dicFullFrag.GetSkippedFragments(this) == null, "Destroying the fragment explicitely.");
}
{
IList <ReadElementObjectInfo> errors;
dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
// This destroy an unknown plugin:
// we must destroy the fragments even if the id is not known.
dicFullFrag.Destroy(uid2);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 2, "Destroying the fragment via an unknown Id.");
dicFullFrag.Destroy(uid3);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 1, "Destroying the fragment via an unknown Id.");
// No op.
dicFullFrag.Destroy(uid3);
dicFullFrag.Destroy(uid1);
Assert.That(dicFullFrag.GetSkippedFragments(this) == null);
}
{
IList <ReadElementObjectInfo> errors;
dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
dicFullFrag.ClearAll();
Assert.That(dicFullFrag.GetSkippedFragments(this) == null);
}
}
public void SimpleConfig()
{
INamedVersionedUniqueId id1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId id2 = SharedDicTestContext.Plugins[1];
SharedDictionaryImpl dic1 = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
// 1 - Writes the data to the file without any skipped fragments since we do not have any yet.
dic1[this, id1, "AnIntParam"] = 1;
dic1[this, id1, "ABoolParam"] = true;
dic1[this, id1, "AStringParam"] = "This marvellous API works!";
dic1[this, id1, "ANullObject"] = null;
dic1[this, id2, "AnIntParam"] = 1;
dic1[this, id2, "ABoolParam"] = true;
dic1[this, id2, "AStringParam"] = "This must not be reloaded since the plugin is not runnable for dic2.";
Assert.That(dic1.Contains(id1) && dic1.Contains(id2));
string path1 = TestBase.GetTestFilePath("SharedDic", "SimpleConfig");
SharedDicTestContext.Write("Test", path1, dic1, this);
Assert.IsTrue(new FileInfo(path1).Length > 0, "File must exist and be not empty.");
// 2 - Reloads the file in another dictionary: fragments are now updated with data from the not runnable plugin.
IList <ReadElementObjectInfo> errors;
ISharedDictionary dic2 = SharedDicTestContext.Read("Test", path1, this, d => d.Ensure(id1), out errors);
Assert.AreEqual(0, errors.Count, "This file has no errors in it.");
Assert.That(dic1[this, id1, "AnIntParam"], Is.EqualTo(dic2[this, id1, "AnIntParam"]));
Assert.That(dic1[this, id1, "ABoolParam"], Is.EqualTo(dic2[this, id1, "ABoolParam"]));
Assert.That(dic1[this, id1, "AStringParam"], Is.EqualTo(dic2[this, id1, "AStringParam"]));
Assert.That(dic1[this, id1, "ANullObject"], Is.EqualTo(dic2[this, id1, "ANullObject"]));
Assert.That(dic1.Contains(this, id1, "ANullObject") && dic2.Contains(this, id1, "ANullObject"), "The null value has a key.");
Assert.That(dic2.Contains(this, id2, "AnUnexistingKey"), Is.False, "Any other key is not defined.");
// _notRunnables data are not loaded...
Assert.That(dic2[this, id2, "AnIntParam"], Is.Null);
Assert.That(dic2.Contains(this, id2, "AnIntParam"), Is.False);
Assert.That(dic2[this, id2, "ABoolParam"], Is.Null);
Assert.That(dic2.Contains(this, id2, "ABoolParam"), Is.False);
Assert.That(dic2[this, id2, "AStringParam"], Is.Null);
Assert.That(dic2.Contains(this, id2, "AStringParam"), Is.False);
Assert.That(dic2.Contains(this, id2, "ANullObject"), Is.False);
// 3 - Rewrites the file n°2 from dic2 with the skipped fragments.
string path2 = TestBase.GetTestFilePath("SharedDic", "SimpleConfig2");
SharedDicTestContext.Write("Test", path2, dic2, this);
Assert.IsTrue(new FileInfo(path2).Length > 0, "File must exist and be not empty.");
// Files are not equal due to whitespace handling and node reordering.
// To compare them we should reload the 2 documents and to be independant of the element ordering
// we need to ensure that every element of d1 exists with the same attributes in d2 and vice-versa.
// 4 - In fragments, we have the NotRunnables[0] plugin fragment.
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
Assert.That(implDic2.GetSkippedFragments(this).Count == 1);
Assert.That(implDic2.GetSkippedFragments(this)[0].PluginId == id2.UniqueId);
// Activate the previously not runnable plugin.
dic2.Ensure(id2);
Assert.That(implDic2.GetSkippedFragments(this), Is.Null, "Fragment has been read (no more fragments).");
Assert.AreEqual(dic1[this, id2, "AnIntParam"], dic2[this, id1, "AnIntParam"]);
Assert.AreEqual(dic1[this, id2, "ABoolParam"], dic2[this, id1, "ABoolParam"]);
Assert.AreEqual(dic1[this, id2, "AStringParam"], "This must not be reloaded since the plugin is not runnable for dic2.");
Assert.AreEqual(dic1[this, id1, "AStringParam"], "This marvellous API works!");
}