Author: suresh
Date: 2005-10-11 10:16:15 -0400 (Tue, 11 Oct 2005)
New Revision: 51574

Added:
   trunk/mcs/class/System.Data/Test/System.Data/DataViewTest_IBindingList.cs
Modified:
   trunk/mcs/class/System.Data/System.Data/ChangeLog
   trunk/mcs/class/System.Data/System.Data/DataView.cs
   trunk/mcs/class/System.Data/System.Data_test.dll.sources
   trunk/mcs/class/System.Data/Test/System.Data/ChangeLog
Log:
In Test/System.Data:
2005-10-11  Sureshkumar T  <[EMAIL PROTECTED]>

        * DataViewTest_IBindingList.cs: Added test cases for IBindingList
        implementation by DataView. This is used by DataGrid control.

In System.Data:
2005-10-11  Sureshkumar T  <[EMAIL PROTECTED]>

        * DataView.cs (IBindingList): Implemented methods for IBindingList 
interface.



Modified: trunk/mcs/class/System.Data/System.Data/ChangeLog
===================================================================
--- trunk/mcs/class/System.Data/System.Data/ChangeLog   2005-10-11 13:53:35 UTC 
(rev 51573)
+++ trunk/mcs/class/System.Data/System.Data/ChangeLog   2005-10-11 14:16:15 UTC 
(rev 51574)
@@ -1,3 +1,7 @@
+2005-10-11  Sureshkumar T  <[EMAIL PROTECTED]>
+
+       * DataView.cs (IBindingList): Implemented methods for IBindingList 
interface.
+
 2005-09-26  Lluis Sanchez Gual <[EMAIL PROTECTED]>
 
        * DataSet.cs: In IXmlSerializable.GetSchema, return null again for

Modified: trunk/mcs/class/System.Data/System.Data/DataView.cs
===================================================================
--- trunk/mcs/class/System.Data/System.Data/DataView.cs 2005-10-11 13:53:35 UTC 
(rev 51573)
+++ trunk/mcs/class/System.Data/System.Data/DataView.cs 2005-10-11 14:16:15 UTC 
(rev 51574)
@@ -41,6 +41,9 @@
                string rowFilter = String.Empty;
                IExpression rowFilterExpr;
                string sort = String.Empty;
+               ListSortDirection [] sortOrder = null;
+               PropertyDescriptor sortProperty = null;
+               DataColumn [] sortColumns = null;
                internal DataViewRowState rowState;
                internal DataRowView[] rowCache = new DataRowView [0];
 
@@ -370,7 +373,8 @@
                        else {
                                _lastAdded.CancelEdit();
                                _lastAdded = null;
-                               OnListChanged(new 
ListChangedEventArgs(ListChangedType.ItemDeleted, Count - 1));
+                               OnListChanged(new 
ListChangedEventArgs(ListChangedType.ItemDeleted, Count - 1, -1));
+                               // FIXME : remove from rowCache
                        }
                }
 
@@ -752,9 +756,8 @@
                        }
 
                        if (Index == null || force) {
-                               ListSortDirection[] sortOrder = null;
-                               DataColumn[] columns = 
DataTable.ParseSortString(Table, Sort, out sortOrder, false);
-                               Index = 
dataTable.GetIndex(columns,sortOrder,RowStateFilter,FilterExpression,true);
+                               sortColumns = DataTable.ParseSortString(Table, 
Sort, out sortOrder, false);
+                               Index = 
dataTable.GetIndex(sortColumns,sortOrder,RowStateFilter,FilterExpression,true);
                        }
                        else {
                                Index.Key.RowStateFilter = RowStateFilter;
@@ -926,16 +929,20 @@
                        throw new NotImplementedException ();
                }
 
-               [MonoTODO]
                object IBindingList.AddNew () 
                {
                        return this.AddNew ();
                }
 
