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 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));
}
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 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 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 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())));
}
}
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;
}
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 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);
}
}
internal Options(
IEnumerable<Project> projects = null,
IEnumerable<string> projectPaths = null,
IEnumerable<string> sourcePaths = null,
IEnumerable<IEnumerable<string>> symbolConfigurations = null,
IEnumerable<string> alwaysIgnoredSymbols = null,
IEnumerable<string> alwaysDefinedSymbols = null,
IEnumerable<string> alwaysDisabledSymbols = null,
Tristate undefinedSymbolValue = default(Tristate),
IAnalysisLogger logger = null)
{
if (projectPaths != null)
{
projects = Task.WhenAll(from path in projectPaths select MSBuildWorkspace.Create().OpenProjectAsync(path, CancellationToken.None)).Result;
}
if (projects != null)
{
Documents = GetSharedDocuments(projects);
}
if (projects == null && sourcePaths != null)
{
var projectId = ProjectId.CreateNewId("AnalysisProject");
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, "AnalysisProject", "AnalysisProject", LanguageNames.CSharp);
foreach (var path in sourcePaths)
{
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(
documentId,
Path.GetFileName(path),
new FileTextLoader(path, defaultEncoding: Encoding.UTF8));
}
Documents = solution.Projects.Single().Documents.ToImmutableArray();
}
_symbolConfigurations = CalculateSymbolConfigurations(
alwaysDisabledSymbols,
alwaysDefinedSymbols,
alwaysIgnoredSymbols,
symbolConfigurations);
_undefinedSymbolValue = undefinedSymbolValue;
Logger = logger ?? new ConsoleAnalysisLogger();
}
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);
}
}
static Project CreateProject(string source)
{
var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
var projectId = ProjectId.CreateNewId();
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, "TestProject", "TestProject", LanguageNames.CSharp)
.WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location))
.AddMetadataReference(projectId, MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")))
.AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(ConstAttribute).Assembly.Location));
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(documentId, "Test.cs", SourceText.From(source));
return solution.GetProject(projectId);
}
internal static Document Create(string code)
{
var projectName = "Test";
var projectId = ProjectId.CreateNewId(projectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, projectName, projectName, LanguageNames.CSharp)
.WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddMetadataReference(projectId, MetadataReference.CreateFromAssembly(typeof(object).Assembly))
.AddMetadataReference(projectId, MetadataReference.CreateFromAssembly(typeof(Enumerable).Assembly))
.AddMetadataReference(projectId, MetadataReference.CreateFromAssembly(typeof(CSharpCompilation).Assembly))
.AddMetadataReference(projectId, MetadataReference.CreateFromAssembly(typeof(Compilation).Assembly))
.AddMetadataReference(projectId, MetadataReference.CreateFromAssembly(typeof(BusinessBase<>).Assembly));
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(documentId, "Test.cs", SourceText.From(code));
return solution.GetProject(projectId).Documents.First();
}
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);
}
private Solution CreateSolution(string[] sources, 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());
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++;
}
return solution;
}
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 static AdhocWorkspace WithFakeDocument(
this AdhocWorkspace workspace,
string name,
string filePath,
string text)
{
if (workspace.CurrentSolution.ProjectIds.Count == 0)
{
workspace.WithFakeProject(
"FakeProject",
"FakeProjectAssembly");
}
workspace.AddDocument(DocumentInfo.Create(
id: DocumentId.CreateNewId(workspace.CurrentSolution.ProjectIds[0]),
name: name,
filePath: filePath,
loader: TextLoader.From(TextAndVersion.Create(
version: VersionStamp.Default,
text: SourceText.From(text)))));
return(workspace);
}
private Project CreateSolution(string source)
{
var testProjectName = "Test";
var projectId = ProjectId.CreateNewId(testProjectName);
var references = new[]
{
s_CorlibReference,
s_SystemCoreReference,
s_MSTestReference,
s_XunitReference
};
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, testProjectName, testProjectName, LanguageNames.CSharp)
.AddMetadataReferences(projectId, references);
var fileName = "File.cs";
var documentId = DocumentId.CreateNewId(projectId, fileName);
solution = solution.AddDocument(documentId, fileName, SourceText.From(source));
return solution.GetProject(projectId);
}
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);
}
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 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);
}
private static Project CreateProject(string[] sources, string language = LanguageNames.VisualBasic)
#endif
{
string fileNamePrefix = DefaultFilePathPrefix;
string fileExt = language == LanguageNames.CSharp ? CSharpDefaultFileExt : VisualBasicDefaultExt;
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, language)
#if CSHARP
.WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
#elif VISUAL_BASIC
.WithProjectCompilationOptions(projectId, new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
#endif
.AddMetadataReference(projectId, CorlibReference)
.AddMetadataReference(projectId, SystemCoreReference)
#if CSHARP
.AddMetadataReference(projectId, CSharpSymbolsReference)
#elif VISUAL_BASIC
.AddMetadataReference(projectId, VisualBasicSymbolsReference)
#endif
.AddMetadataReference(projectId, CodeAnalysisReference)
.AddMetadataReference(projectId, FakeItEasyReference);
int count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
count++;
}
return solution.GetProject(projectId);
}
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>
/// 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;
}
/// <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>
/// <returns>A Project created out of the Documents created from the source strings</returns>
private static Project CreateProject(string[] sources)
{
string TestProjectName = "TestProject";
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, LanguageNames.CSharp)
.AddMetadataReference(projectId, CorlibReference)
.AddMetadataReference(projectId, SystemCoreReference)
.AddMetadataReference(projectId, CSharpSymbolsReference)
.AddMetadataReference(projectId, CodeAnalysisReference)
.AddMetadataReference(projectId, EntityReference)
.AddMetadataReference(projectId, UtilitiesReference);
int count = 0;
foreach (var source in sources)
{
var newFileName = "Test" + count + ".cs";
var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
count++;
}
return solution.GetProject(projectId);
}
public async Task Run()
{
var op = new AzureAsyncOperation();
var restOp = new RestException();
var files = Settings.Instance.FileSystem.GetFiles(Settings.Instance.OutputDirectory, "*.cs",
SearchOption.AllDirectories).
ToDictionary(each => each, each => Settings.Instance.FileSystem.ReadFileAsText(each));
var projectId = ProjectId.CreateNewId();
var solution = new AdhocWorkspace().CurrentSolution
.AddProject(projectId, "MyProject", "MyProject", LanguageNames.CSharp)
.AddMetadataReference(projectId, Mscorlib)
.AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
.Where(
a =>
string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime.Azure",
StringComparison.OrdinalIgnoreCase) == 0)
.Select(a => MetadataReference.CreateFromFile(a.Location)).Single())
.AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
.Where(
a =>
string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime",
StringComparison.OrdinalIgnoreCase) == 0)
.Select(a => MetadataReference.CreateFromFile(a.Location)).Single())
.AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
.Where(a => string.Compare(a.GetName().Name, "System", StringComparison.OrdinalIgnoreCase) == 0)
.Select(a => MetadataReference.CreateFromFile(a.Location)).Single());
// Add existing files
foreach (var file in files.Keys)
{
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(documentId, file, SourceText.From(files[file]));
}
// Simplify docs and add to
foreach (var proj in solution.Projects)
{
foreach (var document in proj.Documents)
{
var newRoot = await document.GetSyntaxRootAsync();
// get the namespaces used in the file
var names = new GetQualifiedNames().GetNames(newRoot);
// add the usings that we found
newRoot = new AddUsingsRewriter(names).Visit(newRoot);
// tell roslyn to simplify where it can
newRoot = new SimplifyNamesRewriter().Visit(newRoot);
var doc = document.WithSyntaxRoot(newRoot);
// reduce the code
var text = Simplifier.ReduceAsync(doc)
.Result.GetTextAsync()
.Result.ToString()
// get rid of any BOMs
.Trim('\x00EF', '\x00BB', '\x00BF', '\uFEFF', '\u200B');
// special cases the simplifier can't handle.
text = text.
Replace("[Newtonsoft.Json.JsonConverter(", "[JsonConverter(").
Replace("[System.Runtime.Serialization.EnumMember(", "[EnumMember(").
Replace("[Newtonsoft.Json.JsonProperty(", "[JsonProperty(").
Replace("[Newtonsoft.Json.JsonProperty]", "[JsonProperty]").
Replace("[Newtonsoft.Json.JsonObject]", "[JsonObject]").
Replace("[Microsoft.Rest.Serialization.JsonTransformation]", "[JsonTransformation]").
Replace("[Newtonsoft.Json.JsonExtensionData]", "[JsonExtensionData]");
// Write out the files back to their original location
var output = Path.Combine(Settings.Instance.FileSystem.CurrentDirectory, document.Name);
Settings.Instance.FileSystem.WriteFile(output, text);
}
}
}
/// <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>
/// <returns>A Project created out of the Documents created from the source strings</returns>
private static Project CreateProject(string[] sources, string language = LanguageNames.CSharp)
{
string fileNamePrefix = DefaultFilePathPrefix;
string fileExt = language == LanguageNames.CSharp ? CSharpDefaultFileExt : VisualBasicDefaultExt;
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, language)
.AddMetadataReference(projectId, CorlibReference)
.AddMetadataReference(projectId, SystemCoreReference)
.AddMetadataReference(projectId, CSharpSymbolsReference)
.AddMetadataReference(projectId, CodeAnalysisReference);
int count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
count++;
}
return solution.GetProject(projectId);
}
/// <summary>
/// Create a project using the inputted strings as sources.
/// </summary>
/// <param name="fileSources">Classes in the form of MvxTestFileSources</param>
/// <returns>A Solution created out of the Documents created from the source strings</returns>
private static Solution CreateSolution(MvxTestFileSource[] fileSources)
{
string fileNamePrefix = DefaultFilePathPrefix;
_coreProjectId = ProjectId.CreateNewId(debugName: TestCoreProjectName);
_droidProjectId = ProjectId.CreateNewId(debugName: TestDroidProjectName);
_iosProjectId = ProjectId.CreateNewId(debugName: TestIosProjectName);
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(_coreProjectId, TestCoreProjectName, TestCoreProjectName, LanguageNames.CSharp)
.AddProject(_droidProjectId, TestDroidProjectName, TestDroidProjectName, LanguageNames.CSharp)
.AddProject(_iosProjectId, TestIosProjectName, TestIosProjectName, LanguageNames.CSharp)
.AddMetadataReference(_coreProjectId, _corlibReference)
.AddMetadataReference(_coreProjectId, _systemCoreReference)
.AddMetadataReference(_coreProjectId, _cSharpSymbolsReference)
.AddMetadataReference(_coreProjectId, _codeAnalysisReference)
.AddMetadataReference(_coreProjectId, _mvvmCrossCoreReference)
.AddMetadataReference(_coreProjectId, _mvvmCrossPlatformReference)
.AddMetadataReference(_coreProjectId, _componentModelReference)
.AddMetadataReference(_coreProjectId, _objectModelReference)
.AddMetadataReference(_coreProjectId, _runtimeReference)
.AddMetadataReference(_droidProjectId, _corlibReference)
.AddMetadataReference(_droidProjectId, _systemCoreReference)
.AddMetadataReference(_droidProjectId, _cSharpSymbolsReference)
.AddMetadataReference(_droidProjectId, _codeAnalysisReference)
.AddMetadataReference(_droidProjectId, _mvvmCrossCoreReference)
.AddMetadataReference(_droidProjectId, _mvvmCrossDroidReference)
.AddMetadataReference(_droidProjectId, _componentModelReference)
.AddMetadataReference(_droidProjectId, _objectModelReference)
.AddProjectReference(_droidProjectId, new ProjectReference(_coreProjectId))
.AddMetadataReference(_iosProjectId, _corlibReference)
.AddMetadataReference(_iosProjectId, _systemCoreReference)
.AddMetadataReference(_iosProjectId, _cSharpSymbolsReference)
.AddMetadataReference(_iosProjectId, _codeAnalysisReference)
.AddMetadataReference(_iosProjectId, _mvvmCrossCoreReference)
.AddMetadataReference(_iosProjectId, _mvvmCrossIosReference)
.AddMetadataReference(_iosProjectId, _componentModelReference)
.AddMetadataReference(_iosProjectId, _objectModelReference)
.AddProjectReference(_iosProjectId, new ProjectReference(_coreProjectId));
int count = 0;
foreach (var fileSource in fileSources)
{
var newFileName = fileNamePrefix + count + "." + CSharpDefaultFileExt;
var documentId = DocumentId.CreateNewId(GetProjectId(fileSource), debugName: newFileName);
solution = solution.AddDocument(documentId, newFileName, SourceText.From(fileSource.Source));
count++;
}
return solution;
}
