public static void BuildAssemblyName___Should_build_the_expected_assembly_name___When_TypeRepresentation_is_unversioned()
        {
            // Arrange
            var types = TypeGenerator.GenerateTypesForTesting();

            var expected = types.Select(_ => _.Assembly.GetName().Name).ToList();

            // Act
            var actual = types.Select(_ => _.ToRepresentation().RemoveAssemblyVersions().BuildAssemblyName().FullName).ToList();

            // Assert
            actual.AsTest().Must().BeEqualTo(expected);
        }
        public static void ResolvedFromLoadedTypes_typeRepresentation___Should_roundtrip_a_type_from_its_representation___When_called()
        {
            // Arrange
            var expectedTypes = TypeGenerator.GenerateTypesForTesting().ToList();

            var representations = expectedTypes.Select(_ => _.ToRepresentation()).ToList();

            // Act
            var actualTypes = representations.Select(_ => _.ResolveFromLoadedTypes(throwIfCannotResolve: true)).ToList();

            // Assert
            actualTypes.AsTest().Must().BeEqualTo(expectedTypes);
        }
        public static void BuildAssemblyQualifiedName___Should_build_the_expected_assembly_qualified_name___When_TypeRepresentation_is_unversioned()
        {
            // Arrange
            var types = TypeGenerator.GenerateTypesForTesting();

            var expected = types.Select(_ => Regex.Replace(_.AssemblyQualifiedName, ", Version=.*?, Culture=.*?, PublicKeyToken=[a-z0-9]*", string.Empty)).ToList();

            // Act
            var actual = types.Select(_ => _.ToRepresentation().RemoveAssemblyVersions().BuildAssemblyQualifiedName()).ToList();

            // Assert
            actual.AsTest().Must().BeEqualTo(expected);
        }
        public static void ToTypeRepresentationFromAssemblyQualifiedName___Should_roundtrip_a_TypeRepresentation___When_assembly_qualified_name_generated_using_unversioned_TypeRepresentation_BuildAssemblyQualifiedName()
        {
            // Arrange
            var types = TypeGenerator.GenerateTypesForTesting().ToList();

            var expected = types.Select(_ => _.ToRepresentation().RemoveAssemblyVersions()).ToList();

            var assemblyQualifiedNames = expected.Select(_ => _.BuildAssemblyQualifiedName()).ToList();

            // Act
            var actual = assemblyQualifiedNames.Select(_ => _.ToTypeRepresentationFromAssemblyQualifiedName()).ToList();

            // Assert
            actual.AsTest().Must().BeEqualTo(expected);
        }
        public static void ResolvedFromLoadedTypes_typeRepresentation___Should_return_null___When_multiple_versions_of_assembly_are_loaded_and_throwIfCannotResolve_is_false()
        {
            // Arrange
            TypeGenerator.LoadOlderVersionOfConditions();

            var type = typeof(Conditions.Condition);

            var representation = type.ToRepresentation();

            // Act
            var actual = representation.ResolveFromLoadedTypes(AssemblyMatchStrategy.AnySingleVersion, throwIfCannotResolve: false);

            // Assert
            actual.AsTest().Must().BeNull();
        }
        public static void ResolvedFromLoadedTypes_typeRepresentation___Should_throw_InvalidOperationException___When_multiple_versions_of_assembly_are_loaded_and_throwIfCannotResolve_is_true()
        {
            // Arrange
            TypeGenerator.LoadOlderVersionOfConditions();

            var type = typeof(Conditions.Condition);

            var representation = type.ToRepresentation();

            // Act
            var actual = Record.Exception(() => representation.ResolveFromLoadedTypes(AssemblyMatchStrategy.AnySingleVersion, throwIfCannotResolve: true));

            // Assert
            actual.AsTest().Must().BeOfType <InvalidOperationException>();
            actual.Message.AsTest().Must().ContainString("Unable to resolve the specified TypeRepresentation (Conditions.Condition, Conditions, Version=2.1.0.24) with AssemblyMatchStrategy.AnySingleVersion.  There were multiple versions of the following assemblies loaded: [Conditions,");
        }
        public static void Equals___Should_return_true___When_parameters_are_equal_and_have_different_versions()
        {
            // Arrange
            var systemUnderTest = new VersionlessTypeEqualityComparer();

            var oldConditionsAssembly = TypeGenerator.LoadOlderVersionOfConditions();

            var type1 = typeof(Conditions.Condition);
            var type2 = oldConditionsAssembly.GetTypes().Single(_ => _.Name == "Condition");

            // Act
            var actual = systemUnderTest.Equals(type1, type2);

            // Assert
            actual.AsTest().Must().BeTrue();
        }
        public static void ToTypeRepresentationFromAssemblyQualifiedName___Should_return_same_result_as_ToRepresentation___When_assembly_qualified_name_generated_using_old_OBC_serialization_inherited_type_concrete_type_logic()
        {
            // versioned

            // Arrange
            var types = TypeGenerator.GenerateTypesForTesting().ToList();

            var expected = types.Select(_ => _.ToRepresentation().DeepCloneWithAssemblyVersion(null)).ToList();

            var assemblyQualifiedNames = types.Select(_ => _.FullName + ", " + _.Assembly.GetName().Name).ToList();

            // Act
            var actual = assemblyQualifiedNames.Select(_ => _.ToTypeRepresentationFromAssemblyQualifiedName()).ToList();

            // Assert
            actual.AsTest().Must().BeEqualTo(expected);
        }
        public static void ToTypeRepresentationFromAssemblyQualifiedName___Should_return_same_result_as_ToRepresentation___When_assembly_qualified_name_generated_using_Type_AssemblyQualifiedName()
        {
            // versioned

            // Arrange
            var types = TypeGenerator.GenerateTypesForTesting().ToList();

            var expected = types.Select(_ => _.ToRepresentation()).ToList();

            var assemblyQualifiedNames = types.Select(_ => _.AssemblyQualifiedName).ToList();

            // Act
            var actual = assemblyQualifiedNames.Select(_ => _.ToTypeRepresentationFromAssemblyQualifiedName()).ToList();

            // Assert
            actual.AsTest().Must().BeEqualTo(expected);
        }
        public static void GetHashCode___Should_return_the_same_hash_code_for_representations_that_are_equal___When_called()
        {
            // Arrange
            var systemUnderTest = new VersionlessTypeEqualityComparer();

            var oldConditionsAssembly = TypeGenerator.LoadOlderVersionOfConditions();

            var types = new[]
            {
                typeof(Conditions.Condition),
                oldConditionsAssembly.GetTypes().Single(_ => _.Name == "Condition"),
            };

            // Act
            var actual = types.Select(_ => systemUnderTest.GetHashCode(_)).ToList();

            // Assert
            actual.Distinct().AsTest().Must().HaveCount(1);
        }