private static MultipleRelationship<ContactPersonTestBO> GetAggregateRelationship(OrganisationTestBO organisationTestBO, out BusinessObjectCollection<ContactPersonTestBO> cpCol) {
     MultipleRelationship<ContactPersonTestBO> aggregateRelationship = organisationTestBO.Relationships.GetMultiple<ContactPersonTestBO>("ContactPeople");
     RelationshipDef relationshipDef = (RelationshipDef) aggregateRelationship.RelationshipDef;
     relationshipDef.RelationshipType = RelationshipType.Aggregation;
     cpCol = aggregateRelationship.BusinessObjectCollection;
     return aggregateRelationship;
 }

        public void Test_BusinessObjectEdited_ShouldRefreshTheValueInTheList()
        {
            //---------------Set up test pack-------------------
            ClassDef.ClassDefs.Clear();
            MyBO.LoadDefaultClassDef();
            var listBox = GetControlFactory().CreateListBox();
            var manager = CreateListBoxCollectionManager(listBox);
            var boToBeUpdated = new MyBO();
            var myBoCol = new BusinessObjectCollection<MyBO> {new MyBO(), boToBeUpdated };
            manager.BusinessObjectCollection = myBoCol;

            manager.Control.SelectedItem = boToBeUpdated;
            var initialListBoxDisplayText = manager.Control.Text;
            var initialBOToString = boToBeUpdated.ToString();
            //---------------Assert Precondition----------------
            Assert.AreEqual(2, manager.Control.Items.Count);

            Assert.AreSame(boToBeUpdated, manager.Control.Items[1]);
            Assert.AreEqual(initialBOToString, initialListBoxDisplayText);
            //---------------Execute Test ----------------------
            boToBeUpdated.TestProp = GetRandomString();
            boToBeUpdated.Save();
            //---------------Test Result -----------------------
            var updatedListBoxDisplayText = manager.Control.Text;
            var updatedBOToString = boToBeUpdated.ToString();
            Assert.AreNotEqual(initialListBoxDisplayText, updatedListBoxDisplayText);
            Assert.AreNotEqual(initialBOToString, updatedBOToString);

            Assert.AreEqual(updatedBOToString, updatedListBoxDisplayText);
        }

        public void TestBusinessObjectControlHasDifferentBOWhenTabChanges()
        {
            //---------------Set up test pack-------------------
            IBOColTabControl boColTabControl = GetControlFactory().CreateBOColTabControl();

            IBusinessObjectControl busControl = GetBusinessObjectControlStub();
            boColTabControl.BusinessObjectControl = busControl;

            BusinessObjectCollection<MyBO> myBoCol = new BusinessObjectCollection<MyBO>();
            MyBO firstBo = new MyBO();
            myBoCol.Add(firstBo);
            myBoCol.Add(new MyBO());
            MyBO thirdBO = new MyBO();
            myBoCol.Add(thirdBO);
            boColTabControl.BusinessObjectCollection = myBoCol;

            //---------------Assert Precondition----------------
            Assert.AreEqual(firstBo, boColTabControl.BusinessObjectControl.BusinessObject);

            //---------------Execute Test ----------------------
            boColTabControl.TabControl.SelectedIndex = 2;

            //---------------Test Result -----------------------
            Assert.AreNotSame(firstBo, boColTabControl.BusinessObjectControl.BusinessObject);
            Assert.AreEqual(thirdBO, boColTabControl.BusinessObjectControl.BusinessObject);
        }

        public void TearDown()
        {
            BusinessObjectCollection<Shape> shapes = new BusinessObjectCollection<Shape>();
            shapes.LoadAll();
            Shape[] shapesClone = shapes.ToArray();
            foreach (Shape shape in shapesClone)
            {
                shape.MarkForDelete();
            }
            shapes.SaveAll();
            //Shape shape = BOLoader.Instance.GetBusinessObject<Shape>(
            //    "ShapeName = 'MyShape' OR ShapeName = 'MyShapeChanged'");
            //if (shape != null)
            //{
            //    shape.MarkForDelete();
            //    shape.Save();
            //}

            //CircleNoPrimaryKey circle = BOLoader.Instance.GetBusinessObject<CircleNoPrimaryKey>(
            //    "ShapeName = 'Circle' OR ShapeName = 'CircleChanged'");
            //if (circle != null)
            //{
            //    circle.MarkForDelete();
            //    circle.Save();
            //}

            //FilledCircleInheritsCircleNoPK filledCircle = BOLoader.Instance.GetBusinessObject<FilledCircleInheritsCircleNoPK>(
            //    "ShapeName = 'FilledCircle' OR ShapeName = 'FilledCircleChanged'");
            //if (filledCircle != null)
            //{
            //    filledCircle.MarkForDelete();
            //    filledCircle.Save();
            //}
        }

 protected MultipleRelationship<ContactPersonTestBO> GetRelationship(
     out OrganisationTestBO organisationTestBO, 
     out BusinessObjectCollection<ContactPersonTestBO> cpCol)
 {
     RelationshipCol relationships;
     return GetRelationship(out organisationTestBO, out relationships, out cpCol);
 }

 private static void SetupSelectorWithTestPackCollection(ComboBoxCollectionSelector selectorManager, bool includeBlankItems)
 {
     MyBO.LoadDefaultClassDef();
     selectorManager.IncludeBlankItem = includeBlankItems;
     BusinessObjectCollection<MyBO> myBOs = new BusinessObjectCollection<MyBO> { { new MyBO(), new MyBO() } };
     selectorManager.SetCollection(myBOs);
 }

 public void InitialiseCollection()
 {
     _boCol = new BusinessObjectCollection<MultiPropBO>();
     _boCol.Add((MultiPropBO)_classDef.CreateNewBusinessObject());
     _boCol.Add((MultiPropBO)_classDef.CreateNewBusinessObject());
     //_boCol.Add((MultiPropBO)_classDef.CreateNewBusinessObject());
     //_boCol.Add((MultiPropBO)_classDef.CreateNewBusinessObject());
 }

        public static BusinessObjectCollection GetData(int categoryId)
        {
            List<BusinessObject> result = GetData().FindAll(obj => obj.CategoryID == categoryId);
            BusinessObjectCollection ret = new BusinessObjectCollection();
            ret.Clear();
            ret.AddRange(result);

            return ret;
        }

 public static void AssertAllCollectionsHaveNoItems(BusinessObjectCollection<ContactPersonTestBO> cpCol)
 {
     Assert.AreEqual(0, cpCol.Count);
     Assert.AreEqual(0, cpCol.AddedBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.RemovedBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.PersistedBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.MarkedForDeleteBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.CreatedBusinessObjects.Count);
 }

 private static MultipleRelationship<ContactPersonTestBO> GetCompositionRelationship(out BusinessObjectCollection<ContactPersonTestBO> cpCol, OrganisationTestBO organisationTestBO)
 {
     MultipleRelationship<ContactPersonTestBO> compositionRelationship =
         organisationTestBO.Relationships.GetMultiple<ContactPersonTestBO>("ContactPeople");
     RelationshipDef relationshipDef = (RelationshipDef)compositionRelationship.RelationshipDef;
     relationshipDef.RelationshipType = RelationshipType.Composition;
     cpCol = compositionRelationship.BusinessObjectCollection;
     return compositionRelationship;
 }

        public static BusinessObjectCollection GetHierarchicalData(int? parentId)
        {
            List<BusinessObject> result = GetData().FindAll(obj => obj.ParentID == parentId);
            BusinessObjectCollection ret = new BusinessObjectCollection();
            ret.Clear();
            ret.AddRange(result);

            return ret;
        }

 public static void AssertOneObjectInCurrentPersistedCollectionOnly
     (BusinessObjectCollection<ContactPersonTestBO> cpCol)
 {
     Assert.AreEqual(1, cpCol.Count);
     Assert.AreEqual(0, cpCol.AddedBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.RemovedBusinessObjects.Count);
     Assert.AreEqual(1, cpCol.PersistedBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.MarkedForDeleteBusinessObjects.Count);
     Assert.AreEqual(0, cpCol.CreatedBusinessObjects.Count);
 }

 protected void CreateDirtyChildren(BusinessObjectCollection<ContactPersonTestBO> cpCol,
                         out ContactPersonTestBO existingChild,
                         out ContactPersonTestBO editedChild,
                         out ContactPersonTestBO deletedChild,
                         out ContactPersonTestBO createdChildWithEdits,
                         out ContactPersonTestBO createdChild)
 {
     createdChild = CreateCreatedChild(cpCol);
     createdChildWithEdits = CreateCreatedChildWithEdits(cpCol);
     existingChild = CreateExistingChild(cpCol);
     editedChild = CreateEditedChild(cpCol);
     deletedChild = CreateDeletedChild(cpCol);
 }

 public void Test_BindBusinessObjectCollection_ToListBox_ShouldAddToControlList()
 {
     //---------------Set up test pack-------------------
     var lstBox = new ListBox();
     var selectorBinder = new HabaneroSelectorControlBinder<FakeBo, ListBox>(lstBox);
     var businessObjectCollection = new BusinessObjectCollection<FakeBo>();
     businessObjectCollection.CreateBusinessObject();
     //---------------Assert Precondition----------------
     Assert.AreEqual(0, lstBox.Items.Count);
     //---------------Execute Test ----------------------
     selectorBinder.SetBusinessObjectCollection(businessObjectCollection);
     //---------------Test Result -----------------------
     Assert.AreEqual(1, lstBox.Items.Count, "The business object collection's items should be in list");
 }

        public void TestFixtureSetup()
        {
            //Code that is executed before any test is run in this class. If multiple tests
            // are executed then it will still only be called once.
            ClassDef.ClassDefs.Clear();
            BOWithIntID.LoadClassDefWithIntID();
            _propDef_int = new PropDef("PropName", typeof (int), PropReadWriteRule.ReadWrite, null);
            _validBusinessObject = new BOWithIntID {TestField = _validLookupValue};
            _validIntID = 3;
            _validBusinessObject.IntID = _validIntID;
            _collection_IntId = new BusinessObjectCollection<BOWithIntID> {_validBusinessObject};

            _propDef_int.LookupList = new BusinessObjectLookupListStub(typeof (BOWithIntID), _collection_IntId);
        }

        public void TestSetCollection_EmptyCollection()
        {
            //---------------Set up test pack-------------------
            ListViewCollectionManager cntrl = CreateDefaultListVievController();
            BusinessObjectCollection<MyBO> col = new BusinessObjectCollection<MyBO>();

            //---------------Execute Test ----------------------
            cntrl.SetCollection(col);
            //---------------Test Result -----------------------
            Assert.AreEqual(0, cntrl.ListView.Items.Count);
            //UIDef uiDef = GetDefaultUIDef(cntrl);
            //Assert.AreEqual(uiDef.GetUIGridProperties().Count, cntrl.ListView.Columns.Count);//There are 8 columns in the collection BO
            //Assert.IsNull(gridBase.SelectedBusinessObject);
            //---------------Tear Down -------------------------          
        }

 public override void Test_SelectedBusinessObject_ReturnsNullIfNoItemSelected()
 {
     //---------------Set up test pack-------------------
     IBOColSelectorControl colSelector = CreateSelector();
     MyBO myBO = new MyBO();
     BusinessObjectCollection<MyBO> collection = new BusinessObjectCollection<MyBO> { myBO };
     colSelector.BusinessObjectCollection = collection;
     colSelector.SelectedBusinessObject = null;
     //---------------Assert Precondition----------------
     Assert.AreEqual(collection.Count + NumberOfLeadingBlankRows(), colSelector.NoOfItems, "The blank item and one other");
     //---------------Execute Test ----------------------
     IBusinessObject selectedBusinessObject = colSelector.SelectedBusinessObject;
     //---------------Test Result -----------------------
     Assert.IsNull(selectedBusinessObject);
 }

 public void TestCreateTestTabControlCollectionController()
 {
     //---------------Set up test pack-------------------
     BusinessObjectCollection<MyBO> myBOs = new BusinessObjectCollection<MyBO> {{new MyBO(), new MyBO()}};
     ITabControl tabControl = CreateTabControl();
     BOColTabControlManager selectorManager = new BOColTabControlManager(tabControl, GetControlFactory());
     selectorManager.BusinessObjectControl = GetBusinessObjectControl();
     //---------------Verify test pack-------------------
     //---------------Execute Test ----------------------
     selectorManager.BusinessObjectCollection = myBOs;
     //---------------Verify Result -----------------------
     Assert.AreEqual(myBOs, selectorManager.BusinessObjectCollection);
     Assert.AreSame(tabControl, selectorManager.TabControl);
     //---------------Tear Down -------------------------   
 }

        public void TestSetCollectionOnGrid_EmptyCollection()
        {
            //---------------Set up test pack-------------------
            MyBO.LoadDefaultClassDef();
            var col = new BusinessObjectCollection<MyBO>();
            var gridBase = CreateGridBaseStub();
            SetupGridColumnsForMyBo(gridBase);
            //---------------Execute Test ----------------------
#pragma warning disable 618,612
            gridBase.SetBusinessObjectCollection(col);
#pragma warning restore 618,612
            //---------------Test Result -----------------------
            Assert.AreEqual(0, gridBase.Rows.Count);
            //Assert.AreEqual(classDef.PropDefcol.Count, myGridBase.Columns.Count);//There are 8 columns in the collection BO
            Assert.IsNull(gridBase.SelectedBusinessObject);
            //---------------Tear Down -------------------------          
        }

 public void Test_CreateTestComboBoxCollectionController()
 {
     //---------------Set up test pack-------------------
     MyBO.LoadClassDefWithBoolean();
     BusinessObjectCollection<MyBO> myBOs = new BusinessObjectCollection<MyBO> {{new MyBO(), new MyBO()}};
     IComboBox cmb = GetControlFactory().CreateComboBox();
     DisposeOnTearDown(cmb);
     ComboBoxCollectionSelector selector = new ComboBoxCollectionSelector(cmb, GetControlFactory());
     DisposeOnTearDown(selector);
     //---------------Verify test pack-------------------
     //---------------Execute Test ----------------------
     selector.SetCollection(myBOs);
     //---------------Verify Result -----------------------
     Assert.AreEqual(myBOs, selector.BusinessObjectCollection);
     Assert.AreSame(cmb,selector.Control);
     //---------------Tear Down -------------------------   
 }