Exemple #1
0
        public void ConverterBase_TwoIdenticalLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            LogicalLocationComponent[] logicalLocationComponents = new[]
            {
                new LogicalLocationComponent
                {
                    Name = "a",
                    Kind = LogicalLocationKind.Namespace
                }
            };

            var converter = new LogicalLocationTestConverter();

            converter.AddLogicalLocation(location1, logicalLocationComponents);
            converter.AddLogicalLocation(location2, logicalLocationComponents);

            location1.LogicalLocationKey.Should().BeNull();
            location2.LogicalLocationKey.Should().BeNull();

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(1);
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a");
            converter.LogicalLocationsDictionary["a"].SequenceEqual(logicalLocationComponents).Should().BeTrue();
        }
Exemple #2
0
        public void ConverterBase_SingleLogicalLocation()
        {
            Location location = new Location
            {
                LogicalLocation = new LogicalLocation
                {
                    FullyQualifiedName = "a"
                }
            };

            var logicalLocation = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var converter = new LogicalLocationTestConverter();

            int index = converter.AddLogicalLocation(logicalLocation);

            index.Should().Be(0);

            converter.LogicalLocations.Count.Should().Be(1);
            converter.LogicalLocations[index].Name.Should().Be("a");
            converter.LogicalLocations[index].ValueEquals(logicalLocation).Should().BeTrue();
        }
        public void ConverterBase_MultipleDistinctIdenticallyNamedLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation1 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation2 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Package
            };

            Location location3 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation3 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Member
            };

            var converter = new LogicalLocationTestConverter();

            string logicalLocationKey = converter.AddLogicalLocation(logicalLocation1);

            logicalLocationKey.Should().Be("a");

            logicalLocationKey = converter.AddLogicalLocation(logicalLocation2);
            logicalLocationKey.Should().Be("a-0");

            logicalLocationKey = converter.AddLogicalLocation(logicalLocation3);
            logicalLocationKey.Should().Be("a-1");

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(3);
            converter.LogicalLocationsDictionary["a"].ValueEquals(logicalLocation1).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-0");
            converter.LogicalLocationsDictionary["a-0"].ValueEquals(logicalLocation2).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-1");
            converter.LogicalLocationsDictionary["a-1"].ValueEquals(logicalLocation3).Should().BeTrue();
        }
        public void ConverterBase_MultipleDistinctIdenticallyNamedLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation1 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation2 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Package
            };

            Location location3 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation3 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Member
            };

            var converter = new LogicalLocationTestConverter();

            string logicalLocationKey = converter.AddLogicalLocation(logicalLocation1);
            logicalLocationKey.Should().Be("a");

            logicalLocationKey = converter.AddLogicalLocation(logicalLocation2);
            logicalLocationKey.Should().Be("a-0");

            logicalLocationKey = converter.AddLogicalLocation(logicalLocation3);
            logicalLocationKey.Should().Be("a-1");

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(3);
            converter.LogicalLocationsDictionary["a"].ValueEquals(logicalLocation1).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-0");
            converter.LogicalLocationsDictionary["a-0"].ValueEquals(logicalLocation2).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-1");
            converter.LogicalLocationsDictionary["a-1"].ValueEquals(logicalLocation3).Should().BeTrue();
        }
        public void ConverterBase_MultipleDistinctIdenticallyNamedLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation1 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation2 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Package
            };

            Location location3 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation3 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Member
            };

            var converter = new LogicalLocationTestConverter();

            int index = converter.AddLogicalLocation(logicalLocation1);

            converter.LogicalLocations[index].Name.Should().Be("a");
            converter.LogicalLocations[index].FullyQualifiedName.Should().BeNull();

            index = converter.AddLogicalLocation(logicalLocation2);
            index.Should().Be(1);
            converter.LogicalLocations[index].Name.Should().Be("a");
            converter.LogicalLocations.Count.Should().Be(2);

            index = converter.AddLogicalLocation(logicalLocation3);
            index.Should().Be(2);
            converter.LogicalLocations[index].Name.Should().Be("a");
            converter.LogicalLocations.Count.Should().Be(3);
        }
