//[Theory]
        //[InlineData(null)]
        //[InlineData(typeof(CustomEqualityComparerDummyRefType))]
        public async Task DictionaryDevConcurrentAccessDetection_ReferenceTypeKey(Type comparerType)
        {
            IEqualityComparer <DummyRefType> customComparer = null;

            DictionaryDev <DummyRefType, DummyRefType> dic = comparerType == null ?
                                                             new DictionaryDev <DummyRefType, DummyRefType>() :
                                                             new DictionaryDev <DummyRefType, DummyRefType>((customComparer = (IEqualityComparer <DummyRefType>)Activator.CreateInstance(comparerType)));

            var keyValueSample = new DummyRefType()
            {
                Value = 1
            };

            dic.Add(keyValueSample, keyValueSample);

            await DictionaryDevConcurrentAccessDetection(dic,
                                                         typeof(DummyRefType).IsValueType,
                                                         customComparer,
                                                         d => d.Add(keyValueSample, keyValueSample),
                                                         d => { var v = d[keyValueSample]; },
                                                         d => d.Remove(keyValueSample),
                                                         d => d.Remove(keyValueSample, out DummyRefType value),
                                                         d => d.RemoveAll(kvp => true)
                                                         );
        }
 private void InstanceSetup()
 {
     for (int index = 0; index < keys.Length; index += 1)
     {
         devDict.Add(keys[index], values[index]);
         refDict.Add(keys[index], values[index]);
     }
 }
        //[Theory]
        //[InlineData(null)]
        //[InlineData(typeof(CustomEqualityComparerInt32ValueType))]
        public async Task DictionaryDevConcurrentAccessDetection_ValueTypeKey(Type comparerType)
        {
            IEqualityComparer <int> customComparer = null;

            DictionaryDev <int, int> dic = comparerType == null ?
                                           new DictionaryDev <int, int>() :
                                           new DictionaryDev <int, int>((customComparer = (IEqualityComparer <int>)Activator.CreateInstance(comparerType)));

            dic.Add(1, 1);
            dic.Add(4, 2);

            await DictionaryDevConcurrentAccessDetection(dic,
                                                         typeof(int).IsValueType,
                                                         customComparer,
                                                         d => d.Add(1, 1),
                                                         d => { var v = d[1]; },
                                                         d => d.Remove(1),
                                                         d => d.Remove(1, out int value),
                                                         d => d.RemoveAll(kvp => true)
                                                         );
        }