public void Read_ZeroLength_ReturnsEmptyArray()
{
var stream = new MemoryStream(new byte[10]);
var container = new StreamContainer(stream);
CollectionAssert.AreEqual(container.Read(0, 0), new byte[0]);
}
public void Read_TooCloseToEnd_ReturnsTruncatedArray()
{
var stream = new MemoryStream(new byte[10]);
var container = new StreamContainer(stream);
CollectionAssert.AreEqual(container.Read(5, 10), new byte[5]);
}
public void AddOrUpdateStream(StreamInfo streamInfo, int maxItemsInQueue)
{
streamInfo.Validate();
StreamContainer container = new StreamContainer(streamInfo, maxItemsInQueue);
m_containers[streamInfo.ID] = container;
}
public void Length_ReturnsLengthOfGivenArray(int length)
{
var stream = new MemoryStream(new byte[length]);
var container = new StreamContainer(stream);
Assert.That(container.Length, Is.EqualTo(length));
}
public void Read_NegativeOffset_ThrowsArgumentOutOfRangeException()
{
var stream = new MemoryStream();
var container = new StreamContainer(stream);
Assert.Throws <ArgumentOutOfRangeException>(() => container.Read(-1, 0));
}
public void Read_BeyondEnd_ReturnsEmptyArray()
{
var stream = new MemoryStream(new byte[10]);
var container = new StreamContainer(stream);
CollectionAssert.AreEqual(container.Read(20, 10), new byte[0]);
}
public void Read_WithBogusStream_ReturnsEmptyArray()
{
var stream = new BogusStream();
var container = new StreamContainer(stream);
CollectionAssert.AreEqual(container.Read(0, 10), new byte[0]);
}
public void AddReader(StreamReader reader)
{
var head = new StreamContainer()
{
Reader = reader, Container = Container
};
Container = head;
}
public Client(StreamContainer container)
{
if (container == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at client init: " + ex.ToString());
throw ex;
}
streamContainer = container;
}
public Client(IClientListener listener, StreamContainer container)
{
if (listener == null || container == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at client init: " + ex.ToString());
throw ex;
}
this.listener = listener;
streamContainer = container;
}
public void MergeChunks(string outputFilePath, string[] chunkFiles)
{
Console.WriteLine(nameof(SortedDictionaryMergeStrategy));
using (var writer = File.CreateText(outputFilePath))
{
List <StreamReader> readers = null;
try
{
readers = chunkFiles.Select(s => new StreamReader(s, Encoding.UTF8)).ToList();
SortedDictionary <string, StreamContainer> kWayMerger
= new SortedDictionary <string, StreamContainer>(_comparer);
// Here SortedDictionary is used as a priority queue for k-Way merge. The key is string, and the value
// is a linked list of readers this string came from. Approach is similar as in PriorityQueueMergeStrategy,
// but the difference is that here there could be multiple readers for the same line.
// It could be beneficial if there are many identical strings
// At first read a line from each stream
readers.ForEach(reader => AddLineForMerging(kWayMerger, reader, reader.ReadLine()));
while (kWayMerger.Count > 0)
{
var pair = kWayMerger.First();
kWayMerger.Remove(pair.Key);
string lineToWrite = pair.Key;
StreamContainer readersForLine = pair.Value;
// Write minimal line from the dictionary to the output for each reader in the list
do
{
StreamReader reader = readersForLine.Reader;
readersForLine = readersForLine.Container;
writer.WriteLine(lineToWrite);
AddLineForMerging(kWayMerger, reader, reader.ReadLine());
}while (readersForLine != null);
}
}
finally
{
readers?.ForEach(r => r.Dispose());
}
}
foreach (var path in chunkFiles)
{
File.Delete(path);
}
}
public async Task WritesReadsNewStream()
{
var hydra = CreateHydra();
var container = new StreamContainer(hydra);
var subject = new Stream(container);
var id = Guid.NewGuid().ToString();
var eventData = "{ \"name\": \"john\" }";
await subject.WriteEventAsync("key", id, eventData);
var persisted = await subject.ReadEventsAsync("key", id);
Assert.Equal(eventData, persisted.First());
}
public void Read_Contents_ReturnsCorrectContents()
{
var stream = new MemoryStream(
new byte[]
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
});
var container = new StreamContainer(stream);
CollectionAssert.AreEqual(
container.Read(5, 10), new byte[]
{
6, 7, 8, 9, 10
});
}
public object OpenStreamChannel(ConnectionBase connection, ExecuteCommand executeCommand, Type parameterType)
{
StreamContainer streamContainer = new StreamContainer(connection.Id, parameterType);
Guid streamId = Guid.NewGuid();
streamContainers.TryAdd(streamId, streamContainer);
_ = connection.Send(new InitStreamResponse()
{
ReferenceId = executeCommand.ReferenceId,
Id = streamId
});
CloseOldStreamChannels();
return(streamContainer.AsyncEnumerableValue);
}
private static void AddLineForMerging(SortedDictionary <string, StreamContainer> kWayMerger, StreamReader reader, string line)
{
if (line == null)
{
return;
}
if (kWayMerger.ContainsKey(line))
{
kWayMerger[line].AddReader(reader);
}
else
{
kWayMerger[line] = new StreamContainer()
{
Reader = reader
};
}
}
public Stream GetStream()
{
if (disposed != 0)
{
throw new ObjectDisposedException("StreamFactory");
}
int threadId = Thread.CurrentThread.ManagedThreadId;
StreamContainer res = containers.FirstOrDefault(c => c.Lock(threadId));
if (res == null)
{
res = new StreamContainer(CreateNew());
res.Lock(threadId);
containers.Add(res);
}
return(res);
}
public async Task WritesReadsExistingStream()
{
var hydra = CreateHydra();
var container = new StreamContainer(hydra);
var subject = new Stream(container);
var id = Guid.NewGuid().ToString();
var eventData1 = "{ \"name\": \"john\" }";
var eventData2 = "{ \"lastname\": \"doe\" }";
await subject.WriteEventAsync("key", id, eventData1);
await subject.WriteEventAsync("key", id, eventData2);
var persisted = await subject.ReadEventsAsync("key", id);
Assert.Equal(eventData1, persisted[0]);
Assert.Equal(eventData2, persisted[1]);
}
public static void Run()
{
// To get proper output please apply a valid Aspose.Imaging License. You can purchase full license or get 30 day temporary license from http:// Www.aspose.com/purchase/default.aspx."
// ExStart: SyncRootProperty
// Create an instance of Memory stream class.
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream())
{
// Create an instance of Stream container class and assign memory stream object.
using (StreamContainer streamContainer = new StreamContainer(memoryStream))
{
// check if the access to the stream source is synchronized.
lock (streamContainer.SyncRoot)
{
// do work
// now access to source MemoryStream is synchronized
}
}
}
// ExEnd: SyncRootProperty
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_PSD();
//ExStart:SyncRoot
// Create an instance of Memory stream class.
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream())
{
// Create an instance of Stream container class and assign memory stream object.
using (StreamContainer streamContainer = new StreamContainer(memoryStream))
{
// check if the access to the stream source is synchronized.
lock (streamContainer.SyncRoot)
{
// do work
// now access to source MemoryStream is synchronized
}
}
}
//ExEnd:SyncRoot
}
public void AddStreamController(StreamContainer container) => streamContainer = container;
