Beispiel #1
0
        public void NawArrayOrdered_Add_FillWholeArray_ShouldFit()
        {
            // Arrange
            var expectedSize = 10;
            var expectedNaws = RandomNawGenerator.NewArray(expectedSize);

            var array = new NawArrayOrdered(expectedSize);

            // Act

            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;
            for (int i = 0; i < expectedSize; i++)
            {
                try
                {
                    array.Add(expectedNaws[i]);
                    Assert.AreEqual(i + 1, array.Count, "\n\nNawArrayOrdered.Add(): Het aantal elementen in de array komt niet overeen met het aantal toegevoegde items.");
                }
                catch (NawArrayOrderedOutOfBoundsException)
                {
                    // Assert
                    Assert.Fail("\n\nNawArrayOrdered.Add(): Er konden maar {0} NAW-objecten aan een array die met omvang {1} is geinitialiseerd worden toegevoegd", i, expectedSize);
                }
            }
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
        }
Beispiel #2
0
        public void NawArrayUnordered_BubbleSort_ShouldStartWithFirst()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "4";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "0";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "8";
            testSet[9].Woonplaats = "9";

            // Act
            array.BubbleSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd());

            var swaps = Logger.Instance.RealSwaps.ToList();

            // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is.
            Assert.AreEqual(7, swaps.Count);
            Assert.AreEqual("0", swaps[6].NewNaw1.Woonplaats);
        }
        public void NawArrayUnordered_BubbleSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.BubbleSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is na de bubbleSort niet geordend. De items staan niet op de juiste volgorde.");
            Assert.AreEqual(7, Logger.Instance.RealSwaps.Count(), "Het aantal swaps dat gemaakt wordt is niet 7.");
            Assert.AreEqual(0, Logger.Instance.LogItems.Count(li => li.ArrayAction == ArrayAction.SWAP && li.Index1 == li.Index2),
                            "Je zet verschillende items opnieuw met dezelfde waarde. Dit is niet nodig.");
        }
        public void NawArrayUnordered_BubbleSort_ShouldStartWithFirst()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "4";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "0";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "8";
            testSet[9].Woonplaats = "9";

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.BubbleSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is na de bubbleSort niet geordend. De items staan niet op de juiste volgorde.");

            var swaps = Logger.Instance.RealSwaps.ToList();

            // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is.
            Assert.AreEqual(7, swaps.Count, "Het aantal swaps dat gemaakt wordt is niet 7.");
            Assert.AreEqual("0", swaps[6].NewNaw1.Woonplaats, "Het laatste item dat gezet wordt is niet degene op de eerste plaats. Hij bubbelt niet van voor naar achter.");
        }
Beispiel #5
0
        public void NawArrayUnordered_BubbleSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            array.BubbleSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd());
            Assert.AreEqual(7, Logger.Instance.RealSwaps.Count());
            Assert.AreEqual(0, Logger.Instance.LogItems.Count(li => li.ArrayAction == ArrayAction.SWAP && li.Index1 == li.Index2));
        }
Beispiel #6
0
        public static void WithUniqueOrderedArray(int capacity, int filled, Action <INawArrayOrdered> f)
        {
            var testSet = RandomNawGenerator.NewArrayOfUniqueEntries(filled);
            var arr     = OrderedArrayOfSize(capacity, testSet);

            f(arr);
        }
        public static NawDoublyLinkedList Random(int min, int max, out int count)
        {
            var result = new NawDoublyLinkedList();
            var r      = new Random();

            count = r.Next(min, max);
            DoubleLink prev = null;

            for (var i = 0; i < count; ++i)
            {
                var newLink = new DoubleLink
                {
                    Naw = RandomNawGenerator.New(10)
                };
                if (prev == null)
                {
                    result.First = newLink;
                }
                else
                {
                    prev.Next = newLink;
                }
                newLink.Previous = prev;
                prev             = newLink;
                result.Last      = prev;
            }
            return(result);
        }
