private IMultiKeyMap <T, K, V> AddHelper <T, K, V>(T t, K k, V v,
MultiKeyMaps.MultiKeyCreationStrategy strategy) where K : class, IEnumerable <T>
{
KeyValuePair <K, V> expectedEntry = new KeyValuePair <K, V>(k, v);
var multiDict = MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(strategy);
multiDict.Should().NotBeNull().And.BeEmpty().And.BeAssignableTo(typeof(IMultiKeyMap <T, K, V>))
.And.BeAssignableTo(typeof(IDictionary <K, V>));
multiDict.Add(k, v);
multiDict.Should().NotBeEmpty().And.ContainKey(k).And.ContainValue(v).And.Contain(expectedEntry).And.HaveCount(1);
bool result = multiDict.TryGetFullKeysByPartialKey(k, out var actualKeys);
result.Should().BeTrue();
actualKeys.Should().NotBeNullOrEmpty().And.HaveCount(1).And.HaveElementAt(0, k);
result = multiDict.TryGetValuesByPartialKey(k, out var actualValues);
result.Should().BeTrue();
actualValues.Should().NotBeNullOrEmpty().And.HaveCount(1).And.HaveElementAt(0, v);
result = multiDict.TryGetEntriesByPartialKey(k, out var actualEntries);
result.Should().BeTrue();
actualEntries.Should().NotBeNullOrEmpty().And.HaveCount(1).And.HaveElementAt(0, expectedEntry);
return(multiDict);
}
private void DictionaryBasedAddHelper <T, K, V>(
MultiKeyMaps.MultiKeyCreationStrategy strategy, K[] ks, V[] vs,
IEqualityComparer <T> subKeyComparer = null, IEqualityComparer <K> fullKeyComparer = null) where K : class, IEnumerable <T>
{
subKeyComparer = subKeyComparer ?? EqualityComparer <T> .Default;
fullKeyComparer = fullKeyComparer ?? EqualityComparer <K> .Default;
AddHelper(() => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(subKeyComparer, fullKeyComparer, strategy), ks, vs, subKeyComparer, fullKeyComparer);
}
private void CopyFromDictionaryToEmptyHelper <T, K, V>(K[] keys, V[] values) where K : class, IEnumerable <T>
{
var source = TestHelpers.CreateDictionary <T, K, V>(keys, values);
var target = MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>();
var result = MultiKeyMapCopyExtensions.CopyFrom(target, source);
result.Should().NotBeNull().And.BeSameAs(target).And.Equal(source);
}
private IMultiKeyMap <T, K, V> CreatesEmptyInstanceHelper <T, K, V>(T t, K k, V v,
MultiKeyMaps.MultiKeyCreationStrategy strategy) where K : class, IEnumerable <T>
{
var multiDict = MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(strategy);
Assert.IsNotNull(multiDict);
Assert.IsInstanceOfType(multiDict, typeof(IMultiKeyMap <T, K, V>));
Assert.IsInstanceOfType(multiDict, typeof(IDictionary <K, V>));
Assert.IsTrue(multiDict.Count == 0);
return(multiDict);
}
private IMultiKeyMap <T, K, V> CreateMultiKeyDictionaryWithComparersHelper <T, K, V>(
IEqualityComparer <T> subKeyComparer, IEqualityComparer <K> fullKeyComparer,
T t, K k, V v,
MultiKeyMaps.MultiKeyCreationStrategy strategy) where K : class, IEnumerable <T>
{
var multiDict = MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(subKeyComparer, fullKeyComparer, strategy);
Assert.IsNotNull(multiDict);
Assert.IsInstanceOfType(multiDict, typeof(IMultiKeyMap <T, K, V>));
Assert.IsInstanceOfType(multiDict, typeof(IDictionary <K, V>));
Assert.IsTrue(multiDict.Count == 0);
return(multiDict);
}
public void SerializationTest(MultiKeyMaps.MultiKeyCreationStrategy strategy, ComparersStrategy compStrategy)
{
InitAll(strategy, compStrategy);
var myObj1 = MultiKeyMaps.CreateMultiKeyDictionary <int, int[], string>();
myObj1.Add(new int[] { 1, 2 }, "hi");
myObj1.Add(new int[] { 3, 4 }, "bye");
byte[] serialized = SerializeHelper(myObj1);
var myObj2 = DeserializeHelper <IMultiKeyMap <int, int[], string> >(serialized);
myObj2.ShouldAllBeEquivalentTo(myObj1);
}
Setup(MultiKeyMaps.MultiKeyCreationStrategy strategy, bool subKeyEqualityByRef, bool keyEqualityByRef)
{
var subKeyComparer = subKeyEqualityByRef.SubKeyComparerFor <Employee <int> >();
var keyComparer = keyEqualityByRef.KeyComparerFor <Employee <int> >();
Func <int, Employee <int> > subKeyConverter = x => new Employee <int>(String.Join("", Enumerable.Range(x, 10)), x);
Func <int, string> valueConverter = x => x.ToString();
var tuple = InitData(subKeyComparer, keyComparer, strategy, subKeyConverter, valueConverter, SearchCount, RecordCount, KeySize);
var map = MultiKeyMaps.CreateMultiKeyDictionary <Employee <int>, IEnumerable <Employee <int> >, string>(subKeyComparer, keyComparer, strategy);
map.CopyFrom(tuple.dict);
return(map, tuple.dict, tuple.keys, tuple.partKeys, tuple.positivePositions, tuple.positions);
}
private void CreateMultiKeyDictionaryWithComparersEmptyHelper <T, K, V>(
IEqualityComparer <T> subKeyComparer, IEqualityComparer <K> fullKeyComparer,
MultiKeyMaps.MultiKeyCreationStrategy strategy) where K : class, IEnumerable <T>
{
var multiDict = MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(subKeyComparer, fullKeyComparer, strategy);
multiDict.Should().NotBeNull().And.BeEmpty().And.BeAssignableTo(typeof(IMultiKeyMap <T, K, V>))
.And.BeAssignableTo(typeof(IDictionary <K, V>));
multiDict.GetType().Should().BeDecoratedWith <SerializableAttribute>();
Action act = () => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(null, fullKeyComparer, strategy);
act.ShouldThrow <ArgumentNullException>().Where(e => e.ParamName.Equals("subKeyComparer"));
act = () => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(subKeyComparer, null, strategy);
act.ShouldThrow <ArgumentNullException>().Where(e => e.ParamName.Equals("fullKeyComparer"));
}
public Func <IMultiKeyMap <T, K, V> > Supplier <T, K, V>(
MultiKeyMaps.MultiKeyCreationStrategy strategy = OptimizedForNonPositionalSearch,
ComparersStrategy compStrategy = BothNull) where K : class, IEnumerable <T>
{
switch (compStrategy)
{
case BothNull:
case BothDefault:
return(() => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(strategy));
case StructuralFullKeyOnly:
return(() => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(EqualityComparer <T> .Default,
new EnumerableEqualityComparer <T, K>(EqualityComparer <T> .Default), strategy));
case StructuralBoth:
return(() => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(EqualityComparer <T> .Default,
new EnumerableEqualityComparer <T, K>(EqualityComparer <T> .Default), strategy));
default:
throw new ArgumentOutOfRangeException("compStrategy");
}
}
private MultiKeyMapBaseHelper <T, K, V> InitHelper <T, K, V>(K k1, K k2, V v1 = default(V), V v2 = default(V)) where K : class, IEnumerable <T>
{
return(new MultiKeyMapBaseHelper <T, K, V>(() => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>(), k1, k2, v1, v2));
}
public static IMultiKeyMap <T, K, V> CreateMultiKeyMap <T, K, V>(K[] keys, V[] values) where K : class, IEnumerable <T>
{
return(CreateMultiKeyMap <T, K, V>(keys, values, () => MultiKeyMaps.CreateMultiKeyDictionary <T, K, V>()));
}
