mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.8.0.22

Browse Source 
Former-commit-id: df344e34b07851d296efb3e6604c8db42b6f7aa3
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2017-10-19 20:04:20 +00:00
parent 5f4a27cc8a
commit 7d05485754
5020 changed files with 114082 additions and 186061 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
external/corefx/src/System.Reflection.Metadata/pkg/System.Reflection.Metadata.pkgproj vendored
View File

@@ -14,7 +14,7 @@
<Version>1.1.37</Version>
</FilePackageDependency>
<InboxOnTargetFramework Include="netcoreapp2.0" />
<InboxOnTargetFramework Include="uap10.1" />
<InboxOnTargetFramework Include="$(UAPvNextTFM)" />
</ItemGroup>
<Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
</Project>

5
external/corefx/src/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeSystem/ModuleDefinition.cs vendored
View File

@@ -55,5 +55,10 @@ namespace System.Reflection.Metadata
return _reader.ModuleTable.GetEncBaseId();
}
}
public CustomAttributeHandleCollection GetCustomAttributes()
{
return new CustomAttributeHandleCollection(_reader, EntityHandle.ModuleDefinition);
}
}
}

4
external/corefx/src/System.Reflection.Metadata/tests/Metadata/BlobContentIdTests.cs vendored
View File

@@ -79,8 +79,8 @@ namespace System.Reflection.Metadata.Tests
Assert.Throws<ArgumentNullException>(() => BlobContentId.FromHash(default(ImmutableArray<byte>)));
Assert.Throws<ArgumentNullException>(() => BlobContentId.FromHash(null));
Assert.Throws<ArgumentException>(() => BlobContentId.FromHash(new byte[0]));
Assert.Throws<ArgumentException>(() => BlobContentId.FromHash(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }));
AssertExtensions.Throws<ArgumentException>("hashCode", () => BlobContentId.FromHash(new byte[0]));
AssertExtensions.Throws<ArgumentException>("hashCode", () => BlobContentId.FromHash(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }));
}
}
}

30
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/CodedIndexTests.cs vendored
View File

