public void GetChunks_Empty()
{
var stream = new ComMemoryStream();
var chunks = stream.GetChunks().ToArray();
Assert.Equal(0, chunks.Length);
}
public void GetChunks_Empty()
{
var stream = new ComMemoryStream();
var chunks = stream.GetChunks().ToArray();
Assert.Empty(chunks);
}
public void SetMetadataEmitter(MetadataWriter metadataWriter)
{
try
{
var symWriter = (ISymUnmanagedWriter2)(_symWriterFactory != null ? _symWriterFactory() : CreateSymWriterWorker());
// Correctness: If the stream is not specified or if it is non-empty the SymWriter appends data to it (provided it contains valid PDB)
// and the resulting PDB has Age = existing_age + 1.
_pdbStream = new ComMemoryStream();
if (_deterministic)
{
var deterministicSymWriter = symWriter as ISymUnmanagedWriter6;
if (symWriter == null)
{
throw new NotSupportedException(CodeAnalysisResources.SymWriterNotDeterministic);
}
deterministicSymWriter.InitializeDeterministic(new PdbMetadataWrapper(metadataWriter), _pdbStream);
}
else
{
symWriter.Initialize(new PdbMetadataWrapper(metadataWriter), _fileName, _pdbStream, fullBuild: true);
}
_metadataWriter = metadataWriter;
_symWriter = symWriter;
}
catch (Exception ex)
{
throw new PdbWritingException(ex);
}
}
public unsafe void GetChunks_MultiChunkSeek()
{
var stream = new ComMemoryStream(chunkSize: 1);
long position;
((IUnsafeComStream)stream).Seek(5, ComMemoryStream.STREAM_SEEK_SET, &position);
Assert.Equal(5, position);
Assert.Equal("00-00-00-00-00", ChunksToString(stream.GetChunks()));
}
private void Close()
{
try
{
_symWriter?.Close();
_symWriter = null;
_pdbStream = null;
}
catch (Exception ex)
{
throw new PdbWritingException(ex);
}
}
public unsafe void GetChunks_MultiChunkWrite()
{
var stream = new ComMemoryStream(chunkSize: 1);
fixed(byte *buffer = new byte[] { 0, 1, 2, 3 })
{
int written;
((IUnsafeComStream)stream).Write(buffer, 3, (int *)&written);
Assert.Equal(3, written);
}
AssertEx.Equal("00|01|02", ChunksToString(stream.GetChunks()));
}
public void WriteAndRead()
{
var testData = new byte[10];
_random.NextBytes(testData);
_output.WriteLine($"{nameof(testData)}: {string.Join(", ", testData)}");
using (var stream = new ComMemoryStream())
{
var writtenCountPointer = Marshal.AllocHGlobal(sizeof(long));
try
{
var input = testData.ToArray();
stream.SetSize(input.Length);
stream.Write(input, input.Length, writtenCountPointer);
var writtenCount = Marshal.ReadInt32(writtenCountPointer);
Assert.True(writtenCount == input.Length);
}
finally
{
Marshal.FreeHGlobal(writtenCountPointer);
}
var newPositionPointer = Marshal.AllocHGlobal(sizeof(long));
var readCountPointer = Marshal.AllocHGlobal(sizeof(long));
try
{
var output = new byte[4];
stream.Stat(out var stat, 0);
var offset = _random.Next(0, (int)stat.cbSize - output.Length);
stream.Seek(offset, (int)SeekOrigin.Begin, newPositionPointer);
var newPosition = Marshal.ReadInt32(newPositionPointer);
Assert.True(newPosition == offset);
stream.Read(output, output.Length, readCountPointer);
var readCount = Marshal.ReadInt32(readCountPointer);
Assert.True(readCount == output.Length);
Assert.Equal(output, testData.Skip(offset).Take(output.Length));
}
finally
{
Marshal.FreeHGlobal(readCountPointer);
Marshal.FreeHGlobal(newPositionPointer);
}
}
}
public unsafe void GetChunks_SeekWriteRead()
{
var stream = new ComMemoryStream(chunkSize: 5);
long position;
((IUnsafeComStream)stream).Seek(5, ComMemoryStream.STREAM_SEEK_SET, &position);
Assert.Equal(5, position);
Assert.Equal("00-00-00-00-00", ChunksToString(stream.GetChunks()));
((IUnsafeComStream)stream).Seek(5, ComMemoryStream.STREAM_SEEK_CUR, &position);
Assert.Equal(10, position);
Assert.Equal("00-00-00-00-00-00-00-00-00-00", ChunksToString(stream.GetChunks()));
((IUnsafeComStream)stream).Seek(-2, ComMemoryStream.STREAM_SEEK_END, &position);
Assert.Equal(8, position);
Assert.Equal("00-00-00-00-00-00-00-00-00-00", ChunksToString(stream.GetChunks()));
fixed(byte *bufferPtr = new byte[] { 2, 3 })
{
int written;
((IUnsafeComStream)stream).Write(bufferPtr, 2, &written);
Assert.Equal(2, written);
}
Assert.Equal("00-00-00-00-00|00-00-00-02-03", ChunksToString(stream.GetChunks()));
((IUnsafeComStream)stream).Seek(1, ComMemoryStream.STREAM_SEEK_CUR, &position);
Assert.Equal(11, position);
Assert.Equal("00-00-00-00-00|00-00-00-02-03|00", ChunksToString(stream.GetChunks()));
((IUnsafeComStream)stream).Seek(-3, ComMemoryStream.STREAM_SEEK_CUR, &position);
Assert.Equal(8, position);
var buffer = new byte[] { 1, 1, 1, 1, 1 };
fixed(byte *bufferPtr = buffer)
{
int read;
((IUnsafeComStream)stream).Read(bufferPtr, 3, &read);
AssertEx.Equal(new byte[] { 2, 3, 0, 1, 1 }, buffer);
}
}
public void CopyTo()
{
var testData = new byte[10];
_random.NextBytes(testData);
_output.WriteLine($"{nameof(testData)}: {string.Join(", ", testData)}");
using (var inputStream = new ComMemoryStream(testData.Length))
using (var outputStream = new ComMemoryStream(testData.Length))
{
var writtenCountPointer = Marshal.AllocHGlobal(sizeof(long));
var readCountPointer = Marshal.AllocHGlobal(sizeof(long));
try
{
var input = testData.ToArray();
inputStream.Write(input, input.Length, IntPtr.Zero);
inputStream.Seek(0, (int)SeekOrigin.Begin, IntPtr.Zero);
inputStream.CopyTo(outputStream, input.Length, readCountPointer, writtenCountPointer);
var readCount = Marshal.ReadInt32(readCountPointer);
var writtenCount = Marshal.ReadInt32(writtenCountPointer);
Assert.True(readCount == input.Length);
Assert.True(writtenCount == input.Length);
var output = new byte[input.Length];
outputStream.Seek(0, (int)SeekOrigin.Begin, IntPtr.Zero);
outputStream.Read(output, output.Length, IntPtr.Zero);
Assert.Equal(output, input);
}
finally
{
Marshal.FreeHGlobal(readCountPointer);
Marshal.FreeHGlobal(writtenCountPointer);
}
}
}
public UnsafeComStreamWrapper(ComMemoryStream stream)
{
_stream = stream;
}
