Пример #1
0
        public void TryFindValueReportsProgressBestCase()
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string>[] {
                new KeyValuePair <long, string>(-3, "0"),
                new KeyValuePair <long, string>(-1, "C"),
                new KeyValuePair <long, string>(0, "B"),
                new KeyValuePair <long, string>(1, "A"),
                new KeyValuePair <long, string>(3, "Value"),
                new KeyValuePair <long, string>(4, "A"),
                new KeyValuePair <long, string>(400, "E"),
                new KeyValuePair <long, string>(401, "F"),
                new KeyValuePair <long, string>(405, "G"),
            };

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            List <ProgressReport> gotReports = new List <ProgressReport>();
            ProgressReporter      reporter   = new ProgressReporter((x) => {
                gotReports.Add(x);
            });

            Assert.IsTrue(searchable.TryFindValue(3, out var value, reporter));
            Assert.AreEqual(sample[4].Value, value);
            long complexity = 4;

            CollectionAssert.AreEquivalent(new ProgressReport[] {
                new ProgressReport(1, complexity),
                new ProgressReport(complexity, complexity),//Jumps to full progress when found early
            }, gotReports);
        }
Пример #2
0
        public void TryFindFloorReportsProgress_FixedSample2()
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string>[] {
                new KeyValuePair <long, string>(-3, "0"),
                new KeyValuePair <long, string>(-1, "C"),
                new KeyValuePair <long, string>(0, "B"),
                new KeyValuePair <long, string>(1, "A"),
                new KeyValuePair <long, string>(3, "Value"),
                new KeyValuePair <long, string>(5, "A"),
                new KeyValuePair <long, string>(400, "E"),
                new KeyValuePair <long, string>(401, "F"),
                new KeyValuePair <long, string>(405, "G"),
            };

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            List <ProgressReport> gotReports = new List <ProgressReport>();
            ProgressReporter      reporter   = new ProgressReporter((x) => {
                gotReports.Add(x);
            });

            Assert.IsTrue(searchable.TryFindFloor(4, out long index, out long key, reporter));
            Assert.AreEqual(4, index);
            Assert.AreEqual(sample[4].Key, key);
            long complexity = 4;

            CollectionAssert.AreEquivalent(new ProgressReport[] {
                new ProgressReport(1, complexity),
                new ProgressReport(2, complexity),
                new ProgressReport(3, complexity),
                new ProgressReport(4, complexity),
            }, gotReports);
        }
Пример #3
0
        public void TryFindValueWorks(long count)
        {
            MockBinarySearchable searchable = new MockBinarySearchable(count, 5);

            foreach (var key in searchable.SortedList.Keys)
            {
                Assert.IsTrue(BinarySearch.TryFindValue(searchable, key, out var value));
                Assert.AreEqual(searchable.SortedList[key], value);
            }
        }
Пример #4
0
        public void TryFindIndexWorks(long count)
        {
            MockBinarySearchable searchable = new MockBinarySearchable(count, 5);

            foreach (var key in searchable.SortedList.Keys)
            {
                Assert.IsTrue(BinarySearch.TryFindIndex(searchable, key, out long index));
                Assert.AreEqual(key, searchable.GetKeyAt(index));
            }
        }
Пример #5
0
        public void TryFindIndexFailsWhenNotKeyNotPresent(long count)
        {
            long[] badKeys = new long[] { 1, 2, 5, 6, 7, 10, long.MaxValue, long.MinValue };
            MockBinarySearchable searchable = new MockBinarySearchable(count, 5, badKeys);

            foreach (var badKey in badKeys)
            {
                Assert.IsFalse(BinarySearch.TryFindIndex(searchable, badKey, out long index));
                Assert.AreEqual(-1, index);
            }
        }
Пример #6
0
        public void TryFindFloorFailsWhenNotFound(long count)
        {
            MockBinarySearchable searchable = new MockBinarySearchable(count, 5);

            //Find a 'bad' key (one that is lower than the lowest)
            long badKey = searchable.Count > 0 ? (searchable.SortedList.Keys.Min() - 1) : -1;

            Assert.IsFalse(BinarySearch.TryFindFloor(searchable, badKey, out long index, out var key));
            Assert.AreEqual(-1, index);
            Assert.AreEqual(default(long), key);
        }
Пример #7
0
        public void TryFindValueFailsWhenNotKeyNotPresent(long count)
        {
            long[] badKeys = new long[] { 1, 2, 5, 6, 7, 10, long.MaxValue, long.MinValue };
            MockBinarySearchable searchable = new MockBinarySearchable(count, 5, badKeys);

            foreach (var badKey in badKeys)
            {
                Assert.IsFalse(BinarySearch.TryFindValue(searchable, badKey, out var value));
                Assert.IsNull(value);
            }
        }
Пример #8
0
        public void TryFindFloorCanBeCancelled()
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string>[] {
                new KeyValuePair <long, string>(-3, "0"),
                new KeyValuePair <long, string>(-1, "C"),
                new KeyValuePair <long, string>(0, "B"),
                new KeyValuePair <long, string>(1, "A"),
                new KeyValuePair <long, string>(3, "Value"),
                new KeyValuePair <long, string>(4, "A"),
                new KeyValuePair <long, string>(400, "E"),
                new KeyValuePair <long, string>(401, "F"),
                new KeyValuePair <long, string>(405, "G"),
            };

            MockBinarySearchable    searchable   = new MockBinarySearchable(sample);
            CancellationTokenSource cancellation = new CancellationTokenSource();
            List <ProgressReport>   gotReports   = new List <ProgressReport>();
            ProgressReporter        reporter     = new ProgressReporter((x) => {
                gotReports.Add(x);
                if (gotReports.Count == 2)
                {
                    cancellation.Cancel();
                }
                if (gotReports.Count > 2)
                {
                    Assert.Fail("Expected all progress to stop after the cancellation request.");
                }
            });

            Assert.IsFalse(searchable.TryFindFloor(2, out var index, out var key, reporter, cancellation.Token));
            Assert.AreEqual(-1, index);          //Search was cancelled, index not found
            Assert.AreEqual(default(long), key); //Search was cancelled, key not found
            long complexity = 4;

            CollectionAssert.AreEquivalent(new ProgressReport[] {
                new ProgressReport(1, complexity),
                new ProgressReport(2, complexity),
                //Expect cancellation here, so no more progress reports
            }, gotReports);
        }
