public void EnumerateBasic_2Dimension()
        {
            var indexes = new[] {
                new[] { 1, 1 },
                new[] { 1, 2 },
                new[] { 1, 3 },
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 2, 3 },
                new[] { 3, 1 },
                new[] { 3, 2 },
                new[] { 3, 3 }
            };

            var sut  = new JaggedDictionary <int, int>(indexes.First().Length, SortedDictionaryFactory <int> .Default);
            var keys = indexes.Select(a => JaggedIndex.Create(a)).ToList();

            foreach (var key in keys)
            {
                sut[key] = 0;
            }

            var keyValuePairs = sut.ToList();

            Assert.Equal(keys.Count, keyValuePairs.Count);
            foreach (var kvp in keyValuePairs)
            {
                Assert.True(keys.Cast <IJaggedIndex <int> >().Contains(kvp.Key));
                Assert.Equal(0, kvp.Value);
            }
        }
        public void Enumerate_5Dimension(JaggedDictionary <int, string> sut, JaggedIndex5 <int>[] keys, string value)
        {
            foreach (var key in keys)
            {
                sut[key] = value;
            }

            var keyValuePairs = sut.ToList();

            Assert.Equal(keys.Length, keyValuePairs.Count);
            foreach (var kvp in keyValuePairs)
            {
                Assert.True(keys.Cast <IJaggedIndex <int> >().Contains(kvp.Key));
                Assert.Equal(value, kvp.Value);
            }
        }
        public void Enumerate_5Dimension(JaggedDictionary<int, string> sut, JaggedIndex5<int>[] keys, string value)
        {
            foreach (var key in keys) sut[key] = value;

            var keyValuePairs = sut.ToList();
            Assert.Equal(keys.Length, keyValuePairs.Count);
            foreach (var kvp in keyValuePairs)
            {
                Assert.True(keys.Cast<IJaggedIndex<int>>().Contains(kvp.Key));
                Assert.Equal(value, kvp.Value);
            }
        }
        public void EnumerateBasic_5Dimension()
        {
            var indexes = new[] {
                new[] { 1, 1, 1, 1, 1 },
                new[] { 1, 1, 1, 1, 2 },
                new[] { 1, 1, 1, 1, 3 },
                new[] { 1, 1, 1, 2, 1 },
                new[] { 1, 1, 1, 2, 2 },
                new[] { 1, 1, 1, 2, 3 },
                new[] { 1, 1, 1, 3, 1 },
                new[] { 1, 1, 1, 3, 2 },
                new[] { 1, 1, 1, 3, 3 },
                new[] { 1, 1, 2, 1, 1 },
                new[] { 1, 1, 2, 1, 2 },
                new[] { 1, 1, 2, 1, 3 },
                new[] { 1, 1, 2, 2, 1 },
                new[] { 1, 1, 2, 2, 2 },
                new[] { 1, 1, 2, 2, 3 },
                new[] { 1, 2, 1, 1, 1 },
                new[] { 2, 1, 1, 1, 1 },
                new[] { 2, 2, 2, 2, 2 }
            };

            var sut = new JaggedDictionary<int, int>(indexes.First().Length, SortedDictionaryFactory<int>.Default);
            var keys = indexes.Select(a => JaggedIndex.Create(a)).ToList();
            foreach (var key in keys) sut[key] = 0;

            var keyValuePairs = sut.ToList();
            Assert.Equal(keys.Count, keyValuePairs.Count);
            foreach (var kvp in keyValuePairs)
            {
                Assert.True(keys.Cast<IJaggedIndex<int>>().Contains(kvp.Key));
                Assert.Equal(0, kvp.Value);
            }
        }