public void ValidateAssemblyNameWithPublicKey()
        {
            var assembly = new { Assembly = Misc.Signed, Name = "Signed", Version = new Version(0, 0, 0, 0), ContentType = AssemblyContentType.Default, Flags = AssemblyNameFlags.PublicKey };

            var reader = MetadataReaderTests.GetMetadataReader(assembly.Assembly, options: MetadataReaderOptions.ApplyWindowsRuntimeProjections);

            foreach (var assemblyRefHandle in reader.AssemblyReferences)
            {
                var assemblyDef  = reader.GetAssemblyDefinition();
                var assemblyRef  = reader.GetAssemblyReference(assemblyRefHandle);
                var assemblyName = assemblyDef.GetAssemblyName();

                // Validate against input assembly
                Assert.Equal(assembly.Version, assemblyName.Version);
                Assert.Equal(assembly.Name, assemblyName.Name);
                Assert.Equal(assembly.ContentType, assemblyName.ContentType);
                Assert.Null(assemblyName.CultureName);
                Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.SHA1, assemblyName.HashAlgorithm);
                Assert.Equal(assembly.Flags, assemblyName.Flags);
                Assert.NotNull(assemblyName.GetPublicKeyToken());
                Assert.NotNull(assemblyName.GetPublicKey());

                // Validate against AssemblyDefinition
                ValidateDefinitionAssemblyNameAgainst(assemblyName, reader, assemblyDef);

                // Validate against AssemblyReference
                ValidateDefinitionAssemblyNameAgainst(assemblyName, reader, assemblyRef);
            }
        }