-               [MonoTODO]
                void IBindingList.ApplySort (PropertyDescriptor property, 
ListSortDirection direction) 
                {
-                       throw new NotImplementedException ();
+                       if (! (property is DataColumnPropertyDescriptor))
+                               throw new ArgumentException ("Dataview accepts 
only DataColumnPropertyDescriptors", "property");
+                       sortProperty = property;
+                       string sort = String.Format ("[{0}]" , property.Name);
+                       if (direction == ListSortDirection.Descending)
+                               sort += " DESC";
+                       this.Sort = sort;
                }
 
                [MonoTODO]
@@ -950,21 +957,19 @@
                        throw new NotImplementedException ();
                }
 
-               [MonoTODO]
                void IBindingList.RemoveSort () 
                {
-                       throw new NotImplementedException ();
+                       sortProperty = null;
+                       this.Sort = String.Empty;
                }
                
                bool IBindingList.AllowEdit {
-                       [MonoTODO]
                        get {
                                return AllowEdit;
                        }
                }
 
                bool IBindingList.AllowNew {
-                       [MonoTODO]
                        get {
                                return AllowNew;
                        }
@@ -978,46 +983,45 @@
                }
 
                bool IBindingList.IsSorted {
-                       [MonoTODO]
                        get {
-                               return isSorted;
+                               return Sort != null && Sort != String.Empty;
                        }
                }
 
                ListSortDirection IBindingList.SortDirection {
-                       [MonoTODO]
                        get {
-                               // FIXME: 
+                               if (sortOrder != null && sortOrder.Length > 0)
+                                       return sortOrder [0];
                                return ListSortDirection.Ascending;
                        }
                }
 
                PropertyDescriptor IBindingList.SortProperty {
-                       [MonoTODO]
                        get {
-                               // FIXME:
-                               return null;
+                               if (sortProperty == null && sortColumns != null 
&& sortColumns.Length > 0) {
+                                       // return property from Sort String
+                                       PropertyDescriptorCollection properties 
= ( (ITypedList) this).GetItemProperties (null);
+                                       return properties.Find ( sortColumns 
[0].ColumnName, false);
+                               }
+                               return sortProperty;
                        }
                }
 
                bool IBindingList.SupportsChangeNotification {
-                       [MonoTODO]
                        get {
-                               return false;
+                               return true;
                        }
                }
 
                bool IBindingList.SupportsSearching {
-                       [MonoTODO]
                        get {
-                               return false;
+                               return true;
                        }
                }
 
                bool IBindingList.SupportsSorting {
-                       [MonoTODO]
                        get {
-                               return false;
+                               return true;
                        }
                }
 

Modified: trunk/mcs/class/System.Data/System.Data_test.dll.sources
===================================================================
--- trunk/mcs/class/System.Data/System.Data_test.dll.sources    2005-10-11 
13:53:35 UTC (rev 51573)
+++ trunk/mcs/class/System.Data/System.Data_test.dll.sources    2005-10-11 
14:16:15 UTC (rev 51574)
@@ -42,6 +42,7 @@
 System.Data/DataViewManagerTest.cs
 System.Data/DataViewTest.cs
 System.Data/DataViewTest2.cs
+System.Data/DataViewTest_IBindingList.cs
 System.Data/ForeignKeyConstraintTest.cs
 System.Data/ForeignKeyConstraintTest2.cs
 System.Data/TypedDataSetGeneratorTest.cs

Modified: trunk/mcs/class/System.Data/Test/System.Data/ChangeLog
===================================================================
--- trunk/mcs/class/System.Data/Test/System.Data/ChangeLog      2005-10-11 
13:53:35 UTC (rev 51573)
+++ trunk/mcs/class/System.Data/Test/System.Data/ChangeLog      2005-10-11 
14:16:15 UTC (rev 51574)
@@ -1,3 +1,8 @@
+2005-10-11  Sureshkumar T  <[EMAIL PROTECTED]>
+
+       * DataViewTest_IBindingList.cs: Added test cases for IBindingList
+       implementation by DataView. This is used by DataGrid control.
+
 2005-09-20  Sureshkumar T  <[EMAIL PROTECTED]>
 
        * DataViewTest.cs: Added a case for Sort to accept columns with