Exemple #6
0
        public void ConverterBase_TwoIdenticalLogicalLocations()
        {
            Location location1 = new Location
            {
                LogicalLocation = new LogicalLocation
                {
                    FullyQualifiedName = "a"
                }
            };

            Location location2 = new Location
            {
                LogicalLocation = new LogicalLocation
                {
                    FullyQualifiedName = "a"
                }
            };

            var logicalLocation1 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var logicalLocation2 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var converter = new LogicalLocationTestConverter();

            int index = converter.AddLogicalLocation(logicalLocation1);

            index.Should().Be(0);

            // Second logical location is identical to previous. So
            // we shouldn't add a new instance
            index = converter.AddLogicalLocation(logicalLocation2);
            index.Should().Be(0);

            converter.LogicalLocations.Count.Should().Be(1);
            converter.LogicalLocations[index].Name.Should().Be("a");
            converter.LogicalLocations[index].ValueEquals(logicalLocation1).Should().BeTrue();
        }
        public void ConverterBase_TwoIdenticalLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation1 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var logicalLocation2 = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var converter = new LogicalLocationTestConverter();

            string logicalLocationKey = converter.AddLogicalLocation(logicalLocation1);

            logicalLocationKey.Should().Be(location1.FullyQualifiedLogicalName);

            logicalLocationKey = converter.AddLogicalLocation(logicalLocation2);
            logicalLocationKey.Should().Be(location2.FullyQualifiedLogicalName);

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(1);
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a");
            converter.LogicalLocationsDictionary["a"].ValueEquals(logicalLocation1).Should().BeTrue();
            converter.LogicalLocationsDictionary["a"].ValueEquals(logicalLocation2).Should().BeTrue();
        }
        public void ConverterBase_SingleLogicalLocation()
        {
            Location location = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            var logicalLocation = new LogicalLocation
            {
                Name = "a",
                Kind = LogicalLocationKind.Namespace
            };

            var converter = new LogicalLocationTestConverter();

            string logicalLocationKey = converter.AddLogicalLocation(logicalLocation);

            location.FullyQualifiedLogicalName.Should().Be(logicalLocationKey);

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(1);
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a");
            converter.LogicalLocationsDictionary["a"].ValueEquals(logicalLocation).Should().BeTrue();
        }
Exemple #9
0
        public void ConverterBase_MultipleDistinctIdenticallyNamedLogicalLocations()
        {
            Location location1 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            LogicalLocationComponent[] logicalLocationComponents1 = new[]
            {
                new LogicalLocationComponent
                {
                    Name = "a",
                    Kind = LogicalLocationKind.Namespace
                }
            };

            Location location2 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            LogicalLocationComponent[] logicalLocationComponents2 = new[]
            {
                new LogicalLocationComponent
                {
                    Name = "a",
                    Kind = LogicalLocationKind.Package
                }
            };

            Location location3 = new Location
            {
                FullyQualifiedLogicalName = "a"
            };

            LogicalLocationComponent[] logicalLocationComponents3 = new[]
            {
                new LogicalLocationComponent
                {
                    Name = "a",
                    Kind = LogicalLocationKind.Module
                }
            };

            var converter = new LogicalLocationTestConverter();

            converter.AddLogicalLocation(location1, logicalLocationComponents1);
            converter.AddLogicalLocation(location2, logicalLocationComponents2);
            converter.AddLogicalLocation(location3, logicalLocationComponents3);

            location1.LogicalLocationKey.Should().BeNull();
            location2.LogicalLocationKey.Should().Be("a-0");
            location3.LogicalLocationKey.Should().Be("a-1");

            converter.LogicalLocationsDictionary.Keys.Count.Should().Be(3);
            converter.LogicalLocationsDictionary["a"].SequenceEqual(logicalLocationComponents1).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-0");
            converter.LogicalLocationsDictionary["a-0"].SequenceEqual(logicalLocationComponents2).Should().BeTrue();
            converter.LogicalLocationsDictionary.Keys.Should().Contain("a-1");
            converter.LogicalLocationsDictionary["a-1"].SequenceEqual(logicalLocationComponents3).Should().BeTrue();
        }