public void TestCompilationOptions_NullableAndImport()
{
var csharpOptions = CSharp.CSharpCompilation.Create("dummy").Options.WithNullableContextOptions(NullableContextOptions.Warnings).WithMetadataImportOptions(MetadataImportOptions.All);
var vbOptions = VisualBasic.VisualBasicCompilation.Create("dummy").Options.WithMetadataImportOptions(MetadataImportOptions.Internal);
using var workspace = CreateWorkspace();
var serializer = workspace.Services.GetService <ISerializerService>();
VerifyOptions(csharpOptions);
VerifyOptions(vbOptions);
void VerifyOptions(CompilationOptions originalOptions)
{
using var stream = SerializableBytes.CreateWritableStream();
using var context = SolutionReplicationContext.Create();
using (var objectWriter = new ObjectWriter(stream, leaveOpen: true))
{
serializer.Serialize(originalOptions, objectWriter, context, CancellationToken.None);
}
stream.Position = 0;
using var objectReader = ObjectReader.TryGetReader(stream);
var recoveredOptions = serializer.Deserialize <CompilationOptions>(originalOptions.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
var original = serializer.CreateChecksum(originalOptions, CancellationToken.None);
var recovered = serializer.CreateChecksum(recoveredOptions, CancellationToken.None);
Assert.Equal(original, recovered);
}
}
public ValueTask <ImmutableArray <(Checksum, object)> > GetAssetsAsync(
int serviceId, ISet <Checksum> checksums, ISerializerService deserializerService, CancellationToken cancellationToken)
{
var results = new List <(Checksum, object)>();
foreach (var checksum in checksums)
{
if (_map.TryGetValue(checksum, out var data))
{
using var stream = new MemoryStream();
using var context = SolutionReplicationContext.Create();
using (var writer = new ObjectWriter(stream, leaveOpen: true, cancellationToken))
{
_serializerService.Serialize(data, writer, context, cancellationToken);
}
stream.Position = 0;
using var reader = ObjectReader.GetReader(stream, leaveOpen: true, cancellationToken);
var asset = deserializerService.Deserialize <object>(data.GetWellKnownSynchronizationKind(), reader, cancellationToken);
Contract.ThrowIfTrue(asset is null);
results.Add((checksum, asset));
}
else
{
throw ExceptionUtilities.UnexpectedValue(checksum);
}
}
return(ValueTaskFactory.FromResult(results.ToImmutableArray()));
}
public void TestEncodingSerialization()
{
using var workspace = CreateWorkspace();
var serializer = workspace.Services.GetService <ISerializerService>();
// test with right serializable encoding
var sourceText = SourceText.From("Hello", Encoding.UTF8);
using (var stream = SerializableBytes.CreateWritableStream())
{
using var context = SolutionReplicationContext.Create();
using (var objectWriter = new ObjectWriter(stream, leaveOpen: true))
{
serializer.Serialize(sourceText, objectWriter, context, CancellationToken.None);
}
stream.Position = 0;
using var objectReader = ObjectReader.TryGetReader(stream);
var newText = serializer.Deserialize <SourceText>(sourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
Assert.Equal(sourceText.ToString(), newText.ToString());
}
// test with wrong encoding that doesn't support serialization
sourceText = SourceText.From("Hello", new NotSerializableEncoding());
using (var stream = SerializableBytes.CreateWritableStream())
{
using var context = SolutionReplicationContext.Create();
using (var objectWriter = new ObjectWriter(stream, leaveOpen: true))
{
serializer.Serialize(sourceText, objectWriter, context, CancellationToken.None);
}
stream.Position = 0;
using var objectReader = ObjectReader.TryGetReader(stream);
var newText = serializer.Deserialize <SourceText>(sourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
Assert.Equal(sourceText.ToString(), newText.ToString());
}
}
private static SolutionAsset CloneAsset(ISerializerService serializer, SolutionAsset asset)
{
using var stream = SerializableBytes.CreateWritableStream();
using var context = SolutionReplicationContext.Create();
using (var writer = new ObjectWriter(stream, leaveOpen: true))
{
serializer.Serialize(asset.Value, writer, context, CancellationToken.None);
}
stream.Position = 0;
using var reader = ObjectReader.TryGetReader(stream);
var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = new SolutionAsset(serializer.CreateChecksum(recovered, CancellationToken.None), recovered);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
return(assetFromStorage);
}
public override void WriteMetadataReferenceTo(
MetadataReference reference,
ObjectWriter writer,
SolutionReplicationContext context,
CancellationToken cancellationToken
)
{
var wellKnownReferenceName = s_wellKnownReferenceNames.GetValueOrDefault(
reference,
null
);
if (wellKnownReferenceName is not null)
{
writer.WriteBoolean(true);
writer.WriteString(wellKnownReferenceName);
}
else
{
writer.WriteBoolean(false);
base.WriteMetadataReferenceTo(reference, writer, context, cancellationToken);
}
}
