public void AddSetGetPop()
        {
            const int testSize = 1089;

            List <(ImmutableTrieList <int> list, List <int> expected)> result = new List <(ImmutableTrieList <int>, List <int>)>();

            ImmutableTrieList <int> list = ImmutableTrieList <int> .Empty;

            result.Add((list, list.ToList()));

            // Add
            for (int i = 0; i < testSize; i++)
            {
                var expected = list.ToList();
                expected.Add(i);

                list = list.Add(i);
                result.Add((list, expected));

                Assert.Equal(i, list[i]);
            }

            // Set
            const int offset = 14; // setter offset

            for (int i = 0; i < testSize; i++)
            {
                var expected = list.ToList();
                expected[i] = i + offset;

                list = list.SetItem(i, i + offset);
                result.Add((list, expected));

                Assert.Equal(i + offset, list[i]);
            }

            // Pop
            for (int i = 0; i < testSize; i++)
            {
                int        oldCount = list.Count;
                List <int> expected = list.ToList();
                expected.RemoveAt(oldCount - 1);

                list = list.Pop();
                result.Add((list, expected));

                Assert.Equal(oldCount - 1, list.Count);
            }

            for (int tupleIndex = 0; tupleIndex < result.Count; tupleIndex++)
            {
                var tuple = result[tupleIndex];
                Assert.Equal(tuple.list, tuple.expected);
            }
        }
        private void TrueForAllTestHelper <T>(ImmutableTrieList <T> list, Predicate <T> test)
        {
            var bclList  = list.ToList();
            var expected = bclList.TrueForAll(test);
            var actual   = this.GetListQuery(list).TrueForAll(test);

            Assert.Equal(expected, actual);
        }
        protected override void ReverseTestHelper <T>(ImmutableTrieList <T> list, int index, int count)
        {
            var expected = list.ToList();

            expected.Reverse(index, count);
            var actual = list.Reverse(index, count);

            Assert.Equal <T>(expected, actual.ToList());
        }
        protected override void RemoveAllTestHelper <T>(ImmutableTrieList <T> list, Predicate <T> test)
        {
            var expected = list.ToList();

            expected.RemoveAll(test);
            var actual = list.RemoveAll(test);

            Assert.Equal <T>(expected, actual.ToList());
        }
Ejemplo n.º 5
0
        protected override void ReverseTestHelper <T>(ImmutableTrieList <T> list, int index, int count)
        {
            var expected = list.ToList();

            expected.Reverse(index, count);
            var builder = list.ToBuilder();

            builder.Reverse(index, count);
            Assert.Equal <T>(expected, builder.ToList());
        }
Ejemplo n.º 6
0
        protected override void RemoveAllTestHelper <T>(ImmutableTrieList <T> list, Predicate <T> test)
        {
            var builder = list.ToBuilder();
            var bcl     = list.ToList();

            int expected = bcl.RemoveAll(test);
            var actual   = builder.RemoveAll(test);

            Assert.Equal(expected, actual);
            Assert.Equal <T>(bcl, builder.ToList());
        }