using System.Collections;
using System.ComponentModel;
using System.Globalization;
+using System.Threading;
using NUnit.Framework;
[TestFixture]
public class PropertyDescriptorCollectionTests
{
+ private CultureInfo originalCulture;
+
+ [SetUp]
+ public void SetUp ()
+ {
+ originalCulture = Thread.CurrentThread.CurrentCulture;
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ Thread.CurrentThread.CurrentCulture = originalCulture;
+ }
+
[Test]
-#if TARGET_JVM
- [Ignore ("TD BUG ID: 7229")]
-#endif
public void Empty ()
{
PropertyDescriptorCollection descriptors = PropertyDescriptorCollection.Empty;
+ Assert.AreEqual (0, descriptors.Count);
AssertReadOnly (descriptors, "Empty");
}
[Test]
public void Find ()
{
- PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection (
- new PropertyDescriptor[] { new MockPropertyDescriptor("A", 1),
- new MockPropertyDescriptor("b", 2)});
-
- Assert.IsNotNull (descriptors.Find ("A", false), "#1");
- Assert.IsNotNull (descriptors.Find ("b", false), "#2");
- Assert.IsNull (descriptors.Find ("a", false), "#3");
- Assert.IsNotNull (descriptors.Find ("a", true), "#4");
+ PropertyDescriptor descA = new MockPropertyDescriptor ("hehe_\u0061\u030a", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("heh_\u00e5", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Foo", 5);
+ PropertyDescriptor descD = new MockPropertyDescriptor ("FOo", 6);
+ PropertyDescriptor descE = new MockPropertyDescriptor ("Aim", 1);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("Bar", 4);
+
+ PropertyDescriptorCollection col = new PropertyDescriptorCollection (
+ new PropertyDescriptor [] { descA, descB, descC, descD, descE, descF });
+
+ Assert.IsNull (col.Find ("heh_\u0061\u030a", false), "#1");
+ Assert.IsNull (col.Find ("hehe_\u00e5", false), "#2");
+ Assert.AreSame (descA, col.Find ("hehe_\u0061\u030a", false), "#3");
+ Assert.AreSame (descB, col.Find ("heh_\u00e5", false), "#4");
+ Assert.IsNull (col.Find ("foo", false), "#5");
+ Assert.AreSame (descC, col.Find ("foo", true), "#6");
+ Assert.AreSame (descD, col.Find ("FOo", false), "#7");
+ Assert.AreSame (descC, col.Find ("FOo", true), "#8");
+ Assert.IsNull (col.Find ("fOo", false), "#9");
+ Assert.AreSame (descC, col.Find ("fOo", true), "#10");
+ Assert.IsNull (col.Find ("AIm", false), "#11");
+ Assert.AreSame (descE, col.Find ("AIm", true), "#12");
+ Assert.IsNull (col.Find ("AiM", false), "#13");
+ Assert.AreSame (descE, col.Find ("AiM", true), "#14");
+ Assert.AreSame (descE, col.Find ("Aim", false), "#15");
+ Assert.AreSame (descE, col.Find ("Aim", true), "#16");
}
[Test]
- [ExpectedException (typeof(ArgumentNullException))]
- public void Find_NullKey ()
+ public void Find_Name_Null ()
{
- PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection (
- new PropertyDescriptor[] { new MockPropertyDescriptor("A", 1),
- new MockPropertyDescriptor("b", 2)});
- descriptors.Find (null, false);
+ PropertyDescriptorCollection descriptors;
+
+ descriptors = new PropertyDescriptorCollection (
+ new PropertyDescriptor[] { new MockPropertyDescriptor ("A", 1),
+ new MockPropertyDescriptor ("b", 2)});
+
+ try {
+ descriptors.Find (null, false);
+ Assert.Fail ("#A1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ }
+
+ try {
+ descriptors.Find (null, true);
+ Assert.Fail ("#B1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ }
+
+ descriptors = PropertyDescriptorCollection.Empty;
+
+ try {
+ descriptors.Find (null, false);
+ Assert.Fail ("#C1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
+ Assert.IsNull (ex.InnerException, "#C3");
+ Assert.IsNotNull (ex.Message, "#C4");
+ Assert.IsNotNull (ex.ParamName, "#C5");
+ }
+
+ try {
+ descriptors.Find (null, true);
+ Assert.Fail ("#D1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#D2");
+ Assert.IsNull (ex.InnerException, "#D3");
+ Assert.IsNotNull (ex.Message, "#D4");
+ Assert.IsNotNull (ex.ParamName, "#D5");
+ }
}
[Test]
dictionary.Add ("whatever", 5);
}
+ [Test] // this [String]
+ public void Indexer2 ()
+ {
+ PropertyDescriptor descA = new MockPropertyDescriptor ("hehe_\u0061\u030a", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("heh_\u00e5", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Foo", 5);
+ PropertyDescriptor descD = new MockPropertyDescriptor ("FOo", 6);
+ PropertyDescriptor descE = new MockPropertyDescriptor ("Aim", 1);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("Bar", 4);
+
+ PropertyDescriptorCollection col = new PropertyDescriptorCollection (
+ new PropertyDescriptor [] { descA, descB, descC, descD, descE, descF });
+
+ Assert.IsNull (col ["heh_\u0061\u030a"], "#1");
+ Assert.IsNull (col ["hehe_\u00e5"], "#2");
+ Assert.AreSame (descA, col ["hehe_\u0061\u030a"], "#3");
+ Assert.AreSame (descB, col ["heh_\u00e5"], "#4");
+ Assert.IsNull (col ["foo"], "#5");
+ Assert.AreSame (descD, col ["FOo"], "#6");
+ Assert.IsNull (col ["fOo"], "#7");
+ Assert.IsNull (col ["AIm"], "#8");
+ Assert.IsNull (col ["AiM"], "#9");
+ Assert.AreSame (descE, col ["Aim"], "#10");
+ }
+
[Test]
- public void CultureInsensitiveFindTest ()
+ public void Indexer2_Name_Null ()
{
- Assert.AreEqual(0, string.Compare ("\u0061\u030a", "\u00e5", true), "#1");
+ PropertyDescriptorCollection descriptors;
- PropertyDescriptorCollection col =
- new PropertyDescriptorCollection (
- new PropertyDescriptor [] {
- new MockPropertyDescriptor ("hehe_\u0061\u030a", null),
- new MockPropertyDescriptor ("heh_\u00e5", null) });
+ descriptors = new PropertyDescriptorCollection (
+ new PropertyDescriptor [] { new MockPropertyDescriptor ("A", 1),
+ new MockPropertyDescriptor ("b", 2)});
- Assert.IsNull (col.Find ("heh_\u0061\u030a", false), "#2");
- Assert.IsNull (col.Find ("hehe_\u00e5", false), "#3");
+ try {
+ PropertyDescriptor desc = descriptors [(string) null];
+ Assert.Fail ("#A1:" + desc);
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ }
+
+ descriptors = PropertyDescriptorCollection.Empty;
+ try {
+ PropertyDescriptor desc = descriptors [(string) null];
+ Assert.Fail ("#B1:" + desc);
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ }
}
+
#if NET_2_0
public void ReadOnly ()
{
}
#endif
+ [Test] // Sort ()
+ public void Sort1 ()
+ {
+ PropertyDescriptorCollection descriptors;
+ PropertyDescriptorCollection sorted;
+
+ PropertyDescriptor descA = new MockPropertyDescriptor("Foo", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
+ PropertyDescriptor descD = new MockPropertyDescriptor("AIm", 5);
+ PropertyDescriptor descE = new MockPropertyDescriptor("Boo", 4);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
+
+ PropertyDescriptor [] props = new PropertyDescriptor [] {
+ descA, descB, descC, descD, descE, descF };
+ descriptors = new PropertyDescriptorCollection (props);
+
+ Assert.AreSame (descA, descriptors [0], "#A1");
+ Assert.AreSame (descB, descriptors [1], "#A2");
+ Assert.AreSame (descC, descriptors [2], "#A3");
+ Assert.AreSame (descD, descriptors [3], "#A4");
+ Assert.AreSame (descE, descriptors [4], "#A5");
+ Assert.AreSame (descF, descriptors [5], "#A6");
+
+ sorted = descriptors.Sort ();
+
+ Assert.AreSame (descA, descriptors [0], "#B1");
+ Assert.AreSame (descB, descriptors [1], "#B2");
+ Assert.AreSame (descC, descriptors [2], "#B3");
+ Assert.AreSame (descD, descriptors [3], "#B4");
+ Assert.AreSame (descE, descriptors [4], "#B5");
+ Assert.AreSame (descF, descriptors [5], "#B6");
+
+ Assert.AreSame (descB, sorted [0], "#C1");
+ Assert.AreSame (descD, sorted [1], "#C2");
+ Assert.AreSame (descC, sorted [2], "#C3");
+ Assert.AreSame (descE, sorted [3], "#C4");
+ Assert.AreSame (descA, sorted [4], "#C5");
+ Assert.AreSame (descF, sorted [5], "#C6");
+ }
+
+ [Test] // Sort (String [])
+ public void Sort2 ()
+ {
+ PropertyDescriptorCollection descriptors;
+ PropertyDescriptorCollection sorted;
+
+ PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
+ PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
+ PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
+
+ PropertyDescriptor [] props = new PropertyDescriptor [] {
+ descA, descB, descC, descD, descE, descF };
+ descriptors = new PropertyDescriptorCollection (props);
+
+ Assert.AreSame (descA, descriptors [0], "#A1");
+ Assert.AreSame (descB, descriptors [1], "#A2");
+ Assert.AreSame (descC, descriptors [2], "#A3");
+ Assert.AreSame (descD, descriptors [3], "#A4");
+ Assert.AreSame (descE, descriptors [4], "#A5");
+ Assert.AreSame (descF, descriptors [5], "#A5");
+
+ sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" });
+
+ Assert.AreSame (descA, descriptors [0], "#B1");
+ Assert.AreSame (descB, descriptors [1], "#B2");
+ Assert.AreSame (descC, descriptors [2], "#B3");
+ Assert.AreSame (descD, descriptors [3], "#B4");
+ Assert.AreSame (descE, descriptors [4], "#B5");
+ Assert.AreSame (descF, descriptors [5], "#B6");
+
+ Assert.AreSame (descA, sorted [0], "#C1");
+ Assert.AreSame (descE, sorted [1], "#C2");
+ Assert.AreSame (descB, sorted [2], "#C3");
+ Assert.AreSame (descD, sorted [3], "#C4");
+ Assert.AreSame (descC, sorted [4], "#C5");
+ Assert.AreSame (descF, sorted [5], "#C6");
+
+ sorted = descriptors.Sort ((string []) null);
+
+ Assert.AreSame (descA, descriptors [0], "#D1");
+ Assert.AreSame (descB, descriptors [1], "#D2");
+ Assert.AreSame (descC, descriptors [2], "#D3");
+ Assert.AreSame (descD, descriptors [3], "#D4");
+ Assert.AreSame (descE, descriptors [4], "#D5");
+ Assert.AreSame (descF, descriptors [5], "#D6");
+
+ Assert.AreSame (descB, sorted [0], "#E1");
+ Assert.AreSame (descD, sorted [1], "#E2");
+ Assert.AreSame (descC, sorted [2], "#E3");
+ Assert.AreSame (descE, sorted [3], "#E4");
+ Assert.AreSame (descA, sorted [4], "#E5");
+ Assert.AreSame (descF, sorted [5], "#E6");
+ }
+
+ [Test] // Sort (IComparer)
+ public void Sort3 ()
+ {
+ PropertyDescriptorCollection descriptors;
+ PropertyDescriptorCollection sorted;
+
+ PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
+ PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
+ PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
+
+ PropertyDescriptor [] props = new PropertyDescriptor [] {
+ descA, descB, descC, descD, descE, descF };
+ descriptors = new PropertyDescriptorCollection (props);
+
+ Assert.AreSame (descA, descriptors [0], "#A1");
+ Assert.AreSame (descB, descriptors [1], "#A2");
+ Assert.AreSame (descC, descriptors [2], "#A3");
+ Assert.AreSame (descD, descriptors [3], "#A4");
+ Assert.AreSame (descE, descriptors [4], "#A5");
+ Assert.AreSame (descF, descriptors [5], "#A6");
+
+ sorted = descriptors.Sort (new ComparableComparer ());
+
+ Assert.AreSame (descA, descriptors [0], "#B1");
+ Assert.AreSame (descB, descriptors [1], "#B2");
+ Assert.AreSame (descC, descriptors [2], "#B3");
+ Assert.AreSame (descD, descriptors [3], "#B4");
+ Assert.AreSame (descE, descriptors [4], "#B5");
+ Assert.AreSame (descF, descriptors [5], "#B6");
+
+ Assert.AreSame (descC, sorted [0], "#C1");
+ Assert.AreSame (descA, sorted [1], "#C2");
+ Assert.AreSame (descB, sorted [2], "#C3");
+ Assert.AreSame (descE, sorted [3], "#C4");
+ Assert.AreSame (descD, sorted [4], "#C5");
+ Assert.AreSame (descF, sorted [5], "#C6");
+
+ sorted = descriptors.Sort ((Comparer) null);
+
+ Assert.AreSame (descA, descriptors [0], "#D1");
+ Assert.AreSame (descB, descriptors [1], "#D2");
+ Assert.AreSame (descC, descriptors [2], "#D3");
+ Assert.AreSame (descD, descriptors [3], "#D4");
+ Assert.AreSame (descE, descriptors [4], "#D5");
+ Assert.AreSame (descF, descriptors [5], "#D6");
+
+ Assert.AreSame (descB, sorted [0], "#E1");
+ Assert.AreSame (descD, sorted [1], "#E2");
+ Assert.AreSame (descC, sorted [2], "#E3");
+ Assert.AreSame (descE, sorted [3], "#E4");
+ Assert.AreSame (descA, sorted [4], "#E5");
+ Assert.AreSame (descF, sorted [5], "#E6");
+ }
+
+ [Test] // Sort (String [], IComparer)
+ public void Sort4 ()
+ {
+ PropertyDescriptorCollection descriptors;
+ PropertyDescriptorCollection sorted;
+
+ PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
+ PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
+ PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
+ PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
+ PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
+ PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
+
+ PropertyDescriptor [] props = new PropertyDescriptor [] {
+ descA, descB, descC, descD, descE, descF };
+ descriptors = new PropertyDescriptorCollection (props);
+
+ Assert.AreSame (descA, descriptors [0], "#A1");
+ Assert.AreSame (descB, descriptors [1], "#A2");
+ Assert.AreSame (descC, descriptors [2], "#A3");
+ Assert.AreSame (descD, descriptors [3], "#A4");
+ Assert.AreSame (descE, descriptors [4], "#A5");
+ Assert.AreSame (descF, descriptors [5], "#A6");
+
+ sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
+ new ComparableComparer ());
+
+ Assert.AreSame (descA, descriptors [0], "#B1");
+ Assert.AreSame (descB, descriptors [1], "#B2");
+ Assert.AreSame (descC, descriptors [2], "#B3");
+ Assert.AreSame (descD, descriptors [3], "#B4");
+ Assert.AreSame (descE, descriptors [4], "#B5");
+ Assert.AreSame (descF, descriptors [5], "#B6");
+
+ Assert.AreSame (descA, sorted [0], "#C1");
+ Assert.AreSame (descE, sorted [1], "#C2");
+ Assert.AreSame (descC, sorted [2], "#C3");
+ Assert.AreSame (descB, sorted [3], "#C4");
+ Assert.AreSame (descD, sorted [4], "#C5");
+ Assert.AreSame (descF, sorted [5], "#C6");
+
+ sorted = descriptors.Sort ((string []) null, new ComparableComparer ());
+
+ Assert.AreSame (descA, descriptors [0], "#D1");
+ Assert.AreSame (descB, descriptors [1], "#D2");
+ Assert.AreSame (descC, descriptors [2], "#D3");
+ Assert.AreSame (descD, descriptors [3], "#D4");
+ Assert.AreSame (descE, descriptors [4], "#D5");
+ Assert.AreSame (descF, descriptors [5], "#D6");
+
+ Assert.AreSame (descC, sorted [0], "#E1");
+ Assert.AreSame (descA, sorted [1], "#E2");
+ Assert.AreSame (descB, sorted [2], "#E3");
+ Assert.AreSame (descE, sorted [3], "#E4");
+ Assert.AreSame (descD, sorted [4], "#E5");
+ Assert.AreSame (descF, sorted [5], "#E6");
+
+ sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
+ (Comparer) null);
+
+ Assert.AreSame (descA, descriptors [0], "#F1");
+ Assert.AreSame (descB, descriptors [1], "#F2");
+ Assert.AreSame (descC, descriptors [2], "#F3");
+ Assert.AreSame (descD, descriptors [3], "#F4");
+ Assert.AreSame (descE, descriptors [4], "#F5");
+ Assert.AreSame (descF, descriptors [5], "#F6");
+
+ Assert.AreSame (descA, sorted [0], "#G1");
+ Assert.AreSame (descE, sorted [1], "#G2");
+ Assert.AreSame (descB, sorted [2], "#G3");
+ Assert.AreSame (descD, sorted [3], "#G4");
+ Assert.AreSame (descC, sorted [4], "#G5");
+ Assert.AreSame (descF, sorted [5], "#G6");
+
+ sorted = descriptors.Sort ((string []) null, (Comparer) null);
+
+ Assert.AreSame (descA, descriptors [0], "#H1");
+ Assert.AreSame (descB, descriptors [1], "#H2");
+ Assert.AreSame (descC, descriptors [2], "#H3");
+ Assert.AreSame (descD, descriptors [3], "#H4");
+ Assert.AreSame (descE, descriptors [4], "#H5");
+ Assert.AreSame (descF, descriptors [5], "#H6");
+
+ Assert.AreSame (descB, sorted [0], "#I1");
+ Assert.AreSame (descD, sorted [1], "#I2");
+ Assert.AreSame (descC, sorted [2], "#I3");
+ Assert.AreSame (descE, sorted [3], "#I4");
+ Assert.AreSame (descA, sorted [4], "#I5");
+ Assert.AreSame (descF, sorted [5], "#I6");
+ }
+
private void AssertReadOnly (PropertyDescriptorCollection descriptors, string testCase)
{
MockPropertyDescriptor mockPropertyDescr = new MockPropertyDescriptor (
}
}
}
+
+ class ComparableComparer : IComparer
+ {
+ public int Compare (object x, object y)
+ {
+ PropertyDescriptor descX = x as PropertyDescriptor;
+ PropertyDescriptor descY = y as PropertyDescriptor;
+
+ if (descX == null && descY == null)
+ return 0;
+ if (descX == null)
+ return -1;
+ if (descY == null)
+ return 1;
+
+ IComparable compX = descX.GetValue (null) as IComparable;
+ IComparable compY = descY.GetValue (null) as IComparable;
+
+ if (compX == null && compY == null)
+ return 0;
+ if (compX == null)
+ return -1;
+ if (compY == null)
+ return 1;
+ return compX.CompareTo (compY);
+ }
+ }
}
}
-
projects / mono.git / blobdiff