public void CouldNotMoveNextPreviousOnEmpty() { var s = new AppendSeries <int, int>(); var c = s.GetCursor(); Assert.IsFalse(c.MoveNext()); Assert.IsFalse(c.MovePrevious()); Assert.IsFalse(c.MoveFirst()); Assert.IsFalse(c.MoveLast()); s.Append(1, 1); Assert.IsTrue(c.MoveNext()); Assert.IsFalse(c.MovePrevious()); Assert.IsTrue(c.MoveFirst()); Assert.IsTrue(c.MoveLast()); s.Append(2, 2); Assert.IsTrue(c.MoveNext()); Assert.AreEqual(2, c.CurrentKey); Assert.AreEqual(2, c.CurrentValue); Assert.IsTrue(c.MovePrevious()); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); Assert.IsTrue(c.MoveFirst()); Assert.IsTrue(c.MoveLast()); c.Dispose(); s.Dispose(); }
public void DeadCursorDoesNotCauseEndlessLoopInNotifyUpdate() { var s = new AppendSeries <int, int>(); s.Append(1, 1); var cursor = s.GetAsyncEnumerator(); Assert.True(cursor.MoveNext()); Assert.False(cursor.MoveNext()); cursor.MoveNextAsync(); cursor.Dispose(); cursor = default; GC.Collect(2, GCCollectionMode.Forced, true); GC.Collect(2, GCCollectionMode.Forced, true); //var t = Task.Run(() => cursor.MoveNextAsync(cts.Token)); s.Append(2, 2); s.Append(3, 3); Assert.True(s.RowCount == 3); s.Dispose(); }
public void CouldMoveAtOnNonEmpty(int count) { Assert.Fail("Need a proper MA test"); var s = new AppendSeries <int, int>(); for (int i = 1; i <= count; i++) { s.Append(i, i); } var searchValue = count / 2; // TODO all corners all directions and all inner var c = s.GetCursor(); Assert.IsTrue(c.MoveAt(searchValue, Lookup.GT)); Assert.AreEqual(searchValue + 1, c.CurrentValue); Assert.AreEqual(searchValue + 1, c.CurrentKey); Assert.IsTrue(c.MoveAt(searchValue, Lookup.GE)); Assert.IsTrue(c.MoveAt(searchValue, Lookup.EQ)); Assert.IsTrue(c.MoveAt(searchValue, Lookup.LE)); Assert.IsTrue(c.MoveAt(searchValue, Lookup.LT)); c.Dispose(); s.Dispose(); }
public async Task CouldEnumerateSMUsingCursor() { var s = new AppendSeries <int, int>(); var count = (int)TestUtils.GetBenchCount(); for (int i = 0; i < count; i++) { s.Append(i, i); } #pragma warning disable HAA0401 // Possible allocation of reference type enumerator var ae = s.GetAsyncEnumerator(); #pragma warning restore HAA0401 // Possible allocation of reference type enumerator var t = Task.Run(async() => { using (Benchmark.Run("SCM.AsyncEnumerator", count)) { var cnt = 0; while (await ae.MoveNextAsync()) { cnt++; } await ae.DisposeAsync(); Assert.AreEqual(count * 2, cnt); } Benchmark.Dump(); }); for (int i = count; i < count * 2; i++) { s.Append(i, i); } s.MarkReadOnly(); t.Wait(); s.Dispose(); }
public void CancelledCursorDoesntCauseEndlessLoopInNotifyUpdate() { var s = new AppendSeries <int, int>(); s.Append(1, 1); var c = s.GetAsyncEnumerator(); Assert.True(c.MoveNext()); Assert.False(c.MoveNext()); c.MoveNextAsync(); s.Append(2, 2); s.Append(3, 3); Assert.True(s.RowCount == 3); c.Dispose(); s.Dispose(); }
public async Task NotificationWorksWhenCursorIsNotWating() { var s = new AppendSeries <int, int>(); s.Append(1, 1); s.Append(2, 2); var c = s.GetAsyncEnumerator(); Assert.True(await c.MoveNextAsync()); Assert.True(await c.MoveNextAsync()); Assert.IsTrue(c.MovePrevious()); s.Append(3, 3); await Task.Delay(250); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); c.Dispose(); s.Dispose(); }
public async Task CouldAsyncEnumerate() { var s = new AppendSeries <int, int>(); var count = (int)TestUtils.GetBenchCount(10_000_000, 5); for (int i = 0; i < count; i++) { s.Append(i, i); } var t = Task.Run(async() => { using (Benchmark.Run("SCM.AsyncEnumerator", count)) { var cnt = 0; await foreach (var _ in s) { cnt++; } Assert.AreEqual(count * 2, cnt); } Benchmark.Dump(); }); for (int i = count; i < count * 2; i++) { s.Append(i, i); } s.MarkReadOnly(); t.Wait(); s.Dispose(); }
public void CouldMoveAtOnSingle() { Assert.Fail("Proper MA tests"); var s = new AppendSeries <int, int>(); s.Append(1, 1); var c = s.GetCursor(); Assert.IsFalse(c.MoveAt(1, Lookup.GT)); Assert.IsTrue(c.MoveAt(1, Lookup.GE)); Assert.IsTrue(c.MoveAt(1, Lookup.EQ)); Assert.IsTrue(c.MoveAt(1, Lookup.LE)); Assert.IsFalse(c.MoveAt(1, Lookup.LT)); c.Dispose(); s.Dispose(); }
public void CouldMovePreviousFromInitialized(int count) { var s = new AppendSeries <int, int>(); for (int i = 1; i <= count; i++) { s.Append(i, i); } var c = s.GetCursor(); Assert.IsTrue(c.MovePrevious()); Assert.AreEqual(count, c.CurrentKey); Assert.AreEqual(count, c.CurrentValue); c.Dispose(); s.Dispose(); }
public void CouldMoveFirstLast(int count) { var s = new AppendSeries <int, int>(); for (int i = 1; i <= count; i++) { s.Append(i, i); } SCursor <int, int> c; c = s.GetCursor(); Assert.IsTrue(c.MoveFirst()); Assert.IsTrue(c.MoveLast()); c.Dispose(); c = s.GetCursor(); Assert.IsTrue(c.MoveLast()); Assert.IsTrue(c.MoveFirst()); c.Dispose(); s.Dispose(); }
public async Task CouldEnumerateSCMUsingCursor() { var s = new AppendSeries <int, int>(); var count = 1_000_000; // Settings.SCMDefaultChunkLength - 1; for (int i = 0; i < count; i++) { s.Append(i, i); } Console.WriteLine("Added first half"); #pragma warning disable HAA0401 // Possible allocation of reference type enumerator var ae = s.GetAsyncEnumerator(); #pragma warning restore HAA0401 // Possible allocation of reference type enumerator var t = Task.Run(async() => { using (Benchmark.Run("SCM.AsyncEnumerator", count)) { try { var cnt = 0; while (await ae.MoveNextAsync()) { if (cnt != ae.Current.Key) { ThrowHelper.ThrowInvalidOperationException(); } cnt++; } await ae.DisposeAsync(); } catch (Exception ex) { Console.WriteLine("EXCEPTION: " + ex.ToString()); throw; } // Assert.AreEqual(scm.Count, cnt); } Benchmark.Dump(); }); // Thread.Sleep(1000); for (int i = count; i < count * 2; i++) { s.Append(i, i); //Thread.SpinWait(50); } // Thread.Sleep(2000); s.MarkReadOnly(); t.Wait(); s.Dispose(); }
public void CouldMovePartialFromMoving(int count) { var s = new AppendSeries <int, int>(); for (int i = 1; i <= count; i++) { s.Append(i, i); } SCursor <int, int> c; c = s.GetCursor(); c.MoveNext(); Assert.AreEqual(count - 1, c.Move(count * 2, true)); Assert.AreEqual(count, c.CurrentKey); Assert.AreEqual(count, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MoveNext(); Assert.AreEqual(count - 1, c.Move(count * 200, true)); Assert.AreEqual(count, c.CurrentKey); Assert.AreEqual(count, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MoveNext(); Assert.AreEqual(count - 1, c.Move(count + 1, true)); Assert.AreEqual(count, c.CurrentKey); Assert.AreEqual(count, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MoveNext(); Assert.AreEqual(count - 1, c.Move(count, true)); Assert.AreEqual(count, c.CurrentKey); Assert.AreEqual(count, c.CurrentValue); c.Dispose(); // --------- c = s.GetCursor(); c.MovePrevious(); Assert.AreEqual(-count + 1, c.Move(-count * 2, true)); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MovePrevious(); Assert.AreEqual(-count + 1, c.Move(-count * 200, true)); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MovePrevious(); Assert.AreEqual(-count + 1, c.Move(-(count + 1), true)); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); c.Dispose(); c = s.GetCursor(); c.MovePrevious(); Assert.AreEqual(-count + 1, c.Move(-count, true)); Assert.AreEqual(1, c.CurrentKey); Assert.AreEqual(1, c.CurrentValue); c.Dispose(); s.Dispose(); }