@@ -13,21 +13,21 @@ namespace System.Reflection.Metadata.Ecma335.Tests
{
var badHandleKind = CustomAttributeHandle.FromRowId(1);
Assert.Throws<ArgumentException>(() => CodedIndex.HasCustomAttribute(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.HasConstant(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.CustomAttributeType(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.HasDeclSecurity(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.HasFieldMarshal(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.HasSemantics(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.Implementation(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.MemberForwarded(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.MemberRefParent(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.MethodDefOrRef(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.ResolutionScope(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.TypeDefOrRef(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.TypeDefOrRefOrSpec(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.TypeOrMethodDef(badHandleKind));
Assert.Throws<ArgumentException>(() => CodedIndex.HasCustomDebugInformation(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasCustomAttribute(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasConstant(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.CustomAttributeType(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasDeclSecurity(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasFieldMarshal(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasSemantics(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.Implementation(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.MemberForwarded(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.MemberRefParent(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.MethodDefOrRef(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.ResolutionScope(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.TypeDefOrRef(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.TypeDefOrRefOrSpec(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.TypeOrMethodDef(badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => CodedIndex.HasCustomDebugInformation(badHandleKind));
}
[Fact]

26
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/Encoding/BlobEncodersTests.cs vendored
View File

@@ -575,7 +575,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
AssertEx.Equal(new byte[] { 0x03, 0xED, 0xA0, 0x80 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentException>(() => e.SystemType(""));
AssertExtensions.Throws<ArgumentException>("serializedTypeName", () => e.SystemType(""));
}
[Fact]
@@ -626,7 +626,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
b.Clear();
Assert.Throws<ArgumentNullException>(() => e.Name(null));
Assert.Throws<ArgumentException>(() => e.Name(""));
AssertExtensions.Throws<ArgumentException>("name", () => e.Name(""));
}
[Fact]
@@ -888,7 +888,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
b.Clear();
Assert.Throws<ArgumentNullException>(() => e.Enum(null));
Assert.Throws<ArgumentException>(() => e.Enum(""));
AssertExtensions.Throws<ArgumentException>("enumTypeName", () => e.Enum(""));
}
[Fact]
@@ -1083,8 +1083,8 @@ namespace System.Reflection.Metadata.Ecma335.Tests
AssertEx.Equal(new byte[] { 0x12, 0x05 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentException>(() => e.Type(MetadataTokens.TypeSpecificationHandle(1), isValueType: false));
Assert.Throws<ArgumentException>(() => e.Type(default(EntityHandle), isValueType: false));
AssertExtensions.Throws<ArgumentException>(null, () => e.Type(MetadataTokens.TypeSpecificationHandle(1), isValueType: false));
AssertExtensions.Throws<ArgumentException>(null, () => e.Type(default(EntityHandle), isValueType: false));
Assert.Equal(0, b.Count);
}
@@ -1118,7 +1118,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
AssertEx.Equal(new byte[] { 0x1B, 0x00 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentException>(() => e.FunctionPointer(0, (FunctionPointerAttributes)1000, genericParameterCount: 0));
AssertExtensions.Throws<ArgumentException>("attributes", () => e.FunctionPointer(0, (FunctionPointerAttributes)1000, genericParameterCount: 0));
Assert.Throws<ArgumentOutOfRangeException>(() => e.FunctionPointer(0, 0, genericParameterCount: -1));
Assert.Throws<ArgumentOutOfRangeException>(() => e.FunctionPointer(0, 0, genericParameterCount: ushort.MaxValue + 1));
Assert.Equal(0, b.Count);
@@ -1148,8 +1148,8 @@ namespace System.Reflection.Metadata.Ecma335.Tests
AssertEx.Equal(new byte[] { 0x15, 0x12, 0x04, 0xC0, 0x00, 0xFF, 0xFF }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentException>(() => e.GenericInstantiation(MetadataTokens.TypeSpecificationHandle(1), 1, isValueType: false));
Assert.Throws<ArgumentException>(() => e.GenericInstantiation(default(EntityHandle), 1, isValueType: false));
AssertExtensions.Throws<ArgumentException>(null, () => e.GenericInstantiation(MetadataTokens.TypeSpecificationHandle(1), 1, isValueType: false));
AssertExtensions.Throws<ArgumentException>(null, () => e.GenericInstantiation(default(EntityHandle), 1, isValueType: false));
Assert.Throws<ArgumentOutOfRangeException>(() => e.GenericInstantiation(default(TypeDefinitionHandle), 0, true));
Assert.Throws<ArgumentOutOfRangeException>(() => e.GenericInstantiation(default(TypeDefinitionHandle), -1, true));
Assert.Throws<ArgumentOutOfRangeException>(() => e.GenericInstantiation(default(TypeDefinitionHandle), ushort.MaxValue + 1, true));
@@ -1263,11 +1263,11 @@ namespace System.Reflection.Metadata.Ecma335.Tests
AssertEx.Equal(new byte[] { 0x1f, 0x06 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentException>(() => e.AddModifier(default(EntityHandle), true));
Assert.Throws<ArgumentException>(() => e.AddModifier(default(TypeDefinitionHandle), true));
Assert.Throws<ArgumentException>(() => e.AddModifier(default(TypeReferenceHandle), true));
Assert.Throws<ArgumentException>(() => e.AddModifier(default(TypeSpecificationHandle), true));
Assert.Throws<ArgumentException>(() => e.AddModifier(MetadataTokens.FieldDefinitionHandle(1), true));
AssertExtensions.Throws<ArgumentException>("type", () => e.AddModifier(default(EntityHandle), true));
AssertExtensions.Throws<ArgumentException>("type", () => e.AddModifier(default(TypeDefinitionHandle), true));
AssertExtensions.Throws<ArgumentException>("type", () => e.AddModifier(default(TypeReferenceHandle), true));
AssertExtensions.Throws<ArgumentException>("type", () => e.AddModifier(default(TypeSpecificationHandle), true));
AssertExtensions.Throws<ArgumentException>(null, () => e.AddModifier(MetadataTokens.FieldDefinitionHandle(1), true));
}
[Fact]

12
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/Encoding/ControlFlowBuilderTests.cs vendored
View File

@@ -189,18 +189,18 @@ namespace System.Reflection.Metadata.Ecma335.Tests
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, default(TypeDefinitionHandle)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.MethodDefinitionHandle(1)));
AssertExtensions.Throws<ArgumentException>("catchType", () => flow.AddCatchRegion(l1, l2, l3, l4, default(TypeDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>("catchType", () => flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.MethodDefinitionHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(default(LabelHandle), l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, default(LabelHandle), l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, default(LabelHandle), l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentNullException>(() => flow.AddCatchRegion(l1, l2, l3, default(LabelHandle), MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(lx, l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, lx, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, lx, l4, MetadataTokens.TypeReferenceHandle(1)));
Assert.Throws<ArgumentException>(() => flow.AddCatchRegion(l1, l2, l3, lx, MetadataTokens.TypeReferenceHandle(1)));
AssertExtensions.Throws<ArgumentException>("tryStart", () => flow.AddCatchRegion(lx, l2, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
AssertExtensions.Throws<ArgumentException>("tryEnd", () => flow.AddCatchRegion(l1, lx, l3, l4, MetadataTokens.TypeReferenceHandle(1)));
AssertExtensions.Throws<ArgumentException>("handlerStart", () => flow.AddCatchRegion(l1, l2, lx, l4, MetadataTokens.TypeReferenceHandle(1)));
AssertExtensions.Throws<ArgumentException>("handlerEnd", () => flow.AddCatchRegion(l1, l2, l3, lx, MetadataTokens.TypeReferenceHandle(1)));
}
[Fact]

4
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/Encoding/ExceptionRegionEncoderTests.cs vendored
View File

@@ -207,8 +207,8 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Throws<ArgumentOutOfRangeException>(() => fatEncoder.Add((ExceptionRegionKind)5, 1, 2, 4, 5));
Assert.Throws<ArgumentOutOfRangeException>(() => fatEncoder.Add(ExceptionRegionKind.Filter, 1, 2, 4, 5, filterOffset: -1));
Assert.Throws<ArgumentException>(() => fatEncoder.Add(ExceptionRegionKind.Catch, 1, 2, 4, 5, catchType: default(EntityHandle)));
Assert.Throws<ArgumentException>(() => fatEncoder.Add(ExceptionRegionKind.Catch, 1, 2, 4, 5, catchType: MetadataTokens.ImportScopeHandle(1)));
AssertExtensions.Throws<ArgumentException>("catchType", () => fatEncoder.Add(ExceptionRegionKind.Catch, 1, 2, 4, 5, catchType: default(EntityHandle)));
AssertExtensions.Throws<ArgumentException>("catchType", () => fatEncoder.Add(ExceptionRegionKind.Catch, 1, 2, 4, 5, catchType: MetadataTokens.ImportScopeHandle(1)));
}
}
}

6
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/Encoding/InstructionEncoderTests.cs vendored
View File

@@ -494,10 +494,10 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Throws<ArgumentNullException>(() => ilcf1.Branch(ILOpCode.Br, default(LabelHandle)));
Assert.Throws<ArgumentNullException>(() => ilcf1.MarkLabel(default(LabelHandle)));
Assert.Throws<ArgumentException>(() => ilcf1.Branch(ILOpCode.Br, l2));
Assert.Throws<ArgumentException>(() => ilcf1.MarkLabel(l2));
AssertExtensions.Throws<ArgumentException>("label", () => ilcf1.Branch(ILOpCode.Br, l2));
AssertExtensions.Throws<ArgumentException>("label", () => ilcf1.MarkLabel(l2));
Assert.Throws<ArgumentException>(() => ilcf1.Branch(ILOpCode.Box, l1));
AssertExtensions.Throws<ArgumentException>("opCode", () => ilcf1.Branch(ILOpCode.Box, l1));
}
[Fact]

4
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/Encoding/MethodBodyStreamEncoderTests.cs vendored
View File

@@ -444,9 +444,9 @@ namespace System.Reflection.Metadata.Ecma335.Tests
il = new InstructionEncoder(codeBuilder, flowBuilder);
var l0 = il.DefineLabel();
Assert.Throws<ArgumentException>(() => il.Branch(ILOpCode.Nop, l0));
AssertExtensions.Throws<ArgumentException>("opCode", () => il.Branch(ILOpCode.Nop, l0));
Assert.Throws<ArgumentNullException>(() => il.Branch(ILOpCode.Br, default(LabelHandle)));
Assert.Throws<ArgumentException>(() => il.Branch(ILOpCode.Br, l2));
AssertExtensions.Throws<ArgumentException>("label", () => il.Branch(ILOpCode.Br, l2));
}
[Fact]

4
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/MetadataAggregatorTests.cs vendored
View File

@@ -120,7 +120,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
TestGenerationHandle(aggregator, MetadataTokens.Handle(0x1800003a), expectedHandle: MetadataTokens.Handle(0x18000002), expectedGeneration: 3);
Assert.Throws<ArgumentException>(() => TestGenerationHandle(aggregator, MetadataTokens.Handle(0x11000032), expectedHandle: MetadataTokens.Handle(0x00000000), expectedGeneration: 0));
AssertExtensions.Throws<ArgumentException>("handle", () => TestGenerationHandle(aggregator, MetadataTokens.Handle(0x11000032), expectedHandle: MetadataTokens.Handle(0x00000000), expectedGeneration: 0));
}
[Fact]
@@ -170,7 +170,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
TestGenerationHandle(aggregator, MetadataTokens.UserStringHandle(12), expectedHandle: MetadataTokens.UserStringHandle(2), expectedGeneration: 2);
TestGenerationHandle(aggregator, MetadataTokens.StringHandle(0), expectedHandle: MetadataTokens.StringHandle(0), expectedGeneration: 2);
Assert.Throws<ArgumentException>(() => TestGenerationHandle(aggregator, MetadataTokens.StringHandle(22), expectedHandle: MetadataTokens.StringHandle(0), expectedGeneration: 0));
AssertExtensions.Throws<ArgumentException>("handle", () => TestGenerationHandle(aggregator, MetadataTokens.StringHandle(22), expectedHandle: MetadataTokens.StringHandle(0), expectedGeneration: 0));
}
}
}

40
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/MetadataBuilderTests.cs vendored
View File

@@ -18,7 +18,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Throws<ArgumentOutOfRangeException>(() => new MetadataBuilder(0, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => new MetadataBuilder(0, 0, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => new MetadataBuilder(0, 0, 0, -1));
Assert.Throws<ArgumentException>(() => new MetadataBuilder(0, 0, 0, 1));
AssertExtensions.Throws<ArgumentException>("guidHeapStartOffset", () => new MetadataBuilder(0, 0, 0, 1));
new MetadataBuilder(userStringHeapStartOffset: 0x00fffffe);
Assert.Throws<ImageFormatLimitationException>(() => new MetadataBuilder(userStringHeapStartOffset: 0x00ffffff));
@@ -214,25 +214,25 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Throws<ArgumentNullException>(() => builder.AddAssembly(default(StringHandle), null, default(StringHandle), default(BlobHandle), 0, 0));
Assert.Throws<ArgumentNullException>(() => builder.AddAssemblyReference(default(StringHandle), null, default(StringHandle), default(BlobHandle), 0, default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddTypeDefinition(0, default(StringHandle), default(StringHandle), badHandleKind, default(FieldDefinitionHandle), default(MethodDefinitionHandle)));
Assert.Throws<ArgumentException>(() => builder.AddInterfaceImplementation(default(TypeDefinitionHandle), badHandleKind));
Assert.Throws<ArgumentException>(() => builder.AddTypeReference(badHandleKind, default(StringHandle), default(StringHandle)));
Assert.Throws<ArgumentException>(() => builder.AddEvent(0, default(StringHandle), badHandleKind));
Assert.Throws<ArgumentException>(() => builder.AddConstant(badHandleKind, 0));
Assert.Throws<ArgumentException>(() => builder.AddMethodSemantics(badHandleKind, 0, default(MethodDefinitionHandle)));
Assert.Throws<ArgumentException>(() => builder.AddCustomAttribute(badHandleKind, default(MethodDefinitionHandle), default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddCustomAttribute(default(TypeDefinitionHandle), badHandleKind, default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddMethodSpecification(badHandleKind, default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddGenericParameter(badHandleKind, 0, default(StringHandle), 0));
Assert.Throws<ArgumentException>(() => builder.AddGenericParameterConstraint(default(GenericParameterHandle), badHandleKind));
Assert.Throws<ArgumentException>(() => builder.AddMarshallingDescriptor(badHandleKind, default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddMethodImplementation(default(TypeDefinitionHandle), badHandleKind, default(MethodDefinitionHandle)));
Assert.Throws<ArgumentException>(() => builder.AddMethodImplementation(default(TypeDefinitionHandle), default(MethodDefinitionHandle), badHandleKind));
Assert.Throws<ArgumentException>(() => builder.AddMemberReference(badHandleKind, default(StringHandle), default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddManifestResource(0, default(StringHandle), badHandleKind, 0));
Assert.Throws<ArgumentException>(() => builder.AddExportedType(0, default(StringHandle), default(StringHandle), badHandleKind, 0));
Assert.Throws<ArgumentException>(() => builder.AddDeclarativeSecurityAttribute(badHandleKind, 0, default(BlobHandle)));
Assert.Throws<ArgumentException>(() => builder.AddCustomDebugInformation(badHandleKind, default(GuidHandle), default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddTypeDefinition(0, default(StringHandle), default(StringHandle), badHandleKind, default(FieldDefinitionHandle), default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddInterfaceImplementation(default(TypeDefinitionHandle), badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddTypeReference(badHandleKind, default(StringHandle), default(StringHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddEvent(0, default(StringHandle), badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddConstant(badHandleKind, 0));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMethodSemantics(badHandleKind, 0, default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddCustomAttribute(badHandleKind, default(MethodDefinitionHandle), default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddCustomAttribute(default(TypeDefinitionHandle), badHandleKind, default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMethodSpecification(badHandleKind, default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddGenericParameter(badHandleKind, 0, default(StringHandle), 0));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddGenericParameterConstraint(default(GenericParameterHandle), badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMarshallingDescriptor(badHandleKind, default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMethodImplementation(default(TypeDefinitionHandle), badHandleKind, default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMethodImplementation(default(TypeDefinitionHandle), default(MethodDefinitionHandle), badHandleKind));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddMemberReference(badHandleKind, default(StringHandle), default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddManifestResource(0, default(StringHandle), badHandleKind, 0));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddExportedType(0, default(StringHandle), default(StringHandle), badHandleKind, 0));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddDeclarativeSecurityAttribute(badHandleKind, 0, default(BlobHandle)));
AssertExtensions.Throws<ArgumentException>(null, () => builder.AddCustomDebugInformation(badHandleKind, default(GuidHandle), default(BlobHandle)));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddModule(-1, default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle)));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddModule(ushort.MaxValue + 1, default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle)));

2
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/MetadataRootBuilderTests.cs vendored
View File

@@ -24,7 +24,7 @@ namespace System.Reflection.Metadata.Ecma335.Tests
var mdBuilder = new MetadataBuilder();
Assert.Throws<ArgumentNullException>(() => new MetadataRootBuilder(null));
Assert.Throws<ArgumentException>(() => new MetadataRootBuilder(mdBuilder, new string('x', 255)));
AssertExtensions.Throws<ArgumentException>("metadataVersion", () => new MetadataRootBuilder(mdBuilder, new string('x', 255)));
}
[Fact]

30
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/MetadataTokensTests.cs vendored
View File

@@ -59,8 +59,8 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Equal(1, MetadataTokens.GetHeapOffset(s_writerGuidHandle));
Assert.Equal(1, MetadataTokens.GetHeapOffset((GuidHandle)s_writerGuidHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetHeapOffset(s_assemblyRefHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetHeapOffset(s_virtualAssemblyRefHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetHeapOffset(s_assemblyRefHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetHeapOffset(s_virtualAssemblyRefHandle));
}
[Fact]
@@ -73,11 +73,11 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Equal(0, MetadataTokens.GetToken(s_virtualAssemblyRefHandle));
Assert.Equal(0x70000001, MetadataTokens.GetToken(s_userStringHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetToken(s_virtualBlobHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetToken(s_stringHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetToken(s_winrtPrefixedStringHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetToken(s_blobHandle));
Assert.Throws<ArgumentException>(() => MetadataTokens.GetToken(s_guidHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetToken(s_virtualBlobHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetToken(s_stringHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetToken(s_winrtPrefixedStringHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetToken(s_blobHandle));
AssertExtensions.Throws<ArgumentException>("handle", () => MetadataTokens.GetToken(s_guidHandle));
}
[Fact]
@@ -183,14 +183,14 @@ namespace System.Reflection.Metadata.Ecma335.Tests
Assert.Equal(s_userStringHandle, MetadataTokens.Handle(0x70000001));
Assert.Equal(s_exportedTypeHandle, MetadataTokens.ExportedTypeHandle((int)(TokenTypeIds.ExportedType | s_exportedTypeHandle.RowId)));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(-1));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x71000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x72000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x73000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x74000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x7a000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x7e000001));
Assert.Throws<ArgumentException>(() => MetadataTokens.Handle(0x7fffffff));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(-1));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x71000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x72000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x73000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x74000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x7a000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x7e000001));
AssertExtensions.Throws<ArgumentException>("token", () => MetadataTokens.Handle(0x7fffffff));
}
[Fact]

8
external/corefx/src/System.Reflection.Metadata/tests/Metadata/Ecma335/PortablePdbBuilderTests.cs vendored
View File

@@ -20,19 +20,19 @@ namespace System.Reflection.Metadata.Ecma335.Tests
var rowCounts = new int[128];
rowCounts[64] = 1;
Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[63] = 1;
Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.EventPtr] = 1;
Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.CustomDebugInformation] = 1;
Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
AssertExtensions.Throws<ArgumentException>("typeSystemRowCounts", () => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle)));
rowCounts = new int[64];
rowCounts[(int)TableIndex.MethodDef] = -1;

4
external/corefx/src/System.Reflection.Metadata/tests/Metadata/MetadataReaderProviderTests.cs vendored
View File

@@ -66,8 +66,8 @@ namespace System.Reflection.Metadata.Tests
[Fact]
public void FromMetadataStream2()
{
Assert.Throws<ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
Assert.Throws<ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: true, canWrite: false));
}

2
external/corefx/src/System.Reflection.Metadata/tests/Metadata/MetadataReaderTests.cs.REMOVED.git-id vendored
View File

@@ -1 +1 @@
ee99dc845ec92deaefa519b0acda736022569a60
16133431b8691a178e50b86a6af445dc7506a8c7

6
external/corefx/src/System.Reflection.Metadata/tests/PortableExecutable/DebugDirectoryBuilderTests.cs vendored
View File

@@ -29,9 +29,9 @@ namespace System.Reflection.PortableExecutable.Tests
public void AddCodeViewEntry_Args()
{
var builder = new DebugDirectoryBuilder();
Assert.Throws<ArgumentException>(() => builder.AddCodeViewEntry("", default(BlobContentId), 0x0100));
Assert.Throws<ArgumentException>(() => builder.AddCodeViewEntry("\0", default(BlobContentId), 0x0100));
Assert.Throws<ArgumentException>(() => builder.AddCodeViewEntry("\0xx", default(BlobContentId), 0x0100));
AssertExtensions.Throws<ArgumentException>("pdbPath", () => builder.AddCodeViewEntry("", default(BlobContentId), 0x0100));
AssertExtensions.Throws<ArgumentException>("pdbPath", () => builder.AddCodeViewEntry("\0", default(BlobContentId), 0x0100));
AssertExtensions.Throws<ArgumentException>("pdbPath", () => builder.AddCodeViewEntry("\0xx", default(BlobContentId), 0x0100));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddCodeViewEntry("xx", default(BlobContentId), 0x0100, int.MinValue));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddCodeViewEntry("xx", default(BlobContentId), 0x0100, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddCodeViewEntry("xx", default(BlobContentId), 0x0100, 0));

4
external/corefx/src/System.Reflection.Metadata/tests/PortableExecutable/PEHeadersTests.cs vendored
View File

@@ -29,8 +29,8 @@ namespace System.Reflection.PortableExecutable.Tests
[Fact]
public void Ctor_Streams()
{
Assert.Throws<ArgumentException>(() => new PEHeaders(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
Assert.Throws<ArgumentException>(() => new PEHeaders(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("peStream", () => new PEHeaders(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("peStream", () => new PEHeaders(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
var s = new CustomAccessMemoryStream(canRead: true, canSeek: true, canWrite: false, buffer: Misc.Members);

6
external/corefx/src/System.Reflection.Metadata/tests/PortableExecutable/PEReaderTests.cs vendored
View File

@@ -55,8 +55,8 @@ namespace System.Reflection.PortableExecutable.Tests
[Fact]
public void Ctor_Streams()
{
Assert.Throws<ArgumentException>(() => new PEReader(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
Assert.Throws<ArgumentException>(() => new PEReader(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("peStream", () => new PEReader(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
AssertExtensions.Throws<ArgumentException>("peStream", () => new PEReader(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
var s = new CustomAccessMemoryStream(canRead: true, canSeek: true, canWrite: false);
@@ -756,7 +756,7 @@ namespace System.Reflection.PortableExecutable.Tests
string pdbPath;
// pass-thru:
Assert.Throws<ArgumentException>(() =>
AssertExtensions.Throws<ArgumentException>(null, () =>
reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), _ => { throw new ArgumentException(); }, out pdbProvider, out pdbPath));
Assert.Throws<InvalidOperationException>(() =>

3
external/corefx/src/System.Reflection.Metadata/tests/System.Reflection.Metadata.Tests.csproj vendored
View File

@@ -90,9 +90,6 @@
<Compile Include="Utilities\ImmutableByteArrayInteropTest.cs" />
<Compile Include="Utilities\MemoryBlockTests.cs" />
<Compile Include="Utilities\OrderByTests.cs" />
<Compile Include="$(CommonTestPath)\System\AssertExtensions.cs">
<Link>Common\System\AssertExtensions.cs</Link>
</Compile>
</ItemGroup>
<ItemGroup>
<None Include="Resources\Namespace\NamespaceForwardedCS.cs" />