Beispiel #8
0
        public void NawArrayOrdered_Add_Valid_ShouldAddInOrder()
        {
            // Arrange
            char[] woonplaatsen = "abcde".ToCharArray();
            NAW[]  testSet      = RandomNawGenerator.NewArray(5);
            testSet[0].Woonplaats = woonplaatsen[3].ToString();
            testSet[1].Woonplaats = woonplaatsen[2].ToString();
            testSet[2].Woonplaats = woonplaatsen[4].ToString();
            testSet[3].Woonplaats = woonplaatsen[0].ToString();
            testSet[4].Woonplaats = woonplaatsen[1].ToString();

            var array = new NawArrayOrdered(20);

            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            for (int i = 0; i < testSet.Length; i++)
            {
                // Act
                array.Add(testSet[i]);

                // Assert
                Assert.IsTrue(array.CheckIsGesorteerd(), "NawArrayOrdered.Add(): Na het toevoegen van het element is de array niet langer goed gesorteerd.");
            }
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
        }
        public void NawArrayUnordered_InsertionSort_ShouldStartWithFirst()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "4";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "0";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "8";
            testSet[9].Woonplaats = "9";

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.InsertionSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de InsertionSort.");

            var setters = Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET && li.OldNaw1 != li.NewNaw1).ToList();

            // We moeten eerst alles naar achteren schuiven voordat er voor de 0 plaats is.
            setters.Last().AssertAreEqual(0, "0", "Je moet het gesorteerde deel van voor naar achteren laten opbouwen. Dit gebeurt nu niet.");
        }
        public void SelectionSortNawArray_SelectionSortGeinverteerd_SortedArrayDescending_ShouldHaveRightBounds()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            array.SelectionSortInverted();

            // Assert
            var realSwaps = Logger.Instance.RealSwaps.ToList();
            var logItems  = Logger.Instance.LogItems.ToList();

            Assert.IsTrue(array.CheckIsGesorteerd());
            Assert.AreEqual(1, realSwaps.Count);

            // We assert to not touch previous touched items.
            var indexOfSwap = logItems.IndexOf(realSwaps[0]);

            Assert.IsFalse(logItems.Skip(indexOfSwap + 1).Any(li => li.Index1 >= realSwaps[0].Index2));
        }
Beispiel #11
0
        public void NawArrayUnordered_SelectionSort_SortedArrayDescending_ShouldHaveRightBounds()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            array.SelectionSort();

            // Assert
            var realSwaps = Logger.Instance.RealSwaps.ToList();
            var logItems  = Logger.Instance.LogItems.ToList();

            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort");
            Assert.AreEqual(1, realSwaps.Count, "Wanneer je de 4 hebt gevonden en ruilt met de 8 zou je daarna geen swaps meer hoeven doen.");

            // We assert to not touch previous touched items.
            var indexOfSwap = logItems.IndexOf(realSwaps[0]);

            Assert.IsFalse(logItems.Skip(indexOfSwap + 1).Any(li => li.Index1 <= realSwaps[0].Index1), "We verwachten dat je geen swaps doet voor index 4.");
        }
        public void NawArrayUnordered_Add_Valid_ShouldAddAtTheEnd()
        {
            const int capacity = 10;
            const int filled   = 5;

            WithUnordenedArray(capacity, filled, arr =>
            {
                var prevState = new NAW[filled];
                WithoutLogging(() =>
                {
                    for (int i = 0; i < filled; ++i)
                    {
                        prevState[i] = arr.Array[i];
                    }
                });

                WithoutCallingArrayMethods(() =>
                {
                    arr.Add(RandomNawGenerator.New());
                });

                for (int i = 0; i < filled; ++i)
                {
                    Assert.AreSame(prevState[i], arr.Array[i], "Jouw Add methode van NAWArrayUnordered doet ook iets met de elementen die al in de array zaten. Dit is niet de bedoeling");
                }
            });
        }
Beispiel #13
0
        public void NawArrayUnordered_Add_Valid_ShouldAddAtTheEnd()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 5;
            var   array          = InitializeTestsubject(10, expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.Add(newNaw);

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.AreEqual(expectedLength + 1, array.Count, "Na het toevoegen is de ItemCount() niet opgehoogd.");

            // Niets is overschreven
            for (var i = 0; i < testSet.Length; i++)
            {
                Assert.AreEqual(testSet[i], array.Array[i], "\n\nNawArrayUnordered.Add(): Bij het toevoegen aan de array is item {0} onterecht overschreven.", i);
            }
            // Aan het einde toegevoegd
            Assert.AreEqual(newNaw, array.Array[expectedLength], "\n\nNawArrayUnordered.Add(): Bij het toevoegen aan de array is de nieuwe item niet aan het einde ingevoegd.");
        }
