Пример #1
0
            public void EnsureThrowsAfterModification(T[] items, T item, int index, int count)
            {
                SegmentedList <T> list  = new SegmentedList <T>(items);
                SegmentedList <T> range = list.GetRange(index, count);
                T tempItem = list[index];

                list[index] = item;

                Assert.Equal(range[0], tempItem); //String.Format("Err_1221589ajpa Expected item: {0} at: {1} actual: {2}", tempItem, 0, range[0])
            }
Пример #2
0
            public void BasicGetRange(T[] items, int index, int count)
            {
                SegmentedList <T> list  = new SegmentedList <T>(items);
                SegmentedList <T> range = list.GetRange(index, count);

                //ensure range is good
                for (int i = 0; i < count; i++)
                {
                    Assert.Equal(range[i], items[i + index]); //String.Format("Err_170178aqhbpa Expected item: {0} at: {1} actual: {2}", items[i + index], i, range[i])
                }

                //ensure no side effects
                for (int i = 0; i < items.Length; i++)
                {
                    Assert.Equal(list[i], items[i]); //String.Format("Err_00125698ahpap Expected item: {0} at: {1} actual: {2}", items[i], i, list[i])
                }
            }
Пример #3
0
            public void GetRangeValidations(T[] items)
            {
                //
                //Always send items.Length is even
                //
                SegmentedList <T> list = new SegmentedList <T>(items);

                int[] bad = new int[] { /**/ items.Length, 1,
                                             /**/
                                             items.Length + 1, 0,
                                             /**/
                                             items.Length + 1, 1,
                                             /**/
                                             items.Length, 2,
                                             /**/
                                             items.Length / 2, items.Length / 2 + 1,
                                             /**/
                                             items.Length - 1, 2,
                                             /**/
                                             items.Length - 2, 3,
                                             /**/
                                             1, items.Length,
                                             /**/
                                             0, items.Length + 1,
                                             /**/
                                             1, items.Length + 1,
                                             /**/
                                             2, items.Length,
                                             /**/
                                             items.Length / 2 + 1, items.Length / 2,
                                             /**/
                                             2, items.Length - 1,
                                             /**/
                                             3, items.Length - 2 };

                for (int i = 0; i < bad.Length; i++)
                {
                    Assert.Throws <ArgumentException>(null, () => list.GetRange(bad[i], bad[++i])); //"ArgumentException expected."
                }

                bad = new int[] {
                    /**/
                    -1, -1,
                    /**/
                    -1, 0,
                    /**/
                    -1, 1,
                    /**/
                    -1, 2,
                    /**/
                    0, -1,
                    /**/
                    1, -1,
                    /**/
                    2, -1
                };

                for (int i = 0; i < bad.Length; i++)
                {
                    Assert.Throws <ArgumentOutOfRangeException>(() => list.GetRange(bad[i], bad[++i])); //"ArgumentOutOfRangeException expected."
                }
            }