Added: trunk/mcs/class/System.Data/Test/System.Data/DataViewTest_IBindingList.cs
===================================================================
--- trunk/mcs/class/System.Data/Test/System.Data/DataViewTest_IBindingList.cs   
2005-10-11 13:53:35 UTC (rev 51573)
+++ trunk/mcs/class/System.Data/Test/System.Data/DataViewTest_IBindingList.cs   
2005-10-11 14:16:15 UTC (rev 51574)
@@ -0,0 +1,193 @@
+// DataViewTest_IBindingList.cs - Nunit Test Cases for for testing the DataView
+// class for IBindingList Implementation
+//
+// Authors:
+//      Sureshkumar T <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+
+using System;
+using System.IO;
+using System.Data;
+using System.ComponentModel;
+
+namespace MonoTests.System.Data
+{
+       using NUnit.Framework;
+
+       [TestFixture]
+       public class DataViewTest_IBindingList
+       {
+               DataTable dt = new DataTable ();
+
+               public DataViewTest_IBindingList ()
+               {
+                       dt.Columns.Add ("id", typeof (int));
+                       dt.Columns [0].AutoIncrement = true;
+                       dt.Columns [0].AutoIncrementSeed = 5;
+                       dt.Columns [0].AutoIncrementStep = 5;
+                       dt.Columns.Add ("name", typeof (string));
+
+                       dt.Rows.Add (new object [] { null, "mono test 1" });
+                       dt.Rows.Add (new object [] { null, "mono test 3" });
+                       dt.Rows.Add (new object [] { null, "mono test 2" });
+                       dt.Rows.Add (new object [] { null, "mono test 4" });
+               }
+
+               [Test]
+               public void PropertyTest ()
+               {
+                       DataView dv = dt.DefaultView;
+                       IBindingList ib = (IBindingList) dv;
+                       Assert.IsTrue (ib.AllowEdit, "#1");
+                       Assert.IsTrue (ib.AllowNew, "#2");
+                       Assert.IsTrue (ib.AllowRemove, "#3");
+                       Assert.IsFalse (ib.IsSorted, "#4");
+                       Assert.AreEqual (ListSortDirection.Ascending, 
ib.SortDirection, "#5");
+                       Assert.IsTrue (ib.SupportsChangeNotification, "#6");
+                       Assert.IsTrue (ib.SupportsSearching, "#7");
+                       Assert.IsTrue (ib.SupportsSorting, "#8");
+                       Assert.IsNull (ib.SortProperty, "#9");
+               }
+
+               [Test]
+               [Category ("NotWorking")] // Enable this after rowCache removal 
is fixed
+               public void AddNewTest ()
+               {
+                       DataView dv = dt.DefaultView;
+                       IBindingList ib = (IBindingList) dv;
+                       ib.ListChanged += new ListChangedEventHandler 
(OnListChanged);
+
+                       try {
+                               args = null;
+                               object o = ib.AddNew ();
+                               Assert.AreEqual (typeof (DataRowView), 
o.GetType (), "#1");
+                               Assert.AreEqual (ListChangedType.ItemAdded, 
args.ListChangedType, "#1.1");
+                               Assert.AreEqual (4, args.NewIndex, "#1.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#1.3");
+
+                               DataRowView r = (DataRowView) o;
+                               Assert.AreEqual (25, r ["id"], "#2"); 
+                               Assert.AreEqual (DBNull.Value, r ["name"], 
"#3"); 
+                               Assert.AreEqual (5, dv.Count, "#4");
+
+                               args = null;
+                               r.CancelEdit ();
+                               Assert.AreEqual (ListChangedType.ItemDeleted, 
args.ListChangedType, "#4.1");
+                               Assert.AreEqual (4, args.NewIndex, "#4.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#4.3");
+                               Assert.AreEqual (4, dv.Count, "#5");
+                       } finally {
+                               ib.ListChanged -= new ListChangedEventHandler 
(OnListChanged);
+                       }
+               }
+
+               ListChangedEventArgs args = null;
+
+               public void OnListChanged (object sender, ListChangedEventArgs 
args)
+               {
+                       this.args = args;
+               }
+
+               [Test]
+               public void SortTest ()
+               {
+                       DataView dv = dt.DefaultView;
+                       IBindingList ib = (IBindingList) dv;
+                       ib.ListChanged += new ListChangedEventHandler 
(OnListChanged);
+                       try {
+                               args = null;
+                               dv.Sort = "[id] DESC";
+                               Assert.AreEqual (ListChangedType.Reset, 
args.ListChangedType, "#0.1");
+                               Assert.AreEqual (-1, args.NewIndex, "#0.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#0.3");
+                               Assert.IsTrue (ib.IsSorted, "#1");
+                               Assert.IsNotNull (ib.SortProperty, "#2");
+                               Assert.AreEqual (ListSortDirection.Descending, 
ib.SortDirection, "2.0");
+
+
+                               args = null;
+                               dv.Sort = null;
+                               Assert.AreEqual (ListChangedType.Reset, 
args.ListChangedType, "#2.1");
+                               Assert.AreEqual (-1, args.NewIndex, "#2.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#2.3");
+                               Assert.IsFalse (ib.IsSorted, "#3");
+                               Assert.IsNull (ib.SortProperty, "#4");
+
+                               PropertyDescriptorCollection pds = ( 
(ITypedList) dv).GetItemProperties (null);
+                               PropertyDescriptor pd = pds.Find ("id", false);
+                               args = null;
+                               ib.ApplySort (pd, ListSortDirection.Ascending);
+                               Assert.AreEqual (ListChangedType.Reset, 
args.ListChangedType, "#4.1");
+                               Assert.AreEqual (-1, args.NewIndex, "#4.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#4.3");
+                               Assert.IsTrue (ib.IsSorted, "#5");
+                               Assert.IsNotNull (ib.SortProperty, "#6");
+                               Assert.AreEqual ("[id]", dv.Sort, "#6.1");
+
+                               args = null;
+                               ib.RemoveSort ();
+                               Assert.AreEqual (ListChangedType.Reset, 
args.ListChangedType, "#6.1");
+                               Assert.AreEqual (-1, args.NewIndex, "#6.2");
+                               Assert.AreEqual (-1, args.OldIndex, "#6.3");
+                               Assert.IsFalse (ib.IsSorted, "#7");
+                               Assert.IsNull (ib.SortProperty, "#8");
+                               Assert.AreEqual (String.Empty, dv.Sort, "#8.1");
+                               args = null;
+
+                               // descending
+                               args = null;
+                               ib.ApplySort (pd, ListSortDirection.Descending);
+                               Assert.AreEqual (20, dv [0] [0], "#9");
+                               Assert.AreEqual ("[id] DESC", dv.Sort, "#10");
+                               args = null;
+                       } finally {
+                               ib.ListChanged -= new ListChangedEventHandler 
(OnListChanged);
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")] // Feature not yet implemented
+               public void FindTest ()
+               {
+                       DataView dv = dt.DefaultView;
+                       IBindingList ib = (IBindingList) dv;
+                       ib.ListChanged += new ListChangedEventHandler 
(OnListChanged);
+                       try {
+                               args = null;
+
+                               PropertyDescriptorCollection pds = ( 
(ITypedList) dv).GetItemProperties (null);
+                               PropertyDescriptor pd = pds.Find ("id", false);
+                               int index = ib.Find (pd, 15);
+                               Assert.AreEqual (2, index, "#1");
+
+                               // negative search
+                               index = ib.Find (pd, 44);
+                               Assert.AreEqual (-1, index, "#2");
+                       } finally {
+                               ib.ListChanged -= new ListChangedEventHandler 
(OnListChanged);
+                       }
+               }
+       }
+}


Property changes on: 
trunk/mcs/class/System.Data/Test/System.Data/DataViewTest_IBindingList.cs
___________________________________________________________________
Name: svn:eol-style
   + native

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to