2 // DataTableReaderTest.cs - NUnit Test Cases for testing the DataTableReader
5 // Sureshkumar T <tsureshkumar@novell.com>
10 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
12 // Permission is hereby granted, free of charge, to any person obtaining
13 // a copy of this software and associated documentation files (the
14 // "Software"), to deal in the Software without restriction, including
15 // without limitation the rights to use, copy, modify, merge, publish,
16 // distribute, sublicense, and/or sell copies of the Software, and to
17 // permit persons to whom the Software is furnished to do so, subject to
18 // the following conditions:
20 // The above copyright notice and this permission notice shall be
21 // included in all copies or substantial portions of the Software.
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 using System.Data.Common;
36 using System.Collections;
38 using NUnit.Framework;
40 namespace MonoTests.System.Data
43 public class DataTableReaderTest
50 dt = new DataTable ("test");
51 dt.Columns.Add ("id", typeof (int));
52 dt.Columns.Add ("name", typeof (string));
53 dt.PrimaryKey = new DataColumn [] { dt.Columns ["id"] };
55 dt.Rows.Add (new object [] { 1, "mono 1" });
56 dt.Rows.Add (new object [] { 2, "mono 2" });
57 dt.Rows.Add (new object [] { 3, "mono 3" });
63 #region Positive Tests
65 public void CtorTest ()
67 dt.Rows [1].Delete ();
68 DataTableReader reader = new DataTableReader (dt);
72 while (reader.Read ())
76 Assert.AreEqual (2, i, "no. of rows iterated is wrong");
78 if (reader != null && !reader.IsClosed)
84 [ExpectedException (typeof (InvalidOperationException))]
85 public void RowInAccessibleTest ()
88 DataTableReader reader = new DataTableReader (dt);
91 reader.Read (); // 2nd row
92 dt.Rows [1].Delete ();
93 string value = reader [1].ToString ();
95 if (reader != null && !reader.IsClosed)
101 public void IgnoreDeletedRowsDynamicTest ()
104 DataTableReader reader = new DataTableReader (dt);
106 reader.Read (); // first row
107 dt.Rows [1].Delete ();
108 reader.Read (); // it should be 3rd row
109 string value = reader [0].ToString ();
110 Assert.AreEqual ("3", value, "#1 reader should have moved to 3rd row");
112 if (reader != null && !reader.IsClosed)
118 public void SeeTheModifiedTest ()
120 DataTableReader reader = new DataTableReader (dt);
122 reader.Read (); // first row
123 dt.Rows [1] ["name"] = "mono changed";
125 string value = reader [1].ToString ();
126 Assert.AreEqual ("mono changed", value, "#2 reader should have moved to 3rd row");
128 if (reader != null && !reader.IsClosed)
134 public void SchemaTest ()
136 DataTable another = new DataTable ("another");
137 another.Columns.Add ("x", typeof (string));
139 another.Rows.Add (new object [] {"test 1" });
140 another.Rows.Add (new object [] {"test 2" });
141 another.Rows.Add (new object [] {"test 3" });
143 DataTableReader reader = new DataTableReader (new DataTable [] { dt, another });
145 DataTable schema = reader.GetSchemaTable ();
147 Assert.AreEqual (dt.Columns.Count, schema.Rows.Count, "#1 should be same");
148 Assert.AreEqual (dt.Columns [1].DataType.ToString (), schema.Rows [1] ["DataType"].ToString (), "#2 data type should match");
150 reader.NextResult (); //schema should change here
151 schema = reader.GetSchemaTable ();
153 Assert.AreEqual (another.Columns.Count, schema.Rows.Count, "#3 should be same");
154 Assert.AreEqual (another.Columns [0].DataType.ToString (), schema.Rows [0] ["DataType"].ToString (), "#4 data type should match");
157 if (reader != null && !reader.IsClosed)
163 public void MultipleResultSetsTest ()
165 DataTable dt1 = new DataTable ("test2");
166 dt1.Columns.Add ("x", typeof (string));
167 dt1.Rows.Add (new object [] {"test"} );
168 dt1.Rows.Add (new object [] {"test1"} );
169 dt1.AcceptChanges ();
171 DataTable [] collection = new DataTable [] { dt, dt1 } ;
173 DataTableReader reader = new DataTableReader (collection);
177 while (reader.Read ())
179 } while (reader.NextResult ());
181 Assert.AreEqual (5, i, "#1 rows should be of both the tables");
183 if (reader != null && !reader.IsClosed)
189 public void GetTest ()
191 dt.Columns.Add ("nullint", typeof (int));
192 dt.Rows [0] ["nullint"] = 333;
194 DataTableReader reader = new DataTableReader (dt);
198 int ordinal = reader.GetOrdinal ("nullint");
200 Assert.AreEqual (1, (int) reader ["id"], "#1 should be able to get by name");
201 Assert.AreEqual (333, reader.GetInt32 (ordinal), "#2 should get int32");
202 Assert.AreEqual ("Int32", reader.GetDataTypeName (ordinal), "#3 data type should match");
204 if (reader != null && !reader.IsClosed)
210 [ExpectedException (typeof (InvalidOperationException))]
211 public void CloseTest ()
213 DataTableReader reader = new DataTableReader (dt);
216 while (reader.Read () && i < 1)
221 if (reader != null && !reader.IsClosed)
227 public void GetOrdinalTest ()
229 DataTableReader reader = new DataTableReader (dt);
231 Assert.AreEqual (1, reader.GetOrdinal ("name"), "#1 get ordinal should work even" +
232 " without calling Read");
234 if (reader != null && !reader.IsClosed)
238 #endregion // Positive Tests
241 #region Negative Tests
243 public void NoRowsTest ()
248 DataTableReader reader = new DataTableReader (dt);
251 Assert.IsFalse (reader.Read (), "#1 there are no rows");
252 Assert.IsFalse (reader.NextResult (), "#2 there are no further resultsets");
254 if (reader != null && !reader.IsClosed)
260 [ExpectedException (typeof (ArgumentException))]
261 public void NoTablesTest ()
263 DataTableReader reader = new DataTableReader (new DataTable [] {});
267 if (reader != null && !reader.IsClosed)
273 [ExpectedException (typeof (InvalidOperationException))]
274 public void ReadAfterClosedTest ()
276 DataTableReader reader = new DataTableReader (dt);
282 if (reader != null && !reader.IsClosed)
288 [ExpectedException (typeof (InvalidOperationException))]
289 public void AccessAfterClosedTest ()
291 DataTableReader reader = new DataTableReader (dt);
295 int i = (int) reader [0];
296 i++; // to supress warning
298 if (reader != null && !reader.IsClosed)
304 [ExpectedException (typeof (InvalidOperationException))]
305 public void AccessBeforeReadTest ()
307 DataTableReader reader = new DataTableReader (dt);
309 int i = (int) reader [0];
310 i++; // to supress warning
312 if (reader != null && !reader.IsClosed)
318 [ExpectedException (typeof (ArgumentOutOfRangeException))]
319 public void InvalidIndexTest ()
321 DataTableReader reader = new DataTableReader (dt);
324 int i = (int) reader [90]; // kidding, ;-)
325 i++; // to supress warning
327 if (reader != null && !reader.IsClosed)
333 public void DontSeeTheEarlierRowsTest ()
335 DataTableReader reader = new DataTableReader (dt);
337 reader.Read (); // first row
338 reader.Read (); // second row
340 // insert a row at position 0
341 DataRow r = dt.NewRow ();
343 r [1] = "adhi bagavan";
344 dt.Rows.InsertAt (r, 0);
346 Assert.AreEqual (2, (int) reader.GetInt32 (0), "#1 should not alter the position");
348 if (reader != null && !reader.IsClosed)
354 public void AddBeforePointTest ()
356 DataTableReader reader = new DataTableReader (dt);
358 reader.Read (); // first row
359 reader.Read (); // second row
360 DataRow r = dt.NewRow ();
362 r [1] = "adhi bagavan";
363 dt.Rows.InsertAt (r, 0);
364 dt.Rows.Add (new object [] { 4, "mono 4"}); // should not affect the counter
365 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
367 if (reader != null && !reader.IsClosed)
373 public void AddAtPointTest ()
375 DataTableReader reader = new DataTableReader (dt);
377 reader.Read (); // first row
378 reader.Read (); // second row
379 DataRow r = dt.NewRow ();
381 r [1] = "same point";
382 dt.Rows.InsertAt (r, 1);
383 dt.Rows.Add (new object [] { 4, "mono 4"}); // should not affect the counter
384 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
386 if (reader != null && !reader.IsClosed)
392 public void DeletePreviousAndAcceptChangesTest ()
394 DataTableReader reader = new DataTableReader (dt);
396 reader.Read (); // first row
397 reader.Read (); // second row
398 dt.Rows [0].Delete ();
400 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
402 if (reader != null && !reader.IsClosed)
409 public void DeleteCurrentAndAcceptChangesTest2 ()
411 DataTableReader reader = new DataTableReader (dt);
413 reader.Read (); // first row
414 reader.Read (); // second row
415 dt.Rows [1].Delete (); // delete row, where reader points to
416 dt.AcceptChanges (); // accept the action
417 Assert.AreEqual (1, (int) reader [0], "#1 should point to the first row");
419 if (reader != null && !reader.IsClosed)
425 [ExpectedException (typeof (InvalidOperationException))]
426 public void DeleteFirstCurrentAndAcceptChangesTest ()
428 DataTableReader reader = new DataTableReader (dt);
430 reader.Read (); // first row
431 dt.Rows [0].Delete (); // delete row, where reader points to
432 dt.AcceptChanges (); // accept the action
433 Assert.AreEqual (2, (int) reader [0], "#1 should point to the first row");
435 if (reader != null && !reader.IsClosed)
441 public void DeleteLastAndAcceptChangesTest2 ()
443 DataTableReader reader = new DataTableReader (dt);
445 reader.Read (); // first row
446 reader.Read (); // second row
447 reader.Read (); // third row
448 dt.Rows [2].Delete (); // delete row, where reader points to
449 dt.AcceptChanges (); // accept the action
450 Assert.AreEqual (2, (int) reader [0], "#1 should point to the first row");
452 if (reader != null && !reader.IsClosed)
458 public void ClearTest ()
460 DataTableReader reader = null;
462 reader = new DataTableReader (dt);
463 reader.Read (); // first row
464 reader.Read (); // second row
467 int i = (int) reader [0];
468 i++; // supress warning
469 Assert.Fail("#1 should have thrown RowNotInTableException");
470 } catch (RowNotInTableException) {}
472 // clear and add test
474 reader = new DataTableReader (dt);
475 reader.Read (); // first row
476 reader.Read (); // second row
478 dt.Rows.Add (new object [] {8, "mono 8"});
480 bool success = reader.Read ();
481 Assert.IsFalse (success, "#2 is always invalid");
483 // clear when reader is not read yet
485 reader = new DataTableReader (dt);
487 dt.Rows.Add (new object [] {8, "mono 8"});
489 success = reader.Read ();
490 Assert.IsTrue (success, "#3 should add");
492 if (reader != null && !reader.IsClosed)
499 public void MultipleDeleteTest ()
501 dt.Rows.Add (new object [] {4, "mono 4"});
502 dt.Rows.Add (new object [] {5, "mono 5"});
503 dt.Rows.Add (new object [] {6, "mono 6"});
504 dt.Rows.Add (new object [] {7, "mono 7"});
505 dt.Rows.Add (new object [] {8, "mono 8"});
508 DataTableReader reader = new DataTableReader (dt);
510 reader.Read (); // first row
516 dt.Rows [3].Delete ();
517 dt.Rows [1].Delete ();
518 dt.Rows [2].Delete ();
519 dt.Rows [0].Delete ();
520 dt.Rows [6].Delete ();
523 Assert.AreEqual (5, (int) reader [0], "#1 should keep pointing to 5");
525 if (reader != null && !reader.IsClosed)
529 #endregion // Negative Tests
532 public void TestSchemaTable()
534 DataSet ds = new DataSet();
535 DataTable testTable = new DataTable ("TestTable1");
536 DataTable testTable1 = new DataTable ();
538 testTable.Namespace = "TableNamespace";
540 testTable1.Columns.Add ("col1", typeof(int));
541 testTable1.Columns.Add ("col2", typeof(int));
542 ds.Tables.Add (testTable);
543 ds.Tables.Add (testTable1);
545 //create a col for standard datatype
547 testTable.Columns.Add ("col_string");
548 testTable.Columns.Add ("col_string_fixed");
549 testTable.Columns ["col_string_fixed"].MaxLength = 10;
550 testTable.Columns.Add ("col_int", typeof(int));
551 testTable.Columns.Add ("col_decimal", typeof(decimal));
552 testTable.Columns.Add ("col_datetime", typeof(DateTime));
553 testTable.Columns.Add ("col_float", typeof (float));
555 // Check for col constraints/properties
556 testTable.Columns.Add ("col_readonly").ReadOnly = true;
558 testTable.Columns.Add ("col_autoincrement", typeof(Int64)).AutoIncrement = true;
559 testTable.Columns ["col_autoincrement"].AutoIncrementStep = 5;
560 testTable.Columns ["col_autoincrement"].AutoIncrementSeed = 10;
562 testTable.Columns.Add ("col_pk");
563 testTable.PrimaryKey = new DataColumn[] {testTable.Columns ["col_pk"]};
565 testTable.Columns.Add ("col_unique");
566 testTable.Columns ["col_unique"].Unique = true;
568 testTable.Columns.Add ("col_defaultvalue");
569 testTable.Columns ["col_defaultvalue"].DefaultValue = "DefaultValue";
571 testTable.Columns.Add ("col_expression_local", typeof(int));
572 testTable.Columns ["col_expression_local"].Expression = "col_int*5";
574 ds.Relations.Add ("rel", new DataColumn[] {testTable1.Columns ["col1"]},
575 new DataColumn[] {testTable.Columns ["col_int"]}, false);
576 testTable.Columns.Add ("col_expression_ext");
577 testTable.Columns ["col_expression_ext"].Expression = "parent.col2";
579 testTable.Columns.Add ("col_namespace");
580 testTable.Columns ["col_namespace"].Namespace = "ColumnNamespace";
582 testTable.Columns.Add ("col_mapping");
583 testTable.Columns ["col_mapping"].ColumnMapping = MappingType.Attribute;
585 DataTable schemaTable = testTable.CreateDataReader ().GetSchemaTable ();
587 Assert.AreEqual (25, schemaTable.Columns.Count, "#1");
588 Assert.AreEqual (testTable.Columns.Count, schemaTable.Rows.Count, "#2");
591 for (int i = 0; i < schemaTable.Rows.Count; ++i) {
592 Assert.AreEqual (testTable.TableName, schemaTable.Rows [i]["BaseTableName"], i+"_#3");
593 Assert.AreEqual (ds.DataSetName, schemaTable.Rows [i]["BaseCatalogName"], i+"_#4");
594 Assert.AreEqual (DBNull.Value, schemaTable.Rows [i]["BaseSchemaName"], i+"_#5");
595 Assert.AreEqual (schemaTable.Rows [i]["BaseColumnName"], schemaTable.Rows [i]["ColumnName"], i+"_#6");
596 Assert.IsFalse ((bool)schemaTable.Rows [i]["IsRowVersion"], i+"_#7");
599 Assert.AreEqual ("col_string", schemaTable.Rows [0]["ColumnName"], "#8");
600 Assert.AreEqual (typeof(string), schemaTable.Rows [0]["DataType"], "#9");
601 Assert.AreEqual (-1, schemaTable.Rows [0]["ColumnSize"], "#10");
602 Assert.AreEqual (0, schemaTable.Rows [0]["ColumnOrdinal"], "#11");
603 // ms.net contradicts documented behavior
604 Assert.IsFalse ((bool)schemaTable.Rows [0]["IsLong"], "#12");
606 Assert.AreEqual ("col_string_fixed", schemaTable.Rows [1]["ColumnName"], "#13");
607 Assert.AreEqual (typeof(string), schemaTable.Rows [1]["DataType"], "#14");
608 Assert.AreEqual (10, schemaTable.Rows [1]["ColumnSize"], "#15");
609 Assert.AreEqual (1, schemaTable.Rows [1]["ColumnOrdinal"], "#16");
610 Assert.IsFalse ((bool)schemaTable.Rows [1]["IsLong"], "#17");
612 Assert.AreEqual ("col_int", schemaTable.Rows [2]["ColumnName"], "#18");
613 Assert.AreEqual (typeof(int), schemaTable.Rows [2]["DataType"], "#19");
614 Assert.AreEqual (DBNull.Value, schemaTable.Rows [2]["NumericPrecision"], "#20");
615 Assert.AreEqual (DBNull.Value, schemaTable.Rows [2]["NumericScale"], "#21");
616 Assert.AreEqual (-1, schemaTable.Rows [2]["ColumnSize"], "#22");
617 Assert.AreEqual (2, schemaTable.Rows [2]["ColumnOrdinal"], "#23");
619 Assert.AreEqual ("col_decimal", schemaTable.Rows [3]["ColumnName"], "#24");
620 Assert.AreEqual (typeof(decimal), schemaTable.Rows [3]["DataType"], "#25");
621 // When are the Precision and Scale Values set ?
622 Assert.AreEqual (DBNull.Value, schemaTable.Rows [3]["NumericPrecision"], "#26");
623 Assert.AreEqual (DBNull.Value, schemaTable.Rows [3]["NumericScale"], "#27");
624 Assert.AreEqual (-1, schemaTable.Rows [3]["ColumnSize"], "#28");
625 Assert.AreEqual (3, schemaTable.Rows [3]["ColumnOrdinal"], "#29");
627 Assert.AreEqual ("col_datetime", schemaTable.Rows [4]["ColumnName"], "#30");
628 Assert.AreEqual (typeof(DateTime), schemaTable.Rows [4]["DataType"], "#31");
629 Assert.AreEqual (4, schemaTable.Rows [4]["ColumnOrdinal"], "#32");
631 Assert.AreEqual ("col_float", schemaTable.Rows [5]["ColumnName"], "#33");
632 Assert.AreEqual (typeof(float), schemaTable.Rows [5]["DataType"], "#34");
633 Assert.AreEqual (5, schemaTable.Rows [5]["ColumnOrdinal"], "#35");
634 Assert.AreEqual (DBNull.Value, schemaTable.Rows [5]["NumericPrecision"], "#36");
635 Assert.AreEqual (DBNull.Value, schemaTable.Rows [5]["NumericScale"], "#37");
636 Assert.AreEqual (-1, schemaTable.Rows [5]["ColumnSize"], "#38");
638 Assert.AreEqual ("col_readonly", schemaTable.Rows [6]["ColumnName"], "#39");
639 Assert.IsTrue ((bool)schemaTable.Rows [6]["IsReadOnly"], "#40");
641 Assert.AreEqual ("col_autoincrement", schemaTable.Rows [7]["ColumnName"], "#9");
642 Assert.IsTrue ((bool)schemaTable.Rows [7]["IsAutoIncrement"], "#41");
643 Assert.AreEqual (10, schemaTable.Rows [7]["AutoIncrementSeed"], "#42");
644 Assert.AreEqual (5, schemaTable.Rows [7]["AutoIncrementStep"], "#43");
645 Assert.IsFalse ((bool)schemaTable.Rows [7]["IsReadOnly"], "#44");
647 Assert.AreEqual ("col_pk", schemaTable.Rows [8]["ColumnName"], "#45");
648 Assert.IsTrue ((bool)schemaTable.Rows [8]["IsKey"], "#46");
649 Assert.IsTrue ((bool)schemaTable.Rows [8]["IsUnique"], "#47");
651 Assert.AreEqual ("col_unique", schemaTable.Rows [9]["ColumnName"], "#48");
652 Assert.IsTrue ((bool)schemaTable.Rows [9]["IsUnique"], "#49");
654 Assert.AreEqual ("col_defaultvalue", schemaTable.Rows [10]["ColumnName"], "#50");
655 Assert.AreEqual ("DefaultValue", schemaTable.Rows [10]["DefaultValue"], "#51");
657 Assert.AreEqual ("col_expression_local", schemaTable.Rows [11]["ColumnName"], "#52");
658 Assert.AreEqual ("col_int*5", schemaTable.Rows [11]["Expression"], "#53");
659 Assert.IsTrue ((bool)schemaTable.Rows [11]["IsReadOnly"], "#54");
661 // if expression depends on a external col, then set Expression as null..
662 Assert.AreEqual ("col_expression_ext", schemaTable.Rows [12]["ColumnName"], "#55");
663 Assert.AreEqual (DBNull.Value, schemaTable.Rows [12]["Expression"], "#56");
664 Assert.IsTrue ((bool)schemaTable.Rows [12]["IsReadOnly"], "#57");
666 Assert.AreEqual ("col_namespace", schemaTable.Rows [13]["ColumnName"], "#58");
667 Assert.AreEqual ("TableNamespace", schemaTable.Rows [13]["BaseTableNamespace"], "#59");
668 Assert.AreEqual ("TableNamespace", schemaTable.Rows [12]["BaseColumnNamespace"], "#60");
669 Assert.AreEqual ("ColumnNamespace", schemaTable.Rows [13]["BaseColumnNamespace"], "#61");
671 Assert.AreEqual ("col_mapping", schemaTable.Rows [14]["ColumnName"], "#62");
672 Assert.AreEqual (MappingType.Element, (MappingType)schemaTable.Rows [13]["ColumnMapping"], "#63");
673 Assert.AreEqual (MappingType.Attribute, (MappingType)schemaTable.Rows [14]["ColumnMapping"], "#64");
677 public void TestExceptionIfSchemaChanges ()
679 DataTable table = new DataTable ();
680 table.Columns.Add ("col1");
681 DataTableReader rdr = table.CreateDataReader ();
682 Assert.AreEqual (1, rdr.GetSchemaTable().Rows.Count, "#1");
684 table.Columns [0].ColumnName = "newcol1";
686 rdr.GetSchemaTable ();
688 } catch (InvalidOperationException e) {
689 // Never premise English.
690 //Assert.AreEqual ("Schema of current DataTable '" + table.TableName +
691 // "' in DataTableReader has changed, DataTableReader is invalid.", e.Message, "#1");
694 rdr = table.CreateDataReader ();
695 rdr.GetSchemaTable (); //no exception
696 table.Columns.Add ("col2");
698 rdr.GetSchemaTable ();
700 } catch (InvalidOperationException e) {
701 // Never premise English.
702 //Assert.AreEqual ("Schema of current DataTable '" + table.TableName +
703 // "' in DataTableReader has changed, DataTableReader is invalid.", e.Message, "#1");
708 public void EnumeratorTest ()
710 DataTable table = new DataTable ();
711 table.Columns.Add ("col1", typeof(int));
712 table.Rows.Add (new object[] {0});
713 table.Rows.Add (new object[] {1});
715 DataTableReader rdr = table.CreateDataReader ();
716 IEnumerator enmr = rdr.GetEnumerator ();
718 table.Rows.Add (new object[] {2});
719 table.Rows.RemoveAt (0);
721 //Test if the Enumerator is stable
723 while (enmr.MoveNext ()) {
724 DbDataRecord rec = (DbDataRecord)enmr.Current;
725 Assert.AreEqual (i, rec.GetInt32 (0), "#2_" + i);
731 public void GetCharsTest()
733 dt.Columns.Add ("col2", typeof (char[]));
736 dt.Rows.Add (new object[] {1, "string", "string".ToCharArray()});
737 dt.Rows.Add (new object[] {2, "string1", null});
738 DataTableReader rdr = dt.CreateDataReader ();
743 rdr.GetChars (1, 0, null, 0, 10);
745 } catch (InvalidCastException e) {
746 // Never premise English.
747 //Assert.AreEqual ("Unable to cast object of type 'System.String'" +
748 // " to type 'System.Char[]'.", e.Message, "#1");
750 char[] char_arr = null;
753 len = rdr.GetChars (2, 0, null, 0, 0);
754 Assert.AreEqual(6, len, "#2");
756 char_arr = new char [len];
757 len = rdr.GetChars (2, 0, char_arr, 0, 0);
758 Assert.AreEqual(0, len, "#3");
760 len = rdr.GetChars (2, 0, null, 0, 0);
761 char_arr = new char [len+2];
762 len = rdr.GetChars (2, 0, char_arr, 2, 100);
763 Assert.AreEqual (6, len, "#4");
764 char[] val = (char[])rdr.GetValue (2);
765 for (int i = 0; i < len; ++i)
766 Assert.AreEqual (val[i], char_arr[i+2], "#5_"+i);
770 public void GetProviderSpecificTests()
772 DataTableReader rdr = dt.CreateDataReader ();
773 while (rdr.Read ()) {
774 object[] values = new object [rdr.FieldCount];
775 object[] pvalues = new object [rdr.FieldCount];
776 rdr.GetValues (values);
777 rdr.GetProviderSpecificValues (pvalues);
779 for (int i = 0; i < rdr.FieldCount; ++i) {
780 Assert.AreEqual(values [i], pvalues [i], "#1");
781 Assert.AreEqual(rdr.GetValue (i), rdr.GetProviderSpecificValue (i), "#2");
782 Assert.AreEqual(rdr.GetFieldType (i), rdr.GetProviderSpecificFieldType (i), "#3");
788 public void GetNameTest()
790 DataTableReader rdr = dt.CreateDataReader();
791 for (int i = 0; i < dt.Columns.Count; ++i)
792 Assert.AreEqual(dt.Columns[i].ColumnName, rdr.GetName(i), "#1_" + i);