public static Stream GetVulnerabilities(CxRestContext ctx,
CancellationToken token, String reportId)
{
return(WebOperation.ExecuteGet <Stream>(
ctx.Xml.CreateSastClient
, (response) =>
{
var report = response.Content.ReadAsStreamAsync().Result;
var mem = new SharedMemoryStream(response.Content.Headers.ContentLength.Value);
int readAmount = 0;
byte[] buffer = new byte[BUFFER_SIZE];
do
{
readAmount = report.Read(buffer, 0, BUFFER_SIZE);
mem.Write(buffer, 0, readAmount);
if (readAmount < BUFFER_SIZE)
{
mem.Seek(0, SeekOrigin.Begin);
}
} while (readAmount == BUFFER_SIZE);
return mem;
}
, CxRestContext.MakeUrl(ctx.Url, String.Format(URL_SUFFIX, reportId))
, ctx
, token));
}
public void Seek_ShouldMovePositionInStreamIndependentlyForEachSharedInstance()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream1 = new SharedMemoryStream(bytes);
var sharedMemoryStream2 = sharedMemoryStream1.MakeShared();
sharedMemoryStream1.Position = 123;
sharedMemoryStream2.Position = 321;
// Assume
Assume.That(sharedMemoryStream1.Position, Is.EqualTo(123));
Assume.That(sharedMemoryStream2.Position, Is.EqualTo(321));
// Act
var seek1 = sharedMemoryStream1.Seek(10, SeekOrigin.Current);
var seek2 = sharedMemoryStream2.Seek(100, SeekOrigin.Current);
// Assert
Assert.That(seek1, Is.EqualTo(133));
Assert.That(sharedMemoryStream1.Position, Is.EqualTo(133));
Assert.That(seek2, Is.EqualTo(421));
Assert.That(sharedMemoryStream2.Position, Is.EqualTo(421));
}
public void SeekCurrentNoSeekPastEnd()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
try
{
sms.Seek(buffer1.Length, System.IO.SeekOrigin.Current);
sms.Seek(1, System.IO.SeekOrigin.Current);
}
catch (ArgumentOutOfRangeException)
{
Assert.True(true);
return;
}
Assert.True(false);
}
public void ReadLengthZeroAtEnd()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Seek(0, System.IO.SeekOrigin.End);
Assert.Equal(0, sms.Read(buffer1, 0, 0));
}
}
public void SeekEndZeroOffsetDoesMovesToEnd()
{
using (var sms = new SharedMemoryStream(buffer1.Length * 2))
{
sms.Write(buffer1, 0, buffer1.Length);
sms.Seek(0, System.IO.SeekOrigin.End);
Assert.Equal(buffer1.Length, sms.Position);
}
}
public void SeekBeginZeroOffsetMovesToBegin()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Position = buffer1.Length - 1;
sms.Seek(0, System.IO.SeekOrigin.Begin);
Assert.Equal(0, sms.Position);
}
}
public void SeekCurrentZeroOffsetDoesNotMovePosition()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Position = buffer1.Length - 1;
sms.Seek(0, System.IO.SeekOrigin.Current);
Assert.Equal(buffer1.Length - 1, sms.Position);
}
}
public void NoReadBeyondCapacity()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Write(buffer1, 0, buffer1.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] localBuf = new byte[buffer1.Length * 2];
int amount = sms.Read(localBuf, 0, localBuf.Length);
Assert.Equal(buffer1.Length, amount);
}
}
public void Seek_ShouldThrowExceptionWhenStreamDisposed()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
sharedMemoryStream.Dispose();
// Act
// Assert
Assert.That(() => sharedMemoryStream.Seek(123, SeekOrigin.Begin), Throws.TypeOf <ObjectDisposedException>());
}
public void ReadAfterWriteResultsInSameData()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Write(buffer1, 0, buffer1.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] readBack = new byte[buffer1.Length];
int amount = sms.Read(readBack, 0, readBack.Length);
Assert.Equal(buffer1.Length, amount);
Assert.Equal(buffer1, readBack);
}
}
public void Seek_ShouldMovePositionInStream()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Assume
Assume.That(sharedMemoryStream.Position, Is.Zero);
// Act
var seek = sharedMemoryStream.Seek(123, SeekOrigin.Begin);
// Assert
Assert.That(seek, Is.EqualTo(123));
Assert.That(sharedMemoryStream.Position, Is.EqualTo(123));
}
public void SeekEndNoSeekPastBegin()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Position = buffer1.Length - 1;
try
{
sms.Seek(buffer1.Length + 1, System.IO.SeekOrigin.End);
}
catch (ArgumentOutOfRangeException)
{
Assert.True(true);
return;
}
}
Assert.True(false);
}
public void NoReadUnwritten()
{
using (var sms = new SharedMemoryStream(buffer1.Length * 2))
{
sms.Write(buffer1, 0, buffer1.Length);
byte[] one = new byte[] { 5 };
sms.Write(one, 0, one.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] outData = new byte[buffer1.Length + one.Length];
int read = sms.Read(outData, 0, buffer1.Length + one.Length);
Assert.Equal(read, buffer1.Length + one.Length);
}
}
public void commit()
{
if (_committed)
{
throw new UnrecoverableOperationException
($"{_recordType}: Attempted to commit a transaction that has already been committed.");
}
_committed = true;
_stage.Flush();
_stage.Dispose();
_stage = null;
if (_stageStorage.Seek(0, SeekOrigin.Begin) != 0)
{
throw new UnrecoverableOperationException($"{_recordType}: could not seek to beginning of storage.");
}
var timer = DateTime.Now;
long recordCount = 0;
using (var reader = new StreamReader(_stageStorage))
while (true)
{
var line = reader.ReadLine();
if (line == null)
{
break;
}
else
{
_recordLog.Info(line);
recordCount++;
}
}
_log.Debug($"COMMITTED: {recordCount} records for {_recordType} in {DateTime.Now.Subtract(timer).TotalMilliseconds}ms");
}
public void Dispose_ShouldNotDisposeSharedResourcesUntilAllSharedInstancesAreDisposed()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream1 = new SharedMemoryStream(bytes);
var sharedMemoryStream2 = sharedMemoryStream1.MakeShared();
// Assume
Assume.That(sharedMemoryStream1.Position, Is.EqualTo(0));
Assume.That(sharedMemoryStream2.Position, Is.EqualTo(0));
// Act
sharedMemoryStream1.Dispose();
// Assert
Assert.That(() => sharedMemoryStream1.Seek(10, SeekOrigin.Current), Throws.TypeOf <ObjectDisposedException>());
var seek = sharedMemoryStream2.Seek(100, SeekOrigin.Current);
Assert.That(seek, Is.EqualTo(100));
Assert.That(sharedMemoryStream2.Position, Is.EqualTo(100));
}
