public static void AssertProgressUpdateWasCalledRightNumberOfTimes(this ICorrelater <string> correlater) { var array1 = new[] { "A", "D", "B", "C" }; var array2 = new[] { "A", "B", "D", "C" }; correlater.AssertProgressUpdateWasCalledRightNumberOfTimes(array1, array2, array1.Length + 1); }
public static void AsseertCancellationTokenWorks(this ICorrelater <char> correlater) { var string1 = Utils.GetLongString(10_000); var string2 = Utils.GetLongString(10_000); correlater.AsseertCancellationTokenWorks(string1, string2); }
public IgnoreIdenticalBeginningAndEndCorrelaterWrapper(ICorrelater <T> innerCorrelater) { this.innerCorrelater = innerCorrelater; innerCorrelater.OnProgressUpdate += (p, t) => OnProgressUpdate?.Invoke(p, t); if (innerCorrelater is IContinuousCorrelater <T> continuousCorrelater) { continuousCorrelater.OnResultUpdate += r => OnResultUpdate?.Invoke(r); } }
/// <summary> /// SplitToChunksCorrelaterWrapper improves the correlation's performance by splitting the collection or string into chunks, and correlates each chunk individually. /// </summary> /// <param name="chunkSize">Bigger chunks will result in a slower, but more accurate correlation</param> /// <param name="maxDistance">If at any point during the correlation we find that the distance will be greater than maxDistance, we'll terminate the correlation and return null</param> public SplitToChunksCorrelaterWrapper(ICorrelater <T> innerCorrelater, int chunkSize, long maxDistance) : this(innerCorrelater, chunkSize) { if (maxDistance <= 0) { throw new ArgumentException($"{nameof(maxDistance)} must be greater than zero", nameof(maxDistance)); } this.maxDistance = maxDistance; }
/// <summary> /// SplitToChunksCorrelaterWrapper improves the correlation's performance by splitting the collection or string into chunks, and correlates each chunk individually. /// </summary> /// <param name="chunkSize">Bigger chunks will result in a slower, but more accurate correlation</param> public SplitToChunksCorrelaterWrapper(ICorrelater <T> innerCorrelater, int chunkSize) { if (chunkSize <= 0) { throw new ArgumentException($"{nameof(chunkSize)} must be greater than zero", nameof(chunkSize)); } this.chunkSize = chunkSize; this.innerCorrelater = innerCorrelater; maxEdgeSize = chunkSize / 2; }
public static void AssertProgressUpdateWasCalledRightNumberOfTimes <T>(this ICorrelater <T> correlater, T[] array1, T[] array2, int expectedProgress) { var progressUpdates = 0; correlater.OnProgressUpdate += (progress, outOf) => { Assert.AreEqual(expectedProgress, outOf); Interlocked.Increment(ref progressUpdates); Assert.AreEqual(progressUpdates, progress); }; correlater.Correlate(array1, array2); Assert.AreEqual(expectedProgress, progressUpdates); }
public static void AssetThrowsNullElementException <T>(this ICorrelater <T> correlater, IEnumerable <T> collection1, IEnumerable <T> collection2, string badCollectionName, int nullIndex) { try { correlater.Correlate(collection1, collection2); Assert.Fail("Exception wasn't thrown"); } catch (NullElementException e) { Assert.IsTrue(e.Message.Contains(badCollectionName)); Assert.IsTrue(e.Message.Contains($"index {nullIndex}")); } }
public static void AsseertCancellationTokenWorks <T>(this ICorrelater <T> correlater, IEnumerable <T> collection1, IEnumerable <T> collection2) { try { var cancellationTokenSource = new CancellationTokenSource(); var task = Task.Run(() => correlater.Correlate(collection1, collection2, cancellationTokenSource.Token)); cancellationTokenSource.Cancel(); task.Wait(TimeSpan.FromSeconds(1)); Assert.Fail("The task doesn't seem to have stopped"); } catch (Exception e) when(e is AggregateException) { var innerException = e.InnerException; while (innerException is AggregateException aggregateException) { innerException = aggregateException.InnerException; } Assert.AreEqual(typeof(OperationCanceledException), innerException.GetType()); } }
public SplitByPatienceAlgorithmWrapper(ICorrelater <T> innerCorrelater, bool multiThread = true) { this.innerCorrelater = innerCorrelater; this.multiThread = multiThread; }
public static void SetToRetrun <T>(this ICorrelater <T> correlater, Func <IEnumerable <T>, IEnumerable <T> > func1, Func <IEnumerable <T>, IEnumerable <T> > func2, int distance = 0) { A.CallTo(() => correlater.Correlate(A <IEnumerable <T> > ._, A <IEnumerable <T> > ._, A <CancellationToken> ._)) .ReturnsLazily((IEnumerable <T> c1, IEnumerable <T> c2, CancellationToken ct) => new CorrelaterResult <T>(distance, func1(c1).ToArray(), func2(c2).ToArray())); }
public static void SetToRetrunInputCollection <T>(this ICorrelater <T> correlater, int distance) { A.CallTo(() => correlater.Correlate(A <IEnumerable <T> > ._, A <IEnumerable <T> > ._, A <CancellationToken> ._)) .ReturnsLazily((IEnumerable <T> c1, IEnumerable <T> c2, CancellationToken ct) => new CorrelaterResult <T>(distance, c1.ToArray(), c2.ToArray())); }
public SlowCorrelater(ICorrelater <T> innerCorrelater, int sleepTime) { this.innerCorrelater = innerCorrelater; innerCorrelater.OnProgressUpdate += (p, t) => OnProgressUpdate?.Invoke(t, p); this.sleepTime = sleepTime; }
public StringCorrelatorUserControl() { correlater = new LevenshteinCorrelater <char>(10, 7, 7); InitializeComponent(); }
public static void AssertComparision <T>(this ICorrelater <T> correlater, IEnumerable <T> collection1, IEnumerable <T> collection2, CorrelaterResult <T> expectedResult) { var result = correlater.Correlate(collection1, collection2); AssertResultIsAsExpected(expectedResult, result); }