public void CanReadLegacyDataAndRewriteInNewFormat(string originalFileName)
{
var tempFile = Path.GetTempFileName();
using (var sourceStream = new FileStream(originalFileName, FileMode.Open, FileAccess.Read))
using (var sourceReader = new PersistedDataReader(sourceStream, this.streamManager))
using (var destStream = new FileStream(tempFile, FileMode.Open, FileAccess.Write))
{
while (sourceReader.ReadDataHeader())
{
using (var destWriter = new PersistedDataWriter(destStream, sourceReader.DimensionSet,
this.streamManager))
{
if (sourceReader.DataType == typeof(InternalHitCount))
{
destWriter.WriteData(sourceReader.Header.Name, sourceReader.StartTime, sourceReader.EndTime,
sourceReader.Header.DataCount, sourceReader.Header.Sources,
sourceReader.LoadData <InternalHitCount>());
}
else
{
destWriter.WriteData(sourceReader.Header.Name, sourceReader.StartTime, sourceReader.EndTime,
sourceReader.Header.DataCount, sourceReader.Header.Sources,
sourceReader.LoadData <InternalHistogram>());
}
}
}
}
this.VerifyMatchingContents(originalFileName, tempFile);
File.Delete(tempFile);
}
public void CanReadMultipleWrittenDataFromSameStream()
{
const int iterations = 10;
for (int i = 0; i < iterations; ++i)
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
}
stream.Position = 0;
using (var reader = new PersistedDataReader(stream, this.streamManager))
{
for (int i = 0; i < iterations; ++i)
{
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual(reader.Header.Name, "/Foo");
Assert.AreEqual((uint)data.Count, reader.Header.DataCount);
reader.ReadData <InternalHitCount>(
(key, value) => Assert.AreEqual(AnyDataValue, value.HitCount));
}
}
}
public void ReadingTruncatedDataThrowsPersistedDataException()
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
for (int i = (int)stream.Length / 2; i >= 0; --i)
{
var buffer = new byte[i];
Buffer.BlockCopy(stream.GetBuffer(), 0, buffer, 0, i);
using (var truncatedStream = new MemoryStream(buffer, false))
using (var reader = new PersistedDataReader(truncatedStream, this.streamManager))
{
try
{
// If we can't read the header it's fine.
if (reader.ReadDataHeader())
{
reader.ReadData <InternalHitCount>((key, value) => { });
Assert.Fail();
}
}
catch (PersistedDataException) {}
}
}
}
private void VerifyMatchingContents(string left, string right)
{
using (var leftStream = new FileStream(left, FileMode.Open, FileAccess.Read))
using (var leftReader = new PersistedDataReader(leftStream, this.streamManager))
using (var rightStream = new FileStream(right, FileMode.Open, FileAccess.Read))
using (var rightReader = new PersistedDataReader(rightStream, this.streamManager))
{
while (leftReader.ReadDataHeader())
{
rightReader.ReadDataHeader();
Assert.IsFalse(leftReader.IsLatestProtocol);
Assert.IsTrue(rightReader.IsLatestProtocol);
Assert.AreEqual(leftReader.Header.DataCount, rightReader.Header.DataCount);
Assert.IsTrue(leftReader.DimensionSet.Equals(rightReader.DimensionSet));
Assert.AreEqual(leftReader.StartTime, rightReader.StartTime);
Assert.AreEqual(leftReader.EndTime, rightReader.EndTime);
if (leftReader.DataType == typeof(InternalHitCount))
{
Assert.AreEqual(leftReader.Header.DataType, rightReader.Header.DataType);
var leftData = leftReader.LoadData <InternalHitCount>().ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.HitCount);
var rightData = rightReader.LoadData <InternalHitCount>().ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.HitCount);
Assert.AreEqual(leftData.Count, rightData.Count);
Assert.IsTrue(leftData.All(kvp => rightData[kvp.Key] == kvp.Value));
}
else
{
var leftData = leftReader.LoadData <InternalHistogram>()
.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Data);
var rightData = rightReader.LoadData <InternalHistogram>()
.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Data);
Assert.AreEqual(leftData.Count, rightData.Count);
Assert.IsTrue(leftData.All(
kvp =>
{
var otherData = rightData[kvp.Key];
return(otherData.Count == kvp.Value.Count &&
kvp.Value.All(x => otherData[x.Key] == x.Value));
}
));
}
}
}
}
public void CanReadWrittenData()
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
stream.Position = 0;
using (var reader = new PersistedDataReader(stream, this.streamManager))
{
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual("/Foo", reader.Header.Name);
Assert.AreEqual((uint)data.Count, reader.Header.DataCount);
reader.ReadData <InternalHitCount>(
(key, value) => Assert.AreEqual(AnyDataValue, value.HitCount));
}
}
private void ValidateStreamContents(Stream input)
{
var reader = new PersistedDataReader(input, this.memoryStreamManager);
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual((uint)3, reader.Header.DataCount);
Assert.AreEqual(AnyCounter, reader.Header.Name);
Assert.AreEqual(this.GetStartTime().ToUniversalTime(), reader.StartTime);
Assert.AreEqual(this.GetEndTime().ToUniversalTime(), reader.EndTime);
reader.ReadData <InternalHitCount>(
(key, data) =>
{
bool allDimensionsProvided;
if (
key.Matches(this.dimensionSet.CreateKey(new DimensionSpecification {
{ AnyDimension, "a" }
},
out allDimensionsProvided)))
{
Assert.AreEqual((ulong)1, data.HitCount);
}
else if (
key.Matches(this.dimensionSet.CreateKey(
new DimensionSpecification {
{ AnyDimension, "b" }
}, out allDimensionsProvided)))
{
Assert.AreEqual((ulong)2, data.HitCount);
}
else if (
key.Matches(
this.dimensionSet.CreateKey(new DimensionSpecification {
{ AnyDimension, "c" }
},
out allDimensionsProvided)))
{
Assert.AreEqual((ulong)1, data.HitCount);
}
else
{
Assert.Fail("Unexpected data found!");
}
});
}
public void CanReadWrittenData()
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
stream.Position = 0;
using (var reader = new PersistedDataReader(stream, this.streamManager))
{
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual("/Foo", reader.Header.Name);
Assert.AreEqual((uint)data.Count, reader.Header.DataCount);
reader.ReadData<InternalHitCount>(
(key, value) => Assert.AreEqual(AnyDataValue, value.HitCount));
}
}
private void VerifyMatchingContents(string left, string right)
{
using (var leftStream = new FileStream(left, FileMode.Open, FileAccess.Read))
using (var leftReader = new PersistedDataReader(leftStream, this.streamManager))
using (var rightStream = new FileStream(right, FileMode.Open, FileAccess.Read))
using (var rightReader = new PersistedDataReader(rightStream, this.streamManager))
{
while (leftReader.ReadDataHeader())
{
rightReader.ReadDataHeader();
Assert.IsFalse(leftReader.IsLatestProtocol);
Assert.IsTrue(rightReader.IsLatestProtocol);
Assert.AreEqual(leftReader.Header.DataCount, rightReader.Header.DataCount);
Assert.IsTrue(leftReader.DimensionSet.Equals(rightReader.DimensionSet));
Assert.AreEqual(leftReader.StartTime, rightReader.StartTime);
Assert.AreEqual(leftReader.EndTime, rightReader.EndTime);
if (leftReader.DataType == typeof(InternalHitCount))
{
Assert.AreEqual(leftReader.Header.DataType, rightReader.Header.DataType);
var leftData = leftReader.LoadData<InternalHitCount>().ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.HitCount);
var rightData = rightReader.LoadData<InternalHitCount>().ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.HitCount);
Assert.AreEqual(leftData.Count, rightData.Count);
Assert.IsTrue(leftData.All(kvp => rightData[kvp.Key] == kvp.Value));
}
else
{
var leftData = leftReader.LoadData<InternalHistogram>()
.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Data);
var rightData = rightReader.LoadData<InternalHistogram>()
.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Data);
Assert.AreEqual(leftData.Count, rightData.Count);
Assert.IsTrue(leftData.All(
kvp =>
{
var otherData = rightData[kvp.Key];
return otherData.Count == kvp.Value.Count &&
kvp.Value.All(x => otherData[x.Key] == x.Value);
}
));
}
}
}
}
public void CanReadLegacyDataAndRewriteInNewFormat(string originalFileName)
{
var tempFile = Path.GetTempFileName();
using (var sourceStream = new FileStream(originalFileName, FileMode.Open, FileAccess.Read))
using (var sourceReader = new PersistedDataReader(sourceStream, this.streamManager))
using (var destStream = new FileStream(tempFile, FileMode.Open, FileAccess.Write))
{
while (sourceReader.ReadDataHeader())
{
using (var destWriter = new PersistedDataWriter(destStream, sourceReader.DimensionSet,
this.streamManager))
{
if (sourceReader.DataType == typeof(InternalHitCount))
{
destWriter.WriteData(sourceReader.Header.Name, sourceReader.StartTime, sourceReader.EndTime,
sourceReader.Header.DataCount, sourceReader.Header.Sources,
sourceReader.LoadData<InternalHitCount>());
}
else
{
destWriter.WriteData(sourceReader.Header.Name, sourceReader.StartTime, sourceReader.EndTime,
sourceReader.Header.DataCount, sourceReader.Header.Sources,
sourceReader.LoadData<InternalHistogram>());
}
}
}
}
this.VerifyMatchingContents(originalFileName, tempFile);
File.Delete(tempFile);
}
public void CanReadMultipleWrittenDataFromSameStream()
{
const int iterations = 10;
for (int i = 0; i < iterations; ++i)
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
}
stream.Position = 0;
using (var reader = new PersistedDataReader(stream, this.streamManager))
{
for (int i = 0; i < iterations; ++i)
{
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual(reader.Header.Name, "/Foo");
Assert.AreEqual((uint)data.Count, reader.Header.DataCount);
reader.ReadData<InternalHitCount>(
(key, value) => Assert.AreEqual(AnyDataValue, value.HitCount));
}
}
}
public void ReadingTruncatedDataThrowsPersistedDataException()
{
using (var writer = new PersistedDataWriter(stream, dimensions, this.streamManager))
{
writer.WriteData(AnyCounterName, AnyStart, AnyEnd, (uint)data.Count, AnySources, data);
}
for (int i = (int)stream.Length / 2; i >= 0; --i)
{
var buffer = new byte[i];
Buffer.BlockCopy(stream.GetBuffer(), 0, buffer, 0, i);
using (var truncatedStream = new MemoryStream(buffer, false))
using (var reader = new PersistedDataReader(truncatedStream, this.streamManager))
{
try
{
// If we can't read the header it's fine.
if (reader.ReadDataHeader())
{
reader.ReadData<InternalHitCount>((key, value) => { });
Assert.Fail();
}
}
catch (PersistedDataException) {}
}
}
}
private void ValidateStreamContents(Stream input)
{
var reader = new PersistedDataReader(input, this.memoryStreamManager);
Assert.IsTrue(reader.ReadDataHeader());
Assert.AreEqual((uint)3, reader.Header.DataCount);
Assert.AreEqual(AnyCounter, reader.Header.Name);
Assert.AreEqual(this.GetStartTime().ToUniversalTime(), reader.StartTime);
Assert.AreEqual(this.GetEndTime().ToUniversalTime(), reader.EndTime);
reader.ReadData<InternalHitCount>(
(key, data) =>
{
bool allDimensionsProvided;
if (
key.Matches(this.dimensionSet.CreateKey(new DimensionSpecification {{AnyDimension, "a"}},
out allDimensionsProvided)))
{
Assert.AreEqual((ulong)1, data.HitCount);
}
else if (
key.Matches(this.dimensionSet.CreateKey(
new DimensionSpecification {{AnyDimension, "b"}}, out allDimensionsProvided)))
{
Assert.AreEqual((ulong)2, data.HitCount);
}
else if (
key.Matches(
this.dimensionSet.CreateKey(new DimensionSpecification {{AnyDimension, "c"}},
out allDimensionsProvided)))
{
Assert.AreEqual((ulong)1, data.HitCount);
}
else
{
Assert.Fail("Unexpected data found!");
}
});
}