Beispiel #14
0
        public void NawArrayOrdered_Add_Valid_ShouldMoveTheRightNumberOfItems()
        {
            // Arrange
            char[] woonplaatsen = "acegi".ToCharArray();
            NAW[]  testSet      = RandomNawGenerator.NewArray(5);
            testSet[0].Woonplaats = woonplaatsen[3].ToString();
            testSet[1].Woonplaats = woonplaatsen[2].ToString();
            testSet[2].Woonplaats = woonplaatsen[4].ToString();
            testSet[3].Woonplaats = woonplaatsen[0].ToString();
            testSet[4].Woonplaats = woonplaatsen[1].ToString();

            var array = new NawArrayOrdered(20);

            for (int i = 0; i < testSet.Length; i++)
            {
                // Act
                array.Add(testSet[i]);
            }

            Logger.Instance.ClearLog();
            array.Add(new NAW()
            {
                Woonplaats = "f"
            });

            var setters = Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET);

            Assert.AreEqual(3, setters.Count(), "NawArrayOrdered.Add(): Er worden teveel elementen verschoven om ruimte te maken voor het nieuwe element.");
            Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "f"));
            Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "g"));
            Assert.IsTrue(setters.Any(li => li.NewNaw1.Woonplaats == "i"));
            //     Assert.IsTrue(array.CheckIsGesorteerd()); Wordt al bij andere testcase beoordeeld.
        }
        public void NawArrayUnordered_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.InsertionSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de InsertionSort.");

            int lowerBound = 4, upperBound = 8;

            NAW toMoveUp        = testSet[lowerBound];
            var toMoveUpSetters = (from li in Logger.Instance.LogItems
                                   where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET
                                   orderby li.Index1
                                   select li).ToArray();

            // This one bubbles up slowly.
            for (int i = lowerBound + 1; i <= upperBound; i++)
            {
                Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i, "Er zouden 4 items verplaatst moeten zijn om ruimte te maken in het geordende deel.");
            }

            NAW toBeInsertedDown        = testSet[upperBound];
            var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems
                                           where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET
                                           orderby li.Index1
                                           select li).ToArray();

            // This one moves down in an insertion way.
            Assert.AreEqual(1, toBeInsertedDownSetters.Count(), "Meerdere items zijn geïnsert in de sortering, dit had er 1 moeten zijn.");
            Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1, "Item met woonplaats 4 zou op de 4e index geïnsert moeten zijn.");


            // All setters must be in between the bounds.
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound)
                          , "Je hebt items gezet waarbij de oude index gelijk was aan de nieuwe, dit is niet nodig.");
        }
Beispiel #16
0
        public void InsertionSortNawArray_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            testSet[0].Woonplaats = "0";
            testSet[1].Woonplaats = "1";
            testSet[2].Woonplaats = "2";
            testSet[3].Woonplaats = "3";
            testSet[4].Woonplaats = "8";
            testSet[5].Woonplaats = "5";
            testSet[6].Woonplaats = "6";
            testSet[7].Woonplaats = "7";
            testSet[8].Woonplaats = "4";
            testSet[9].Woonplaats = "9";

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.InsertionSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.IsTrue(array.CheckIsGesorteerd());

            int lowerBound = 4, upperBound = 8;

            NAW toMoveUp        = testSet[lowerBound];
            var toMoveUpSetters = (from li in Logger.Instance.LogItems
                                   where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET
                                   orderby li.Index1
                                   select li).ToArray();

            // This one bubbles up slowly.
            for (int i = lowerBound + 1; i <= upperBound; i++)
            {
                Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i);
            }

            NAW toBeInsertedDown        = testSet[upperBound];
            var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems
                                           where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET
                                           orderby li.Index1
                                           select li).ToArray();

            // This one moves down in an insertion way.
            Assert.AreEqual(1, toBeInsertedDownSetters.Count());
            Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1);


            // All setters must be in between the bounds.
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound));
        }
        private static INawArrayUnordered InitializeTestsubject(int maxSize, int initialFilledSize, out NAW[] testSet, int?maxStringLenght = null)
        {
            testSet = RandomNawGenerator.NewArray(initialFilledSize);
            var array = new NawArrayUnordered(maxSize);

            Array.ForEach(testSet, naw => array.Add(naw));

            // We have to clear the log because adding to the array will cause the logger to log as well.
            Logger.Instance.ClearLog();
            return(array);
        }
Beispiel #18
0
        public void NawArrayUnordered_SelectionSort_EmptyArray_ShouldNotSort()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 0;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.SelectionSort();

            // Assert
            Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je controleert items terwijl de array leeg is. Dit is niet nodig.");
        }
Beispiel #19
0
        public void NawArrayUnordered_BubbleSort_EmptyArray_ShouldNotSort()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 0;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.BubbleSort();

            // Assert
            Assert.AreEqual(0, Logger.Instance.LogItems.Count());
        }
Beispiel #20
0
        public static void WithOrderedArray(int capacity, int filled, Action <INawArrayOrdered> f)
        {
            var array = OrderedArrayOfSize(capacity);

            WithoutLogging(() =>
            {
                var testSet = RandomNawGenerator.NewArray(filled);
                foreach (var i in testSet)
                {
                    array.Add(i);
                }
            });
            f(array);
        }
        public void SelectionSortNawArray_SelectionSort_SortedArray_ShouldNotSwapAtAll()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderAscending: true);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.SelectionSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd());
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength);
            Assert.AreEqual(0, Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SWAP).Count());
        }
 public void NawArrayUnordered_Add_OneTooMany_ShouldThrowException()
 {
     int[] capacities = { 1, 10, 100 };
     foreach (var capacity in capacities)
     {
         WithoutCallingArrayMethods(() =>
         {
             WithUnordenedArray(capacity, capacity, arr =>
             {
                 Assert.Throws <NawArrayUnorderedOutOfBoundsException>(
                     () => arr.Add(RandomNawGenerator.New()),
                     $"Jouw implementatie van de Add methode werpt geen uitzondering op wanneer we een element aan een volle array proberen toe te voegen");
             });
         });
     }
 }
