public async Task WriteAsync_Cancel_ThrowsOpCancelled()
{
byte[] inputBuffer = Enumerable.Range(1, 10).Select(f => (byte)f).ToArray();
var taskBlocker1 = new TaskCompletionSource <object>();
var taskBlocker2 = new TaskCompletionSource <object>();
var taskBlocker3 = new TaskCompletionSource <object>();
bool triggered = false;
var streamMock = new Mock <Stream>(MockBehavior.Strict);
streamMock
.Setup(p => p.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(async(byte[] buffer, int offset, int count, CancellationToken token) =>
{
taskBlocker1.SetResult(null);
await taskBlocker3.Task;
triggered = token.IsCancellationRequested;
taskBlocker2.SetResult(null);
token.ThrowIfCancellationRequested();
});
CancellationTokenSource ts = new CancellationTokenSource();
CancellationToken token = ts.Token;
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(4));
Task task = s.WriteAsync(inputBuffer, 0, inputBuffer.Length, token);
await taskBlocker1.Task;
ts.Cancel();
taskBlocker3.SetResult(null);
await taskBlocker2.Task;
Assert.IsTrue(triggered);
Assert.ThrowsAsync <OperationCanceledException>(async() => await task);
}
public void Writer_Should_Be_Thread_Safe()
{
var fileLength = 10000000;
var fileBuffer = CreateRandomFile(fileLength);
var destFilePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.dat");
var blocksCount = 100;
var blockSize = fileLength / blocksCount;
var parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = 5
};
using (var writer = new BufferedStreamWriter(destFilePath, fileLength))
{
Parallel.For(0, blocksCount, index =>
{
var startPos = index * blockSize;
var endPos = startPos + blockSize;
var blockBuffer = GetBlock(fileBuffer, startPos, endPos);
writer.WriteFileBlock(blockBuffer, index);
});
}
var originalFileHash = Helpers.ComputeMd5Hash(fileBuffer);
var destFileHash = Helpers.ComputeFileMd5Hash(destFilePath);
//cleanup
File.Delete(destFilePath);
Assert.AreEqual(originalFileHash, destFileHash);
}
internal DicomStreamWriter(BufferedStreamWriter output, DicomTransferSyntax transferSyntax)
{
Output = output;
TransferSyntax = transferSyntax;
DataWriter = new BinaryDataWriter(output, transferSyntax.ByteOrder);
VRCoding = transferSyntax.VRCoding;
}
public void Writer_Should_Accurately_Write_Files_When_Blocks_Received_Randomly()
{
var fileLength = 10000000;
var fileBuffer = CreateRandomFile(fileLength);
var destFilePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.dat");
var blocksCount = 100;
var blockSize = fileLength / blocksCount;
var blockIndexes = new int[blocksCount];
// set the indexes
blockIndexes.ForEach((item, index) => blockIndexes[index] = index);
// shuffle the indexes
blockIndexes.Shuffle();
using (var writer = new BufferedStreamWriter(destFilePath, fileLength))
{
foreach (var index in blockIndexes)
{
var startPos = index * blockSize;
var endPos = startPos + blockSize;
var blockBuffer = GetBlock(fileBuffer, startPos, endPos);
writer.WriteFileBlock(blockBuffer, index);
}
}
var originalFileHash = Helpers.ComputeMd5Hash(fileBuffer);
var destFileHash = Helpers.ComputeFileMd5Hash(destFilePath);
//cleanup
File.Delete(destFilePath);
Assert.AreEqual(originalFileHash, destFileHash);
}
public void Writer_Should_Accurately_Write_Files()
{
var fileLength = 10000000;
var fileBuffer = CreateRandomFile(fileLength);
var destFilePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.dat");
var blocksCount = 100;
var blockSize = fileLength / blocksCount;
using (var writer = new BufferedStreamWriter(destFilePath, fileLength))
{
for (var i = 0; i < blocksCount; i++)
{
var startPos = i * blockSize;
var endPos = startPos + blockSize;
var blockBuffer = GetBlock(fileBuffer, startPos, endPos);
writer.WriteFileBlock(blockBuffer, i);
}
}
var originalFileHash = Helpers.ComputeMd5Hash(fileBuffer);
var destFileHash = Helpers.ComputeFileMd5Hash(destFilePath);
//cleanup
File.Delete(destFilePath);
Assert.AreEqual(originalFileHash, destFileHash);
}
private DicomConnection(Socket socket, CancellationToken cancellationToken)
{
Socket = socket;
SocketInputStream = new SocketInputStream(socket, cancellationToken);
SocketOutputStream = new SocketOutputStream(socket, cancellationToken);
Input = new BufferedStreamReader(SocketInputStream);
Output = new BufferedStreamWriter(SocketOutputStream);
}
public void CanSeek_ReturnsFalse(bool innerCanSeek)
{
var streamMock = new Mock <Stream>();
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.AreEqual(false, s.CanSeek);
}
public void CanWrite_ReturnsTrue()
{
var streamMock = new Mock <Stream>();
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.AreEqual(true, s.CanWrite);
}
public void Position_set_Throws()
{
var streamMock = new Mock <Stream>(MockBehavior.Strict);
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.That(() => s.Position = It.IsAny <long>(), Throws.InstanceOf <NotSupportedException>());
}
public void Length_get_Throws()
{
var streamMock = new Mock <Stream>(MockBehavior.Strict);
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.That(() => s.Length, Throws.InstanceOf <NotSupportedException>());
}
public void SetLength_Throws()
{
var streamMock = new Mock <Stream>(MockBehavior.Strict);
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.Throws <NotSupportedException>(() => s.SetLength(0L));
Assert.Throws <NotSupportedException>(() => s.SetLength(1L));
}
public void Read_Throws()
{
var streamMock = new Mock <Stream>(MockBehavior.Strict);
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1));
Assert.Throws <NotSupportedException>(() => s.Read(null, 0, 0));
Assert.Throws <NotSupportedException>(() => s.ReadByte());
}
public void Seek_Throws(SeekOrigin origin, long seekOffset, bool delayedWriter)
{
int length = 10;
byte[] finalBuffer = new byte[length];
MemoryStream memStream = new MemoryStream(finalBuffer);
BufferedStreamWriter s = new BufferedStreamWriter(memStream, GetConfig(4));
Assert.Throws <NotSupportedException>(() => s.Seek(seekOffset, origin));
}
protected static void WriteLengthPrefixedData(BinaryDataWriter dataWriter, Action <BinaryDataWriter, long> lengthWriter,
Action <BinaryDataWriter> writeDataAction)
{
using (var dataStream = new MemoryStream())
{
var dataOutput = new BufferedStreamWriter(dataStream);
writeDataAction.Invoke(new BinaryDataWriter(dataOutput, ByteOrder.BigEndian));
dataOutput.Flush(FlushMode.Shallow);
lengthWriter.Invoke(dataWriter, dataStream.Length);
dataWriter.Write(dataStream.GetBuffer().AsSpan(0, checked ((int)dataStream.Length)));
}
}
public Stream ComposeChain(Stream s, BufferedStreamWriterConfig sw_cfg)
{
if (!(s is MemoryStream))
{
itemsToDispose.Add(s);
}
if (sw_cfg != null)
{
itemsToDispose.Add(s = new BufferedStreamWriter(s, sw_cfg));
}
return(s);
}
public static async Task New_WriteAsync(string fileName)
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
byte[] buffer = Enumerable.Range(0, 10).Select(f => (byte)f).ToArray();
using (var s = File.Create(fileName))
using (var sr = new BufferedStreamWriter(s))
await sr.WriteAsync(buffer);
}
public void WriteByte_WriteByteNotCalledOnInnerStream(bool delayedWriter)
{
var streamMock = new Mock <Stream>();
byte[] tmparr = new byte[1];
BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1, delayedWriter));
s.WriteByte(1);
s.WriteByte(1);
streamMock.Verify(f => f.WriteByte(It.IsAny <byte>()), Times.Never());
}
public void Dispose_WriterAborts(bool delayedWriter)
{
int shadowBufferSize = 4;
var config = GetConfig(shadowBufferSize, delayedWriter);
var writerMock = new Mock <IWriter>(MockBehavior.Loose);
writerMock.Setup(p => p.RequestBuffer())
.Returns(() => new ShadowBufferData(shadowBufferSize));
using (BufferedStreamWriter sw = new BufferedStreamWriter(new MemoryStream(), config, writerMock.Object))
sw.Write(new byte[] { 1, 2 }, 0, 2);
writerMock.Verify(f => f.Abort(), Times.Once());
}
public async Task DisposeAsync_PositionMatchesInnerStreams(int count, int shadowBufferSize, bool delayedWriter)
{
var originalBuffer = Enumerable.Range(1, 10).Select(f => (byte)f).ToArray();
byte[] finalBuffer = new byte[originalBuffer.Length];
var stream = new MemoryStream(finalBuffer);
await using (BufferedStreamWriter s = new BufferedStreamWriter(stream, GetConfig(shadowBufferSize, delayedWriter)))
{
await s.WriteAsync(originalBuffer, 0, count);
}
Assert.AreEqual(count, stream.Position);
}
public void Dispose_StreamFlushes(bool delayedWriter)
{
byte[] inputBuffer = Enumerable.Range(1, 10).Select(f => (byte)f).ToArray();
var streamMock = new Mock <Stream>(MockBehavior.Strict);
streamMock
.Setup(p => p.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()));
streamMock
.Setup(p => p.Flush());
using (BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(4, delayedWriter)))
s.Write(inputBuffer, 0, inputBuffer.Length);
streamMock.Verify(f => f.Flush(), Times.Once());
}
public void WriteByte_CorrectBytesAreSaved(int shadowBufferSize, int totBytes, bool delayedWriter)
{
byte[] inputBuffer = Enumerable.Range(1, totBytes).Select(f => (byte)f).ToArray();
byte[] destBuffer = new byte[totBytes];
MemoryStream memStream = new MemoryStream(destBuffer);
using (BufferedStreamWriter s = new BufferedStreamWriter(memStream, GetConfig(shadowBufferSize, delayedWriter)))
{
for (int f = 0; f < totBytes; f++)
{
s.WriteByte(inputBuffer[f]);
}
}
Assert.AreEqual(inputBuffer, destBuffer);
}
public async Task FlushAsync_CorrectBytesAreSaved(int shadowBufferSize, int totBytes, int writeBlockLength, bool delayedWriter)
{
byte[] inputBuffer = Enumerable.Range(1, totBytes).Select(f => (byte)f).ToArray();
byte[] destBuffer = new byte[totBytes];
MemoryStream destStream = new MemoryStream(destBuffer);
BufferedStreamWriter s = new BufferedStreamWriter(destStream, GetConfig(shadowBufferSize, delayedWriter));
for (int ix = 0; ix < totBytes; ix += writeBlockLength)
{
await s.WriteAsync(inputBuffer, ix, Math.Min(totBytes - ix, writeBlockLength));
}
await s.FlushAsync();
Assert.AreEqual(inputBuffer, destBuffer);
}
public async Task DisposeAsync_StreamFlushesAsync()
{
byte[] inputBuffer = Enumerable.Range(1, 10).Select(f => (byte)f).ToArray();
var streamMock = new Mock <Stream>(MockBehavior.Strict);
streamMock
.Setup(p => p.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns((byte[] buffer, int offset, int count, CancellationToken token) => Task.CompletedTask);
streamMock
.Setup(p => p.FlushAsync(It.IsAny <CancellationToken>()))
.Returns((CancellationToken token) => Task.CompletedTask);
await using (BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(4)))
await s.WriteAsync(inputBuffer, 0, inputBuffer.Length, CancellationToken.None);
streamMock.Verify(f => f.FlushAsync(It.IsAny <CancellationToken>()), Times.Once());
}
private static void TestWrite(Stream stream, ByteOrder byteOrder)
{
var output = new BufferedStreamWriter(stream);
var dataWriter = new BinaryDataWriter(output, byteOrder);
Trace.Assert(stream.Position == 0);
dataWriter.Write(TestByte);
output.Flush(FlushMode.Shallow);
Trace.Assert(stream.Position == 1);
dataWriter.Write(TestShort);
dataWriter.Write(TestUShort);
Trace.Assert(stream.Position == 1);
output.Flush(FlushMode.Shallow);
Trace.Assert(stream.Position == 5);
dataWriter.Write(TestInt);
dataWriter.Write(TestUInt);
dataWriter.Write(TestLong);
dataWriter.Write(TestULong);
dataWriter.Write(TestFloat);
dataWriter.Write(TestDouble);
Trace.Assert(stream.Position == 5);
output.Flush(FlushMode.Shallow);
Trace.Assert(stream.Position == 41);
TestWriteArray(9 * ushort.MaxValue, TestByte, dataWriter.Write);
TestWriteArray(8 * ushort.MaxValue, TestShort, dataWriter.Write);
TestWriteArray(7 * ushort.MaxValue, TestUShort, dataWriter.Write);
TestWriteArray(6 * ushort.MaxValue, TestInt, dataWriter.Write);
TestWriteArray(5 * ushort.MaxValue, TestUInt, dataWriter.Write);
TestWriteArray(4 * ushort.MaxValue, TestLong, dataWriter.Write);
TestWriteArray(3 * ushort.MaxValue, TestULong, dataWriter.Write);
TestWriteArray(2 * ushort.MaxValue, TestFloat, dataWriter.Write);
TestWriteArray(1 * ushort.MaxValue, TestDouble, dataWriter.Write);
output.Flush(FlushMode.Deep);
}
public async Task Dispose_InnerStreamDoesntDisposeAsync(bool canSeek, bool delayedWriter)
{
var streamMock = new Mock <Stream>(MockBehavior.Loose);
streamMock.SetupGet(p => p.CanSeek)
.Returns(canSeek);
streamMock.SetupGet(p => p.Position)
.Returns(0);
streamMock.SetupGet(p => p.Length)
.Returns(1);
using (BufferedStreamWriter s = new BufferedStreamWriter(streamMock.Object, GetConfig(1, delayedWriter)))
{
await s.WriteAsync(new byte[] { 1 }, 0, 1);
}
streamMock.Verify(f => f.Close(), Times.Never());
}
public void RequestBuffer_BufferReleasedAfterWrite(int writeBlockLength, int repCount, bool delayedWriter)
{
int totBytes = repCount * writeBlockLength;
int shadowBufferSize = 4;
bool isRented = false;
var config = GetConfig(shadowBufferSize, delayedWriter: delayedWriter);
var writerMock = new Mock <IWriter>(MockBehavior.Loose);
writerMock.Setup(p => p.RequestBuffer())
.Returns(() =>
{
if (isRented)
{
throw new InvalidOperationException();
}
isRented = true;
return(new ShadowBufferData(shadowBufferSize));
});
writerMock.Setup(p => p.ReturnBufferAndWrite(It.IsAny <ShadowBufferData>()))
.Callback <ShadowBufferData>((sourceBuffer) =>
{
if (!isRented)
{
throw new InvalidOperationException();
}
isRented = false;
});
byte[] tmpBuf = new byte[writeBlockLength];
byte[] destBuffer = new byte[totBytes];
TestDelegate body = delegate()
{
using (BufferedStreamWriter sw = new BufferedStreamWriter(new MemoryStream(destBuffer), config, writerMock.Object))
{
for (int ix = 0, f = 0; f < repCount; ix += writeBlockLength, f++)
{
sw.Write(tmpBuf, 0, writeBlockLength);
}
}
};
Assert.DoesNotThrow(body);
}
public void SendCommand(byte presentationContextID, ICommand command, Action <Stream> dataSetWriter)
{
if (command is IMayHaveDataSet mayHaveDataSet)
{
if ((dataSetWriter == null) && mayHaveDataSet.IsDataSetRequired())
{
throw new ArgumentException($"{command} must be followed by a data set");
}
}
else if (dataSetWriter != null)
{
throw new ArgumentException($"{command} must not be followed by a data set");
}
var commandAttribute = command.GetType().GetCustomAttribute <CommandAttribute>();
command.CommandField = commandAttribute.CommandType;
command.CommandDataSetType = (ushort)((dataSetWriter == null) ? 0x0101 : 0xFEFE);
if (TraceWriter != null)
{
NetUtils.TraceOutput(TraceWriter, $"PC {presentationContextID} sending ", command);
}
using (var stream = new PresentationContextOutputStream(this, presentationContextID, FragmentType.Command))
{
var output = new BufferedStreamWriter(stream);
CommandSerialization.WriteTo(output, command);
output.Flush(FlushMode.Deep);
}
if (dataSetWriter != null)
{
using (var stream = new PresentationContextOutputStream(this, presentationContextID, FragmentType.DataSet))
{
dataSetWriter.Invoke(stream);
stream.Flush();
}
}
}
/// <summary>Writes a DICOM file header to a stream</summary>
public static void WriteHeader(BufferedStreamWriter output, DicomFileMetaInformation fileMetaInformation)
{
output.WriteZeros(128);
output.WriteBytes(BeforeFileMetaInformationLength);
var fileMetaInformationLengthPosition = output.Position;
output.WriteZeros(4);
output.WriteBytes(AfterFileMetaInformationLength);
var metaInformationWriter = DicomStreamWriter.Create(output, DicomUID.TransferSyntax.ExplicitVRLittleEndian);
FileMetaInformationSerializer.Serialize(metaInformationWriter, fileMetaInformation);
var endOfFileMetaInformationPosition = output.Position;
output.Flush(FlushMode.Shallow);
var fileMetaInformationLength = endOfFileMetaInformationPosition - (fileMetaInformationLengthPosition + 4);
output.Stream.Seek(fileMetaInformationLengthPosition, SeekOrigin.Begin);
output.Stream.Write(BitConverter.GetBytes((uint)fileMetaInformationLength));
output.Stream.Seek(endOfFileMetaInformationPosition, SeekOrigin.Begin);
}
/// <summary>Creates a DicomStreamWriter for writing DICOM data elements to a stream using the given transfer syntax</summary>
public static DicomStreamWriter Create(BufferedStreamWriter output, DicomUID transferSyntaxUID)
{
var transferSyntax = new DicomTransferSyntax(transferSyntaxUID);
return(new DicomStreamWriter(output, transferSyntax));
}
async ValueTask IAsyncBinaryWriter.WriteAsync <TArg>(Action <TArg, IBufferWriter <byte> > writer, TArg arg, CancellationToken token)
{
using var bufferWriter = new BufferedStreamWriter(buffer);
writer(arg, bufferWriter);
await stream.WriteAsync(bufferWriter.WrittenMemory, token).ConfigureAwait(false);
}