Example #2
0
        public void ValidateTypeDefinitionIsNestedWindowsProjection()
        {
            var reader = MetadataReaderTests.GetMetadataReader(Namespace.NamespaceTests, options: MetadataReaderOptions.ApplyWindowsRuntimeProjections);

            foreach (var typeDefHandle in reader.TypeDefinitions)
            {
                var typeDef = reader.GetTypeDefinition(typeDefHandle);

                Assert.Equal(typeDef.Attributes.IsNested(), typeDef.IsNested);
            }
        }
        public void ValidateAssemblyNameForMultipleAssemblyReferences()
        {
            var expRefs = new string[] { "mscorlib", "System.Core", "System", "Microsoft.VisualBasic" };

            byte[][] expKeys = new byte[][]
            {
                new byte[] { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 },
                new byte[] { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 },
                new byte[] { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 },

                // VB: B0 3F 5F 7F 11 D5 0A 3A
                new byte[] { 0xb0, 0x3f, 0x5f, 0x7f, 0x11, 0xd5, 0x0a, 0x3a }
            };

            var expVers = new Version[]
            {
                new Version(4, 0, 0, 0),
                new Version(4, 0, 0, 0),
                new Version(4, 0, 0, 0),
                new Version(/*VB*/ 10, 0, 0, 0),
            };

            var reader = MetadataReaderTests.GetMetadataReader(NetModule.AppCS);

            int i = 0;

            foreach (var assemblyRefHandle in reader.AssemblyReferences)
            {
                var assemblyRef  = reader.GetAssemblyReference(assemblyRefHandle);
                var assemblyDef  = reader.GetAssemblyDefinition();
                var assemblyName = assemblyRef.GetAssemblyName();

                // Validate against input assembly
                Assert.Equal(expRefs[i], assemblyName.Name);
                Assert.Equal(expVers[i], assemblyName.Version);
                Assert.Equal(expKeys[i], assemblyName.GetPublicKeyToken());
                Assert.Null(assemblyName.CultureName);
                Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.None, assemblyName.HashAlgorithm);
                Assert.Null(assemblyName.GetPublicKey());
                Assert.Equal(AssemblyNameFlags.None, assemblyName.Flags);
                Assert.Equal(AssemblyContentType.Default, assemblyName.ContentType);

                // Validate against AssemblyRefernce
                ValidateReferenceAssemblyNameAgainst(assemblyName, reader, assemblyRef);

                // Validate against AssemblyDefinition
                ValidateReferenceAssemblyNameAgainst(assemblyName, reader, assemblyDef);

                i++;
            }
        }
        public void ValidateAssemblyNameForAssemblyDefinition()
        {
            var assemblyItems = new[]
            {
                new { Assembly = WinRT.Lib, Name = "Lib", Version = new Version(1, 0, 0, 0), ContentType = AssemblyContentType.WindowsRuntime },
                new { Assembly = NetModule.AppCS, Name = "AppCS", Version = new Version(1, 2, 3, 4), ContentType = AssemblyContentType.Default },
                new { Assembly = Namespace.NamespaceTests, Name = "NamespaceTests", Version = new Version(0, 0, 0, 0), ContentType = AssemblyContentType.Default },
                new { Assembly = PortablePdbs.DocumentsDll, Name = "Documents", Version = new Version(0, 0, 0, 0), ContentType = AssemblyContentType.Default }
            };

            foreach (var item in assemblyItems)
            {
                var reader = MetadataReaderTests.GetMetadataReader(item.Assembly, options: MetadataReaderOptions.ApplyWindowsRuntimeProjections);

                foreach (var assemblyRefHandle in reader.AssemblyReferences)
                {
                    var assemblyDef  = reader.GetAssemblyDefinition();
                    var assemblyRef  = reader.GetAssemblyReference(assemblyRefHandle);
                    var assemblyName = assemblyDef.GetAssemblyName();

                    // Validate against input assembly
                    Assert.Equal(item.Version, assemblyName.Version);
                    Assert.Equal(item.Name, assemblyName.Name);
                    Assert.Equal(item.ContentType, assemblyName.ContentType);
                    Assert.Null(assemblyName.CultureName);
                    Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.SHA1, assemblyName.HashAlgorithm);
                    Assert.Null(assemblyName.GetPublicKey());
                    Assert.Null(assemblyName.GetPublicKeyToken());
                    Assert.Equal(AssemblyNameFlags.None, assemblyName.Flags);

                    // Validate against AssemblyDefinition
                    ValidateDefinitionAssemblyNameAgainst(assemblyName, reader, assemblyDef);

                    // Validate against AssemblyReference
                    ValidateDefinitionAssemblyNameAgainst(assemblyName, reader, assemblyRef);
                }
            }
        }
        public void ValidateAssemblyNameForSingleAssemblyReference()
        {
            var reader       = MetadataReaderTests.GetMetadataReader(WinRT.Lib, options: MetadataReaderOptions.ApplyWindowsRuntimeProjections);
            var handle       = reader.AssemblyReferences.Skip(3).First();
            var assemblyRef  = reader.GetAssemblyReference(handle);
            var assemblyDef  = reader.GetAssemblyDefinition();
            var assemblyName = assemblyRef.GetAssemblyName();

            // Validate against input assembly
            Assert.Equal("System.Runtime", assemblyName.Name);
            Assert.Equal(new Version(4, 0, 0, 0), assemblyName.Version);
            Assert.Equal(new byte[] { 0xB0, 0x3F, 0x5F, 0x7F, 0x11, 0xD5, 0x0A, 0x3A }, assemblyName.GetPublicKeyToken());
            Assert.Null(assemblyName.CultureName);
            Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.None, assemblyName.HashAlgorithm);
            Assert.Null(assemblyName.GetPublicKey());
            Assert.Equal(AssemblyNameFlags.None, assemblyName.Flags);
            Assert.Equal(AssemblyContentType.Default, assemblyName.ContentType);

            // Validate against AssemblyRefernce
            ValidateReferenceAssemblyNameAgainst(assemblyName, reader, assemblyRef);

            // Validate against AssemblyDefinition
            ValidateReferenceAssemblyNameAgainst(assemblyName, reader, assemblyDef);
        }