Beispiel #23
0
        public void NawArrayUnordered_SelectionSort_SortedArray_ShouldNotSwapDifferentIndexes()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderAscending: true);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.SelectionSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort");
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength, "Je bent niet door de hele lijst heen gelopen om te controleren of hij geordend is.");
            Assert.AreEqual(0, Logger.Instance.RealSwaps.Count(), "De lijst was vooraf al geordend. Toch heb je items geswitched. Dit klopt niet.");
        }
        public void NawArrayOrdered_Add_OneTooMany_ShouldThrowException()
        {
            // Arrange
            NAW[] testSet;
            var   array      = InitializeTestsubject(3, 3, out testSet);
            var   oneTooMany = RandomNawGenerator.New();

            // Act

            Alg1.Practica.Utils.Globals.Alg1NawArrayMethodCalled = false;

            Assert.Throws <NawArrayOrderedOutOfBoundsException>(() => array.Add(oneTooMany),
                                                                "NawArrayOrdered.Add(): Toevoegen van 11e element aan array met omvang van 10 geeft geen exceptie");

            Assert.IsFalse(Alg1.Practica.Utils.Globals.Alg1NawArrayMethodCalled,
                           "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
        }
Beispiel #25
0
        public void NawArrayUnordered_BubbleSort_SortedArrayDescending_ShouldSetAllItemsButOne()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 100;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.BubbleSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd());
            var swaps = Logger.Instance.RealSwaps;

            Assert.AreEqual(expectedLength.SumAllSmallerIncSelf() - expectedLength, swaps.Count());
        }
        public void NawArrayUnordered_BubbleSort_EmptyArray_ShouldNotSort()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 0;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.BubbleSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je hebt de array benaderd terwijl deze leeg is. Dit had niet gehoeven omdat je dit al wist door je ItemCount.");
        }
        public void NawArrayUnordered_Add_ShouldNotUseForloop()
        {
            const int filled = 5;

            WithUnordenedArray(10, filled, arr =>
            {
                WithoutCallingArrayMethods(() =>
                {
                    var toAdd = RandomNawGenerator.New();
                    arr.Add(toAdd);
                    Console.WriteLine(Logger.Instance.LogItems.FirstOrDefault());
                    Assert.IsTrue(
                        Logger.Instance.LogItems.SequenceEqual(new LogItem[] { LogItem.SetItem(filled, null, toAdd) }),
                        "Het enige dat Add moet doen is het nieuwe element opslaan in de onderliggende Alg1NawArray. Dat kan direct op de index _used (voordat je hem verhoogt). Je hoeft verder niets met Alg1NawArray te doen."
                        );
                });
            });
        }
Beispiel #28
0
        public void NawArrayUnordered_SelectionSort_SortedArrayDescending_ShouldSwapAllItems()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.SelectionSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de SelectionSort");
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength, "Je bent niet door de hele lijst heen gelopen om te controleren of hij geordend is.");
            // We expect half the length of the array to be swapped.
            // This occurs because when ordered descending when we swap we coincidentally set two items right.
            Assert.AreEqual(expectedLength / 2, Logger.Instance.RealSwaps.Count(), "De array was vooraf descending geordend. Met de helft van de lengte aan swaps zou je een geordende array moeten hebben.");
        }
        public void NawArrayUnordered_InsertionSort_EmptyArray_ShouldNotSort()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 0;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(10), expectedLength, out testSet);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;

            array.InsertionSort();

            // Assert
            Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");

            Assert.AreEqual(0, Logger.Instance.LogItems.Count(), "Je controleert items terwijl de array leeg is. Dit is niet nodig.");
        }
        public void SelectionSortNawArray_SelectionSort_SortedArrayDescending_ShouldSwapAllItems()
        {
            // Arrange
            NAW[] testSet;
            var   expectedLength = 10;
            var   array          = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet, orderDescending: true);
            var   newNaw         = RandomNawGenerator.New();

            // Act
            array.SelectionSort();

            // Assert
            Assert.IsTrue(array.CheckIsGesorteerd());
            Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.GET).Count() >= expectedLength);
            // We expect half the length of the array to be swapped.
            // This occurs because when ordered descending when we swap we coincidentally set two items right.
            Assert.AreEqual(expectedLength / 2, Logger.Instance.RealSwaps.Count());
        }