public void ClearTest()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);
            sut.Clear();
            Assert.Equal(0, sut.Count);
        }
        public void NotContainsElement()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);

            Assert.False(sut.Contains(9));
        }
        public void TestForInsertingInAnUnsortedArrayShouldNotWork()
        {
            var notSortedArray = new SortedIntArray();

            notSortedArray.Add(1);
            notSortedArray.Add(4);
            notSortedArray.Add(6);
            notSortedArray.Add(12);
            notSortedArray.Insert(2, 100);
            Assert.Equal(-1, notSortedArray.IndexOf(100));
            Assert.Equal(4, notSortedArray.Count);
        }
        public void TestForInsertingInASortedArray()
        {
            var sortedArray = new SortedIntArray();

            sortedArray.Add(1);
            sortedArray.Add(4);
            sortedArray.Add(6);
            sortedArray.Add(12);
            sortedArray.Insert(2, 5);
            Assert.Equal(2, sortedArray.IndexOf(5));
            Assert.Equal(5, sortedArray.Count);
        }
示例#5
0
        public void ChangeValueAtIndexSortedArray()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);

            sut[1] = 2;
            Assert.Equal(2, sut[1]);
        }
示例#6
0
        public void TestClear()
        {
            var array = new SortedIntArray();

            array.Add(3);
            array.Add(5);
            array.Add(7);
            array.Clear();

            Assert.Equal(0, array.Count);
            Assert.False(array.Contains(5));
        }
示例#7
0
        public void InsertAndResize()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(4);
            sut.Add(5);
            sut.Insert(1, 3);
            Assert.Equal(1, sut.IndexOf(3));
            Assert.Equal(5, sut.Count);
        }
示例#8
0
        public void TestInsertFalse()
        {
            var array = new SortedIntArray();

            array.Add(3);
            array.Add(5);
            array.Add(7);
            array.Insert(0, 20);

            Assert.Equal(3, array.Count);
            Assert.False(array.Contains(20));
        }
示例#9
0
        public void CheckLengthAferInsertionNotSorted()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);
            sut.Insert(1, 4);
            Assert.Equal(5, sut.Count);
        }
        public void Test_Insert2()
        {
            var a = new SortedIntArray();

            a.Add(1);
            a.Add(3);
            a.Add(2);
            a.Insert(3, 4);
            Assert.Equal(2, a[1]);
            Assert.Equal(3, a[2]);
            Assert.Equal(4, a[3]);
        }
        public void VerifyCountAfterRemove()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);
            sut.RemoveAt(2);
            Assert.Equal(4, sut.Count);
        }
示例#12
0
        public void InsertWhenPosition0Number3ShouldDoNothing()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(5);
            arrayTest.Add(2);

            arrayTest.Insert(0, 3);

            Assert.Equal(2, arrayTest.Count);
            Assert.Equal(2, arrayTest[0]);
            Assert.Equal(5, arrayTest[1]);
        }
示例#13
0
        public void TestInsertTrue()
        {
            var array = new SortedIntArray();

            array.Add(3);
            array.Add(5);
            array.Add(7);
            array.Insert(1, 4);

            Assert.Equal(4, array.Count);
            Assert.True(array.Contains(4));
            Assert.Equal(1, array.IndexOf(4));
        }
        public void VerifyElementsAfterRemove()
        {
            var sut = new SortedIntArray();

            sut.Add(1);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);
            sut.RemoveAt(1);
            Assert.Equal(4, sut[2]);
            Assert.Equal(5, sut[3]);
        }
        public void TestForAddingFourNotSortedValues()
        {
            var notSortedArray = new SortedIntArray();

            notSortedArray.Add(3);
            notSortedArray.Add(1);
            notSortedArray.Add(6);
            notSortedArray.Add(2);
            Assert.Equal(1, notSortedArray[0]);
            Assert.Equal(2, notSortedArray[1]);
            Assert.Equal(3, notSortedArray[2]);
            Assert.Equal(6, notSortedArray[3]);
        }
示例#16
0
        public void TestAdd()
        {
            var array = new SortedIntArray();

            array.Add(3);
            array.Add(20);
            array.Add(5);
            array.Add(2);
            array.Add(100);

            Assert.Equal(5, array.Count);
            Assert.Equal(20, array[3]);
            Assert.Equal(2, array[0]);
        }
示例#17
0
        public void InsertWhenPosition0Number1ShouldReturnCount3AndBeSorted()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(5);
            arrayTest.Add(2);

            arrayTest.Insert(0, 1);

            Assert.Equal(3, arrayTest.Count);
            Assert.Equal(1, arrayTest[0]);
            Assert.Equal(2, arrayTest[1]);
            Assert.Equal(5, arrayTest[2]);
        }
