public void FilePositionAfterWritingItems()
{
var stream = new MemoryStream();
using (var tf = TeaFile <int> .Create(stream))
{
tf.ItemAreaSize.Should().Be(0);
stream.Position.Should().Be(stream.Length);
stream.Position.Should().Be(tf.ItemAreaStart);
tf.ItemAreaStart.Should().Be(80);
tf.Write(11);
tf.ItemAreaStart.Should().Be(80);
tf.ItemAreaEnd.Should().Be(84);
tf.ItemAreaSize.Should().Be(4);
tf.Count.Should().Be(1);
stream.Position.Should().Be(84);
stream.Position.Should().Be(84);
tf.Write(7);
tf.ItemAreaStart.Should().Be(80);
tf.ItemAreaEnd.Should().Be(88);
tf.ItemAreaSize.Should().Be(8);
tf.Count.Should().Be(2);
stream.Position.Should().Be(88);
stream.Position.Should().Be(88);
}
}
public void DiscDriveFailureDuringCreate()
{
var stream = new TestStream();
stream.FailAfterPosition = 17;
Executing.This(() => TeaFile <int> .Create(stream)).Should().Throw <IOException>();
}
public void ItemsT_Enumerating_Returns_Correct_Values()
{
using (TeaFile <OHLCV> f = TeaFile <OHLCV> .Create(Guid.NewGuid() + "lab1.tea"))
{
var firstValue = new OHLCV {
Open = 111
};
var someValue = new OHLCV {
Open = 222
};
var lastValue = new OHLCV {
Open = 333
};
List <OHLCV> values = new List <OHLCV>();
values.Add(firstValue);
values.Add(someValue);
values.Add(lastValue);
int i = 0;
foreach (OHLCV ohlcv in f.Items)
{
Assert.AreEqual(values[i], ohlcv);
}
}
}
public void GetEnumeratorTest()
{
var filename = "ItemCollectionTest_GetEnumeratorTest.tea";
using (var tf = TeaFile <int> .Create(filename))
{
tf.Write(Enumerable.Range(2, 4));
}
using (var tf = TeaFile.OpenRead(filename))
{
var e = tf.Items.GetEnumerator(0);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(2);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(3);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(4);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(5);
e.MoveNext().Should().Be.False();
e = tf.Items.GetEnumerator(2);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(4);
e.MoveNext().Should().Be.True();
e.Current.Values[0].Should().Be(5);
e.MoveNext().Should().Be.False();
}
}
public void ExoticCoverage()
{
Executing.This(() => TeaFile <int> .Create((string)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Create((string)null, "contento", null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Create((string)null, "a", null, true)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Create((Stream)null, "a", null, true)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Create((Stream)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Create((Stream)null, "contento", null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenRead((Stream)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenRead((Stream)null, ItemDescriptionElements.None)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenRead((string)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenRead((string)null, ItemDescriptionElements.None)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenWrite((Stream)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenWrite((Stream)null, ItemDescriptionElements.None)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenWrite((string)null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .OpenWrite((string)null, ItemDescriptionElements.None)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Append(null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Append(null)).Should().Throw <ArgumentNullException>();
Executing.This(() => TeaFile <int> .Append(null, ItemDescriptionElements.None)).Should().Throw <ArgumentNullException>();
var stream = new MemoryStream();
using (var tf = TeaFile <int> .Create(stream))
{
tf.Write(Enumerable.Range(100, 7));
}
stream.Position = 0;
using (var tf = TeaFile <int> .OpenRead(stream))
{
tf.Items.GetEnumerator().Should().Not.Be.Null();
}
}
public void OpenWrite()
{
var filename = "TeaFileTTest_OpenWrite.tea";
using (var tf = TeaFile <int> .Create(filename))
{
tf.Count.Should().Be(0);
tf.Write(Enumerable.Range(1, 10));
tf.Count.Should().Be(10);
}
using (var tf = TeaFile <int> .OpenRead(filename))
{
tf.Items.ForEach(Console.WriteLine);
}
using (var tf = TeaFile <int> .OpenWrite(filename))
{
tf.Count.Should().Be(10);
tf.Write(Enumerable.Range(1, 5));
tf.Count.Should().Be(10);
tf.Write(Enumerable.Range(1, 5));
tf.Count.Should().Be(10);
tf.Write(Enumerable.Range(1, 5));
tf.Count.Should().Be(15);
}
Console.WriteLine("..................");
using (var tf = TeaFile <int> .OpenRead(filename))
{
tf.Items.ForEach(Console.WriteLine);
}
}
public void TimeValuesAreCorrect()
{
Time.Scale = Timescale.Net;
const string filename = "TeaFileTest_TimeValuesAreCorrect.tea";
using (var tf = TeaFile <OHLCV3> .Create(filename))
{
tf.Write(new OHLCV3 {
High = 71, Low = 20, Open = 33, Close = 21, Time = new DateTime(2000, 7, 6)
});
tf.Write(new OHLCV3 {
High = 72, Low = 20, Open = 34, Close = 22, Time = new DateTime(2000, 7, 11)
});
}
using (var tf = TeaFile.OpenRead(filename))
{
tf.Items.Count.Should().Be(2);
var timeField = tf.Description.ItemDescription.GetFieldByName("Time");
var item = tf.Read();
var time = tf.GetFieldValue(item, timeField);
time.Should().Be(new Time(2000, 7, 6));
item = tf.Read();
time = tf.GetFieldValue(item, timeField);
time.Should().Be(new Time(2000, 7, 11));
}
}
public void CreateZeroTeaFile()
{
var ms = new MemoryStream();
var tf = TeaFile <Event <OHLCV> > .Create(ms, null, null, false);
tf.Dispose();
ms.Length.Should().Be(32);
ms.Position = 0;
var r = new BinaryReader(ms);
var bom = r.ReadInt64();
bom.Should().Be(0x0d0e0a0402080500);
var itemstart = r.ReadInt64();
itemstart.Should().Be(32);
var eof = r.ReadInt64();
eof.Should().Be(0);
var sectionCount = r.ReadInt64();
sectionCount.Should().Be(0);
ms.Position = 0;
var tf2 = TeaFile.OpenRead(ms);
var d = tf2.Description;
d.ItemDescription.Should().Be.Null();
d.ContentDescription.Should().Be.Null();
d.NameValues.Should().Be.Null();
}
public void OpenWriteStream()
{
Stream stream = new MemoryStream();
using (var tf = TeaFile <int> .Create(stream))
{
tf.Write(Enumerable.Range(1, 10));
}
stream.Position = 0;
using (var tf = TeaFile <int> .OpenWrite(stream))
{
tf.Write(Enumerable.Range(70, 5));
}
stream.Position = 0;
using (var tf = TeaFile <int> .OpenRead(stream))
{
tf.Count.Should().Be(10);
tf.Read().Should().Be(70);
tf.Read().Should().Be(71);
tf.Read().Should().Be(72);
tf.Read().Should().Be(73);
tf.Read().Should().Be(74);
tf.Read().Should().Be(6);
tf.Read().Should().Be(7);
tf.Read().Should().Be(8);
tf.Read().Should().Be(9);
tf.Read().Should().Be(10);
}
}
public void ItemsT_property_has_count_0()
{
using (TeaFile <OHLCV> f = TeaFile <OHLCV> .Create(Guid.NewGuid() + "lab1.tea"))
{
var items = f.Items;
Assert.AreEqual(0, items.Count);
}
}
public void ItemsT_property_returns_value()
{
using (TeaFile <OHLCV> f = TeaFile <OHLCV> .Create(Guid.NewGuid() + "lab1.tea"))
{
var items = f.Items;
Assert.IsNotNull(items);
}
}
public void TeaFileDoesNotDisposeExternalStream()
{
var stream = new TestStream();
using (var tf = TeaFile <int> .Create(stream))
{
}
stream.WasDisposed.Should().Be.False();
}
public void AccessorRawMemoryMappingTest()
{
var filename = "TeaFileTTest_AccessorRawMemoryMappingTest.tea";
using (TeaFile <Tick> .Create(filename))
{
// an empty file holding the description is enough for this test
}
Executing.This(() => TeaFile <OHLCV> .OpenRawMemoryMapping(filename)).Should().Throw <TypeMismatchException>();
}
public void TestStreamTest()
{
TestStream stream;
using (stream = new TestStream())
using (var tf = TeaFile <int> .Create(stream))
{
}
stream.WasDisposed.Should().Be.True();
}
public void IsTimeSeriesTrue()
{
var stream = new MemoryStream();
using (var tf = TeaFile <Event <int> > .Create(stream))
{
var d = tf.Description;
d.ItemDescription.HasEventTime.Should().Be.True();
}
}
public void ItemsT_Enumerating_No_Enumeration_On_Empty_Collection()
{
using (TeaFile <OHLCV> f = TeaFile <OHLCV> .Create(Guid.NewGuid() + "lab1.tea"))
{
foreach (OHLCV ohlcv in f.Items)
{
Assert.Fail("no values are available, so no iteration should occur");
}
}
}
public void ItemsT_property_has_count_4()
{
using (TeaFile <OHLCV> f = TeaFile <OHLCV> .Create(Guid.NewGuid() + "lab1.tea"))
{
4.Times(() => f.Write(new OHLCV {
Open = 111
}));
var items = f.Items;
Assert.AreEqual(4, items.Count);
}
}
public void Flush()
{
var filename = "TeaFileTTest_Flush.tea";
var tf = TeaFile <int> .Create(filename);
tf.Write(Enumerable.Range(1, 10));
tf.Flush(); // we can easily test only that the call does not except
tf.Close();
Executing.This(tf.Flush).Should().Throw(); // and that it fails after closing the stream
}
public void DescriptionOfZeroFileIsNotNull()
{
var filename = "DescriptionTest_DescriptionOfZeroFileIsNotNull.tea";
using (TeaFile <StructA> .Create(filename))
{
}
using (var tf = TeaFile <StructA> .OpenRead(filename))
{
tf.Description.Should().Not.Be.Null();
}
}
public void TimeScaleIsSetInDescriptionOfCreatedFile()
{
var filename = "TeaFileTTest_TimeScaleIsSetInDescriptionOfCreatedFile.tea";
File.Delete(filename);
using (var tf = TeaFile <Tick> .Create(filename))
{
tf.Description.Timescale.HasValue.Should().Be.True();
tf.Description.Timescale.Value.Epoch.Should().Be(Time.Scale.Epoch);
tf.Description.Timescale.Value.TicksPerDay.Should().Be(Time.Scale.TicksPerDay);
}
}
public void TimeScaleCollisionIgnored()
{
Time.ScaleCollisionBehavior = ScaleCollisionBehavior.Ignore;
Time.Scale = Timescale.FromEpoch(2000, 1, 1, 86400);
var stream = new MemoryStream();
using (var tf = TeaFile <Event <int> > .Create(stream))
{
}
stream.Position = 0;
Time.Scale = Timescale.Net;
TeaFile.OpenRead(stream);
}
public void TimeScaleCollisionThrowsTimescaleException()
{
Time.ScaleCollisionBehavior = ScaleCollisionBehavior.ThrowException;
Time.Scale = Timescale.FromEpoch(2000, 1, 1, 86400);
var stream = new MemoryStream();
using (var tf = TeaFile <Event <int> > .Create(stream))
{
}
stream.Position = 0;
Time.Scale = Timescale.Net;
Executing.This(() => TeaFile.OpenRead(stream)).Should().Throw <TimescaleException>();
}
public void FinalizerClosesNonDisposedFile()
{
const string filename = "TeaFileTTest_FinalizerClosesNonDisposedFile.tea";
TeaFile <int> .Create(filename);
TestUtils.IsLocked(filename).Should().Be.True();
GC.Collect();
GC.WaitForPendingFinalizers();
TestUtils.IsLocked(filename).Should().Be.False();
}
public void DiscDriveFailureDuringOpenWrite()
{
var stream = new TestStream();
using (var tf = TeaFile <int> .Create(stream))
{
tf.Write(111);
}
stream.Position = 0;
stream.FailAfterPosition = 17;
Executing.This(() => TeaFile <int> .OpenWrite(stream)).Should().Throw <FileFormatException>()
.Exception.InnerException.Should().Be.OfType <IOException>();
}
public void EventTimeFieldIsNullIfNoSuchFieldExists()
{
var stream = new MemoryStream();
using (var tf = TeaFile <int> .Create(stream))
{
tf.Write(1);
}
stream.Position = 0;
using (var tf = TeaFile.OpenRead(stream))
{
tf.Description.ItemDescription.EventTimeField.Should().Be.Null();
}
}
public void TimeScaleCollisionUse()
{
Time.ScaleCollisionBehavior = ScaleCollisionBehavior.UseNewScale;
Time.Scale = Timescale.FromEpoch(2000, 1, 1, 86400);
var stream = new MemoryStream();
using (TeaFile <Event <int> > .Create(stream))
{
}
stream.Position = 0;
Time.Scale = Timescale.Net;
TeaFile.OpenRead(stream);
Time.Scale.Should().Be(Timescale.FromEpoch(2000, 1, 1, 86400));
}
public void FieldSpacingsComputation()
{
var stream = new MemoryStream();
using (var tf = TeaFile <PaddedStruct> .Create(stream))
{
}
stream.Position = 0;
using (var tf = TeaFile.OpenRead(stream))
{
var itemSize = tf.Description.ItemDescription.ItemSize;
tf.GetFieldSpacings().Should().Have.SameSequenceAs(1, 2, 5, itemSize - 15);
}
}
public void CreatedFileIsDisposed()
{
const string filename = "TeaFileTTest_CreatedFileIsDisposed.tea";
using (var tf = TeaFile <int> .Create(filename))
{
Executing.This(() => File.Move(filename, filename + "moved")).Should().Throw <IOException>();
}
File.Move(filename, filename + "moved"); // the file is movable, so it was disposed.
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
public void FlushIsCalled()
{
var stream = new TestStream();
var tf = TeaFile <int> .Create(stream);
tf.Write(Enumerable.Range(1, 10));
stream.FlushWasCalled = false; // the header was flushed already, so we reset the flag here
stream.FlushWasCalled.Should().Be.False();
tf.Flush(); // we can easily test only that the call does not except
stream.FlushWasCalled.Should().Be.True();
tf.Close();
}
public void TimeScale()
{
Time.Scale = Timescale.Java;
var stream = new MemoryStream();
using (var tf = TeaFile <Event <OHLCV> > .Create(stream))
{
tf.Write(new Event <OHLCV> {
Time = new Time(1970, 1, 1), Value = new OHLCV {
Open = 11, Close = 22
}
});
tf.Write(new Event <OHLCV> {
Time = new Time(1970, 1, 2), Value = new OHLCV {
Open = 11, Close = 22
}
});
tf.Write(new Event <OHLCV> {
Time = new Time(1970, 1, 3), Value = new OHLCV {
Open = 11, Close = 22
}
});
}
stream.Position = 0;
using (var tf = TeaFile.OpenRead(stream))
{
tf.Description.Timescale.Value.Epoch.Should().Be(719162);
tf.Description.Timescale.Value.TicksPerDay.Should().Be(Timescale.MillisecondsPerDay);
var time = tf.Description.ItemDescription.GetFieldByName("Time");
var open = tf.Description.ItemDescription.GetFieldByName("Open");
foreach (var item in tf.Items)
{
Console.WriteLine(item);
Console.WriteLine(tf.GetFieldValue(item, time));
Console.WriteLine(tf.GetFieldValue(item, open));
}
tf.GetFieldValue(tf.Items[0], time).Should().Be(new Time(1970, 1, 1));
tf.GetFieldValue(0, time).Should().Be(new Time(1970, 1, 1));
tf.GetFieldValue(1, time).Should().Be(new Time(1970, 1, 2));
tf.GetFieldValue(2, time).Should().Be(new Time(1970, 1, 3));
var t = (Time)tf.GetFieldValue(0, time);
t.Should().Be(new DateTime(1970, 1, 1));
}
}
