Пример #1
0
        public bool PolynomialTest_CheckOverrideGetHashCode()
        {
            Polynomial elementFirst  = new Polynomial(new double[] { 7, 5, 9 });
            Polynomial elementSecond = new Polynomial(new double[] { 7, 5, 9 });

            return(elementFirst.GetHashCode() == elementFirst.GetHashCode());
        }
        public void GetHashCode_EqualPolynomials_EqualHash()
        {
            Polynomial a = Polynomial1;
            Polynomial b = Polynomial1;

            Console.WriteLine($"{a.GetHashCode()}\t{b.GetHashCode()}");
            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
        }
        public void GetHashCode_DifferentPolynomes_DifferentHash()
        {
            Polynomial a = Polynomial1;
            Polynomial b = GetPolynomial2();

            Console.WriteLine($"{a.GetHashCode()}\t{b.GetHashCode()}");
            Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
        }
Пример #4
0
        public void Polynomial_GetHashCode_Test()
        {
            Polynomial a = new Polynomial(1, 2, 3, 4);
            Polynomial b = new Polynomial(1, 2, 3, 4);
            Polynomial c = new Polynomial(1, 2, 3);

            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
            Assert.AreNotEqual(a.GetHashCode(), c.GetHashCode());
        }
Пример #5
0
        public void GetHashCode_TwoPolynomsAreEqual_HashCodesAreEqual(double[] coefs1, double[] coefs2)
        {
            var polynomial1 = new Polynomial(coefs1);
            var polynomial2 = new Polynomial(coefs2);

            Assert.AreEqual(polynomial1.GetHashCode(), polynomial2.GetHashCode());
        }
Пример #6
0
        public void GetHashCode_ALotOfCoefficients_HashCodesAreEqual(double[] coefs1, double[] coefs2)
        {
            var polynomial1 = new Polynomial(coefs1);
            var polynomial2 = new Polynomial(coefs2);

            Assert.AreEqual(polynomial1.GetHashCode(), polynomial2.GetHashCode());
        }
Пример #7
0
        public void GetHashCode_BigNumbersAndPolynomsAreDifferent_HashCodesAreEqual(double[] coefs1, double[] coefs2)
        {
            var polynomial1 = new Polynomial(coefs1);
            var polynomial2 = new Polynomial(coefs2);

            Assert.AreEqual(polynomial1.GetHashCode(), polynomial2.GetHashCode());
        }
Пример #8
0
        public bool Polinoms_GetHashcodeOverload_Test(double[] first, double[] second)
        {
            Polynomial firstPoly  = new Polynomial(first);
            Polynomial secondPoly = new Polynomial(second);

            return(firstPoly.GetHashCode() == secondPoly.GetHashCode());
        }
        public void GetHashCode_SameObject_SameHashCode()
        {
            var polynom1 = new Polynomial(2.01, 2.02);
            var polynom2 = new Polynomial(2.01, 2.02);

            Assert.IsTrue(polynom1.GetHashCode() == polynom2.GetHashCode());
        }
        public void GetHashCodeTest()
        {
            Polynomial polynom1 = new Polynomial(2, 5, 3, 6);
            Polynomial polynom2 = new Polynomial(1, 8, 3, 6);

            Assert.AreNotEqual(polynom1.GetHashCode(), polynom2.GetHashCode());
        }
Пример #11
0
        public void GetHashCodeTests_DifferentPolynomials_Returns_DifferentHashCodes()
        {
            Polynomial p1 = new Polynomial(new double[] { -1.0d, 0, 1.0d });
            Polynomial p2 = new Polynomial(new double[] { 5.0d, 0, 1.0d, 5.0d });

            Assert.IsFalse(p1.GetHashCode() == p2.GetHashCode());
        }
        public bool PolynomialsGetHashCodeTest(double[] coefficientsFirst, double[] coefficientsSecond)
        {
            var first  = new Polynomial(coefficientsFirst);
            var second = new Polynomial(coefficientsSecond);

            return(first.GetHashCode() == second.GetHashCode());
        }
        public void GetHashCode_DifferentPolynomials_DifferentHashCodes()
        {
            var p1 = new Polynomial(new int[] { 1, 2, 3 });
            var p2 = new Polynomial(new int[] { 1, 2, 0 });

            Assert.AreNotEqual(p1.GetHashCode(), p2.GetHashCode());
        }
        public static void Polynomial_GetHashCode_Equal(double[] array1, double[] array2)
        {
            Polynomial p1 = new Polynomial(array1);
            Polynomial p2 = new Polynomial(array2);

            Assert.AreEqual(p1.GetHashCode(), p2.GetHashCode());
        }
        public static void Polynomial_GetHashCode_Array()
        {
            double[]   array = new double[] { 1, 2 };
            Polynomial p1    = new Polynomial(array);

            Assert.AreNotEqual(p1.GetHashCode(), array.GetHashCode());
        }
        public void GetHashCode_GivenEqualsPolynomial_ReturnsTheSamrResult()
        {
            var poly1 = new Polynomial(-5, -8, -5);
            var poly2 = new Polynomial(-5, -8, -5);

            Assert.AreEqual(poly1.GetHashCode(), poly2.GetHashCode());
        }
