public async Task CreateSolutionSnapshotId_Duplicate()
{
using var workspace = CreateWorkspace();
var solution = CreateFullSolution(workspace);
// this is just data, one can hold the id outside of using statement. but
// one can't get asset using checksum from the id.
SolutionStateChecksums solutionId1;
SolutionStateChecksums solutionId2;
var validator = new SerializationValidator(workspace.Services);
using (var scope1 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false))
{
solutionId1 = await validator.GetValueAsync <SolutionStateChecksums>(scope1.SolutionInfo.SolutionChecksum).ConfigureAwait(false);
}
using (var scope2 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false))
{
solutionId2 = await validator.GetValueAsync <SolutionStateChecksums>(scope2.SolutionInfo.SolutionChecksum).ConfigureAwait(false);
}
// once pinned snapshot scope is released, there is no way to get back to asset.
// catch Exception because it will throw 2 different exception based on release or debug (ExceptionUtilities.UnexpectedValue)
Assert.ThrowsAny <Exception>(() => validator.SolutionStateEqual(solutionId1, solutionId2));
}
public async Task CreateSolutionSnapshotId_Full()
{
using var workspace = CreateWorkspace();
var solution = CreateFullSolution(workspace);
var firstProjectChecksum = await solution.GetProject(solution.ProjectIds[0]).State.GetChecksumAsync(CancellationToken.None);
var secondProjectChecksum = await solution.GetProject(solution.ProjectIds[1]).State.GetChecksumAsync(CancellationToken.None);
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false);
var syncObject = await validator.AssetStorage.GetAssetAsync(scope.SolutionInfo.ScopeId, scope.SolutionInfo.SolutionChecksum, CancellationToken.None).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(syncObject.Checksum).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(syncObject).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Attributes, WellKnownSynchronizationKind.SolutionAttributes).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Options, WellKnownSynchronizationKind.OptionSet).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Projects.Checksum, WellKnownSynchronizationKind.Projects).ConfigureAwait(false);
Assert.Equal(2, solutionObject.Projects.Count);
var projects = validator.ToProjectObjects(solutionObject.Projects);
await validator.VerifySnapshotInServiceAsync(projects.Where(p => p.Checksum == firstProjectChecksum).First(), 1, 1, 1, 1, 1).ConfigureAwait(false);
await validator.VerifySnapshotInServiceAsync(projects.Where(p => p.Checksum == secondProjectChecksum).First(), 1, 0, 0, 0, 0).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId()
{
var code = "class A { }";
using var workspace = CreateWorkspace();
var document = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code));
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false);
var syncObject = await validator.AssetStorage.GetAssetAsync(scope.SolutionInfo.ScopeId, scope.SolutionInfo.SolutionChecksum, CancellationToken.None).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(syncObject.Checksum).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(syncObject).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Attributes, WellKnownSynchronizationKind.SolutionAttributes).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Options, WellKnownSynchronizationKind.OptionSet).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Projects.Checksum, WellKnownSynchronizationKind.Projects).ConfigureAwait(false);
Assert.Equal(1, solutionObject.Projects.Count);
await validator.VerifySnapshotInServiceAsync(validator.ToProjectObjects(solutionObject.Projects)[0], 1, 0, 0, 0, 0).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Empty()
{
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution;
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false);
var checksum = scope.SolutionInfo.SolutionChecksum;
var solutionSyncObject = await validator.AssetStorage.GetAssetAsync(scope.SolutionInfo.ScopeId, checksum, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(solutionSyncObject).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(checksum).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Attributes, WellKnownSynchronizationKind.SolutionAttributes).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Options, WellKnownSynchronizationKind.OptionSet).ConfigureAwait(false);
var projectsSyncObject = await validator.AssetStorage.GetAssetAsync(scope.SolutionInfo.ScopeId, solutionObject.Projects.Checksum, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(projectsSyncObject).ConfigureAwait(false);
Assert.Equal(0, solutionObject.Projects.Count);
}
public ChecksumObjectCollection(SerializationValidator validator, ChecksumCollection collection)
: base(collection.Checksum, collection.GetWellKnownSynchronizationKind())
{
// using .Result here since we don't want to convert all calls to this to async.
// and none of ChecksumWithChildren actually use async
Children = ImmutableArray.CreateRange(collection.Select(c => validator.GetValueAsync <T>(c).Result));
}
private static async Task VerifyOptionSetsAsync(Workspace workspace, Action <OptionSet> verifyOptionValues)
{
var solution = workspace.CurrentSolution;
verifyOptionValues(workspace.Options);
verifyOptionValues(solution.Options);
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false);
var checksum = scope.SolutionInfo.SolutionChecksum;
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(checksum).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Attributes, WellKnownSynchronizationKind.SolutionAttributes);
await validator.VerifyChecksumInServiceAsync(solutionObject.Options, WellKnownSynchronizationKind.OptionSet);
var recoveredSolution = await validator.GetSolutionAsync(scope);
// option should be exactly same
Assert.Equal(0, recoveredSolution.Options.GetChangedOptions(workspace.Options).Count());
verifyOptionValues(workspace.Options);
verifyOptionValues(recoveredSolution.Options);
// checksum for recovered solution should be the same.
using var recoveredScope = await validator.AssetStorage.StoreAssetsAsync(recoveredSolution, CancellationToken.None).ConfigureAwait(false);
var recoveredChecksum = recoveredScope.SolutionInfo.SolutionChecksum;
Assert.Equal(checksum, recoveredChecksum);
}
public async Task CreateSolutionSnapshotId_Project()
{
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution;
var project = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None).ConfigureAwait(false);
var checksum = scope.SolutionChecksum;
var solutionSyncObject = await scope.GetAssetAsync(checksum, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(solutionSyncObject).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(checksum).ConfigureAwait(false);
await validator.VerifyChecksumInServiceAsync(solutionObject.Attributes, WellKnownSynchronizationKind.SolutionAttributes);
var projectSyncObject = await scope.GetAssetAsync(solutionObject.Projects.Checksum, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(projectSyncObject).ConfigureAwait(false);
Assert.Equal(1, solutionObject.Projects.Count);
await validator.VerifySnapshotInServiceAsync(validator.ToProjectObjects(solutionObject.Projects)[0], 0, 0, 0, 0, 0).ConfigureAwait(false);
}
public async Task SnapshotWithIdenticalAnalyzerFiles()
{
using var workspace = CreateWorkspace();
var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
using var temp = new TempRoot();
var dir = temp.CreateDirectory();
// create two analyzer assembly files whose content is identical but path is different:
var file1 = dir.CreateFile("analyzer1.dll").WriteAllBytes(TestResources.AnalyzerTests.FaultyAnalyzer);
var file2 = dir.CreateFile("analyzer2.dll").WriteAllBytes(TestResources.AnalyzerTests.FaultyAnalyzer);
var analyzer1 = new AnalyzerFileReference(file1.Path, TestAnalyzerAssemblyLoader.LoadNotImplemented);
var analyzer2 = new AnalyzerFileReference(file2.Path, TestAnalyzerAssemblyLoader.LoadNotImplemented);
project = project.AddAnalyzerReferences(new[] { analyzer1, analyzer2 });
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None).ConfigureAwait(false);
var recovered = await validator.GetSolutionAsync(snapshot).ConfigureAwait(false);
AssertEx.Equal(new[] { file1.Path, file2.Path }, recovered.GetProject(project.Id).AnalyzerReferences.Select(r => r.FullPath));
}
public async Task CreateSolutionSnapshotId_Project_Serialization()
{
using var workspace = CreateWorkspace();
var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySolutionStateSerializationAsync(project.Solution, snapshot.SolutionInfo.SolutionChecksum).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Empty_Serialization()
{
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution;
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySolutionStateSerializationAsync(solution, snapshot.SolutionChecksum).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Empty_Serialization()
{
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution;
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySolutionStateSerializationAsync(solution, scope.SolutionInfo.SolutionChecksum).ConfigureAwait(false);
}
public async Task UnknownLanguageTest()
{
using var workspace = CreateWorkspace(new[] { typeof(NoCompilationLanguageServiceFactory) });
var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", NoCompilationConstants.LanguageName);
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None).ConfigureAwait(false);
// this shouldn't throw
var recovered = await validator.GetSolutionAsync(snapshot).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Full_Asset_Serialization_Desktop()
{
using var workspace = CreateWorkspace();
var solution = CreateFullSolution(workspace);
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(scope.SolutionInfo.SolutionChecksum);
await validator.VerifyAssetAsync(solutionObject).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Full_Asset_Serialization()
{
using var workspace = CreateWorkspace();
var solution = CreateFullSolution(workspace);
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(snapshot.SolutionChecksum);
await validator.VerifyAssetAsync(solutionObject).ConfigureAwait(false);
}
public async Task CreateSolutionSnapshotId_Serialization()
{
var code = "class A { }";
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution;
var document = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code));
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySolutionStateSerializationAsync(document.Project.Solution, scope.SolutionInfo.SolutionChecksum).ConfigureAwait(false);
}
public async Task SnapshotWithMissingReferencesTest()
{
using var workspace = CreateWorkspace();
var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var metadata = new MissingMetadataReference();
var analyzer = new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing_reference"), new MissingAnalyzerLoader());
project = project.AddMetadataReference(metadata);
project = project.AddAnalyzerReference(analyzer);
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None).ConfigureAwait(false);
// this shouldn't throw
var recovered = await validator.GetSolutionAsync(snapshot).ConfigureAwait(false);
}
public async Task TestMetadataXmlDocComment()
{
using var tempRoot = new TempRoot();
// get original assembly location
var mscorlibLocation = typeof(object).Assembly.Location;
// set up dll and xml doc content
var tempDir = tempRoot.CreateDirectory();
var tempCorlib = tempDir.CopyFile(mscorlibLocation);
var tempCorlibXml = tempDir.CreateFile(Path.ChangeExtension(tempCorlib.Path, "xml"));
tempCorlibXml.WriteAllText(@"<?xml version=""1.0"" encoding=""utf-8""?>
<doc>
<assembly>
<name>mscorlib</name>
</assembly>
<members>
<member name=""T:System.Object"">
<summary>Supports all classes in the .NET Framework class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all classes in the .NET Framework; it is the root of the type hierarchy.To browse the .NET Framework source code for this type, see the Reference Source.</summary>
</member>
</members>
</doc>");
using var workspace = CreateWorkspace();
var solution = workspace.CurrentSolution
.AddProject("Project", "Project.dll", LanguageNames.CSharp)
.AddMetadataReference(MetadataReference.CreateFromFile(tempCorlib.Path))
.Solution;
var validator = new SerializationValidator(workspace.Services);
using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
// recover solution from given snapshot
var recovered = await validator.GetSolutionAsync(scope);
var compilation = await recovered.Projects.First().GetCompilationAsync(CancellationToken.None);
var objectType = compilation.GetTypeByMetadataName("System.Object");
var xmlDocComment = objectType.GetDocumentationCommentXml();
Assert.False(string.IsNullOrEmpty(xmlDocComment));
}
public async Task Workspace_RoundTrip_Test_Desktop()
{
using var workspace = CreateWorkspace();
var solution = CreateFullSolution(workspace);
var validator = new SerializationValidator(workspace.Services);
using var snapshot1 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
// recover solution from given snapshot
var recovered = await validator.GetSolutionAsync(snapshot1).ConfigureAwait(false);
var solutionObject1 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot1.SolutionChecksum).ConfigureAwait(false);
// create new snapshot from recovered solution
using var snapshot2 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(recovered, CancellationToken.None).ConfigureAwait(false);
// verify asset created by recovered solution is good
var solutionObject2 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot2.SolutionChecksum).ConfigureAwait(false);
await validator.VerifyAssetAsync(solutionObject2).ConfigureAwait(false);
// verify snapshots created from original solution and recovered solution are same
validator.SolutionStateEqual(solutionObject1, solutionObject2);
snapshot1.Dispose();
// recover new solution from recovered solution
var roundtrip = await validator.GetSolutionAsync(snapshot2).ConfigureAwait(false);
// create new snapshot from round tripped solution
using var snapshot3 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(roundtrip, CancellationToken.None).ConfigureAwait(false);
// verify asset created by rount trip solution is good
var solutionObject3 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot3.SolutionChecksum).ConfigureAwait(false);
await validator.VerifyAssetAsync(solutionObject3).ConfigureAwait(false);
// verify snapshots created from original solution and round trip solution are same.
validator.SolutionStateEqual(solutionObject2, solutionObject3);
snapshot2.Dispose();
}
public async Task OptionSet_Serialization_CustomValue()
{
using var workspace = CreateWorkspace();
var newQualifyFieldAccessValue = new CodeStyleOption2 <bool>(false, NotificationOption2.Error);
var newQualifyMethodAccessValue = new CodeStyleOption2 <bool>(true, NotificationOption2.Warning);
var newVarWhenTypeIsApparentValue = new CodeStyleOption2 <bool>(false, NotificationOption2.Suggestion);
var newPreferIntrinsicPredefinedTypeKeywordInMemberAccessValue = new CodeStyleOption2 <bool>(true, NotificationOption2.Silent);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(CodeStyleOptions2.QualifyFieldAccess, LanguageNames.CSharp, newQualifyFieldAccessValue)
.WithChangedOption(CodeStyleOptions2.QualifyMethodAccess, LanguageNames.VisualBasic, newQualifyMethodAccessValue)
.WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, newVarWhenTypeIsApparentValue)
.WithChangedOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, LanguageNames.VisualBasic, newPreferIntrinsicPredefinedTypeKeywordInMemberAccessValue)));
var validator = new SerializationValidator(workspace.Services);
await VerifyOptionSetsAsync(workspace, VerifyOptions).ConfigureAwait(false);
void VerifyOptions(OptionSet options)
{
var actualQualifyFieldAccessValue = options.GetOption(CodeStyleOptions2.QualifyFieldAccess, LanguageNames.CSharp);
Assert.Equal(newQualifyFieldAccessValue, actualQualifyFieldAccessValue);
var actualQualifyMethodAccessValue = options.GetOption(CodeStyleOptions2.QualifyMethodAccess, LanguageNames.VisualBasic);
Assert.Equal(newQualifyMethodAccessValue, actualQualifyMethodAccessValue);
var actualVarWhenTypeIsApparentValue = options.GetOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent);
Assert.Equal(newVarWhenTypeIsApparentValue, actualVarWhenTypeIsApparentValue);
var actualPreferIntrinsicPredefinedTypeKeywordInMemberAccessValue = options.GetOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, LanguageNames.VisualBasic);
Assert.Equal(newPreferIntrinsicPredefinedTypeKeywordInMemberAccessValue, actualPreferIntrinsicPredefinedTypeKeywordInMemberAccessValue);
}
}
public AssetProvider(SerializationValidator validator) => _validator = validator;