Пример #9
0
        public void TryFindValueWorked_FixedSample2()
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string>[] {
                new KeyValuePair <long, string>(-102, "_"),
                new KeyValuePair <long, string>(0, "A"),
                new KeyValuePair <long, string>(1, "B"),
                new KeyValuePair <long, string>(2, "C"),
                new KeyValuePair <long, string>(4, "D"),
                new KeyValuePair <long, string>(8, "E"),
                new KeyValuePair <long, string>(10, "F"),
                new KeyValuePair <long, string>(13, "G"),
                new KeyValuePair <long, string>(1024, "H"),
            };

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            for (long i = 0; i < sample.LongLength; i++)
            {
                Assert.IsTrue(BinarySearch.TryFindValue(searchable, sample[i].Key, out var gotValue));
                Assert.AreEqual(sample[i].Value, gotValue);
            }
        }
Пример #10
0
        public void TryFindIndexWorked_FixedSample1()
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string>[] {
                new KeyValuePair <long, string>(-3, "0"),
                new KeyValuePair <long, string>(-1, "C"),
                new KeyValuePair <long, string>(0, "B"),
                new KeyValuePair <long, string>(1, "A"),
                new KeyValuePair <long, string>(3, "Value"),
                new KeyValuePair <long, string>(4, "A"),
                new KeyValuePair <long, string>(400, "E"),
                new KeyValuePair <long, string>(401, "F"),
                new KeyValuePair <long, string>(405, "G"),
            };

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            for (long i = 0; i < sample.LongLength; i++)
            {
                Assert.IsTrue(BinarySearch.TryFindIndex(searchable, sample[i].Key, out long gotIndex));
                Assert.AreEqual(i, gotIndex);
            }
        }
Пример #11
0
        public void TryFindCeilingWorks(long count)
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string> [count];
            for (long i = 0; i < count; i++)
            {
                sample[i] = new KeyValuePair <long, string>((i - 5) * 100, "Value_" + i);
            }

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            //Find the first key that is greater than a key less than the first one (basically: Find the first key)
            Assert.IsTrue(BinarySearch.TryFindCeiling <long, string>(searchable, sample[0].Key - 1, out long index_, out long gotKey_));
            Assert.AreEqual(0, index_);
            Assert.AreEqual(sample[0].Key, gotKey_);

            for (long i = 0; i < count; i++)
            {
                //Find an 'equal' key
                Assert.IsTrue(BinarySearch.TryFindCeiling <long, string>(searchable, sample[i].Key, out long index, out long gotKey));
                Assert.AreEqual(i, index);
                Assert.AreEqual(sample[i].Key, gotKey);

                if (i < count - 1)
                {
                    //Find the first 'greater' key
                    Assert.IsTrue(BinarySearch.TryFindCeiling <long, string>(searchable, sample[i].Key + 1, out index, out gotKey));
                    Assert.AreEqual(i + 1, index);
                    Assert.AreEqual(sample[i + 1].Key, gotKey);
                }
                else
                {
                    //There is no 'greater' key, so ensure it returns false
                    Assert.IsFalse(BinarySearch.TryFindCeiling <long, string>(searchable, sample[i].Key + 1, out index, out gotKey));
                    Assert.AreEqual(-1, index);
                    Assert.AreEqual(default(long), gotKey);
                }
            }
        }
Пример #12
0
        public void TryFindFloorWorks(long count)
        {
            KeyValuePair <long, string>[] sample = new KeyValuePair <long, string> [count];
            for (long i = 0; i < count; i++)
            {
                sample[i] = new KeyValuePair <long, string>((i - 5) * 100, "Value_" + i);
            }

            MockBinarySearchable searchable = new MockBinarySearchable(sample);

            //There is no 'lower' key than the first
            Assert.IsFalse(BinarySearch.TryFindFloor <long, string>(searchable, sample[0].Key - 1, out long index_, out long gotKey_));
            Assert.AreEqual(-1, index_);
            Assert.AreEqual(default(long), gotKey_);

            for (long i = 0; i < count; i++)
            {
                //Find an 'equal' key
                Assert.IsTrue(BinarySearch.TryFindFloor <long, string>(searchable, sample[i].Key, out long index, out long gotKey));
                Assert.AreEqual(i, index);
                Assert.AreEqual(sample[i].Key, gotKey);

                if (i > 0)
                {
                    //Find the first 'lower' key
                    Assert.IsTrue(BinarySearch.TryFindFloor <long, string>(searchable, sample[i].Key - 1, out index, out gotKey));
                    Assert.AreEqual(i - 1, index);
                    Assert.AreEqual(sample[i - 1].Key, gotKey);
                }
            }

            //Find a key lower than a key that is greater than the highest (basically: Find the last key)
            Assert.IsTrue(BinarySearch.TryFindFloor <long, string>(searchable, sample[count - 1].Key + 1, out index_, out gotKey_));
            Assert.AreEqual(count - 1, index_);
            Assert.AreEqual(sample[count - 1].Key, gotKey_);
        }