Пример #17
0
        public static void GetHashCodeTests(double[] array)
        {
            Polynomial irstPolynomial   = new Polynomial(array);
            Polynomial secondPolynomial = new Polynomial(array);

            Assert.True(irstPolynomial.GetHashCode() == secondPolynomial.GetHashCode());
        }
        public void GetHashCodeOverridedMethod_TwoEqualsArrays_EqualsValue(double[] coefficientsFirst, double[] coefficientsSecond)
        {
            Polynomial testPolynomialFirst  = new Polynomial(coefficientsFirst);
            Polynomial testPolynomialSecond = new Polynomial(coefficientsSecond);

            Assert.AreEqual(testPolynomialFirst.GetHashCode(), testPolynomialSecond.GetHashCode());
        }
Пример #19
0
        public void GetHashCodeTests_SamePolynomials_Returns_SameHashCodes()
        {
            Polynomial p1 = new Polynomial(new double[] { 1.0d, 1.0d, 1.0d });
            Polynomial p2 = new Polynomial(new double[] { 1.0d, 1.0d, 1.0d });

            Assert.IsTrue(p1.GetHashCode() == p2.GetHashCode());
        }
        public static void Polynomial_GetHashCode_OneArray()
        {
            double[]   array = new double[] { 1, 2 };
            Polynomial p1    = new Polynomial(array);
            Polynomial p2    = new Polynomial(array);

            Assert.AreEqual(p1.GetHashCode(), p2.GetHashCode());
        }
Пример #21
0
        public void GetHashCode_CopmparisonHashCodesOfUnEqualPolynoms_ReturnFalse(double[] first, double[] second)
        {
            // Arange
            Polynomial p1 = new Polynomial(first);
            Polynomial p2 = new Polynomial(second);

            // Act - Assert
            Assert.IsFalse(p1.GetHashCode() == p2.GetHashCode());
        }
Пример #22
0
        public void PolynomialTest_EqualsTest_NotSamePolynomials()
        {
            var  p1      = new Polynomial(3.7, 12.2, 6.4);
            var  p2      = new Polynomial(3.7, 12.1, 6.4);
            bool result1 = p1.Equals(p2);
            bool result2 = p1.GetHashCode() == p2.GetHashCode();

            Assert.AreEqual(false, result1);
            Assert.AreEqual(false, result2);
        }
Пример #23
0
        public void GetHashCodeTest(int expected, params double[] coeffs)
        {
            // Arrange
            Polynomial polynomial = new Polynomial(coeffs);

            // Act
            int actual = polynomial.GetHashCode();

            // Assert
            Assert.AreEqual(expected, actual);
        }
        public void Override_GetHashCode(double[] inputCoefficientArrayFirst, double[] inputCoefficientArraySecond, bool result)
        {
            var polynomialFirst = new Polynomial(inputCoefficientArrayFirst);

            var polynomialSecond = new Polynomial(inputCoefficientArraySecond);

            var hashCodeFirst = polynomialFirst.GetHashCode();

            var hashCodeSecond = polynomialSecond.GetHashCode();

            Assert.AreEqual((hashCodeFirst == hashCodeSecond), result);
        }
Пример #25
0
        public void PolynomialTest_GetHasCode()
        {
            int[]      degrees     = new int[] { 3, 1, 0, 0 };
            double[]   coeficients = new double[] { 2, 7, -5, -5 };
            Polynomial polynomial1 = new Polynomial(coeficients, degrees);

            int[]      degrees2     = new int[] { 1, 0, 0, 3 };
            double[]   coeficients2 = new double[] { 7, -5, -5, 2 };
            Polynomial polynomial2  = new Polynomial(coeficients, degrees);

            Assert.AreEqual(polynomial1.GetHashCode(), polynomial2.GetHashCode());
        }
Пример #26
0
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = Size.GetHashCode();
         hashCode = (hashCode * 397) ^ Polynomial.GetHashCode();
         hashCode = (hashCode * 397) ^ InitialValue.GetHashCode();
         hashCode = (hashCode * 397) ^ FinalXorValue.GetHashCode();
         hashCode = (hashCode * 397) ^ ReflectInput.GetHashCode();
         hashCode = (hashCode * 397) ^ ReflectOutput.GetHashCode();
         hashCode = (hashCode * 397) ^ ExpectedCheck.GetHashCode();
         return(hashCode);
     }
 }
        public void GetHashCode_AreEqualExpected()
        {
            // arrange
            int expected = new Polynomial(new double[]
            {
                20.2, 11.2, 44.1, 0, 11
            }).GetHashCode();

            // act
            int actual = firstPolynomial.GetHashCode();

            // assert
            Assert.AreEqual(expected, actual);
        }
        public void Constructor_Polynomial_Expected_OverflowException()
        {
            Random random = new Random();

            var inputArray = new double[random.Next(1000000)];

            for (int i = 0; i < inputArray.Length; i++)
            {
                inputArray[i] = random.Next(-1000000, 1000000);
            }

            var polynomial = new Polynomial(inputArray);

            Assert.Throws <OverflowException>(() => polynomial.GetHashCode());
        }
