public virtual void TestSetAfterTimeStampWrongKind()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
try
{
DateTime dateTime = new DateTime(0, DateTimeKind.Local);
cursor.SetAfter(dateTime);
Assert.Fail("Seeking with a date time with local DateTimeKind must fail");
}
catch (ArgumentException)
{
// ok
}
try
{
DateTime dateTime = new DateTime(0, DateTimeKind.Unspecified);
cursor.SetAfter(dateTime);
Assert.Fail("Seeking with a date time with unspecified DateTimeKind must fail");
}
catch (ArgumentException)
{
// ok
}
}
public virtual void TestCurrentForIEnumerator()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
// get an IEnumerator over a time series
IEnumerator enumerator = cursor;
// check that it can move and retrieve an entry
Assert.IsTrue(enumerator.MoveNext());
ITimeSeriesEntry timeSeriesEntry1 = (ITimeSeriesEntry)enumerator.Current;
Assert.IsNotNull(timeSeriesEntry1);
// check that the IEnumerator is a correct Cursor
ITimeSeriesEntryCursor timeSeriesEntryCursor = enumerator as ITimeSeriesEntryCursor;
Assert.IsNotNull(timeSeriesEntryCursor);
Assert.IsNotNull(timeSeriesEntryCursor.Current);
// check that the corresponding cursor gets the same entry
ITimeSeriesEntry timeSeriesEntry2 = timeSeriesEntryCursor.Current;
Assert.IsTrue(TimeSeriesComparisons.CompareTimeSeriesEntry(timeSeriesEntry1, timeSeriesEntry2));
// and that it is the same entry as retrieving it from a native cursor
cursor.SetToStart();
cursor.MoveNext();
ITimeSeriesEntry timeSeriesEntry3 = cursor.Current;
Assert.IsTrue(TimeSeriesComparisons.CompareTimeSeriesEntry(timeSeriesEntry2, timeSeriesEntry3));
}
public void TestActionsOnEmptyCursor()
{
foreach (OperationsHelper.CursorOperation cursorOperation in OperationsHelper.CursorOperations)
{
ITimeSeriesEntryCursor cursor = CreateCursor();
Assert.IsNull(cursor.Current);
cursorOperation(cursor);
}
}
public void TestSetToStartAtMinValue()
{
InsertDefaultEntryByTimeStamp(MinimumTimeStamp);
ITimeSeriesEntryCursor cursor = CreateCursor();
cursor.SetToStart();
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MoveNext());
CheckEntry(cursor.Current);
}
public void TestSetToEndAtMaxValue()
{
InsertDefaultEntryByTimeStamp(MaximumTimeStamp);
ITimeSeriesEntryCursor cursor = CreateCursor();
cursor.SetToEnd();
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MovePrevious());
CheckEntry(cursor.Current);
}
public virtual void TestSetToStart()
{
InsertDefaultEntryByIndex(0);
ITimeSeriesEntryCursor cursor = CreateCursor();
cursor.Reset();
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MoveNext());
ITimeSeriesEntry entry = cursor.Current;
cursor.SetToStart();
Assert.IsTrue(cursor.MoveNext());
Assert.IsTrue(TimeSeriesComparisons.CompareTimeSeriesEntry(entry, cursor.Current));
}
public virtual void TestSetAfterFromBeforeStart()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetAfter(DefaultTimeSeries.TimeInterval.StartTime.AddTicks(-1));
Assert.IsNotNull(cursor.Current);
Assert.AreEqual(DefaultTimeSeries.TimeInterval.StartTime, cursor.Current.TimeStamp);
cursor.SetAfter(DateTimeHelper.UtcMinValue);
Assert.IsNotNull(cursor.Current);
Assert.AreEqual(DefaultTimeSeries.TimeInterval.StartTime, cursor.Current.TimeStamp);
}
public virtual void TestDoubleSetToEnd()
{
InsertDefaultEntryByIndex(0);
ITimeSeriesEntryCursor cursor = CreateCursor();
cursor.SetToEnd();
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MovePrevious());
ITimeSeriesEntry entry = cursor.Current;
cursor.SetToEnd();
Assert.IsTrue(cursor.MovePrevious());
Assert.IsTrue(TimeSeriesComparisons.CompareTimeSeriesEntry(entry, cursor.Current));
}
public virtual void TestSetAfterUnspecifiedTimeStampFails()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
try
{
cursor.SetAfter(new DateTime(DefaultTimeStamps[0], DateTimeKind.Unspecified));
Assert.Fail("SetAfter should not accept DateTime values with and Unspecified DateTimeKind.");
}
catch (ArgumentException)
{
// good
}
}
public virtual void TestSeekTimeStampBeforeStart()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
Assert.IsTrue(cursor.MoveNext());
Assert.IsNotNull(cursor.Current);
// get the first timestamp
DateTime timeStamp = cursor.Current.TimeStamp;
// try to seek before the start
Assert.IsFalse(cursor.Seek(timeStamp - new TimeSpan(100)));
Assert.IsNull(cursor.Current);
}
public virtual void TestSetAfterFromAfterEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetAfter(DefaultTimeSeries.TimeInterval.EndTime.AddTicks(1));
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MovePrevious());
Assert.AreEqual(DefaultTimeSeries.TimeInterval.EndTime, cursor.Current.TimeStamp);
cursor.SetAfter(DateTimeHelper.UtcMaxValue);
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MovePrevious());
Assert.AreEqual(DefaultTimeSeries.TimeInterval.EndTime, cursor.Current.TimeStamp);
}
public virtual void TestSetBeforeLocalTimeStampFails()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
try
{
cursor.SetBefore(new DateTime(DefaultTimeStamps[0], DateTimeKind.Local));
Assert.Fail("SetBefore should not accept DateTime values with and Local DateTimeKind.");
}
catch (ArgumentException)
{
// good
}
}
public virtual void TestSeekingMilesAfterEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
TimeSpan fullDistance = DefaultTimeSeries.TimeInterval.EndTime -
DefaultTimeSeries.TimeInterval.StartTime;
// go into the middle of the timeseries
cursor.Seek(DefaultTimeSeries.TimeInterval.StartTime + new TimeSpan(fullDistance.Ticks / 2));
Assert.IsNotNull(cursor.Current);
// seek will always step to the last valid entry
cursor.Seek(fullDistance, SeekPosition.CURRENT);
Assert.IsNotNull(cursor.Current);
Assert.IsFalse(cursor.MoveNext());
Assert.IsNull(cursor.Current);
}
public virtual void TestWalkingMilesBeforeBegin()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertDefaultEntryByIndex(0);
cursor.SetToStart();
Assert.IsNull(cursor.Current);
// you cannot reach a valid entry before the beginning
for (int i = 1; i < 20; ++i)
{
Assert.IsFalse(cursor.MovePrevious());
}
// one step must be enough to get to the first entry
Assert.IsTrue(cursor.MoveNext());
Assert.IsNotNull(cursor.Current);
}
public virtual void TestWalkingMilesAfterEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetToEnd();
Assert.IsNull(cursor.Current);
// you cannot reach a valid entry behind the end
for (int i = 1; i < 20; ++i)
{
Assert.IsFalse(cursor.MoveNext());
}
// one step must be enough to get to the last entry
Assert.IsTrue(cursor.MovePrevious());
Assert.IsNotNull(cursor.Current);
}
public void TestSeekTimeSpanSpecialValueAtEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
// show that cursor works as expected for a time series with "normal" values
cursor.Seek(TimeSpan.FromTicks(-1), SeekPosition.END); // go to second last element
Assert.IsTrue(cursor.MoveNext()); // go to last element
Assert.IsNotNull(cursor.Current);
Assert.IsFalse(cursor.MoveNext());
InsertDefaultEntryByTimeStamp(MaximumTimeStamp);
// show that cursor still works
cursor.Seek(TimeSpan.FromTicks(-1), SeekPosition.END); // go to second last element
Assert.IsTrue(cursor.MoveNext()); // go to last element
Assert.IsNotNull(cursor.Current);
Assert.IsFalse(cursor.MoveNext());
}
public virtual void TestSetAfter()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
foreach (long timeStamp in DefaultTimeStamps)
{
cursor.SetAfter(DateTimeHelper.ToDateTime(timeStamp));
Assert.IsTrue(cursor.MovePrevious());
Assert.AreEqual(timeStamp, DateTimeHelper.ToLong(cursor.Current.TimeStamp));
cursor.SetAfter(DateTimeHelper.ToDateTime(timeStamp + 1));
Assert.IsTrue(cursor.MovePrevious());
Assert.AreEqual(timeStamp, DateTimeHelper.ToLong(cursor.Current.TimeStamp));
cursor.SetAfter(DateTimeHelper.ToDateTime(timeStamp - 1));
Assert.AreEqual(timeStamp, DateTimeHelper.ToLong(cursor.Current.TimeStamp));
}
}
public virtual void TestCurrentBeforeStartOrBehindEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetToStart();
Assert.IsNull(cursor.Current);
ITimeSeriesEntry timeSeriesEntry = cursor.Current;
Assert.IsNull(timeSeriesEntry);
cursor.SetToEnd();
Assert.IsNull(cursor.Current);
timeSeriesEntry = cursor.Current;
Assert.IsNull(timeSeriesEntry);
}
public virtual void TestSeekTimeStamp()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
// seek time stamp shall return the entry with the correct time stamp
foreach (long timeStamp in DefaultTimeStamps)
{
cursor.Seek(DateTimeHelper.ToDateTime(timeStamp));
Assert.AreEqual(timeStamp, DateTimeHelper.ToLong(cursor.Current.TimeStamp));
}
// seek time stamp shall return the entry with the next smaller time stamp
foreach (long timeStamp in DefaultTimeStamps)
{
cursor.Seek(DateTimeHelper.ToDateTime(timeStamp + 1));
Assert.AreEqual(timeStamp, DateTimeHelper.ToLong(cursor.Current.TimeStamp));
}
}
public virtual void TestSeekingMilesBeforeBegin()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
TimeSpan fullDistance = DefaultTimeSeries.TimeInterval.EndTime -
DefaultTimeSeries.TimeInterval.StartTime;
// go into the middle of the timeseries
cursor.Seek(DefaultTimeSeries.TimeInterval.StartTime + new TimeSpan(fullDistance.Ticks / 2));
Assert.IsNotNull(cursor.Current);
// you cannot reach a valid entry far before the beginning
cursor.Seek(-fullDistance, SeekPosition.CURRENT);
Assert.IsNull(cursor.Current);
// one step must be enough to get to the first entry
Assert.IsTrue(cursor.MoveNext());
Assert.IsNotNull(cursor.Current);
}
public virtual void TestSetBeforeStartTime()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetBefore(DefaultTimeSeries.TimeInterval.StartTime.AddTicks(-1));
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MoveNext());
Assert.AreEqual(DefaultTimeSeries.TimeInterval.StartTime, cursor.Current.TimeStamp);
cursor.SetBefore(DateTimeHelper.ToDateTime(DateTimeHelper.ToLong(DefaultTimeSeries.TimeInterval.StartTime) / 2));
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MoveNext());
Assert.AreEqual(DefaultTimeSeries.TimeInterval.StartTime, cursor.Current.TimeStamp);
cursor.SetBefore(DateTimeHelper.UtcMinValue);
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MoveNext());
Assert.AreEqual(DefaultTimeSeries.TimeInterval.StartTime, cursor.Current.TimeStamp);
}
public void TestActionsOnDisposedCursorFails()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
Assert.IsNull(cursor.Current);
cursor.Dispose();
foreach (OperationsHelper.CursorOperation cursorOperation in OperationsHelper.CursorOperations)
{
try
{
cursorOperation(cursor);
Assert.Fail("The following operation should not work on a disposed cursor: " +
cursorOperation);
}
catch (ObjectDisposedException)
{
// ok
}
}
}
public virtual void TestSeekTimeStampBehindEnd()
{
ITimeSeriesEntryCursor cursor = CreateCursor();
InsertAllDefaultEntries();
cursor.SetToEnd();
Assert.IsNull(cursor.Current);
Assert.IsTrue(cursor.MovePrevious());
Assert.IsNotNull(cursor.Current);
// remember the entry and get its timestamp
ITimeSeriesEntry timeSeriesEntry = cursor.Current;
DateTime timeStamp = timeSeriesEntry.TimeStamp;
// try to seek behind the end; will result in pointing to the last entry (see documentation of Seek(TimeStamp))
Assert.IsTrue(cursor.Seek(timeStamp + new TimeSpan(100)));
Assert.IsNotNull(cursor.Current);
// check that we are indeed at the last entry
Assert.IsTrue(TimeSeriesComparisons.CompareTimeSeriesEntry(timeSeriesEntry, cursor.Current));
}
