public string s;
public string a;
}
+
+ class DataEqual
+ {
+ public override bool Equals (object obj)
+ {
+ return true;
+ }
+ }
+
//End Auxiliary Things
[TestFixture]
Assert("#E38", copy[3] != orig[3]);
}
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void Copy_InvalidCast () {
+ object[] arr1 = new object [10];
+ Type[] arr2 = new Type [10];
+
+ arr1 [0] = new object ();
+
+ Array.Copy (arr1, 0, arr2, 0, 10);
+ }
+
[Test]
public void TestCopyTo() {
{
AssertEquals("#J50", 3, Array.IndexOf(s1, "a", 1, 3));
}
+ [Test]
+ public void TestIndexOf_CustomEqual ()
+ {
+ DataEqual[] test = new DataEqual [] { new DataEqual () };
+ AssertEquals (0, Array.IndexOf (test, "asdfas", 0));
+
+ IList array = (IList)test;
+ AssertEquals (0, array.IndexOf ("asdfas"));
+ }
+
[Test]
public void TestLastIndexOf1() {
{
AssertEquals("#K05", 0, Array.LastIndexOf(s1, "this"));
AssertEquals("#K06", 4, Array.LastIndexOf(s1, "test"));
AssertEquals("#K07", 3, Array.LastIndexOf(s1, "a"));
+
+ AssertEquals (-1, Array.LastIndexOf (new String [0], "foo"));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentOutOfRangeException))]
public void TestLastIndexOf4 ()
{
short [] a = new short [] { 19, 238, 317, 6, 565, 0, -52, 60, -563, 753, 238, 238};
- Array.LastIndexOf (a, 16, -1);
+ try {
+ Array.LastIndexOf (a, (object)16, -1);
+ NUnit.Framework.Assert.Fail ("#1");
+ } catch (ArgumentOutOfRangeException) { }
+
+#if NET_2_0
+ try {
+ Array.LastIndexOf<short> (a, 16, -1);
+ NUnit.Framework.Assert.Fail ("#2");
+ } catch (ArgumentOutOfRangeException) { }
+#endif
}
[Test]
}
#endregion
+
+#if NET_2_0
+ [Test] // bug #322248
+ public void IEnumerator_Reset ()
+ {
+ int[] array = new int[] { 1, 2, 3};
+ IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
+ Assert ("#A1", e.MoveNext ());
+ AssertEquals ("#A2", 1, e.Current);
+ Assert ("#A3", e.MoveNext ());
+ AssertEquals ("#A4", 2, e.Current);
+
+ e.Reset ();
+
+ Assert ("#C1", e.MoveNext ());
+ AssertEquals ("#C2", 1, e.Current);
+ }
+
+ [Test]
+ public void IEnumerator_Current_Finished ()
+ {
+ int[] array = new int[] { 1, 2, 3 };
+ IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
+ Assert ("#A1", e.MoveNext ());
+ AssertEquals ("#A2", 1, e.Current);
+ Assert ("#A3", e.MoveNext ());
+ AssertEquals ("#A4", 2, e.Current);
+ Assert ("#A5", e.MoveNext ());
+ AssertEquals ("#A6", 3, e.Current);
+ Assert ("#A6", !e.MoveNext ());
+
+ try {
+ Fail ("#B1:" + e.Current);
+ } catch (InvalidOperationException ex) {
+ // Enumeration already finished
+ AssertEquals ("#B2", typeof (InvalidOperationException), ex.GetType ());
+ AssertNull ("#B3", ex.InnerException);
+ AssertNotNull ("#B4", ex.Message);
+ }
+ }
+
+ [Test]
+ public void IEnumerator_Current_NotStarted ()
+ {
+ int[] array = new int[] { 1, 2, 3 };
+ IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
+
+ try {
+ Fail ("#A1:" + e.Current);
+ } catch (InvalidOperationException ex) {
+ // Enumeration has not started. Call MoveNext
+ AssertEquals ("#A2", typeof (InvalidOperationException), ex.GetType ());
+ AssertNull ("#A3", ex.InnerException);
+ AssertNotNull ("#A4", ex.Message);
+ }
+ }
+
+ [Test]
+ public void IEnumerator_Current_Reset ()
+ {
+ int[] array = new int[] { 1, 2, 3 };
+ IEnumerator<int> e = ((IEnumerable<int>)array).GetEnumerator ();
+ e.MoveNext ();
+ e.Reset ();
+
+ try {
+ Fail ("#B1:" + e.Current);
+ } catch (InvalidOperationException ex) {
+ // Enumeration has not started. Call MoveNext
+ AssertEquals ("#B2", typeof (InvalidOperationException), ex.GetType ());
+ AssertNull ("#B3", ex.InnerException);
+ AssertNotNull ("#B4", ex.Message);
+ }
+ }
+#endif
}
}