示例#18
0
        public void IndexerSetWhenLastPositionNumber7ShouldSetTheNumber()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(6);
            arrayTest.Add(7);
            arrayTest.Add(5);

            arrayTest[2] = 7;

            Assert.Equal(3, arrayTest.Count);
            Assert.Equal(5, arrayTest[0]);
            Assert.Equal(6, arrayTest[1]);
            Assert.Equal(7, arrayTest[2]);
        }
示例#19
0
        public void IndexerSetWhenPosition0Number7ShouldDoNothing()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(6);
            arrayTest.Add(7);
            arrayTest.Add(5);

            arrayTest[0] = 7;

            Assert.Equal(3, arrayTest.Count);
            Assert.Equal(5, arrayTest[0]);
            Assert.Equal(6, arrayTest[1]);
            Assert.Equal(7, arrayTest[2]);
        }
示例#20
0
        public void InsertWhenPosition1Number4ShouldDoNothing()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(6);
            arrayTest.Add(7);
            arrayTest.Add(5);

            arrayTest.Insert(1, 4);

            Assert.Equal(3, arrayTest.Count);
            Assert.Equal(5, arrayTest[0]);
            Assert.Equal(6, arrayTest[1]);
            Assert.Equal(7, arrayTest[2]);
        }
示例#21
0
        public void InsertWhenPosition2Number5ShouldInsertNumber()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(5);
            arrayTest.Add(2);
            arrayTest.Add(3);

            arrayTest.Insert(2, 5);

            Assert.Equal(4, arrayTest.Count);
            Assert.Equal(2, arrayTest[0]);
            Assert.Equal(3, arrayTest[1]);
            Assert.Equal(5, arrayTest[2]);
            Assert.Equal(5, arrayTest[3]);
        }
示例#22
0
        public void AddWhenEmptyShouldReturnCount1()
        {
            SortedIntArray arrayTest = new SortedIntArray();

            arrayTest.Add(5);

            Assert.Equal(1, arrayTest.Count);
        }
        public void TestIndexForOneElementArray()
        {
            var array = new SortedIntArray();

            array.Add(4);
            array[0] = 1;
            Assert.Equal(1, array[0]);
        }
        public void AddValueAndResizeSortedArray()
        {
            var sut = new SortedIntArray();

            sut.Add(0);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(5);
            sut.Add(6);
            sut.Add(7);
            sut.Add(8);
            sut.Add(9);
            sut.Add(10);

            Assert.Equal(3, sut[2]);
            Assert.Equal(10, sut.Count);
        }
示例#25
0
        public void TestSetElementTrue2()
        {
            var array = new SortedIntArray();

            array.Add(3);
            array[1] = 2;

            Assert.Equal(1, array.Count);
        }
        public void AddValueAndResizeSortedArray()
        {
            var sut = new SortedIntArray();

            sut.Add(0);
            sut.Add(2);
            sut.Add(3);
            sut.Add(4);
            sut.Add(1);
            sut.Add(6);
            sut.Add(7);
            sut.Add(8);
            sut.Add(9);
            sut.Add(10);       //- 0,1,2,3,4,6,7,8,9,10
            sut.Insert(5, 5);  //- 0,1,2,3,4,5,6,7,8,9,10
            sut.RemoveAt(10);  //- 0,1,2,3,4,5,6,7,8,9
            sut.Remove(8);     //- 0,1,2,3,4,5,6,7,9
            Assert.Equal(1, sut[1]);
            Assert.Equal(5, sut[5]);
            Assert.Equal(9, sut[8]);
            Assert.True(sut.Contains(5));
            Assert.False(sut.Contains(8));
            Assert.Equal(3, sut.IndexOf(3));
        }
        public void Test_Insert3()
        {
            var a = new SortedIntArray();

            a.Add(1);
            a.Add(3);
            a.Add(2);
            a.Add(1);
            a.Add(5);
            a.Add(2);
            Assert.Equal(1, a[0]);
        }
        public void Test_Insert4()
        {
            var a = new SortedIntArray();

            a.Add(1);
            a.Add(2);
            a.Add(3);
            a.Add(4);
            a.Add(5);
            a.Add(6);
            Assert.Equal(6, a[5]);
        }
示例#29
0
        public void TestRemoveAt()
        {
            var array = new SortedIntArray();

            array.Add(7);
            array.Add(3);
            array.Add(5);
            array.Add(7);
            array.Add(20);
            array.Add(30);
            array.RemoveAt(3);
            array.Add(40);

            Assert.Equal(6, array.Count);
            Assert.Equal(3, array.IndexOf(20));
            Assert.Equal(5, array.IndexOf(40));
        }
示例#30
0
        public void TestRemove()
        {
            var array = new SortedIntArray();

            array.Add(7);
            array.Add(5);
            array.Add(3);
            array.Add(7);
            array.Add(30);
            array.Remove(7);
            array.Add(20);

            Assert.Equal(5, array.Count);
            Assert.Equal(5, array[1]);
            Assert.Equal(20, array[3]);
        }