website/archived/collectionbasetestcs.md

---
title: "CollectionBaseTest.cs"
lastmodified: '2005-02-25'
redirect_from:
  - /CollectionBaseTest.cs/
---

CollectionBaseTest.cs
=====================

        //
        // System.Collections.CollectionBase
        // Test suite for System.Collections.CollectionBase
        //
        // Author:
        //    Nick D. Drochak II
        //
        // (C) 2001 Nick D. Drochak II
        //


        using System;
        using System.Collections;
        using NUnit.Framework;

        namespace MonoTests.System.Collections
        {

        public class CollectionBaseTest : TestCase
        {
            public CollectionBaseTest () : base
                ("System.Collection.CollectionBase testsuite")
                {}
            public CollectionBaseTest (String name) : base (name)
                {}

            // We need a concrete class to test the abstract base
            // class
            public class ConcreteCollection : CollectionBase
            {
                // These fields are used as markers to test
                // the On* hooks.
                public bool onClearFired;
                public bool onClearCompleteFired;

                public bool onInsertFired;
                public int onInsertIndex;
                public bool onInsertCompleteFired;
                public int onInsertCompleteIndex;

                public bool onRemoveFired;
                public int onRemoveIndex;
                public bool onRemoveCompleteFired;
                public int onRemoveCompleteIndex;

                public bool onSetFired;
                public int onSetOldValue;
                public int onSetNewValue;
                public bool onSetCompleteFired;
                public int onSetCompleteOldValue;
                public int onSetCompleteNewValue;

                // This constructor is used to test OnValid()
                public ConcreteCollection()
                {
                    IList listObj;
                    listObj = this;
                    listObj.Add(null);
                }

                // This constructor puts consecutive integers into the list
                public ConcreteCollection(int i) {
                    IList listObj;
                    listObj = this;

                    int j;
                    for (j = 0; j< i; j++) {
                        listObj.Add(j);
                    }
                }

                // A helper method to look at a value in the
                // list at a specific index
                public int PeekAt(int index)
                {
                    IList listObj;
                    listObj = this;
                    return (int) listObj[index];
                }

                // Mark the flag if this hook is fired
                protected override void OnClear() {
                    this.onClearFired = true;
                }

                // Mark the flag if this hook is fired
                protected override void OnClearComplete()
                {
                    this.onClearCompleteFired = true;
                }

                // Mark the flag, and save the paramter if
                // this hook is fired
                protected override void OnInsert(int index,
                                object value)
                {
                    this.onInsertFired = true;
                    this.onInsertIndex = index;
                }

                // Mark the flag, and save the paramter if
                // this hook is fired
                protected override void OnInsertComplete(int index,
                                object value)
                {
                    this.onInsertCompleteFired = true;
                    this.onInsertCompleteIndex = index;
                }

                // Mark the flag, and save the paramter if this hook
                // is fired
                protected override void OnRemove(int index,
                                object value)
                {
                    this.onRemoveFired = true;
                    this.onRemoveIndex = index;
                }

                // Mark the flag, and save the paramter if this hook
                // is fired
                protected override void OnRemoveComplete(int index,
                                    object value)
                {
                    this.onRemoveCompleteFired = true;
                    this.onRemoveCompleteIndex = index;
                }

                // Mark the flag, and save the paramters if this hook
                // is fired
                protected override void OnSet(int index, object oldValue,
                                    object newValue)
                {
                    this.onSetFired = true;
                    this.onSetOldValue = (int) oldValue;
                    this.onSetNewValue = (int) newValue;
                }

                // Mark the flag, and save the paramters if this hook
                // is fired
                protected override void OnSetComplete(int index,
                                object oldValue,
                                object newValue)
                {
                    this.onSetCompleteFired = true;
                    this.onSetCompleteOldValue = (int) oldValue;
                    this.onSetCompleteNewValue = (int) newValue;
                }
            }  // public class ConcreteCollection

            public static ITest Suite {
                get {
                    return new TestSuite
                        (typeof(CollectionBaseTest));
                }
            }

            // Check the count property
            public void TestCount() {
                ConcreteCollection myCollection;
                myCollection = new ConcreteCollection(4);
                Assert(4 == myCollection.Count);
            }

        // Make sure GetEnumerator returns an object
        public void TestGetEnumerator() {
            ConcreteCollection myCollection;
            myCollection = new ConcreteCollection(4);
            Assert(null != myCollection.GetEnumerator());
        }

        // OnValid disallows nulls
        public void TestOnValid() {
            ConcreteCollection myCollection;
            try {
                myCollection = new ConcreteCollection();
            }
            catch (ArgumentNullException) {
            }
        }

        // Test various Insert paths
        public void TestInsert() {
            ConcreteCollection myCollection;
            int numberOfItems;
            numberOfItems = 3;
            // The constructor inserts
            myCollection = new ConcreteCollection(numberOfItems);
            Assert(myCollection.onInsertFired);
            Assert(myCollection.onInsertCompleteFired);

            // Using the IList interface, check inserts in the middle
            IList listObj = myCollection;
            listObj.Insert(1, 9);
            Assert(myCollection.onInsertIndex == 1);
            Assert(myCollection.onInsertCompleteIndex == 1);
            Assert(myCollection.PeekAt(1) == 9);
        }

        // Test Clear and it's hooks
        public void TestClear()
        {
            ConcreteCollection myCollection;
            int numberOfItems;
            numberOfItems = 1;
            myCollection = new ConcreteCollection(numberOfItems);
            myCollection.Clear();
            Assert(myCollection.Count == 0);
            Assert(myCollection.onClearFired);
            Assert(myCollection.onClearCompleteFired);
        }

        // Test RemoveAt, other removes and the hooks
        public void TestRemove()
        {
            ConcreteCollection myCollection;
            int numberOfItems;
            numberOfItems = 3;
            // Set up a test collection
            myCollection = new ConcreteCollection(numberOfItems);

            // The list is 0-based.  So if we remove the second one
            myCollection.RemoveAt(1);

            // We should see the original third one in it's place
            Assert(myCollection.PeekAt(1) == 2);
            Assert(myCollection.onRemoveFired);
            Assert(myCollection.onRemoveIndex == 1);
            Assert(myCollection.onRemoveCompleteFired);
            Assert(myCollection.onRemoveCompleteIndex == 1);
            IList listObj = myCollection;
            listObj.Remove(0);
            // Confirm parameters are being passed to the hooks
            Assert(myCollection.onRemoveIndex == 0);
            Assert(myCollection.onRemoveCompleteIndex == 0);
        }

        // Test the random access feature
        public void TestSet()
        {
            ConcreteCollection myCollection;
            int numberOfItems;
            numberOfItems = 3;
            myCollection = new ConcreteCollection(numberOfItems);
            IList listObj = myCollection;
            listObj[0] = 99;
            Assert((int) listObj[0] == 99);
            Assert(myCollection.onSetFired);
            Assert(myCollection.onSetCompleteFired);
            Assert(myCollection.onSetOldValue == 0);
            Assert(myCollection.onSetCompleteOldValue == 0);
            Assert(myCollection.onSetNewValue == 99);
            Assert(myCollection.onSetCompleteNewValue == 99);
        }
    }

    }