Пример #1
0
        public void Test_isActive_dataFilter()
        {
            // Arrange
            int[]      seq   = new int[] { 1, 9, 3, 7, 5, 6, 4, 8, 2, 10 };
            int        prime = 7;
            dataFilter obj   = new dataFilter(prime, seq);

            int[] expectedLARGE       = new int[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
            int[] expectedSMALL       = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            int[] expectedInactiveSeq = null;
            bool  expectedActive      = false;

            // Act
            int[] resultLARGE = obj.scramble();
            obj.switchMode();
            int[] resultSMALL = obj.scramble();
            obj.switchMode();
            int[] resultInactive = obj.scramble();
            bool  activeState    = obj.getActiveStatus();

            // Assert
            CollectionAssert.AreEqual(resultLARGE, expectedLARGE);
            CollectionAssert.AreEqual(resultSMALL, expectedSMALL);
            CollectionAssert.AreEqual(resultInactive, expectedInactiveSeq);
            Assert.AreEqual(activeState, expectedActive);
        }
Пример #2
0
        public void Test_scramble_dataFilter()
        {
            // Arrange
            int[]      seq          = new int[] { 1, 9, 3, 7, 5, 6, 4, 8, 2, 10 };
            int        prime        = 7;
            dataFilter objLARGE     = new dataFilter(prime, seq);
            dataFilter objSMALL     = new dataFilter(prime, seq);
            dataFilter objNullLARGE = new dataFilter(prime);
            dataFilter objNullSMALL = new dataFilter(prime);

            int[] expectedLARGE     = new int[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
            int[] expectedSMALL     = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            int[] expectedNullLARGE = expectedLARGE;
            int[] expectedNullSMALL = expectedSMALL;
            // Act
            objSMALL.switchMode();
            objNullSMALL.switchMode();
            int[] resultLARGE     = objLARGE.scramble();
            int[] resultSMALL     = objSMALL.scramble();
            int[] resultNullLARGE = objNullLARGE.scramble(seq);
            int[] resultNullSMALL = objNullSMALL.scramble(seq);
            // Assert
            CollectionAssert.AreEqual(resultLARGE, expectedLARGE);
            CollectionAssert.AreEqual(resultSMALL, expectedSMALL);
            CollectionAssert.AreEqual(resultNullLARGE, expectedNullLARGE);
            CollectionAssert.AreEqual(resultNullSMALL, resultNullSMALL);
        }
Пример #3
0
        public void Test_filter_dataFilter()
        {
            // Arrange
            int[]      seq          = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            int        prime        = 7;
            dataFilter objLARGE     = new dataFilter(prime, seq);
            dataFilter objSMALL     = new dataFilter(prime, seq);
            dataFilter objNullLARGE = new dataFilter(prime);
            dataFilter objNullSMALL = new dataFilter(prime);

            int[] expectedLARGE     = new int[] { 8, 9, 10 };
            int[] expectedSMALL     = new int[] { 1, 2, 3, 4, 5, 6 };
            int[] expectedNullLARGE = new int[] { 7 };
            int[] expectedNullSMALL = new int[] { 7 };
            // Act
            objSMALL.switchMode();
            objNullSMALL.switchMode();
            int[] resultLARGE     = objLARGE.filter();
            int[] resultSMALL     = objSMALL.filter();
            int[] resultNullLARGE = objNullLARGE.filter();
            int[] resultNullSMALL = objNullSMALL.filter();
            // Assert
            CollectionAssert.AreEqual(resultLARGE, expectedLARGE);
            CollectionAssert.AreEqual(resultSMALL, expectedSMALL);
            CollectionAssert.AreEqual(resultNullLARGE, expectedNullLARGE);
            CollectionAssert.AreEqual(resultNullSMALL, expectedNullSMALL);
        }
Пример #4
0
        public void Test_dataFilter_GetDefaultMode()
        {
            // Arrange/Act
            dataFilter d = new dataFilter();

            // Assert
            Assert.IsFalse(d.getMode());
        }
Пример #5
0
        public void Test_dataFilter_SetMode()
        {
            // Arrange
            dataFilter d = new dataFilter();

            // Act
            d.setMode(true);

            // Assert
            Assert.IsTrue(d.getMode());
        }
Пример #6
0
        public void Test_dataFilter_DefaultConstructor()
        {
            // Arrange/Act
            dataFilter d = new dataFilter();

            int[] testArray = new int[1] {
                2
            };

            // Assert
            CollectionAssert.AreEqual(d.filter(), testArray);
        }
Пример #7
0
        public void Test_dataFilter_SetPrimeWithoutPrime()
        {
            // Arrange
            dataFilter d = new dataFilter(17);

            int[] testArray = new int[1] {
                17
            };

            // Act
            d.setPrime(18);

            // Assert
            CollectionAssert.AreEqual(d.filter(), testArray);
        }
Пример #8
0
        public void Test_dataFilter_ScrambleOddLengthSeq()
        {
            // Arrange
            dataFilter d = new dataFilter();

            int[] testArray = new int[5] {
                29, 14, 34, 73, 5
            };
            int[] assertArray = new int[5] {
                14, 29, 34, 73, 5
            };

            // Act
            int[] dScramble = d.scramble(testArray);

            // Assert
            CollectionAssert.AreEqual(dScramble, assertArray);
        }
Пример #9
0
        public void Test_dataFilter_ScrambleLargeMode()
        {
            // Arrange
            dataFilter d = new dataFilter();

            d.setMode(true);
            int[] testArray = new int[6] {
                29, 14, 34, 73, 5, 9
            };
            int[] assertArray = new int[6] {
                29, 14, 73, 34, 9, 5
            };

            // Act
            int[] dScramble = d.scramble(testArray);

            // Assert
            CollectionAssert.AreEqual(dScramble, assertArray);
        }
Пример #10
0
        public void Test_dataFilter_FilterSmallMode()
        {
            // Arrange
            dataFilter d = new dataFilter(23);

            int[] testArray = new int[7] {
                25, 14, 29, 40, 8, 59, 2
            };
            int[] assertArray = new int[3] {
                14, 8, 2
            };

            // Act
            d.scramble(testArray); // Using scramble to set array, ignoring its output in this test
            int[] dFilter = d.filter();

            // Assert
            CollectionAssert.AreEqual(dFilter, assertArray);
        }
Пример #11
0
        public void Test_dataFilter_FilterLargeMode()
        {
            // Arrange
            dataFilter d = new dataFilter(41);

            d.setMode(true);
            int[] testArray = new int[7] {
                59, 24, 37, 15, 63, 104, 2
            };
            int[] assertArray = new int[3] {
                59, 63, 104
            };

            // Act
            d.scramble(testArray);
            int[] dFilter = d.filter();

            // Assert
            CollectionAssert.AreEqual(dFilter, assertArray);
        }