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));
}
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 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");
}
}
}
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 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 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())));
}
}
/// <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 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);
}
}
// 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);
}
}
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 void CreateAndManipulateAdhocWorkspace_UnderstandingIsCorrect()
{
using (var adhocWorkspace = new AdhocWorkspace())
{
var solution = adhocWorkspace.CurrentSolution;
var newProject = adhocWorkspace.AddProject("Project.Test", LanguageNames.CSharp);
adhocWorkspace.AddDocument(newProject.Id, "TestFile.cs", SourceText.From("public class Bar { }"));
Assert.AreEqual(1, adhocWorkspace.CurrentSolution.Projects.Count());
var project = adhocWorkspace.CurrentSolution.Projects.Single();
Assert.AreEqual("Project.Test", project.Name);
Assert.AreEqual(1, project.Documents.Count());
Assert.AreEqual("TestFile.cs", project.Documents.Single().Name);
}
}
public static AdhocWorkspace WithFakeProject(
this AdhocWorkspace workspace,
string name,
string assemblyName)
{
workspace.AddProject(ProjectInfo.Create(
id: ProjectId.CreateNewId(),
version: VersionStamp.Default,
name: name,
assemblyName: assemblyName,
language: LanguageNames.CSharp)
.WithMetadataReferences(Enumerable.Empty <MetadataReference>()
.Append(CorlibReference)
.Append(SystemCoreReference)
.Append(CSharpSymbolsReference)
.Append(CodeAnalysisReference)));
return(workspace);
}
public async Task Should_ReturnIgnoredSolutionTestProject_When_SolutionContainsTestProject_And_StoredSettingsAreUnavailable()
{
// arrange
var workspace = new AdhocWorkspace();
var project = workspace.AddProject("foo", LanguageNames.CSharp);
var testClass = CSharpSyntaxTree.ParseText(@"[TestFixtureViewModel]class MathHelperTests{ [Test]void Test(){}}");
workspace.AddDocument(project.Id, "MathHelperTests.cs", SourceText.From(testClass.ToString()));
_testExtractorMock.GetTestClasses(Arg.Any<SyntaxNode>()).Returns(new[] { testClass.GetRoot().GetClassDeclarationSyntax() });
_solutionExplorerMock.Solution.Returns(workspace.CurrentSolution);
// act
TestProject[] projects = await _sut.GetAllTestProjectsAsync();
// assert
Assert.That(projects.Length, Is.EqualTo(1));
Assert.That(projects[0].Project.Name, Is.EqualTo("foo"));
Assert.IsFalse(projects[0].IsCoverageEnabled);
}
public static DisposableResult BuildProjectTreeFromDocuments(params string[] documentContents)
{
var fakeWorkspace = new AdhocWorkspace();
var project = fakeWorkspace.AddProject("ProjectA", LanguageNames.CSharp);
var i = 0;
foreach (var content in documentContents)
{
fakeWorkspace.AddDocument(project.Id, "doc" + i, SourceText.From(content));
i++;
}
var projectA = new ProjectNode
{ Documents = fakeWorkspace.CurrentSolution
.GetProject(project.Id).Documents };
var tree = new SolutionNode();
tree.AddChild(projectA);
ClassTreeBuilder.AddClassesInProjectsToTree(tree);
return new DisposableResult
{Workspace = fakeWorkspace,
result = projectA};
}
public void TestProjectWithBrokenCrossLanguageReferenceHasIncompleteReferences()
{
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("CSharpProject", LanguageNames.CSharp);
workspace.AddDocument(project1.Id, "Broken.cs", SourceText.From("class "));
var project2 = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic,
projectReferences: new[] { new ProjectReference(project1.Id) }));
Assert.True(project1.HasCompleteReferencesAsync().Result);
Assert.False(project2.HasCompleteReferencesAsync().Result);
Assert.Empty(project2.GetCompilationAsync().Result.ExternalReferences);
}
public void TestProjectWithNoBrokenReferencesHasNoIncompleteReferences()
{
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("CSharpProject", LanguageNames.CSharp);
var project2 = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic,
projectReferences: new[] { new ProjectReference(project1.Id) }));
// Nothing should have incomplete references, and everything should build
Assert.True(project1.HasCompleteReferencesAsync().Result);
Assert.True(project2.HasCompleteReferencesAsync().Result);
Assert.Single(project2.GetCompilationAsync().Result.ExternalReferences);
}
public void TestEncodingRetainedAfterTreeChanged()
{
var ws = new AdhocWorkspace();
var proj = ws.AddProject("proj", LanguageNames.CSharp);
var doc = ws.AddDocument(proj.Id, "a.cs", SourceText.From("public class c { }", Encoding.UTF32));
Assert.Equal(Encoding.UTF32, doc.GetTextAsync().Result.Encoding);
// updating root doesn't change original encoding
var root = doc.GetSyntaxRootAsync().Result;
var newRoot = root.WithLeadingTrivia(root.GetLeadingTrivia().Add(CS.SyntaxFactory.Whitespace(" ")));
var newDoc = doc.WithSyntaxRoot(newRoot);
Assert.Equal(Encoding.UTF32, newDoc.GetTextAsync().Result.Encoding);
}
public void TestWorkspaceDiagnosticHasDebuggerText()
{
var solution = new AdhocWorkspace().CurrentSolution;
WorkspaceDiagnostic diagnostic = null;
solution.Workspace.WorkspaceFailed += (sender, args) =>
{
diagnostic = args.Diagnostic;
};
ProjectId pid = ProjectId.CreateNewId();
DocumentId did = DocumentId.CreateNewId(pid);
solution = solution.AddProject(pid, "foo", "foo", LanguageNames.CSharp)
.AddDocument(did, "x", new FileTextLoader(@"C:\doesnotexist.cs", Encoding.UTF8));
var doc = solution.GetDocument(did);
var text = doc.GetTextAsync().Result;
WaitFor(() => diagnostic != null, TimeSpan.FromSeconds(5));
Assert.NotNull(diagnostic);
var dd = diagnostic as DocumentDiagnostic;
Assert.NotNull(dd);
Assert.Equal(dd.GetDebuggerDisplay(), string.Format("[{0}] {1}", dd.Kind.ToString(), dd.Message));
}
public void TestDocumentFileAccessFailureMissingFile()
{
var solution = new AdhocWorkspace().CurrentSolution;
WorkspaceDiagnostic diagnostic = null;
solution.Workspace.WorkspaceFailed += (sender, args) =>
{
diagnostic = args.Diagnostic;
};
ProjectId pid = ProjectId.CreateNewId();
DocumentId did = DocumentId.CreateNewId(pid);
solution = solution.AddProject(pid, "foo", "foo", LanguageNames.CSharp)
.AddDocument(did, "x", new FileTextLoader(@"C:\doesnotexist.cs", Encoding.UTF8));
var doc = solution.GetDocument(did);
var text = doc.GetTextAsync().Result;
WaitFor(() => diagnostic != null, TimeSpan.FromSeconds(5));
Assert.NotNull(diagnostic);
var dd = diagnostic as DocumentDiagnostic;
Assert.NotNull(dd);
Assert.Equal(did, dd.DocumentId);
Assert.Equal(WorkspaceDiagnosticKind.Failure, dd.Kind);
}
public void TestLoadProjectFromCommandLine()
{
string commandLine = @"foo.cs subdir\bar.cs /out:foo.dll /target:library";
var info = CommandLineProject.CreateProjectInfo("TestProject", LanguageNames.CSharp, commandLine, @"C:\ProjectDirectory");
var ws = new AdhocWorkspace();
ws.AddProject(info);
var project = ws.CurrentSolution.GetProject(info.Id);
Assert.Equal("TestProject", project.Name);
Assert.Equal("foo", project.AssemblyName);
Assert.Equal(OutputKind.DynamicallyLinkedLibrary, project.CompilationOptions.OutputKind);
Assert.Equal(2, project.Documents.Count());
var fooDoc = project.Documents.First(d => d.Name == "foo.cs");
Assert.Equal(0, fooDoc.Folders.Count);
Assert.Equal(@"C:\ProjectDirectory\foo.cs", fooDoc.FilePath);
var barDoc = project.Documents.First(d => d.Name == "bar.cs");
Assert.Equal(1, barDoc.Folders.Count);
Assert.Equal("subdir", barDoc.Folders[0]);
Assert.Equal(@"C:\ProjectDirectory\subdir\bar.cs", barDoc.FilePath);
}
private static void GetMultipleProjects(
out Project csBrokenProject,
out Project vbNormalProject,
out Project dependsOnBrokenProject,
out Project dependsOnVbNormalProject,
out Project transitivelyDependsOnBrokenProjects,
out Project transitivelyDependsOnNormalProjects)
{
var workspace = new AdhocWorkspace();
csBrokenProject = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp).WithHasAllInformation(hasAllInformation: false));
vbNormalProject = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic));
dependsOnBrokenProject = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic,
projectReferences: new[] { new ProjectReference(csBrokenProject.Id), new ProjectReference(vbNormalProject.Id) }));
dependsOnVbNormalProject = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp,
projectReferences: new[] { new ProjectReference(vbNormalProject.Id) }));
transitivelyDependsOnBrokenProjects = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp,
projectReferences: new[] { new ProjectReference(dependsOnBrokenProject.Id) }));
transitivelyDependsOnNormalProjects = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic,
projectReferences: new[] { new ProjectReference(dependsOnVbNormalProject.Id) }));
}
public RosylnController()
{
_workspace = new AdhocWorkspace();
_project = _workspace.AddProject("AdhocProject", LanguageNames.CSharp);
}
private static Document CreateDocument(string code, string language)
{
var solution = new AdhocWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);
return project.AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib)
.AddDocument("Document", SourceText.From(code));
}
private static Document CreateDocument(string code, string language)
{
var solution = new AdhocWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);
return project.AddDocument("Document", SourceText.From(code));
}
public async Task TestGetInteriorSymbolsDoesNotCrashOnSpeculativeSemanticModel()
{
var markup = @"
class C
{
void foo()
{
System.Func<int> lambda = () =>
{
int x;
$$
}
}
}";
int position;
string text;
MarkupTestFile.GetPosition(markup, out text, out position);
var sourceText = SourceText.From(text);
var workspace = new AdhocWorkspace();
var project = workspace.AddProject("Test", LanguageNames.CSharp);
var document = workspace.AddDocument(project.Id, "testdocument", sourceText);
var firstModel = await document.GetSemanticModelAsync();
var tree1 = await document.GetSyntaxTreeAsync();
var basemethod1 = tree1.FindTokenOnLeftOfPosition(position, CancellationToken.None).GetAncestor<CSharp.Syntax.BaseMethodDeclarationSyntax>();
// Modify the document so we can use the old semantic model as a base.
var updated = sourceText.WithChanges(new TextChange(new TextSpan(position, 0), "insertion"));
workspace.TryApplyChanges(document.WithText(updated).Project.Solution);
document = workspace.CurrentSolution.GetDocument(document.Id);
var tree2 = await document.GetSyntaxTreeAsync();
var basemethod2 = tree2.FindTokenOnLeftOfPosition(position, CancellationToken.None).GetAncestor<CSharp.Syntax.BaseMethodDeclarationSyntax>();
var service = new CSharp.CSharpSemanticFactsService();
SemanticModel testModel;
var m = service.TryGetSpeculativeSemanticModel(firstModel, basemethod1, basemethod2, out testModel);
var xSymbol = testModel.LookupSymbols(position).First(s => s.Name == "x");
// This should not throw an exception.
Assert.NotNull(SymbolKey.Create(xSymbol));
}
public void Should_RewriteTwoDocumentsFromDifferentProjects()
{
const string sourceCode = "class SampleClass{}";
SyntaxNode node = CSharpSyntaxTree.ParseText(sourceCode).GetRoot();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo.dll", LanguageNames.CSharp);
var project2 = workspace.AddProject("foo2.dll", LanguageNames.CSharp);
DocumentInfo documentInfo1 = DocumentInfo.Create(DocumentId.CreateNewId(project1.Id), "HelloWorld.cs",
filePath: "c:\\helloworld.cs");
DocumentInfo documentInfo2 = DocumentInfo.Create(DocumentId.CreateNewId(project2.Id), "HelloWorld2.cs",
filePath: "c:\\helloworld2.cs");
workspace.AddDocument(documentInfo1);
workspace.AddDocument(documentInfo2);
_auditVariablesRewriterMock.Rewrite(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<SyntaxNode>()).
Returns(new RewrittenDocument(node.SyntaxTree, null, false));
RewriteResult result = _solutionRewriter.RewriteAllClasses(workspace.CurrentSolution.Projects);
Assert.That(result.Items.Count, Is.EqualTo(2));
Assert.That(result.Items.Keys.First().Id, Is.EqualTo(project1.Id));
Assert.That(result.Items.Keys.Last().Id, Is.EqualTo(project2.Id));
}
/// <summary>
/// Creates a new P# project using the specified references.
/// </summary>
/// <param name="references">MetadataReferences</param>
/// <returns>Project</returns>
private Project CreateProject(ISet<MetadataReference> references)
{
var workspace = new AdhocWorkspace();
var solutionInfo = SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Create());
var solution = workspace.AddSolution(solutionInfo);
var project = workspace.AddProject("Test", "C#");
CompilationOptions options = null;
if (this.Configuration.OptimizationTarget == OptimizationTarget.Debug)
{
options = project.CompilationOptions.WithOptimizationLevel(OptimizationLevel.Debug);
}
else if (this.Configuration.OptimizationTarget == OptimizationTarget.Release)
{
options = project.CompilationOptions.WithOptimizationLevel(OptimizationLevel.Release);
}
project = project.WithCompilationOptions(options);
project = project.AddMetadataReferences(references);
workspace.TryApplyChanges(project.Solution);
return project;
}
public void TestFrozenPartialProjectAlwaysIsIncomplete()
{
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("CSharpProject", LanguageNames.CSharp);
var project2 = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"VisualBasicProject",
"VisualBasicProject",
LanguageNames.VisualBasic,
projectReferences: new[] { new ProjectReference(project1.Id) }));
var document = workspace.AddDocument(project2.Id, "Test.cs", SourceText.From(""));
// Nothing should have incomplete references, and everything should build
var frozenSolution = document.WithFrozenPartialSemanticsAsync(CancellationToken.None).Result.Project.Solution;
Assert.True(frozenSolution.GetProject(project1.Id).HasCompleteReferencesAsync().Result);
Assert.True(frozenSolution.GetProject(project2.Id).HasCompleteReferencesAsync().Result);
}
/// <summary>
/// Create a project using the inputted strings as sources.
/// </summary>
/// <param name="sources">Classes in the form of strings</param>
/// <param name="language">The language the source code is in</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <returns>A Project created out of the Douments created from the source strings</returns>
public static Project CreateProject(string[] sources,
string language,
LanguageVersion languageVersionCSharp,
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var fileNamePrefix = DefaultFilePathPrefix;
string fileExt;
ParseOptions parseOptions;
if (language == LanguageNames.CSharp)
{
fileExt = CSharpDefaultFileExt;
parseOptions = new CSharpParseOptions(languageVersionCSharp);
}
else
{
fileExt = VisualBasicDefaultExt;
parseOptions = new Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions(languageVersionVB);
}
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
#pragma warning disable CC0022
var workspace = new AdhocWorkspace();
#pragma warning restore CC0022
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), TestProjectName,
TestProjectName, language,
parseOptions: parseOptions,
metadataReferences: ImmutableList.Create(
CorlibReference, SystemCoreReference, RegexReference,
CSharpSymbolsReference, CodeAnalysisReference, JsonNetReference));
workspace.AddProject(projectInfo);
var count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
workspace.AddDocument(projectId, newFileName, SourceText.From(source));
count++;
}
var project = workspace.CurrentSolution.GetProject(projectId);
var newCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(diagOptions);
var newSolution = workspace.CurrentSolution.WithProjectCompilationOptions(projectId, newCompilationOptions);
var newProject = newSolution.GetProject(projectId);
return newProject;
}
private static Document CreateDocument(string code, string language, LanguageVersion langVersion)
{
var solution = new AdhocWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution
.AddProject(projectId, "Project", "Project.dll", language)
.GetProject(projectId);
var parseOptions = (VisualBasicParseOptions)project.ParseOptions;
parseOptions = parseOptions.WithLanguageVersion(langVersion);
project = project.WithParseOptions(parseOptions);
return project.AddDocument("Document", SourceText.From(code));
}
