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);
}