Пример #29
0
        public void TestGetHashCode_Polynomial_HeshCode(
            [Values(-9, -1, 0, 1, 9)] int a,
            [Values(-9, -1, 0, 1, 9)] int b,
            [Values(-9, -1, 0, 1, 9)] int c,
            [Values(-9, -1, 0, 1, 9)] int d,
            [Values(-9, -1, 0, 1, 9)] int e,
            [Values(-9, -1, 0, 1, 9)] int f
            )
        {
            int[]      firstCoefficients  = { a, b, c };
            int[]      secondCoefficients = { d, e, f };
            Polynomial first    = new Polynomial(firstCoefficients);
            Polynomial second   = new Polynomial(secondCoefficients);
            bool       expected = first.Equals(second);

            bool actual = first.GetHashCode() == second.GetHashCode();

            Assert.AreEqual(expected, actual);
        }
Пример #30
0
        public void HashCodeTests()
        {
            var p1 = new Polynomial(new RationalNumber[] { 1 }, XName);
            var p2 = new Polynomial(new RationalNumber[] { 1 }, XName);

            Assert.IsTrue(p1.GetHashCode() == p2.GetHashCode());


            var p3 = new Polynomial(new RationalNumber[] { 7, -3, 5 }, XName);
            var p4 = new Polynomial(new RationalNumber[] { 15, -13, 0, 3, 0, -6, 32 }, XName);

            Assert.IsFalse(p3.GetHashCode() == p4.GetHashCode());


            var p5 = new Polynomial(GetRepeatCoefficients(new RationalNumber(1, 3), 5), XName);
            var p6 = new Polynomial(GetRepeatCoefficients(new RationalNumber(2, 3), 5), XName);

            Assert.IsFalse(p5.GetHashCode() == p6.GetHashCode());


            var p7 = new Polynomial(new RationalNumber[] { 1, 2, 0, 1 }, YName);
            var p8 = new Polynomial(new RationalNumber[] { 1, 2, 0, 1, 0, 0, 0 }, YName);

            Assert.IsTrue(p7.GetHashCode() == p8.GetHashCode());


            var p9 = new Polynomial(new RationalNumber[] { 1, 2, 0, 1 }, YName);

            p9 -= p9;
            var p10 = new Polynomial(new RationalNumber[] { 0 }, YName);

            Assert.IsTrue(p9.GetHashCode() == p10.GetHashCode());


            var p11 = new Polynomial(new RationalNumber[] {}, XName);
            var p12 = new Polynomial(new RationalNumber[] { 0 }, YName);

            Assert.IsFalse(p11.GetHashCode() == p12.GetHashCode());
        }
 public void GetHashCode_GhcEqualGhc_TrueReturned()
 {
     Polynomial a = new Polynomial(1, 2, 3, 4);
     Polynomial b = new Polynomial(1, 2, 3, 4);
     Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
 }
 public void GetHashCode_GivenEqualsPolynomial_ReturnsTheSamrResult()
 {
     var poly1 = new Polynomial(-5, -8, -5);
     var poly2 = new Polynomial(-5, -8, -5);
     Assert.AreEqual(poly1.GetHashCode(), poly2.GetHashCode());
 }
 public void GetHashCode_OfTwoNonEqualPolynomialsObject_ReturnDiffernValues()
 {
     Polynomial p = new Polynomial(new double[] { 0, 5.6, 5, 0.5, 0, 0, 0 });
     Polynomial pp = new Polynomial(new double[] { 0, 5.6, 5.0000001, 0.5, 0, 0, 0 });
     Assert.AreNotEqual(pp.GetHashCode(), p.GetHashCode());
 }
 public void GetHashCode_OfEqualPolynomials_ReturnsTheSameResult()
 {
     Polynomial p = new Polynomial(new double[] { 0, 5.6, 5, 0.5, 0, 0, 0 });
     Polynomial pp = new Polynomial(new double[] { 0, 5.6, 5, 0.5, 0, 0, 0 });
     Assert.AreEqual(p.GetHashCode(), pp.GetHashCode());
 }
 public void GetHashCode_OfPolynomialsObject_ReturnsCorrectValue()
 {
     Polynomial p = new Polynomial(new double[] { 0, 5.6, 5, 0.5, 0, 0, 0 });
     Assert.AreEqual(1717986534, p.GetHashCode());
 }
        public void GetHashCodeOfTwoDifferentPolynomials()
        {
            Polynomial first = new Polynomial(4, 8);
            Polynomial second = new Polynomial();

            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
        }
        public void GetHashCodeOfTwoSamePolynomials()
         {
             Polynomial first = new Polynomial( 4, 8);
             Polynomial second = first.Clone();

             Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
         }