public void MatchIsFalseIfFilterHasMoreOrLessValuesThanKey()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            const string anyDim3      = "d3";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension>
            {
                new Dimension(anyDim1),
                new Dimension(anyDim2),
                new Dimension(anyDim3),
            });
            var keyValueSet = new DimensionSpecification {
                { anyDim1, "val1" }, { anyDim2, "val2" }, { anyDim3, "val3" }
            };
            bool allDimensionsProvided;
            Key  key = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            var smallerDimensionSet =
                new DimensionSet(new HashSet <Dimension> {
                new Dimension(anyDim1), new Dimension(anyDim2)
            });
            Key smallerFilter = smallerDimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            Assert.IsFalse(smallerFilter.Matches(key));

            var largerDimensionSet = new DimensionSet(new HashSet <Dimension>(dimensionSet.Dimensions)
            {
                new Dimension
                    ("anotherDim")
            });
            Key largerFilter = largerDimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            Assert.IsFalse(largerFilter.Matches(key));
        }
        public void MatchIsFalseIfValuesDiffer()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            const string anyDim3      = "d3";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension>
            {
                new Dimension(anyDim1),
                new Dimension(anyDim2),
                new Dimension(anyDim3),
            });
            var keyValueSet = new DimensionSpecification {
                { anyDim1, "val1" }, { anyDim2, "val2" }, { anyDim3, "val3" }
            };
            bool allDimensionsProvided;
            Key  key = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            // Longer values
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "valAnyOther";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }

            // Same length
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "valX";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }

            // Shorter length
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "v";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }
        }
        public void MatchIsTrueIfNoValuesAreProvidedInFilter()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            const string anyDim3      = "d3";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension>
            {
                new Dimension(anyDim1),
                new Dimension(anyDim2),
                new Dimension(anyDim3),
            });
            var keyValueSet = new DimensionSpecification {
                { anyDim1, "val1" }, { anyDim2, "val2" }, { anyDim3, "val3" }
            };
            bool allDimensionsProvided;
            Key  key    = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);
            Key  filter = dimensionSet.CreateKey(new DimensionSpecification(), out allDimensionsProvided);

            Assert.IsTrue(filter.Matches(key));
        }
        public void CreateKeyIgnoresExtraDimensions()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension> {
                new Dimension(anyDim1), new Dimension(anyDim2)
            });
            var anyDimensionValues = new DimensionSpecification {
                { anyDim1, "anyVal1" }, { anyDim2, "anyVal2" }
            };

            bool allDimensionsProvided;
            Key  key1 = dimensionSet.CreateKey(anyDimensionValues, out allDimensionsProvided);
            Key  key2 = dimensionSet.CreateKey(new DimensionSpecification(anyDimensionValues)
            {
                { "newDim", "anyVal" }
            },
                                               out allDimensionsProvided);

            Assert.AreEqual(key1, key2);
        }
        public void CreateKeySetsAllDimensionsProvidedFalseIfSomeDimensionsAreNotProvided()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension> {
                new Dimension(anyDim1), new Dimension(anyDim2)
            });
            var partialDimensionValues = new DimensionSpecification {
                { anyDim1, "anyVal1" }
            };

            bool allDimensionsProvided;

            dimensionSet.CreateKey(partialDimensionValues, out allDimensionsProvided);
            Assert.AreEqual(false, allDimensionsProvided);
        }
        public void CreateKeySetsAllDimensionsProvidedTrueIfAllDimensionsAreInDictionary()
        {
            const string anyDim1      = "d1";
            const string anyDim2      = "d2";
            var          dimensionSet = new DimensionSet(new HashSet <Dimension> {
                new Dimension(anyDim1), new Dimension(anyDim2)
            });
            var allDimensionValues = new DimensionSpecification {
                { anyDim1, "anyVal1" }, { anyDim2, "anyVal2" }
            };

            bool allDimensionsProvided;

            dimensionSet.CreateKey(allDimensionValues, out allDimensionsProvided);
            Assert.AreEqual(true, allDimensionsProvided);
        }
        public void MatchIsFalseIfValuesDiffer()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            const string anyDim3 = "d3";
            var dimensionSet = new DimensionSet(new HashSet<Dimension>
                                           {
                                               new Dimension(anyDim1),
                                               new Dimension(anyDim2),
                                               new Dimension(anyDim3),
                                           });
            var keyValueSet = new DimensionSpecification {{anyDim1, "val1"}, {anyDim2, "val2"}, {anyDim3, "val3"}};
            bool allDimensionsProvided;
            Key key = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            // Longer values
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "valAnyOther";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }

            // Same length
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "valX";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }

            // Shorter length
            foreach (var d in dimensionSet.Dimensions)
            {
                var filterValueSet = new DimensionSpecification(keyValueSet);
                filterValueSet[d.Name] = "v";
                Key filter = dimensionSet.CreateKey(filterValueSet, out allDimensionsProvided);
                Assert.IsFalse(filter.Matches(key));
            }
        }
        public void MatchIsFalseIfFilterHasMoreOrLessValuesThanKey()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            const string anyDim3 = "d3";
            var dimensionSet = new DimensionSet(new HashSet<Dimension>
                                           {
                                               new Dimension(anyDim1),
                                               new Dimension(anyDim2),
                                               new Dimension(anyDim3),
                                           });
            var keyValueSet = new DimensionSpecification {{anyDim1, "val1"}, {anyDim2, "val2"}, {anyDim3, "val3"}};
            bool allDimensionsProvided;
            Key key = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);

            var smallerDimensionSet =
                new DimensionSet(new HashSet<Dimension> {new Dimension(anyDim1), new Dimension(anyDim2)});
            Key smallerFilter = smallerDimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);
            Assert.IsFalse(smallerFilter.Matches(key));

            var largerDimensionSet = new DimensionSet(new HashSet<Dimension>(dimensionSet.Dimensions)
                                                      {
                                                          new Dimension
                                                              ("anotherDim")
                                                      });
            Key largerFilter = largerDimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);
            Assert.IsFalse(largerFilter.Matches(key));
        }
        public void MatchIsTrueIfSomeSameValuesAreProvidedInFilter()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            const string anyDim3 = "d3";
            var dimensionSet = new DimensionSet(new HashSet<Dimension>
                                           {
                                               new Dimension(anyDim1),
                                               new Dimension(anyDim2),
                                               new Dimension(anyDim3),
                                           });
            var keyValueSet = new DimensionSpecification {{anyDim1, "val1"}, {anyDim2, "val2"}, {anyDim3, "val3"}};
            bool allDimensionsProvided;
            Key key = dimensionSet.CreateKey(keyValueSet, out allDimensionsProvided);
            Key filter = dimensionSet.CreateKey(new DimensionSpecification {{anyDim2, "val2"}}, out allDimensionsProvided);

            Assert.IsTrue(filter.Matches(key));
        }
