public void TestReaderStream()
{
using (SharedMemoryStream shared = new SharedMemoryStream())
using (FragmentedFile ff = FragmentedFile.CreateNew(shared, 512, 100, 2))
{
long id;
using (Stream write = ff.Create(out id))
PrimitiveSerializer.Int64.WriteTo(id, write);
using (Stream read = ff.Open(id, FileAccess.Read))
{
Assert.IsTrue(read.CanRead);
Assert.IsFalse(read.CanWrite);
Assert.IsFalse(read.CanSeek);
Assert.AreEqual(id, PrimitiveSerializer.Int64.ReadFrom(read));
read.Flush();//no-op
AssertThrows <NotSupportedException>(delegate() { read.Position = 0; });
AssertThrows <NotSupportedException>(delegate() { GC.KeepAlive(read.Position); });
AssertThrows <NotSupportedException>(delegate() { GC.KeepAlive(read.Length); });
AssertThrows <NotSupportedException>(delegate() { read.SetLength(1); });
AssertThrows <NotSupportedException>(delegate() { read.Seek(1, SeekOrigin.Begin); });
AssertThrows <NotSupportedException>(delegate() { read.WriteByte(1); });
}
}
}
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 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 TestTransactBlock()
{
SharedMemoryStream shared = new SharedMemoryStream();
FragmentedFile.CreateNew(shared, 512, 100, 2).Dispose();
using (FragmentedFile ff = new FragmentedFile(shared, 512, 100, 2))
{
long id;
byte[] orig = MakeBytes(255);
using (Stream write = ff.Create(out id))
write.Write(orig, 0, orig.Length);
Assert.AreEqual(orig, IOStream.ReadAllBytes(ff.Open(id, FileAccess.Read)));
byte[] change = MakeBytes(800);
using (Stream write = ff.Open(id, FileAccess.Write))
using (ITransactable trans = (ITransactable)write) //the Fragmented File Streams are ITransactable
{
write.Write(change, 0, change.Length);
Assert.AreEqual(orig, IOStream.ReadAllBytes(ff.Open(id, FileAccess.Read)));
trans.Commit(); //commit changes so that readers can read
Assert.AreEqual(change, IOStream.ReadAllBytes(ff.Open(id, FileAccess.Read)));
trans.Rollback(); //rollback even after commit to 'undo' the changes
Assert.AreEqual(orig, IOStream.ReadAllBytes(ff.Open(id, FileAccess.Read)));
} //once disposed you can no longer rollback, if rollback has not been called commit is implied.
Assert.AreEqual(orig, IOStream.ReadAllBytes(ff.Open(id, FileAccess.Read)));
}
}
public void Read_ShouldReadBytesAndMovePositionInStreamIndependentlyForEachSharedInstance()
{
// 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 buffer1 = new byte[10];
var read1 = sharedMemoryStream1.Read(buffer1, 0, 10);
var buffer2 = new byte[100];
var read2 = sharedMemoryStream2.Read(buffer2, 0, 100);
// Assert
Assert.That(read1, Is.EqualTo(10));
Assert.That(buffer1, Is.EqualTo(bytes.Skip(123).Take(10)));
Assert.That(sharedMemoryStream1.Position, Is.EqualTo(133));
Assert.That(read2, Is.EqualTo(100));
Assert.That(buffer2, Is.EqualTo(bytes.Skip(321).Take(100)));
Assert.That(sharedMemoryStream2.Position, Is.EqualTo(421));
}
public Audio()
{
try
{
CodecFactory.Instance.Register("ogg-vorbis",
new CodecFactoryEntry(s => new OggSource(s).ToWaveSource(), ".ogg"));
_mixer = new SoundMixer();
_soundOut = new WasapiOut();
_soundOut.Initialize(_mixer.ToWaveSource());
_soundOut.Play();
}
catch
{
Console.WriteLine("Could not load audio");
}
_menu = LoadSound(AppContext.BaseDirectory + "assets/sfx/menu.wav");
LoadSound(AppContext.BaseDirectory + "assets/sfx/fill.wav");
_random = new Random();
_playlist = new List <string>();
_playingPlaylist = false;
var files = Directory.EnumerateFiles(AppContext.BaseDirectory + "/assets/bgm/playlist");
foreach (var file in files)
{
if (!file.EndsWith(".ogg"))
{
continue;
}
_playlist.Add(file);
}
}
public void Stream_Simple_BigWrite_ReadWrite()
{
string name = Guid.NewGuid().ToString();
Random r = new Random();
int bufSize = 32;
byte[] data = new byte[bufSize * 2 + 10];
byte[] readBuf = new byte[bufSize * 2 + 10];
r.NextBytes(data);
using (SharedMemoryStream buffer = new SharedMemoryStream(name, 512, bufSize))
using (BinaryWriter writer = new BinaryWriter(buffer))
using (BinaryReader reader = new BinaryReader(buffer))
{
writer.Write(data, 0, data.Length);
writer.Flush();
//reader.Read(readBuf, 0, readBuf.Length);
writer.Write(data, 0, data.Length);
writer.Flush();
reader.Read(readBuf, 0, readBuf.Length);
writer.Write(data, 0, data.Length);
writer.Flush();
reader.Read(readBuf, 0, readBuf.Length);
for (var i = 0; i < data.Length; i++)
{
Assert.AreEqual(data[i], readBuf[i], String.Format("Data written does not match data read at index {0}", i));
}
}
}
public void CapacityAndEndAreSame()
{
using (var sms = new SharedMemoryStream(10))
sms.Position = 10;
Assert.True(true);
}
//private static void CaptureCompressedDesktopImage(SharedMemoryStream sm)
//{
// int method = sm.ReadByte();
// byte[] buf;
// if (method == 0)
// buf = ScreenCapture.GetScreenCap_DXGI();
// else if (method == 2)
// buf = ScreenCapture.GetScreenCap_2();
// else if (method == 3)
// buf = ScreenCapture.GetScreenCap_3();
// else
// buf = ScreenCapture.GetScreenCap_1();
// if (buf.Length == 0)
// UnknownError(sm, "CaptureCompressedDesktopImage");
// else
// {
// sm.WriteByte((byte)Command.CaptureCompressedDesktopImage); // Write command code
// sm.WriteInt32(buf.Length); // Write length of image
// sm.Write(buf, 0, buf.Length); // Write image
// }
//}
public static void UnknownError(SharedMemoryStream sm, string whoAmI)
{
Logger.Debug(whoAmI + " writing Error_UnknownError response");
lock (sm)
{
sm.WriteByte((byte)Command.Error_Unspecified);
}
}
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 LengthIsWrittenLength()
{
using (var ms = new MemoryStream(1024))
using (var sms = new SharedMemoryStream(1024))
{
Assert.Equal(LengthIsWrittenLengthEquiv(ms), LengthIsWrittenLengthEquiv(sms));
}
}
public void SeekPastWrittenAndSizeRemainsSame()
{
using (var ms = new MemoryStream(1024))
using (var sms = new SharedMemoryStream(1024))
{
Assert.Equal(SeekPastWrittenAndSizeRemainsSameEquiv(ms), SeekPastWrittenAndSizeRemainsSameEquiv(sms));
}
}
public void AutomaticCapacityExpansion()
{
using (var ms = new MemoryStream(1))
using (var sms = new SharedMemoryStream(1))
{
Assert.True(AutomaticCapacityExpansionEquiv(ms) == AutomaticCapacityExpansionEquiv(sms));
}
}
public void SeekPastWritten()
{
using (var ms = new MemoryStream(1024))
using (var sms = new SharedMemoryStream(1024))
{
Assert.Equal(SeekPastWrittenEquiv(ms), SeekPastWrittenEquiv(sms));
}
}
public void SeekEndIsFromWrittenLength()
{
using (var ms = new MemoryStream(1024))
using (var sms = new SharedMemoryStream(1024))
{
Assert.Equal(SeekEndIsFromWrittenLengthEquiv(ms), SeekEndIsFromWrittenLengthEquiv(sms));
}
}
public void TextReadAndWrite()
{
using (var ms = new MemoryStream(64738))
using (var sms = new SharedMemoryStream(64738))
{
Assert.True(TextReadAndWriteEquiv(ms) == TextReadAndWriteEquiv(sms));
}
}
public void SizeAdjustsToLastWritePos()
{
using (var ms = new MemoryStream(1024))
using (var sms = new SharedMemoryStream(1024))
{
Assert.True(SizeAdjustsToLastWritePosEquiv(ms) == SizeAdjustsToLastWritePosEquiv(sms));
}
}
public void Stream_Constructor()
{
string name = Guid.NewGuid().ToString();
using (SharedMemoryStream producer = new SharedMemoryStream(name))
using (SharedMemoryStream consumer = new SharedMemoryStream(name))
{
}
}
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 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 Length_ShouldReturnStreamLength()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Act
// Assert
Assert.That(sharedMemoryStream.Length, Is.EqualTo(bytes.Length));
}
public void CanWrite_ShouldBeFalseAsStreamIsReadOnly()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Act
// Assert
Assert.That(sharedMemoryStream.CanWrite, Is.False);
}
public void Write_ShouldThrowNotSupportedExceptionAsStreamIsReadOnly()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Act
// Assert
Assert.That(() => sharedMemoryStream.Write(new byte[100], 0, 100), Throws.TypeOf <NotSupportedException>());
}
public void SetLength_ShouldThrowNotSupportedExceptionAsStreamIsReadOnly()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Act
// Assert
Assert.That(() => sharedMemoryStream.SetLength(123), Throws.TypeOf <NotSupportedException>());
}
public void Flush_ShouldNotThrowException()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Act
// Assert
Assert.That(() => sharedMemoryStream.Flush(), Throws.Nothing);
}
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 WriteMovesPositionSameAmountDefault()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
var posBefore = sms.Position;
sms.Write(buffer1, 0, buffer1.Length);
Assert.Equal(buffer1.Length, sms.Position - posBefore);
}
}
private void Stream_Parallel_ReadWrite(int dataSize, int nodeCount, int bufferSize, bool bench)
{
int iterations = 10;
byte[] data = new byte[dataSize];
string name = Guid.NewGuid().ToString();
// Fill with random data
Random r = new Random();
r.NextBytes(data);
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations; i++)
{
using (SharedMemoryStream buffer = new SharedMemoryStream(name, nodeCount, bufferSize))
using (SharedMemoryStreamWriter <byte[]> writer = new SharedMemoryStreamWriter <byte[]>(buffer))
using (SharedMemoryStreamReader <byte[]> reader = new SharedMemoryStreamReader <byte[]>(buffer))
{
Action wt = () =>
{
writer.WriteObject(data);
Debug.WriteLine("Write done.", "Information");
};
Action rd = () =>
{
reader.ReadObject();
Debug.WriteLine("Read done.", "Information");
};
Task tWriter = Task.Factory.StartNew(wt);
Task tReader = Task.Factory.StartNew(rd);
if (!Task.WaitAll(new Task[] { tWriter, tReader }, 1200000))
{
Assert.Fail("Reader or writer took too long");
}
}
}
sw.Stop();
double dataRate = Math.Round(((double)iterations * dataSize) / sw.ElapsedMilliseconds, 2);
if (bench)
{
Console.WriteLine(dataSize + ";" + dataRate + ";" + sw.ElapsedMilliseconds + ";" + nodeCount + ";" + bufferSize);
}
else
{
Console.WriteLine("Data Rate: " + dataRate + "kB/s (" + sw.ElapsedMilliseconds + "ms to write " + iterations + "x" + dataSize + "=" + iterations * dataSize + " bytes in " + nodeCount + "x" + bufferSize + "=" + nodeCount * bufferSize + ")");
}
}
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 Read_ShouldThrowExceptionWhenStreamDisposed()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
sharedMemoryStream.Dispose();
// Act
// Assert
Assert.That(() => sharedMemoryStream.Read(new byte[100], 0, 100), Throws.TypeOf <ObjectDisposedException>());
}
public void ReadTest()
{
var stream = new SharedMemoryStream();
var buffer = new byte[10000];
stream.Write(buffer, 0, 10000);
Assert.Equal(10000, stream.Length);
var reader = stream.GetReader();
var b = new byte[1];
while (reader.Read(b, 0, 1) != 0) {
}
Assert.Equal(10000, reader.Position);
}
public ScriptExecutionContext(ScriptManager manager, int id)
{
this.Id = id;
this.scriptIdx = 0;
this.manager = manager;
this.executions = new List<ScriptExecutionInfo>();
this.runningScripts = new HashSet<ScriptExecutionInfo>();
this.setup = new ScriptRuntimeSetup();
setup.LanguageSetups.Add(Python.CreateLanguageSetup(new Dictionary<string, object>()));
this.Runtime = new ScriptRuntime(setup);
this.output = new SharedMemoryStream();
this.Runtime.IO.SetOutput(this.output, Encoding.UTF8);
this.Engine = Runtime.GetEngine("python");
this.scope = Engine.CreateScope();
}
public void BasicTest()
{
var data = new byte[0x1000];
var buffer = new byte[0x1000];
var oStream = new SharedMemoryStream();
var reader = oStream.GetReader();
var evt = new AutoResetEvent(false);
Action a = () =>
{
evt.WaitOne();
oStream.Write(data, 0, 16);
evt.WaitOne();
oStream.Write(data, 0, 16);
};
var t = new Thread(new ThreadStart(a));
t.Start();
var task = reader.ReadAsync(buffer, 0, 1000);
evt.Set();
task.Wait();
var s = task.Result;
log.WriteLine(s.ToString());
task = reader.ReadAsync(buffer, 0, 1000);
evt.Set();
task.Wait();
s = task.Result;
log.WriteLine(s.ToString());
t.Join();
}
public void TestCacheLimit()
{
bool finished = false;
using (SharedMemoryStream shared = new SharedMemoryStream())
using (StreamCache cache = new StreamCache(shared, 1))
{
ManualResetEvent ready = new ManualResetEvent(false);
ManualResetEvent release = new ManualResetEvent(false);
Thread t = new Thread(
delegate()
{
using (Stream stream = cache.Open(FileAccess.ReadWrite))
{
stream.Write(new byte[50], 0, 50);
ready.Set();
release.WaitOne();
stream.Write(new byte[50], 0, 50);
GC.KeepAlive(stream);
finished = true;
}
}
);
t.IsBackground = true;
t.Start();
Assert.IsTrue(ready.WaitOne());
Assert.AreEqual(50, shared.Length);
new Thread(
delegate()
{
Thread.Sleep(10);
release.Set();
}
).Start();
Assert.IsFalse(finished);
using (Stream stream = cache.Open())
{
Assert.IsTrue(finished);
Assert.IsTrue(release.WaitOne(0, false));
Assert.AreEqual(100, stream.Read(new byte[100], 0, 100));
}
Assert.IsTrue(t.Join(1000));
}
}
public void TestSharedMemory()
{
using (SharedMemoryStream shared = new SharedMemoryStream(5))
using (Stream copy = (Stream)((ICloneable)shared).Clone())
{
for (int i = 0; i < 100; i++)
{
PrimitiveSerializer.Int32.WriteTo(i, shared);
Assert.AreEqual(i, PrimitiveSerializer.Int32.ReadFrom(copy));
}
}
}
public void WriteTest()
{
var stream = new SharedMemoryStream();
var buffer = new byte[1];
for(int i = 0; i < 10000;i++)
{
stream.Write(buffer, 0, 1);
}
Assert.Equal(10000, stream.Length);
}
public void TestSharedMemoryThreaded()
{
using (ManualResetEvent mreStart = new ManualResetEvent(false))
using (SharedMemoryStream shared = new SharedMemoryStream(5))
using (SharedMemoryStream copy = shared.Clone())
{
Thread[] allwriters = new Thread[Math.Max(1, Environment.ProcessorCount - 1)];
for (int tix = 0; tix < allwriters.Length; tix++)
{
allwriters[tix] = new Thread(
delegate()
{
using (SharedMemoryStream stream = shared.Clone())
{
Random r = new Random();
mreStart.WaitOne();
for (int i = 0; i < 1000; i++)
{
PrimitiveSerializer.Int32.WriteTo(i, stream);
Thread.SpinWait(r.Next(i));
}
}
}
);
allwriters[tix].IsBackground = true;
allwriters[tix].Start();
}
mreStart.Set();
foreach(Thread t in allwriters)
Assert.IsTrue(t.Join(100));
for (int i = 0; i < 1000; i++)
{
int value = PrimitiveSerializer.Int32.ReadFrom(copy);
Assert.AreEqual(i, value);
}
}
}
public void TestSharedMemoryAsFactory()
{
using (SharedMemoryStream shared = new SharedMemoryStream())
{
shared.Position = ushort.MaxValue - 25;
Assert.AreEqual(ushort.MaxValue - 25, shared.Length);
Assert.AreEqual(ushort.MaxValue - 25, shared.Position);
using (Stream copy = ((IFactory<Stream>) shared).Create())
{
Assert.AreEqual(0L, copy.Position);//does not clone position of original stream...
Assert.AreEqual(shared.Length, copy.Length);//does clone length of the stream...
copy.Position = shared.Position;
for (int i = 0; i < 100; i++)
{
PrimitiveSerializer.Int32.WriteTo(i, shared);
Assert.AreEqual(i, PrimitiveSerializer.Int32.ReadFrom(copy));
}
}
}
}
