internal CompilationVerifier Emit( Compilation compilation, IEnumerable <ModuleData> dependencies, IEnumerable <ResourceDescription> manifestResources, SignatureDescription[] expectedSignatures, string expectedOutput, int?expectedReturnCode, string[] args, Action <PEAssembly> assemblyValidator, Action <IModuleSymbol> symbolValidator, EmitOptions emitOptions, Verification verify) { var verifier = new CompilationVerifier(compilation, VisualizeRealIL, dependencies); verifier.Emit(expectedOutput, expectedReturnCode, args, manifestResources, emitOptions, verify, expectedSignatures); if (assemblyValidator != null || symbolValidator != null) { // We're dual-purposing emitters here. In this context, it // tells the validator the version of Emit that is calling it. RunValidators(verifier, assemblyValidator, symbolValidator); } return(verifier); }
internal static void RunValidators( CompilationVerifier verifier, Action <PEAssembly> assemblyValidator, Action <IModuleSymbol> symbolValidator ) { Assert.True(assemblyValidator != null || symbolValidator != null); var emittedMetadata = verifier.GetMetadata(); if (assemblyValidator != null) { Assert.Equal(MetadataImageKind.Assembly, emittedMetadata.Kind); var assembly = ((AssemblyMetadata)emittedMetadata).GetAssembly(); assemblyValidator(assembly); } if (symbolValidator != null) { var reference = emittedMetadata.Kind == MetadataImageKind.Assembly ? ((AssemblyMetadata)emittedMetadata).GetReference() : ((ModuleMetadata)emittedMetadata).GetReference(); var moduleSymbol = verifier.GetSymbolFromMetadata( reference, verifier.Compilation.Options.MetadataImportOptions ); symbolValidator(moduleSymbol); } }
static internal CompilationVerifier Emit( CommonTestBase test, Compilation compilation, IEnumerable <ModuleData> dependencies, TestEmitters emitOptions, IEnumerable <ResourceDescription> manifestResources, SignatureDescription[] expectedSignatures, string expectedOutput, Action <PEAssembly, TestEmitters> assemblyValidator, Action <IModuleSymbol, TestEmitters> symbolValidator, bool collectEmittedAssembly, bool verify) { CompilationVerifier verifier = null; // We only handle CCI emit here for now... if (emitOptions != TestEmitters.RefEmit) { verifier = new CompilationVerifier(test, compilation, dependencies); verifier.Emit(expectedOutput, manifestResources, verify, expectedSignatures); // We're dual-purposing EmitOptions here. In this context, it // tells the validator the version of Emit that is calling it. RunValidators(verifier, TestEmitters.CCI, assemblyValidator, symbolValidator); } return(verifier); }
internal CompilationVerifier CompileAndVerify( Compilation compilation, IEnumerable <ResourceDescription> manifestResources = null, IEnumerable <ModuleData> dependencies = null, Action <IModuleSymbol> sourceSymbolValidator = null, Action <PEAssembly> assemblyValidator = null, Action <IModuleSymbol> symbolValidator = null, SignatureDescription[] expectedSignatures = null, string expectedOutput = null, EmitOptions emitOptions = null, bool verify = true) { Assert.NotNull(compilation); Assert.True(expectedOutput == null || (compilation.Options.OutputKind == OutputKind.ConsoleApplication || compilation.Options.OutputKind == OutputKind.WindowsApplication), "Compilation must be executable if output is expected."); if (verify) { // Unsafe code might not verify, so don't try. var csharpOptions = compilation.Options as CSharp.CSharpCompilationOptions; verify = (csharpOptions == null || !csharpOptions.AllowUnsafe); } if (sourceSymbolValidator != null) { var module = compilation.Assembly.Modules.First(); sourceSymbolValidator(module); } CompilationVerifier result = null; var verifier = Emit(compilation, dependencies, manifestResources, expectedSignatures, expectedOutput, assemblyValidator, symbolValidator, emitOptions, verify); if (result == null) { result = verifier; } else { // only one emitter should return a verifier Assert.Null(verifier); } // If this fails, it means that more that all emitters failed to return a validator // (i.e. none thought that they were applicable for the given input parameters). Assert.NotNull(result); return(result); }
internal CompilationVerifier CompileAndVerifyCommon( Compilation compilation, IEnumerable <ResourceDescription> manifestResources = null, IEnumerable <ModuleData> dependencies = null, Action <IModuleSymbol> sourceSymbolValidator = null, Action <PEAssembly> assemblyValidator = null, Action <IModuleSymbol> symbolValidator = null, SignatureDescription[] expectedSignatures = null, string expectedOutput = null, bool trimOutput = true, int?expectedReturnCode = null, string[] args = null, EmitOptions emitOptions = null, Verification verify = Verification.Passes) { Assert.NotNull(compilation); Assert.True(expectedOutput == null || (compilation.Options.OutputKind == OutputKind.ConsoleApplication || compilation.Options.OutputKind == OutputKind.WindowsApplication), "Compilation must be executable if output is expected."); if (sourceSymbolValidator != null) { var module = compilation.Assembly.Modules.First(); sourceSymbolValidator(module); } CompilationVerifier result = null; var verifier = Emit(compilation, dependencies, manifestResources, expectedSignatures, expectedOutput, trimOutput, expectedReturnCode, args ?? Array.Empty <string>(), assemblyValidator, symbolValidator, emitOptions, verify); if (result == null) { result = verifier; } else { // only one emitter should return a verifier Assert.Null(verifier); } // If this fails, it means that more that all emitters failed to return a validator // (i.e. none thought that they were applicable for the given input parameters). Assert.NotNull(result); return(result); }
public static CompilationVerifier VerifyPdb( this CompilationVerifier verifier, string expectedPdb, IMethodSymbol debugEntryPoint = null, DebugInformationFormat format = 0, PdbToXmlOptions options = 0, [CallerLineNumber] int expectedValueSourceLine = 0, [CallerFilePath] string expectedValueSourcePath = null) { verifier.Compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath); return(verifier); }
public static CompilationVerifier VerifyPdb( this CompilationVerifier verifier, string expectedPdb, IEnumerable <EmbeddedText> embeddedTexts = null, IMethodSymbol debugEntryPoint = null, DebugInformationFormat format = 0, PdbValidationOptions options = PdbValidationOptions.Default, [CallerLineNumber] int expectedValueSourceLine = 0, [CallerFilePath] string expectedValueSourcePath = null) { verifier.Compilation.VerifyPdb(expectedPdb, embeddedTexts, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath); return(verifier); }
static internal void RunValidators(CompilationVerifier verifier, Action <PEAssembly> assemblyValidator, Action <IModuleSymbol> symbolValidator) { if (assemblyValidator != null) { using (var emittedMetadata = AssemblyMetadata.Create(verifier.GetAllModuleMetadata())) { assemblyValidator(emittedMetadata.GetAssembly()); } } if (symbolValidator != null) { var peModuleSymbol = verifier.GetModuleSymbolForEmittedImage(); Debug.Assert(peModuleSymbol != null); symbolValidator(peModuleSymbol); } }
internal CompilationVerifier Emit( Compilation compilation, IEnumerable <ModuleData> dependencies, IEnumerable <ResourceDescription> manifestResources, SignatureDescription[] expectedSignatures, string expectedOutput, Action <PEAssembly> assemblyValidator, Action <IModuleSymbol> symbolValidator, bool verify) { CompilationVerifier verifier = null; verifier = new CompilationVerifier(this, compilation, dependencies); verifier.Emit(expectedOutput, manifestResources, verify, expectedSignatures); // We're dual-purposing emitters here. In this context, it // tells the validator the version of Emit that is calling it. RunValidators(verifier, assemblyValidator, symbolValidator); return(verifier); }
internal CompilationVerifier CompileAndVerify( Compilation compilation, IEnumerable <ResourceDescription> manifestResources = null, IEnumerable <ModuleData> dependencies = null, TestEmitters emitOptions = TestEmitters.All, Action <IModuleSymbol, TestEmitters> sourceSymbolValidator = null, Action <PEAssembly, TestEmitters> assemblyValidator = null, Action <IModuleSymbol, TestEmitters> symbolValidator = null, SignatureDescription[] expectedSignatures = null, string expectedOutput = null, bool collectEmittedAssembly = true, bool verify = true) { Assert.NotNull(compilation); Assert.True(expectedOutput == null || (compilation.Options.OutputKind == OutputKind.ConsoleApplication || compilation.Options.OutputKind == OutputKind.WindowsApplication), "Compilation must be executable if output is expected."); if (verify) { // Unsafe code might not verify, so don't try. var csharpOptions = compilation.Options as CSharp.CSharpCompilationOptions; verify = (csharpOptions == null || !csharpOptions.AllowUnsafe); } if (sourceSymbolValidator != null) { var module = compilation.Assembly.Modules.First(); sourceSymbolValidator(module, emitOptions); } if (emitters.IsDefaultOrEmpty) { throw new InvalidOperationException( @"You must specify at least one Emitter. Example app.config: <?xml version=""1.0"" encoding=""utf-8""?> <configuration> <roslyn.unittests> <emit> <method assembly=""SomeAssembly"" type=""SomeClass"" name= ""SomeEmitMethod"" /> </emit> </roslyn.unittests> </configuration>"); } CompilationVerifier result = null; foreach (var emit in emitters) { var verifier = emit(this, compilation, dependencies, emitOptions, manifestResources, expectedSignatures, expectedOutput, assemblyValidator, symbolValidator, collectEmittedAssembly, verify); if (result == null) { result = verifier; } else { // only one emitter should return a verifier Assert.Null(verifier); } } // If this fails, it means that more that all emmiters failed to return a validator // (i.e. none thought that they were applicable for the given input parameters). Assert.NotNull(result); return(result); }