public void AddTwoItemInDoubleLinkList()
 {
     var doubleLinkList = new DoubleLinkList<int>();
     doubleLinkList.Add(1);
     doubleLinkList.Add(2);
     CollectionAssert.AreEqual(new[] {2, 1}, doubleLinkList);
 }
        public void DeleteItemFromAListWithThreeItem()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.Add(2);
            doubleLinkList.Add(7);
            doubleLinkList.ShouldContain(2);
            doubleLinkList.Remove(2);
            doubleLinkList.ShouldNotContain(2);
        }
        public void AddThreeItemInDoubleLinkList()
        {
            var doubleLinkList = new DoubleLinkList<int>();
            doubleLinkList.Add(1);
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);

            CollectionAssert.AreEqual(new[] {3,2,1},doubleLinkList);
            doubleLinkList.ShouldContain(1);
            doubleLinkList.ShouldContain(2);
            doubleLinkList.ShouldContain(3);
        }
Esempio n. 4
0
    //Reading through text file and adding text to nodes in linked list
    public Dialogue(string path)
    {
        string[] lines;

        using (StreamReader sr = new StreamReader(path))
        {
            string input = sr.ReadToEnd();


            //Debug.Log("Raw string data in: " + input);

            lines = input.Split('\n');
        }

        for (int i = 0; i < lines.Length; i++)
        {
            if (D.First != null)
            {
                Debug.Log("addng additional node: " + lines[i]);
                D.Add(lines[i]);
                Debug.Log("node added");
            }
            else
            {
                Debug.Log("addng first node: " + lines[i]);
                D.Addfirst(lines[i]);
                Debug.Log("node added");
            }
        }
    }
        public void Test()
        {
            DoubleLinkList <int> list = new DoubleLinkList <int>();

            Assert.Equal(0, list.Length);
            Assert.Null(list.Head);

            // 1 <- 2 <- 3 <- 4
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            Assert.Equal(4, list.Length);
            Assert.Equal(2, list[1]);

            // 1 <- 2  <- 3 <- 4
            // 1 <- 20 <- 3 <- 4
            list[1] = 20;
            Assert.Equal(4, list.Length);
            Assert.Equal(20, list[1]);

            // 1 <- 20      <- 3 <- 4
            // 1 <- 20 <- 5 <- 3 <- 4
            list.Insert(2, 5);
            Assert.Equal(5, list.Length);
            Assert.Equal(5, list[2]);
            Assert.Equal(3, list[3]);

            // 1 <- 20 <- 5 <- 3 <- 4
            //      20 <- 5 <- 3 <- 4
            list.RemoveAt(0);
            Assert.Equal(4, list.Length);
            Assert.Equal(20, list[0]);

            // 20 <- 5 <- 3 <- 4
            // 20 <- 5      <- 4
            list.RemoveAt(2);
            Assert.Equal(3, list.Length);
            Assert.Equal(4, list[2]);

            list.Clear();
            Assert.Equal(0, list.Length);
            Assert.Null(list.Head);
        }
        public void DeleteItemFromAListWithOneItem()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.ShouldContain(5);
            doubleLinkList.Count.ShouldEqual(1);
            doubleLinkList.Remove(5);
            doubleLinkList.ShouldNotContain(5);
            doubleLinkList.Count.ShouldEqual(0);
        }
Esempio n. 7
0
        public void DoubleLinkTest()
        {
            var list = new DoubleLinkList();

            Assert.IsNull(list.Find("Fred"));
            list.Add("Fred");
            Assert.AreEqual("Fred", list.Find("Fred").Value);
            Assert.IsNull(list.Find("Wilma"));
            Assert.AreEqual("Fred", list.Find("Fred").Value);
            list.Add("Wilma");
            Assert.AreEqual("Wilma", list.Find("Wilma").Value);
            var ans = new string[] { "Fred", "Wilma" };

            CollectionAssert.AreEqual(ans, list.Values());

            list = new DoubleLinkList();
            list.Add("Fred");
            list.Add("Wilma");
            list.Add("Betty");
            list.Add("Barney");
            ans = new string[] { "Fred", "Wilma", "Betty", "Barney" };
            CollectionAssert.AreEqual(ans, list.Values());
            list.Delete(list.Find("Wilma").Value);
            ans = new string[] { "Fred", "Betty", "Barney" };

            CollectionAssert.AreEqual(ans, list.Values());
            list.Delete(list.Find("Barney").Value);
            ans = new string[] { "Fred", "Betty" };
            CollectionAssert.AreEqual(ans, list.Values());
            list.Delete(list.Find("Fred").Value);
            ans = new string[] { "Betty" };
            CollectionAssert.AreEqual(ans, list.Values());
            list.Delete(list.Find("Betty").Value);
            ans = new string[] { };
            CollectionAssert.AreEqual(ans, list.Values());
        }
        public void InsertItemInAListWithThreeItemBeforeTheReferanceElement()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);
            doubleLinkList.InsertBefore(5, 7);

            CollectionAssert.AreEqual(new[] { 3, 2,7,5 }, doubleLinkList);
            doubleLinkList.ShouldContain(5);
            doubleLinkList.Count.ShouldEqual(4);
        }
        public void VerifyIndexOutOfRangeForCopyToArray()
        {
            var doubleLinkList = new DoubleLinkList<int>();
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);
            var array = new[] { 1, 2, 0 };

            doubleLinkList.CopyTo(array, 2);
        }
        public void VerifyCopyToInList()
        {
            var doubleLinkList = new DoubleLinkList<int>();
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);
            doubleLinkList.Add(4);

            var array = new[] { 1, 2, 3, 0, 0, 0 };
            var expectedResult = new[] { 1, 2, 3, 4, 3, 2 };

            doubleLinkList.CopyTo(array, 3);
            CollectionAssert.AreEqual(expectedResult, array);
        }
        public void VerifyIfAListContainAnItem()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.Add(2);
            doubleLinkList.Add(7);
            doubleLinkList.Contains(2).ShouldBeTrue();
            doubleLinkList.Contains(7).ShouldBeTrue();
            doubleLinkList.Contains(8).ShouldBeFalse();
        }
        public void VerifyArgumentOutOfRangeExceptionForCopyToArray()
        {
            var doubleLinkList = new DoubleLinkList<int>();
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);
            var array = new[] { 1, 2, 0 };

            doubleLinkList.CopyTo(array, -1);
        }
        public void VerifyArgumentNullExceptionForCopyToArray()
        {
            var doubleLinkList = new DoubleLinkList<int>();
            doubleLinkList.Add(2);
            doubleLinkList.Add(3);
            int[] array = null;

            doubleLinkList.CopyTo(array, 2);
        }
 public void AddItemInEmptyDoubleLinkList()
 {
     var doubleLinkList=new DoubleLinkList<int>();
     doubleLinkList.Add(1);
     doubleLinkList.ShouldContain(1);
 }
        public void ShouldHaveAReverseEnumerableForAListWithTwoItem()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.Add(7);

            var enumerable = doubleLinkList.GetReverseEnumerable();

            enumerable.ShouldContain(7);
        }
        public void InsertItemInDoubleLinkListBeforeTheReferanceElement()
        {
            var doubleLinkList = new DoubleLinkList<int>();

            doubleLinkList.Add(5);
            doubleLinkList.InsertBefore(5, 3);

            CollectionAssert.AreEqual(new[] { 3, 5 }, doubleLinkList);
            doubleLinkList.ShouldContain(5);
        }