public static async Task AssertNoEnforcementAsync(
IStyleRule rule, string documentText, Func<OptionSet, OptionSet> applyOptions)
{
using (var workspace = new AdhocWorkspace())
{
workspace.Options = applyOptions(workspace.Options);
Project project = workspace.AddProject(BuildProject());
Document document = workspace.AddDocument(project.Id, "TestFile.cs", SourceText.From(documentText));
Solution enforcedSolution = await rule.EnforceAsync(document);
Document enforcedDocument = enforcedSolution.GetDocument(document.Id);
if (!document.Equals(enforcedDocument))
{
List<TextChange> changes = (await enforcedDocument.GetTextChangesAsync(document)).ToList();
if (changes.Count == 0)
{
Assert.Fail("Solution mutated without document changes");
}
Console.WriteLine("Document changes:");
foreach (TextChange change in changes)
{
Console.WriteLine($"\t{change}");
}
Assert.Fail($"Enforced document has {changes.Count} changes; expected none");
}
}
}
public void CalculateForAllTests_Should_Return_OneCoverage_From_AllTests_When_There_IsOneProject_And_OneLineCoverage()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo1.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var rewrittenDocument1 = new RewrittenDocument( rewrittenTree, null, true);
rewriteResult.Items[project1] = new List<RewrittenDocument>() { rewrittenDocument1 };
var semanticModel = Substitute.For<ISemanticModel>();
var compiledItem = Substitute.For<ICompiledItem>();
string assembly = "assembly path";
compiledItem.Project.Returns(project1);
compiledItem.DllPath.Returns(assembly);
compiledItem.GetSemanticModel(rewrittenDocument1.SyntaxTree).Returns(semanticModel);
_compiledAllItems.Add(compiledItem);
var expectedLineCoverage = new[] {new LineCoverage()};
_testRunnerMock.RunAllTestsInDocument(rewrittenDocument1,
semanticModel,
project1,
Arg.Is<string[]>(x=>assembly==x[0]))
.Returns(expectedLineCoverage);
// act
LineCoverage[] output = _sut.CalculateForAllTests(rewriteResult);
// assert
Assert.That(output, Is.EquivalentTo(expectedLineCoverage));
}
public void CalculateForAllTests_Should_CompileProvidedDocuments()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo1.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var rewrittenDocument1 = new RewrittenDocument( rewrittenTree, null, false);
rewriteResult.Items[project1] = new List<RewrittenDocument>() { rewrittenDocument1 };
var compiledItem = Substitute.For<ICompiledItem>();
compiledItem.Project.Returns(project1);
_compiledAllItems.Add(compiledItem);
// act
_sut.CalculateForAllTests(rewriteResult);
// assert
_compilerMock.Received(1).Compile
(Arg.Is<IEnumerable<CompilationItem>>(x => x.First().SyntaxTrees[0] ==
rewriteResult.ToCompilationItems().First().SyntaxTrees[0]));
}
public void TestInit()
{
try
{
workspace = new AdhocWorkspace();
project = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "TestProj", "TestProj", LanguageNames.CSharp)
.WithMetadataReferences(new[] {
MetadataReference.CreateFromFile(typeof(DotvvmConfiguration).Assembly.Location),
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)
});
workspace.AddProject(project);
workspace.AddDocument(project.Id, "test", SourceText.From("class A {}"));
context = new DothtmlCompletionContext()
{
Configuration = DotvvmConfiguration.CreateDefault(),
RoslynWorkspace = workspace
};
}
catch (ReflectionTypeLoadException ex)
{
throw new Exception(string.Join("\r\n", ex.LoaderExceptions.Select(e => e.ToString())));
}
}
public static async Task AssertEnforcementAsync(
IStyleRule rule, string originalText, string expectedText, Func<OptionSet, OptionSet> applyOptions)
{
using (var workspace = new AdhocWorkspace())
{
workspace.Options = applyOptions(workspace.Options);
Project project = workspace.AddProject(BuildProject());
Document document = workspace.AddDocument(project.Id, "TestFile.cs", SourceText.From(originalText));
Solution enforcedSolution = await rule.EnforceAsync(document);
Document enforcedDocument = enforcedSolution.GetDocument(document.Id);
if (document.Equals(enforcedDocument))
{
Assert.Fail("Expected enforcement, but no changes were made to the document");
}
SyntaxTree enforcedSyntax = await enforcedDocument.GetSyntaxTreeAsync();
SyntaxTree expectedSyntax = SyntaxFactory.ParseCompilationUnit(expectedText).SyntaxTree;
List<TextChange> unexpectedChanges = expectedSyntax.GetChanges(enforcedSyntax).ToList();
if (unexpectedChanges.Count > 0)
{
Console.WriteLine("Unexpected changes:");
List<TextChange> changes = (await enforcedDocument.GetTextChangesAsync(document)).ToList();
foreach (TextChange change in changes)
{
Console.WriteLine($"\t{change}");
}
Assert.Fail($"Enforced document has {changes.Count} unexpected changes");
}
}
}
private SyntaxNode FormatSyntaxNode(SyntaxNode node)
{
Workspace customWorkspace = new AdhocWorkspace();
var options = customWorkspace.Options;
var formattedResult = Formatter.Format(node, customWorkspace, options);
return formattedResult;
}
protected Project CreateProject(Dictionary<string, string> sources)
{
string fileNamePrefix = DefaultFilePathPrefix;
string fileExt = CSharpDefaultFileExt;
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, LanguageNames.CSharp);
foreach (var reference in References)
{
solution = solution.AddMetadataReference(projectId, reference);
}
int count = 0;
foreach (var source in sources)
{
var newFileName = source.Key;
var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
solution = solution.AddDocument(documentId, newFileName, SourceText.From(source.Value));
count++;
}
var project = solution.GetProject(projectId)
.WithCompilationOptions(CompilationOptions);
return project;
}
public async Task UpdaterService()
{
var exportProvider = TestHostServices.CreateMinimalExportProvider();
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider));
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var listener = new Listener();
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference), listener);
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
var listeners = exportProvider.GetExports<IAsynchronousOperationListener, FeatureMetadata>();
var workspaceListener = listeners.First(l => l.Metadata.FeatureName == FeatureAttribute.Workspace).Value as IAsynchronousOperationWaiter;
// wait for listener
await workspaceListener.CreateWaitTask();
await listener.CreateWaitTask();
// checksum should already exist
SolutionStateChecksums checksums;
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out checksums));
service.Disable();
}
public void Should_Add_InternalToVisible_To_AllReferencedProjects()
{
// arrange
const string expectedAttribute = @"System.Runtime.CompilerServices.InternalsVisibleTo(""Tests.dll_COVERAGE.dll"")";
const string sourceCode = "class SampleClass{}";
SyntaxNode node = CSharpSyntaxTree.ParseText(sourceCode).GetRoot();
var workspace = new AdhocWorkspace();
var referencedProject1 = workspace.AddProject("foo2.dll", LanguageNames.CSharp);
workspace.AddDocument(referencedProject1.Id, "1.cs", SourceText.From(""));
var testsProject = workspace.AddProject("Tests.dll", LanguageNames.CSharp);
var solution = workspace.CurrentSolution.AddProjectReference(testsProject.Id, new ProjectReference(referencedProject1.Id));
_auditVariablesRewriterMock.Rewrite(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<SyntaxNode>()).
Returns(new RewrittenDocument(node.SyntaxTree, null, false));
// act
RewriteResult result = _solutionRewriter.RewriteAllClasses(solution.Projects);
List<RewrittenDocument> projectItems1 = result.Items.Values.First();
var attributes = projectItems1[0].SyntaxTree.GetRoot().DescendantNodes().OfType<AttributeSyntax>().ToArray();
// assert
Assert.That(result.Items.Count, Is.EqualTo(1));
Assert.That(projectItems1.Count, Is.EqualTo(1));
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0].ToString(), Is.EqualTo(expectedAttribute));
}
protected Solution CreateSolution(string[] sources, string[] preprocessorSymbols = null, string language = LanguageNames.CSharp)
{
string fileExtension = language == LanguageNames.CSharp ? CSharpFileExtension : VBFileExtension;
var projectId = ProjectId.CreateNewId(TestProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, language)
.AddMetadataReferences(projectId, GetSolutionMetadataReferences());
if (preprocessorSymbols != null)
{
var project = solution.Projects.Single();
project = project.WithParseOptions(
((CSharpParseOptions)project.ParseOptions).WithPreprocessorSymbols(preprocessorSymbols));
solution = project.Solution;
}
int count = 0;
foreach (var source in sources)
{
var fileName = FileNamePrefix + count + fileExtension;
var documentId = DocumentId.CreateNewId(projectId, fileName);
solution = solution.AddDocument(documentId, fileName, SourceText.From(source));
}
return solution;
}
public override sealed async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
// var syntaxNode = root.FindNode(diagnosticSpan);
//var declaration = root.FindToken(diagnosticSpan.Start);
// var firstToken = declaration.GetFirstToken();
// var leadingTrivia = firstToken.LeadingTrivia;
// var trimmedLocal = declaration.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(SyntaxTriviaList.Empty));
var cw = new AdhocWorkspace();
OptionSet options = cw.Options;
options = options.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInMethods, false);
options = options.WithChangedOption(CSharpFormattingOptions.IndentBlock, false);
context.RegisterCodeFix(
CodeAction.Create(
Title,
async c =>
{
var oldNode = root.FindTrivia(diagnosticSpan.Start);
var newRoot = root.ReplaceTrivia(oldNode, SyntaxTriviaList.Empty);
newRoot = newRoot.WithAdditionalAnnotations(Formatter.Annotation);
newRoot = Formatter.Format(newRoot, new AdhocWorkspace(),options);
//TODO:Need to remove empty line if it followed by a comment(Formatting).
return await Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
public void ImplementProperty_GenerateLineBreaks()
{
WithSourceFiles(Files.ChildClass, Files.Mixin);
var typeSymbol = Substitute.For<ITypeSymbol>();
var mixin = Substitute.For<MixinReference>();
mixin.Name.Returns("_mixin");
var property = new Property("Name", typeSymbol, true, true);
var implementPropertyStrategy = new ImplementPropertyForwarding(
mixin, Semantic, new Settings(avoidLineBreaksInProperties:false));
var memberDeclaration = implementPropertyStrategy.ImplementMember(property, 0);
// Assert:
// let the formatting engine format the output source and ensure
// that the text has only 6 lines:
// <empty line>
// public Name
// {
// get
// {
// ...
// }
// <empty line>
// ...
// }
var workspace = new AdhocWorkspace();
memberDeclaration = (MemberDeclarationSyntax)Formatter.Format(memberDeclaration, workspace);
var sourceText = SourceText.From(memberDeclaration.ToFullString());
Assert.AreEqual(13, sourceText.Lines.Count);
}
public static void VerifyAnalyzer(string path, DiagnosticAnalyzer diagnosticAnalyzer, ParseOptions options = null,
params MetadataReference[] additionalReferences)
{
var file = new FileInfo(path);
var parseOptions = GetParseOptionsAlternatives(options, file);
using (var workspace = new AdhocWorkspace())
{
var document = GetDocument(file, GeneratedAssemblyName, workspace, additionalReferences);
var project = document.Project;
foreach (var parseOption in parseOptions)
{
if (parseOption != null)
{
project = project.WithParseOptions(parseOption);
}
var compilation = project.GetCompilationAsync().Result;
var diagnostics = GetDiagnostics(compilation, diagnosticAnalyzer);
var expected = ExpectedIssues(compilation.SyntaxTrees.First()).ToList();
foreach (var diagnostic in diagnostics)
{
var line = diagnostic.GetLineNumberToReport();
expected.Should().Contain(line);
expected.Remove(line);
}
expected.Should().BeEquivalentTo(Enumerable.Empty<int>());
}
}
}
internal static Document CreateDocument(string code, string fileName,
Func<Solution, ProjectId, Solution> modifySolution)
{
var projectName = "Test";
var projectId = ProjectId.CreateNewId(projectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, projectName, projectName, LanguageNames.CSharp)
.AddMetadataReference(projectId,
MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddMetadataReference(projectId,
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location))
.AddMetadataReference(projectId,
MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location))
.AddMetadataReference(projectId,
MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location));
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(documentId, fileName, SourceText.From(code));
if(modifySolution != null)
{
solution = modifySolution(solution, projectId);
}
return solution.GetProject(projectId).Documents.First();
}
public void Should_RewriteOneDocument()
{
// arrange
const string sourceCode = "class SampleClass{}";
SyntaxNode node = CSharpSyntaxTree.ParseText(sourceCode).GetRoot();
var workspace = new AdhocWorkspace();
var project = workspace.AddProject("foo.dll", LanguageNames.CSharp);
string documentPath = "c:\\helloworld.cs";
DocumentInfo documentInfo = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "HelloWorld.cs",
filePath: documentPath);
Document document = workspace.AddDocument(documentInfo);
_auditVariablesRewriterMock.Rewrite(Arg.Any<string>(), documentPath, Arg.Any<SyntaxNode>()).
Returns(new RewrittenDocument(node.SyntaxTree, null, false));
// act
RewriteResult result = _solutionRewriter.RewriteAllClasses(workspace.CurrentSolution.Projects);
// assert
Assert.That(result.Items.Count, Is.EqualTo(1));
Assert.That(result.Items.Keys.First().Id, Is.EqualTo(project.Id));
Assert.That(result.Items.Values.First().Count, Is.EqualTo(1));
}
public async Task UpdaterService()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// TODO: use waiter to make sure workspace events and updater is ready.
// this delay is temporary until I set all .Next unit test hardness to setup correctly
await Task.Delay(TimeSpan.FromSeconds(1));
// checksum should already exist
SolutionStateChecksums checksums;
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out checksums));
service.Disable();
}
public async Task UpdaterService()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// TODO: use waiter to make sure workspace events and updater is ready.
// this delay is temporary until I set all .Next unit test hardness to setup correctly
await Task.Delay(TimeSpan.FromSeconds(1));
var checksumService = workspace.Services.GetService<ISolutionChecksumService>();
Checksum checksum;
using (var scope = await checksumService.CreateChecksumAsync(workspace.CurrentSolution, CancellationToken.None))
{
// create solution checksum and hold onto the checksum and let it go
checksum = scope.SolutionChecksum.Checksum;
}
// there should be one held in memory by solution checksum updator
var solutionObject = checksumService.GetChecksumObject(checksum, CancellationToken.None);
Assert.Equal(solutionObject.Checksum, checksum);
service.Disable();
}
private Workspace CreateWorkspace(string[] sources, string language = LanguageNames.CSharp)
{
string fileExtension = language == LanguageNames.CSharp ? CSharpFileExtension : VBFileExtension;
var projectId = ProjectId.CreateNewId(TestProjectName);
var workspace = new AdhocWorkspace();
var solution = workspace
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, language)
.AddMetadataReferences(projectId, GetSolutionMetadataReferences());
int count = 0;
foreach (var source in sources)
{
var fileName = FileNamePrefix + count + fileExtension;
var documentId = DocumentId.CreateNewId(projectId, fileName);
solution = solution.AddDocument(documentId, fileName, SourceText.From(source));
count++;
}
workspace.TryApplyChanges(solution);
return workspace;
}
public RoslynGenerator(Job job)
{
_namespace = job.DestinationNamespace;
_customAnnotations = job.CustomAnnotations;
_nullableClasses = job.NullableClasses;
_workspace = new AdhocWorkspace();
_generator = SyntaxGenerator.GetGenerator(_workspace, LanguageNames.CSharp);
}
/// <summary>
/// Initializes a new instance of the <see cref="CsvCompilerModule"/> class.
/// </summary>
public CSharpCompilerModule(Bootstrapper bootstrapper)
: base(bootstrapper)
{
compiler = new CSharpCompiler();
workspace = new AdhocWorkspace();
project = workspace.AddProject("CSharpProject", LanguageNames.CSharp);
document = project.AddDocument("current", "");
context = new CompilationContext(workspace, document);
}
public void Setup()
{
_solutionCoverageEngineMock = Substitute.For<ISolutionCoverageEngine>();
_coverageStoreMock = Substitute.For<ICoverageStore>();
Workspace workspace = new AdhocWorkspace();
_sut = new VsSolutionTestCoverage(workspace,
_solutionCoverageEngineMock,
_coverageStoreMock);
}
public static Solution GetSolutionFromText(string text)
{
using (var workspace = new AdhocWorkspace())
{
return workspace.CurrentSolution.AddProject("foo", "foo.dll", LanguageNames.CSharp)
.AddMetadataReference(MetadataReference.CreateFromFile(typeof (object).Assembly.Location))
.AddDocument("foo.cs", text)
.Project
.Solution;
}
}
public static void VerifyNoExceptionThrown(string path,
IEnumerable<DiagnosticAnalyzer> diagnosticAnalyzers)
{
using (var workspace = new AdhocWorkspace())
{
var document = GetDocument(path, GeneratedAssemblyName, workspace);
var compilation = document.Project.GetCompilationAsync().Result;
var diagnostics = GetAllDiagnostics(compilation, diagnosticAnalyzers);
VerifyNoExceptionThrown(diagnostics);
}
}
public static Solution GetSolutionWithEmptyFile()
{
using (var workspace = new AdhocWorkspace())
{
return workspace.CurrentSolution.AddProject("foo", "foo.dll", LanguageNames.CSharp)
.AddMetadataReference(SystemMetadataReference)
.AddDocument("foo.cs", string.Empty)
.Project
.Solution;
}
}
private Document CreateSolutionDocument(string sourceText)
{
var pid = ProjectId.CreateNewId();
var did = DocumentId.CreateNewId(pid);
var solution = new AdhocWorkspace().CurrentSolution
.AddProject(pid, "test", "test", LanguageNames.CSharp)
.AddMetadataReference(pid, TestReferences.NetFx.v4_0_30319.mscorlib)
.AddDocument(did, "foo.cs", SourceText.From(sourceText));
return solution.GetDocument(did);
}
public static Solution GetSolutionWithEmptyFile(AnalyzerLanguage language)
{
using (var workspace = new AdhocWorkspace())
{
var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic;
return workspace.CurrentSolution.AddProject("foo", "foo.dll", lang)
.AddMetadataReference(SystemMetadataReference)
.AddDocument($"foo.{language.GetFileExtension()}", string.Empty)
.Project
.Solution;
}
}
public TestHelper(string source)
{
Workspace = new AdhocWorkspace();
string projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp);
var newProject = Workspace.AddProject(projectInfo);
var sourceText = SourceText.From(source);
Document = Workspace.AddDocument(newProject.Id, "NewFile.cs", sourceText);
}
public async Task TestCodeGeneration(string resourceBaseName, Language language)
{
var inputResourceName = "BrightstarDB.CodeGeneration.Tests.GeneratorTestsResources." + resourceBaseName + "Input_" + language.ToString() + ".txt";
var outputResourceName = "BrightstarDB.CodeGeneration.Tests.GeneratorTestsResources." + resourceBaseName + "Output_" + language.ToString() + ".txt";
using (var inputStream = this.GetType().Assembly.GetManifestResourceStream(inputResourceName))
using (var outputStream = this.GetType().Assembly.GetManifestResourceStream(outputResourceName))
using (var outputStreamReader = new StreamReader(outputStream))
{
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(
projectId,
versionStamp,
"AdhocProject",
"AdhocProject",
language.ToSyntaxGeneratorLanguageName(),
metadataReferences: new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
MetadataReference.CreateFromFile(typeof(BrightstarException).Assembly.Location)
});
var project = workspace.AddProject(projectInfo);
workspace.AddDocument(projectId, "Source.cs", SourceText.From(inputStream));
var solution = workspace.CurrentSolution;
var results = await Generator
.GenerateAsync(
language,
solution,
"BrightstarDB.CodeGeneration.Tests",
interfacePredicate: x => true);
var result = results
.Aggregate(
new StringBuilder(),
(current, next) => current.AppendLine(next.ToString()),
x => x.ToString());
var expectedCode = outputStreamReader.ReadToEnd();
// make sure version changes don't break the tests
expectedCode = expectedCode.Replace("$VERSION$", typeof(BrightstarException).Assembly.GetName().Version.ToString());
//// useful when converting generated code to something that can be pasted into an expectation file
//var sanitisedResult = result.Replace("1.10.0.0", "$VERSION$");
//System.Diagnostics.Debug.WriteLine(sanitisedResult);
Assert.AreEqual(expectedCode, result);
}
}
static (AdhocWorkspace, Project) CreateWorkspace()
{
var workspace = new Microsoft.CodeAnalysis.AdhocWorkspace();
workspace.WorkspaceFailed += (s, e) => { Console.WriteLine(e.Diagnostic); };
var projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp);
var newProject = workspace.AddProject(projectInfo);
return(workspace, newProject);
}
public static void Verify(string path, DiagnosticAnalyzer diagnosticAnalyzer)
{
var file = new FileInfo(path);
using (var workspace = new AdhocWorkspace())
{
var document = workspace.CurrentSolution.AddProject("foo", "foo.dll", LanguageNames.CSharp)
.AddMetadataReference(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddMetadataReference(MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location))
.AddDocument(file.Name, File.ReadAllText(file.FullName, Encoding.UTF8));
Verify(document.Project, diagnosticAnalyzer);
}
}
// TODO: VB is totally borked - calls to syntaxGenerator.WithStatements don't seem to add the statements! Will need to look into this at a later date
//[InlineData("SimpleInterface", Language.VisualBasic)]
//[InlineData("InterfaceWithGenericMethods", Language.VisualBasic)]
//[InlineData("GenericInterface", Language.VisualBasic)]
//[InlineData("InterfaceWithNonMockableMembers", Language.VisualBasic)]
//[InlineData("PartialInterface", Language.VisualBasic)]
//[InlineData("InheritingInterface", Language.VisualBasic)]
public async Task can_generate_simple_mock(string resourceBaseName, Language language)
{
var inputResourceName = "PCLMock.UnitTests.CodeGeneration.GeneratorFixtureResources." + resourceBaseName + "Input_" + language.ToString() + ".txt";
var outputResourceName = "PCLMock.UnitTests.CodeGeneration.GeneratorFixtureResources." + resourceBaseName + "Output_" + language.ToString() + ".txt";
using (var inputStream = this.GetType().Assembly.GetManifestResourceStream(inputResourceName))
using (var outputStream = this.GetType().Assembly.GetManifestResourceStream(outputResourceName))
using (var outputStreamReader = new StreamReader(outputStream))
{
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(
projectId,
versionStamp,
"AdhocProject",
"AdhocProject",
language.ToSyntaxGeneratorLanguageName(),
metadataReferences: new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
MetadataReference.CreateFromFile(typeof(MockBase<>).Assembly.Location)
});
var project = workspace.AddProject(projectInfo);
workspace.AddDocument(projectId, "Source.cs", SourceText.From(inputStream));
var solution = workspace.CurrentSolution;
var results =
(await Generator.GenerateMocksAsync(
language,
solution,
x => true,
x => "The.Namespace",
x => "Mock"));
var result = results
.Single()
.ToString();
var expectedCode = outputStreamReader.ReadToEnd();
// make sure version changes don't break the tests
expectedCode = expectedCode.Replace("$VERSION$", typeof(MockBase<>).Assembly.GetName().Version.ToString());
// useful when converting generated code to something that can be pasted into an expectation file
var sanitisedResult = result.Replace(typeof(MockBase<>).Assembly.GetName().Version.ToString(), "$VERSION$");
Assert.Equal(expectedCode, result);
}
}