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)); } } } }