public void RollingHashCalculator1Test()
        {
            var r = new RollingHashCalculator <int>(1, 256, 101);

            r.Add(7);
            Assert.AreEqual(7, r.HashCode);

            r.Add(17);
            Assert.AreEqual(17, r.HashCode);
        }
        public void RollingHashCalculator3Test()
        {
            var r = new RollingHashCalculator <int>(3, 256, 101);

            //"abr"
            r.Add(97);
            r.Add(98);
            r.Add(114);
            Assert.AreEqual(4, r.HashCode);

            //"bra"
            r.Add(97);
            Assert.AreEqual(30, r.HashCode);

            // back to "abr"
            r.Add(98);
            r.Add(114);
            Assert.AreEqual(4, r.HashCode);
        }
        public void SequenceEqualTest()
        {
            var r = new RollingHashCalculator <int>(4, 2048, 10007);

            r.Add(8);
            r.Add(316);
            r.Add(76);
            r.Add(130);

            var s = new RollingHashCalculator <int>(4, 2048, 10007);

            s.Add(8);
            s.Add(316);
            s.Add(76);
            s.Add(130);

            Assert.IsTrue(r.Components.SequenceEqual(s.Components));
            Assert.AreEqual(r.HashCode, s.HashCode);
        }
        public void RollingHashCalculator2Test(int b, int m, int val1, int val2, int result)
        {
            var r = new RollingHashCalculator <int>(2, b, m);

            r.Add(val1);
            r.Add(val2);
            Assert.AreEqual(result, r.HashCode);

            // If we flush it other stuff, the hash should be something else
            r.Add(5);
            r.Add(120);
            Assert.AreNotEqual(result, r.HashCode);


            // If we flush "hi" back in, the hash should come back.
            r.Add(val1);
            r.Add(val2);
            Assert.AreEqual(result, r.HashCode);
        }
        public void KnownCollisionTest()
        {
            var r = new RollingHashCalculator <int>(30, 2048, 10007);

            r.Add(8);
            r.Add(316);
            r.Add(76);
            r.Add(130);
            r.Add(9);
            r.Add(150);
            r.Add(162);
            r.Add(316);
            r.Add(8);
            r.Add(316);
            r.Add(8);
            r.Add(316);
            r.Add(9);
            r.Add(9);
            r.Add(20);
            r.Add(133);
            r.Add(8);
            r.Add(124);
            r.Add(26);
            r.Add(316);
            r.Add(8);
            r.Add(316);
            r.Add(9);
            r.Add(9);
            r.Add(150);
            r.Add(162);
            r.Add(316);
            r.Add(8);
            r.Add(316);
            r.Add(8);

            var s = new RollingHashCalculator <int>(30, 2048, 10007);

            s.Add(316);
            s.Add(170);
            s.Add(316);
            s.Add(9);
            s.Add(13);
            s.Add(133);
            s.Add(8);
            s.Add(316);
            s.Add(26);
            s.Add(316);
            s.Add(8);
            s.Add(316);
            s.Add(26);
            s.Add(316);
            s.Add(24);
            s.Add(169);
            s.Add(316);
            s.Add(316);
            s.Add(9);
            s.Add(9);
            s.Add(13);
            s.Add(133);
            s.Add(8);
            s.Add(2);
            s.Add(316);
            s.Add(26);
            s.Add(316);
            s.Add(8);
            s.Add(316);
            s.Add(26);

            Assert.IsFalse(r.Components.SequenceEqual(s.Components));
            Assert.AreEqual(r.HashCode, s.HashCode);
        }