Example #10
0
        public void CreateKeySetsAllDimensionsProvidedFalseIfSomeDimensionsAreNotProvided()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            var dimensionSet = new DimensionSet(new HashSet<Dimension> {new Dimension(anyDim1), new Dimension(anyDim2)});
            var partialDimensionValues = new DimensionSpecification {{anyDim1, "anyVal1"}};

            bool allDimensionsProvided;
            dimensionSet.CreateKey(partialDimensionValues, out allDimensionsProvided);
            Assert.AreEqual(false, allDimensionsProvided);
        }
Example #11
0
        public void CreateKeySetsAllDimensionsProvidedTrueIfAllDimensionsAreInDictionary()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            var dimensionSet = new DimensionSet(new HashSet<Dimension> {new Dimension(anyDim1), new Dimension(anyDim2)});
            var allDimensionValues = new DimensionSpecification {{anyDim1, "anyVal1"}, {anyDim2, "anyVal2"}};

            bool allDimensionsProvided;
            dimensionSet.CreateKey(allDimensionValues, out allDimensionsProvided);
            Assert.AreEqual(true, allDimensionsProvided);
        }
Example #12
0
        public void CreateKeyIgnoresExtraDimensions()
        {
            const string anyDim1 = "d1";
            const string anyDim2 = "d2";
            var dimensionSet = new DimensionSet(new HashSet<Dimension> {new Dimension(anyDim1), new Dimension(anyDim2)});
            var anyDimensionValues = new DimensionSpecification {{anyDim1, "anyVal1"}, {anyDim2, "anyVal2"}};

            bool allDimensionsProvided;
            Key key1 = dimensionSet.CreateKey(anyDimensionValues, out allDimensionsProvided);
            Key key2 = dimensionSet.CreateKey(new DimensionSpecification(anyDimensionValues) {{"newDim", "anyVal"}},
                out allDimensionsProvided);
            Assert.AreEqual(key1, key2);
        }