public async Task CreateSolutionSnapshotId_Duplicate()
{
using var workspace = new AdhocWorkspace();
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 snapshot1 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
{
solutionId1 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot1.SolutionChecksum).ConfigureAwait(false);
}
using (var snapshot2 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
{
solutionId2 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot2.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));
}
private static async Task VerifyOptionSetsAsync(Workspace workspace, Action <OptionSet> verifyOptionValues)
{
var solution = new AdhocWorkspace()
.CurrentSolution.AddProject("Project1", "Project.dll", LanguageNames.CSharp)
.Solution.AddProject("Project2", "Project.dll", LanguageNames.VisualBasic)
.Solution;
verifyOptionValues(workspace.Options);
verifyOptionValues(solution.Options);
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
var checksum = snapshot.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(snapshot);
// option should be exactly same
Assert.Equal(0, recoveredSolution.Options.GetChangedOptions(workspace.Options).Count());
verifyOptionValues(workspace.Options);
verifyOptionValues(recoveredSolution.Options);
}
public async Task CreateSolutionSnapshotId_Empty()
{
using var workspace = new AdhocWorkspace();
var solution = workspace.CurrentSolution;
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
var checksum = snapshot.SolutionChecksum;
var solutionSyncObject = await snapshot.GetRemotableDataAsync(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 snapshot.GetRemotableDataAsync(solutionObject.Projects.Checksum, CancellationToken.None).ConfigureAwait(false);
await validator.VerifySynchronizationObjectInServiceAsync(projectsSyncObject).ConfigureAwait(false);
Assert.Equal(0, solutionObject.Projects.Count);
}
public async Task CreateSolutionSnapshotId_Full()
{
using var workspace = new AdhocWorkspace();
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 snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
var syncObject = await snapshot.GetRemotableDataAsync(snapshot.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 = new AdhocWorkspace();
var document = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code));
var validator = new SerializationValidator(workspace.Services);
using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false);
var syncObject = await snapshot.GetRemotableDataAsync(snapshot.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 Workspace_RoundTrip_Test_Desktop()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Add(typeof(TemporaryStorageServiceFactory.TemporaryStorageService).Assembly));
using var workspace = new AdhocWorkspace(hostServices);
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 CreateSolutionSnapshotId_Full_Asset_Serialization_Desktop()
{
using var workspace = new AdhocWorkspace();
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_Full_Asset_Serialization_Desktop()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Add(typeof(TemporaryStorageServiceFactory.TemporaryStorageService).Assembly));
using var workspace = new AdhocWorkspace(hostServices);
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);
}
