2 // Rafael Mizrahi <rafim@mainsoft.com>
3 // Erez Lotan <erezl@mainsoft.com>
4 // Oren Gurfinkel <oreng@mainsoft.com>
7 // Copyright (c) 2004 Mainsoft Co.
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 using System.Collections;
31 using System.ComponentModel;
33 using System.Globalization;
36 using MonoTests.System.Data.Utils;
38 using NUnit.Framework;
40 namespace MonoTests.System.Data
42 [TestFixture] public class DataRowTest2
45 ArrayList _eventsFired;
51 _eventsFired = new ArrayList ();
54 [Test] public void AcceptChanges()
56 DataTable myTable = new DataTable("myTable");
58 myRow = myTable.NewRow();
59 myTable.Rows.Add(myRow);
61 // DataRow AcceptChanges
62 // DataRowState.Added -> DataRowState.Unchanged
63 myTable.AcceptChanges();
64 Assert.AreEqual(DataRowState.Unchanged , myRow.RowState , "DRW1");
67 [Test] public void CancelEdit()
69 DataTable myTable = new DataTable("myTable");
70 DataColumn dc = new DataColumn("Id",typeof(int));
72 myTable.Columns.Add(dc);
73 myTable.Rows.Add(new object[] {1});
74 myTable.Rows.Add(new object[] {2});
75 myTable.Rows.Add(new object[] {3});
77 DataRow myRow = myTable.Rows[0];
83 Assert.AreEqual(true , (int)myRow[0] == 1, "DRW2");
86 [Test] public void ClearErrors()
88 DataTable dt = new DataTable("myTable");
89 DataRow dr = dt.NewRow();
92 // DataRow ClearErrors
93 Assert.AreEqual(true , dr.HasErrors , "DRW3");
95 // DataRow ClearErrors
97 Assert.AreEqual(false , dr.HasErrors , "DRW4");
100 [Test] public void Delete()
102 DataTable myTable = new DataTable("myTable");
103 DataColumn dc = new DataColumn("Id",typeof(int));
105 myTable.Columns.Add(dc);
106 myTable.Rows.Add(new object[] {1});
107 myTable.Rows.Add(new object[] {2});
108 myTable.Rows.Add(new object[] {3});
109 myTable.AcceptChanges();
111 DataRow myRow = myTable.Rows[0];
115 Assert.AreEqual(DataRowState.Deleted , myRow.RowState , "DRW5");
118 myTable.AcceptChanges();
119 Assert.AreEqual(DataRowState.Detached , myRow.RowState , "DRW6");
122 [Test] public void EndEdit()
124 DataTable myTable = new DataTable("myTable");
125 DataColumn dc = new DataColumn("Id",typeof(int));
127 myTable.Columns.Add(dc);
128 myTable.Rows.Add(new object[] {1});
129 myTable.Rows.Add(new object[] {2});
130 myTable.Rows.Add(new object[] {3});
132 DataRow myRow = myTable.Rows[0];
135 //After calling the DataRow object's BeginEdit method, if you change the value, the Current and Proposed values become available
138 iProposed = (int)myRow[0,DataRowVersion.Proposed];
142 Assert.AreEqual(iProposed , (int)myRow[0,DataRowVersion.Current] , "DRW7");
145 [Test] public void Equals()
147 DataTable myTable = new DataTable("myTable");
149 dr1 = myTable.NewRow();
150 dr2 = myTable.NewRow();
153 Assert.AreEqual(false , dr1.Equals(dr2), "DRW8");
157 Assert.AreEqual(true , dr1.Equals(dr2), "DRW9");
160 [Test] public void GetChildRows_ByDataRealtion()
163 DataRow[] drArrExcepted,drArrResult;
164 DataTable dtChild,dtParent;
165 DataSet ds = new DataSet();
168 dtChild = DataProvider.CreateChildDataTable();
169 dtParent= DataProvider.CreateParentDataTable();
171 //Add tables to dataset
172 ds.Tables.Add(dtChild);
173 ds.Tables.Add(dtParent);
174 dr = dtParent.Rows[0];
177 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
178 ds.Relations.Add(dRel);
179 //Get Excepted result
180 drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
182 drArrResult = dr.GetChildRows(dRel);
185 Assert.AreEqual(drArrExcepted, drArrResult, "DRW10");
188 [Test] public void GetChildRows_ByDataRealtionDataRowVersion()
191 DataRow[] drArrExcepted,drArrResult;
192 DataTable dtChild,dtParent;
193 DataSet ds = new DataSet();
195 dtChild = DataProvider.CreateChildDataTable();
196 dtParent= DataProvider.CreateParentDataTable();
197 //Add tables to dataset
198 ds.Tables.Add(dtChild);
199 ds.Tables.Add(dtParent);
201 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
202 ds.Relations.Add(dRel);
204 drParent = dtParent.Rows[0];
206 // Teting: DateTime.Now.ToShortTimeString()
207 //Get Excepted result
208 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
209 //Get Result DataRowVersion.Current
210 drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Current);
211 Assert.AreEqual(drArrExcepted, drArrResult, "DRW11");
213 // Teting: DataRow.GetParentRows_D_D
214 //Get Excepted result
215 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
216 //Get Result DataRowVersion.Current
217 drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Original );
218 Assert.AreEqual(drArrExcepted, drArrResult, "DRW12");
220 // Teting: DataRow.GetParentRows_D_D
221 //Get Excepted result, in this case Current = Default
222 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
223 //Get Result DataRowVersion.Current
224 drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Default );
225 Assert.AreEqual(drArrExcepted, drArrResult, "DRW13");
227 // Teting: DataRow.GetParentRows_D_D
228 drParent.BeginEdit();
229 drParent["String1"] = "Value";
230 //Get Excepted result
231 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
232 //Get Result DataRowVersion.Current
233 drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Proposed );
234 Assert.AreEqual(drArrExcepted, drArrResult, "DRW14");
237 [Test] public void GetChildRows_ByName()
240 DataRow[] drArrExcepted,drArrResult;
241 DataTable dtChild,dtParent;
242 DataSet ds = new DataSet();
245 dtChild = DataProvider.CreateChildDataTable();
246 dtParent= DataProvider.CreateParentDataTable();
248 //Add tables to dataset
249 ds.Tables.Add(dtChild);
250 ds.Tables.Add(dtParent);
251 dr = dtParent.Rows[0];
254 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
255 ds.Relations.Add(dRel);
256 //Get Excepted result
257 drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
259 drArrResult = dr.GetChildRows("Parent-Child");
262 Assert.AreEqual(drArrExcepted, drArrResult, "DRW15");
265 [Test] public void GetChildRows_ByNameDataRowVersion()
268 DataRow[] drArrExcepted,drArrResult;
269 DataTable dtChild,dtParent;
270 DataSet ds = new DataSet();
272 dtChild = DataProvider.CreateChildDataTable();
273 dtParent= DataProvider.CreateParentDataTable();
274 //Add tables to dataset
275 ds.Tables.Add(dtChild);
276 ds.Tables.Add(dtParent);
278 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
279 ds.Relations.Add(dRel);
281 drParent = dtParent.Rows[0];
284 //Get Excepted result
285 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
286 //Get Result DataRowVersion.Current
287 drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Current);
288 Assert.AreEqual(drArrExcepted, drArrResult, "DRW16");
291 //Get Excepted result
292 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
293 //Get Result DataRowVersion.Current
294 drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Original );
295 Assert.AreEqual(drArrExcepted, drArrResult, "DRW17");
297 // GetParentRows_SD 3
298 //Get Excepted result, in this case Current = Default
299 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
300 //Get Result DataRowVersion.Current
301 drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Default );
302 Assert.AreEqual(drArrExcepted, drArrResult, "DRW18");
304 // GetParentRows_SD 4
305 drParent.BeginEdit();
306 drParent["String1"] = "Value";
307 //Get Excepted result
308 drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
309 //Get Result DataRowVersion.Current
310 drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Proposed );
311 Assert.AreEqual(drArrExcepted, drArrResult, "DRW19");
314 [Test] public void GetColumnError_ByIndex()
316 string sColErr = "Error!";
317 DataTable dt = new DataTable("myTable");
318 DataColumn dc = new DataColumn("Column1");
320 DataRow dr = dt.NewRow();
323 Assert.AreEqual(String.Empty , dr.GetColumnError(0) , "DRW20");
325 dr.SetColumnError(0,sColErr );
328 Assert.AreEqual(sColErr , dr.GetColumnError(0) , "DRW21");
331 [Test] public void GetColumnError_ByName()
333 string sColErr = "Error!";
334 DataTable dt = new DataTable("myTable");
335 DataColumn dc = new DataColumn("Column1");
337 DataRow dr = dt.NewRow();
340 Assert.AreEqual(String.Empty , dr.GetColumnError("Column1") , "DRW22");
342 dr.SetColumnError("Column1",sColErr );
345 Assert.AreEqual(sColErr , dr.GetColumnError("Column1") , "DRW23");
348 [Test] public void GetColumnsInError()
350 string sColErr = "Error!";
352 DataTable dt = new DataTable("myTable");
354 dt.Columns.Add(new DataColumn());
355 dt.Columns.Add(new DataColumn());
356 dt.Columns.Add(new DataColumn());
357 dt.Columns.Add(new DataColumn());
358 dt.Columns.Add(new DataColumn());
361 dt.Rows.Add(new object[] {});
362 dt.Rows.Add(new object[] {});
363 dt.Rows.Add(new object[] {});
365 DataRow dr = dt.Rows[1];
367 dcArr = dr.GetColumnsInError();
369 // GetColumnsInError 1
370 Assert.AreEqual(0, dcArr.Length , "DRW24");
372 dr.SetColumnError(0,sColErr);
373 dr.SetColumnError(2,sColErr);
374 dr.SetColumnError(4,sColErr);
376 dcArr = dr.GetColumnsInError();
378 // GetColumnsInError 2
379 Assert.AreEqual(3, dcArr.Length , "DRW25");
381 //check that the right columns taken
382 // GetColumnsInError 3
383 Assert.AreEqual(dt.Columns[0], dcArr[0], "DRW26");
385 // GetColumnsInError 4
386 Assert.AreEqual(dt.Columns[2], dcArr[1], "DRW27");
388 // GetColumnsInError 5
389 Assert.AreEqual(dt.Columns[4], dcArr[2], "DRW28");
392 [Test] public new void GetHashCode()
396 DataTable dt = new DataTable();
399 iHashCode = dr.GetHashCode();
400 for (int i=0; i<10; i++)
401 { //must return the same value each time
402 // GetHashCode #" + i
403 Assert.AreEqual(dr.GetHashCode() , iHashCode , "DRW29");
407 [Test] public void GetParentRow_ByDataRelation()
409 DataRow drExcepted,drResult,drChild;
410 DataTable dtChild,dtParent;
411 DataSet ds = new DataSet();
414 dtChild = DataProvider.CreateChildDataTable();
415 dtParent = DataProvider.CreateParentDataTable();
417 //Add tables to dataset
418 ds.Tables.Add(dtChild);
419 ds.Tables.Add(dtParent);
422 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
423 ds.Relations.Add(dRel);
426 drExcepted = dtParent.Rows[0];
429 drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
430 drResult = drChild.GetParentRow(dRel);
433 Assert.AreEqual(drExcepted.ItemArray, drResult.ItemArray , "DRW30");
436 [Test] public void GetParentRow_ByDataRelationDataRowVersion()
438 DataRow drParent,drChild;
439 DataRow drArrExcepted,drArrResult;
440 DataTable dtChild,dtParent;
441 DataSet ds = new DataSet();
443 dtChild = DataProvider.CreateChildDataTable();
444 dtParent= DataProvider.CreateParentDataTable();
445 //Add tables to dataset
446 ds.Tables.Add(dtChild);
447 ds.Tables.Add(dtParent);
449 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
450 ds.Relations.Add(dRel);
452 drParent = dtParent.Rows[0];
453 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
456 //Get Excepted result
457 drArrExcepted = drParent;
458 //Get Result DataRowVersion.Current
459 drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Current);
460 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW31");
463 //Get Excepted result
464 drArrExcepted = drParent;
465 //Get Result DataRowVersion.Current
466 drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Original );
467 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW32");
470 //Get Excepted result, in this case Current = Default
471 drArrExcepted = drParent;
472 //Get Result DataRowVersion.Current
473 drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Default );
474 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW33");
478 drChild["String1"] = "Value";
479 //Get Excepted result
480 drArrExcepted = drParent;
481 //Get Result DataRowVersion.Current
482 drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Proposed );
483 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW34");
486 [Test] public void GetParentRow_ByName()
488 DataRow drExcepted,drResult,drChild;
489 DataTable dtChild,dtParent;
490 DataSet ds = new DataSet();
493 dtChild = DataProvider.CreateChildDataTable();
494 dtParent = DataProvider.CreateParentDataTable();
496 //Add tables to dataset
497 ds.Tables.Add(dtChild);
498 ds.Tables.Add(dtParent);
501 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
502 ds.Relations.Add(dRel);
505 drExcepted = dtParent.Rows[0];
508 drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
509 drResult = drChild.GetParentRow("Parent-Child");
512 Assert.AreEqual(drExcepted.ItemArray, drResult.ItemArray , "DRW35");
515 [Test] public void GetParentRow_ByNameDataRowVersion()
517 DataRow drParent,drChild;
518 DataRow drArrExcepted,drArrResult;
519 DataTable dtChild,dtParent;
520 DataSet ds = new DataSet();
522 dtChild = DataProvider.CreateChildDataTable();
523 dtParent= DataProvider.CreateParentDataTable();
524 //Add tables to dataset
525 ds.Tables.Add(dtChild);
526 ds.Tables.Add(dtParent);
528 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
529 ds.Relations.Add(dRel);
531 drParent = dtParent.Rows[0];
532 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
535 //Get Excepted result
536 drArrExcepted = drParent;
537 //Get Result DataRowVersion.Current
538 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
539 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW36");
542 //Get Excepted result
543 drArrExcepted = drParent;
544 //Get Result DataRowVersion.Current
545 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Original );
546 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW37");
549 //Get Excepted result, in this case Current = Default
550 drArrExcepted = drParent;
551 //Get Result DataRowVersion.Current
552 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Default );
553 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW38");
557 drChild["String1"] = "Value";
558 //Get Excepted result
559 drArrExcepted = drParent;
560 //Get Result DataRowVersion.Current
561 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Proposed );
562 Assert.AreEqual(drArrExcepted.ItemArray, drArrResult.ItemArray , "DRW39");
565 [Test] public void GetParentRows_ByDataRelation()
568 DataRow[] drArrExcepted,drArrResult;
569 DataTable dtChild,dtParent;
570 DataSet ds = new DataSet();
573 dtChild = DataProvider.CreateChildDataTable();
574 dtParent = DataProvider.CreateParentDataTable();
576 //Add tables to dataset
577 ds.Tables.Add(dtChild);
578 ds.Tables.Add(dtParent);
579 dr = dtParent.Rows[0];
581 //Duplicate several rows in order to create Many to Many relation
582 dtParent.ImportRow(dr);
583 dtParent.ImportRow(dr);
584 dtParent.ImportRow(dr);
587 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
588 ds.Relations.Add(dRel);
589 //Get Excepted result
590 drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
591 dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
593 drArrResult = dr.GetParentRows(dRel);
596 Assert.AreEqual(drArrExcepted, drArrResult, "DRW40");
599 [Test] public void GetParentRows_ByName()
602 DataRow[] drArrExcepted,drArrResult;
603 DataTable dtChild,dtParent;
604 DataSet ds = new DataSet();
607 dtChild = DataProvider.CreateChildDataTable();
608 dtParent = DataProvider.CreateParentDataTable();
610 //Add tables to dataset
611 ds.Tables.Add(dtChild);
612 ds.Tables.Add(dtParent);
613 dr = dtParent.Rows[0];
615 //Duplicate several rows in order to create Many to Many relation
616 dtParent.ImportRow(dr);
617 dtParent.ImportRow(dr);
618 dtParent.ImportRow(dr);
621 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
622 ds.Relations.Add(dRel);
623 //Get Excepted result
624 drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
625 dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
627 drArrResult = dr.GetParentRows("Parent-Child");
630 Assert.AreEqual(drArrExcepted, drArrResult, "DRW41");
633 [Test] public void GetParentRows_ByNameDataRowVersion()
635 DataRow drParent,drChild;
636 DataRow[] drArrExcepted,drArrResult;
637 DataTable dtChild,dtParent;
638 DataSet ds = new DataSet();
640 dtChild = DataProvider.CreateChildDataTable();
641 dtParent= DataProvider.CreateParentDataTable();
642 //Add tables to dataset
643 ds.Tables.Add(dtChild);
644 ds.Tables.Add(dtParent);
646 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
647 ds.Relations.Add(dRel);
649 //Create several copies of the first row
650 drParent = dtParent.Rows[0]; //row[0] has versions: Default,Current,Original
651 dtParent.ImportRow(drParent); //row[1] has versions: Default,Current,Original
652 dtParent.ImportRow(drParent); //row[2] has versions: Default,Current,Original
653 dtParent.ImportRow(drParent); //row[3] has versions: Default,Current,Original
654 dtParent.ImportRow(drParent); //row[4] has versions: Default,Current,Original
655 dtParent.ImportRow(drParent); //row[5] has versions: Default,Current,Original
656 dtParent.AcceptChanges();
658 //Get the first child row for drParent
659 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
661 DataRow[] drTemp = dtParent.Select("ParentId=" + drParent["ParentId"]);
662 // Console.WriteLine("********");
663 // foreach (DataRow d in drTemp)
665 // CheckRowVersion(d);
667 drTemp[0].BeginEdit();
668 drTemp[0]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
669 drTemp[1].BeginEdit();
670 drTemp[1]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
672 // Console.WriteLine("********");
673 // foreach (DataRow d in drTemp)
675 // CheckRowVersion(d);
677 // Console.WriteLine("********");
679 // Check DataRowVersion.Current
680 //Check DataRowVersion.Current
681 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
682 drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Current);
683 Assert.AreEqual(drArrExcepted, drArrResult, "DRW42");
685 //Check DataRowVersion.Current
686 // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Original
687 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
688 drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Original );
689 Assert.AreEqual(drArrExcepted, drArrResult, "DRW43");
691 //Check DataRowVersion.Default
692 // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Default
693 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
694 drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Default );
695 Assert.AreEqual(drArrExcepted, drArrResult, "DRW44");
697 /* .Net don't work as expected
698 //Check DataRowVersion.Proposed
699 // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Proposed
700 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedCurrent);
701 //drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedOriginal );
703 drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Proposed );
704 Assert.AreEqual(drArrExcepted, drArrResult, "DRW45");
708 private void CheckRowVersion(DataRow dr)
710 Console.WriteLine("");
711 if (dr.HasVersion(DataRowVersion.Current)) Console.WriteLine("Has " + DataRowVersion.Current.ToString());
712 if (dr.HasVersion(DataRowVersion.Default)) Console.WriteLine("Has " + DataRowVersion.Default.ToString());
713 if (dr.HasVersion(DataRowVersion.Original)) Console.WriteLine("Has " + DataRowVersion.Original.ToString());
714 if (dr.HasVersion(DataRowVersion.Proposed)) Console.WriteLine("Has " + DataRowVersion.Proposed.ToString());
717 [Test] public new void GetType()
720 DataTable dt = new DataTable();
721 DataRow dr = dt.NewRow();
722 myType = typeof(DataRow);
725 Assert.AreEqual(typeof(DataRow), myType , "DRW46");
728 [Test] public void HasErrors()
730 DataTable dt = new DataTable("myTable");
731 DataRow dr = dt.NewRow();
733 // HasErrors (default)
734 Assert.AreEqual(false, dr.HasErrors, "DRW47");
738 // HasErrors (set/get)
739 Assert.AreEqual(true , dr.HasErrors , "DRW48");
742 [Test] public void HasVersion_ByDataRowVersion()
744 DataTable t = new DataTable("atable");
745 t.Columns.Add("id", typeof(int));
746 t.Columns.Add("name", typeof(string));
747 t.Columns[0].DefaultValue = 1;
748 t.Columns[1].DefaultValue = "something";
751 DataRow r = t.NewRow();
753 // HasVersion Test #10
754 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW49");
756 // HasVersion Test #11
757 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW50");
759 // HasVersion Test #12
760 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW51");
762 // HasVersion Test #13
763 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW52");
768 // HasVersion Test #20
769 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW53");
771 // HasVersion Test #21
772 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW54");
774 // HasVersion Test #22
775 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW55");
777 // HasVersion Test #23
778 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW56");
783 // HasVersion Test #30
784 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW57");
786 // HasVersion Test #31
787 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW58");
789 // HasVersion Test #32
790 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW59");
792 // HasVersion Test #33
793 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW60");
796 // now it is "unchanged"
798 // HasVersion Test #40
799 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW61");
801 // HasVersion Test #41
802 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW62");
804 // HasVersion Test #42
805 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW63");
807 // HasVersion Test #43
808 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW64");
813 // HasVersion Test #50
814 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW65");
816 // HasVersion Test #51
817 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW66");
819 // HasVersion Test #52
820 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW67");
822 // HasVersion Test #53
823 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW68");
826 // now it is "modified"
827 // HasVersion Test #60
828 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW69");
830 // HasVersion Test #61
831 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW70");
833 // HasVersion Test #62
834 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW71");
836 // HasVersion Test #63
837 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW72");
839 // this or t.AcceptChanges
841 // now it is "unchanged" again
842 // HasVersion Test #70
843 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW73");
845 // HasVersion Test #71
846 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW74");
848 // HasVersion Test #72
849 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW75");
851 // HasVersion Test #73
852 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW76");
855 // now it is "deleted"
857 // HasVersion Test #80
858 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW77");
860 // HasVersion Test #81
861 Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW78");
863 // HasVersion Test #82
864 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW79");
866 // HasVersion Test #83
867 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW80");
871 // HasVersion Test #90
872 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW81");
874 // HasVersion Test #91
875 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW82");
877 // HasVersion Test #92
878 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW83");
880 // HasVersion Test #93
881 Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW84");
884 [Test] // Object this [DataColumn]
885 public void Indexer1 ()
888 DataColumnChangeEventArgs colChangeArgs;
890 DataTable dt = new DataTable ();
891 dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
892 dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
894 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
895 dt.Columns.Add (dc0);
896 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
897 dt.Columns.Add (dc1);
899 Person personA = new Person ("Miguel");
900 Address addressA = new Address ("X", 5);
901 Person personB = new Person ("Chris");
902 Address addressB = new Address ("Y", 4);
903 Person personC = new Person ("Jackson");
904 Address addressC = new Address ("Z", 3);
906 dt.Rows.Add (new object [] { addressA, personA });
907 dt.Rows.Add (new object [] { addressB, personB });
911 Assert.AreEqual (addressA, dr [dc0], "#A1");
912 Assert.AreSame (personA, dr [dc1], "#A2");
915 Assert.AreEqual (addressB, dr [dc0], "#B1");
916 Assert.AreSame (personB, dr [dc1], "#B2");
919 Assert.AreEqual (0, _eventsFired.Count, "#C1");
921 Assert.AreEqual (2, _eventsFired.Count, "#C2");
922 Assert.AreEqual (addressC, dr [dc0], "#C3");
923 Assert.AreSame (personA, dr [dc1], "#C4");
927 Assert.AreEqual (2, _eventsFired.Count, "#D1");
929 Assert.AreEqual (4, _eventsFired.Count, "#D2");
930 Assert.AreEqual (addressB, dr [dc0], "#D3");
931 Assert.AreSame (personC, dr [dc1], "#D4");
933 Assert.AreEqual (4, _eventsFired.Count, "#D5");
934 Assert.AreEqual (addressB, dr [dc0], "#D6");
935 Assert.AreSame (personC, dr [dc1], "#D7");
939 Assert.AreEqual (4, _eventsFired.Count, "#E1");
941 Assert.AreEqual (6, _eventsFired.Count, "#E2");
942 Assert.AreEqual (addressB, dr [dc0], "#E3");
943 Assert.AreSame (personA, dr [dc1], "#E4");
945 Assert.AreEqual (6, _eventsFired.Count, "#E5");
946 Assert.AreEqual (addressC, dr [dc0], "#E6");
947 Assert.AreSame (personA, dr [dc1], "#E7");
949 evt = (EventInfo) _eventsFired [0];
950 Assert.AreEqual ("ColumnChanging", evt.Name, "#F1");
951 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
952 Assert.AreSame (dc0, colChangeArgs.Column, "#F2");
953 Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#F3");
954 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#F4");
956 evt = (EventInfo) _eventsFired [1];
957 Assert.AreEqual ("ColumnChanged", evt.Name, "#G1");
958 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
959 Assert.AreSame (dc0, colChangeArgs.Column, "#G2");
960 Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#G3");
961 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#G4");
963 evt = (EventInfo) _eventsFired [2];
964 Assert.AreEqual ("ColumnChanging", evt.Name, "#H1");
965 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
966 Assert.AreSame (dc1, colChangeArgs.Column, "#H2");
967 Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#H3");
968 Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#H4");
970 evt = (EventInfo) _eventsFired [3];
971 Assert.AreEqual ("ColumnChanged", evt.Name, "#I1");
972 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
973 Assert.AreSame (dc1, colChangeArgs.Column, "#I2");
974 Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#I3");
975 Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#I4");
977 evt = (EventInfo) _eventsFired [4];
978 Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
979 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
980 Assert.AreSame (dc0, colChangeArgs.Column, "#J2");
981 Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#J3");
982 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
984 evt = (EventInfo) _eventsFired [5];
985 Assert.AreEqual ("ColumnChanged", evt.Name, "#K1");
986 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
987 Assert.AreSame (dc0, colChangeArgs.Column, "#K2");
988 Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#K3");
989 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
992 [Test] // Object this [DataColumn]
993 public void Indexer1_Column_NotInTable ()
996 DataColumnChangeEventArgs colChangeArgs;
998 DataTable dtA = new DataTable ("TableA");
999 dtA.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1000 dtA.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1001 DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1002 dtA.Columns.Add (dcA1);
1003 DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1004 dtA.Columns.Add (dcA2);
1006 DataTable dtB = new DataTable ("TableB");
1007 dtB.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1008 dtB.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1009 DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1010 dtB.Columns.Add (dcB1);
1011 DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1012 dtB.Columns.Add (dcB2);
1014 Person personA = new Person ("Miguel");
1015 Address addressA = new Address ("X", 5);
1017 dtA.Rows.Add (new object [] { addressA, personA });
1018 DataRow dr = dtA.Rows [0];
1021 object value = dr [dcB1];
1022 Assert.Fail ("#A1:" + value);
1023 } catch (ArgumentException ex) {
1024 // Column 'Col0' does not belong to table TableA
1025 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1026 Assert.IsNull (ex.InnerException, "#A3");
1027 Assert.IsNotNull (ex.Message, "#A4");
1028 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1029 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1033 object value = dr [new DataColumn ("ZZZ")];
1034 Assert.Fail ("#B1:" + value);
1035 } catch (ArgumentException ex) {
1036 // Column 'Col0' does not belong to table TableA
1037 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1038 Assert.IsNull (ex.InnerException, "#B3");
1039 Assert.IsNotNull (ex.Message, "#B4");
1040 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1041 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1044 dtA.Columns.Remove (dcA2);
1047 object value = dr [dcA2];
1048 Assert.Fail ("#C1:" + value);
1049 } catch (ArgumentException ex) {
1050 // Column 'Col0' does not belong to table TableA
1051 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1052 Assert.IsNull (ex.InnerException, "#C3");
1053 Assert.IsNotNull (ex.Message, "#C4");
1054 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1055 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1059 [Test] // Object this [DataColumn]
1060 public void Indexer1_Column_Null ()
1063 DataColumnChangeEventArgs colChangeArgs;
1065 DataTable dt = new DataTable ();
1066 dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1067 dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1068 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1069 dt.Columns.Add (dc0);
1070 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1071 dt.Columns.Add (dc1);
1073 Person personA = new Person ("Miguel");
1074 Address addressA = new Address ("X", 5);
1075 Person personB = new Person ("Chris");
1077 dt.Rows.Add (new object [] { addressA, personA });
1078 DataRow dr = dt.Rows [0];
1081 object value = dr [(DataColumn) null];
1082 Assert.Fail ("#A1:" + value);
1083 } catch (ArgumentNullException ex) {
1084 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1085 Assert.IsNull (ex.InnerException, "#A3");
1086 Assert.IsNotNull (ex.Message, "#A4");
1087 Assert.AreEqual ("column", ex.ParamName, "#A5");
1091 dr [(DataColumn) null] = personB;
1092 Assert.Fail ("#B1");
1093 } catch (ArgumentNullException ex) {
1094 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1095 Assert.IsNull (ex.InnerException, "#B3");
1096 Assert.IsNotNull (ex.Message, "#B4");
1097 Assert.AreEqual ("column", ex.ParamName, "#B5");
1100 Assert.AreEqual (0, _eventsFired.Count, "#C");
1103 [Test] // Object this [DataColumn]
1104 public void Indexer1_Value_Null ()
1107 DataColumnChangeEventArgs colChangeArgs;
1109 DataTable dt = new DataTable ();
1110 dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1111 dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1112 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1113 dt.Columns.Add (dc0);
1114 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1115 dt.Columns.Add (dc1);
1116 DataColumn dc2 = new DataColumn ("Col2", typeof (string));
1117 dt.Columns.Add (dc2);
1119 Person personA = new Person ("Miguel");
1120 Address addressA = new Address ("X", 5);
1121 string countryA = "U.S.";
1122 Person personB = new Person ("Chris");
1123 Address addressB = new Address ("Y", 4);
1124 string countryB = "Canada";
1125 Person personC = new Person ("Jackson");
1126 Address addressC = new Address ("Z", 3);
1128 dt.Rows.Add (new object [] { addressA, personA, countryA });
1129 dt.Rows.Add (new object [] { addressB, personB, countryB });
1131 DataRow dr = dt.Rows [0];
1135 Assert.Fail ("#A1");
1136 } catch (ArgumentException ex) {
1137 // Cannot set Column 'Col0' to be null.
1138 // Please use DBNull instead
1139 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1140 Assert.IsNull (ex.InnerException, "#A3");
1141 Assert.IsNotNull (ex.Message, "#A4");
1142 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1143 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1146 Assert.AreEqual (1, _eventsFired.Count, "#B1");
1147 Assert.AreEqual (addressA, dr [dc0], "#B2");
1148 Assert.IsFalse (dr.IsNull (dc0), "#B3");
1149 Assert.AreSame (personA, dr [dc1], "#B4");
1150 Assert.IsFalse (dr.IsNull (dc1), "#B5");
1151 Assert.AreEqual (1, _eventsFired.Count, "#B6");
1158 Assert.Fail ("#B1");
1159 } catch (ArgumentException ex) {
1160 // Cannot set Column 'Col1' to be null.
1161 // Please use DBNull instead
1162 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1163 Assert.IsNull (ex.InnerException, "#B3");
1164 Assert.IsNotNull (ex.Message, "#B4");
1165 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1166 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1167 Assert.AreEqual (2, _eventsFired.Count, "#B7");
1169 dr [dc1] = DBNull.Value;
1173 Assert.AreEqual (3, _eventsFired.Count, "#C1");
1175 Assert.AreEqual (4, _eventsFired.Count, "#C1");
1177 Assert.AreEqual (addressA, dr [dc0], "#C2");
1178 Assert.IsFalse (dr.IsNull (dc0), "#C3");
1179 Assert.AreSame (DBNull.Value, dr [dc1], "#C4");
1180 Assert.IsTrue (dr.IsNull (dc1), "#C5");
1182 Assert.AreEqual (3, _eventsFired.Count, "#C6");
1184 Assert.AreEqual (4, _eventsFired.Count, "#C6");
1187 dr [dc0] = DBNull.Value;
1189 Assert.AreEqual (5, _eventsFired.Count, "#D1");
1191 Assert.AreEqual (6, _eventsFired.Count, "#D1");
1193 Assert.AreSame (DBNull.Value, dr [dc0], "#D2");
1194 Assert.IsTrue (dr.IsNull (dc0), "#D3");
1195 Assert.AreSame (DBNull.Value, dr [dc1], "#D4");
1196 Assert.IsTrue (dr.IsNull (dc1), "#D5");
1198 Assert.AreEqual (5, _eventsFired.Count, "#D6");
1200 Assert.AreEqual (6, _eventsFired.Count, "#D6");
1206 Assert.AreEqual (7, _eventsFired.Count, "#E1");
1208 Assert.AreEqual (8, _eventsFired.Count, "#E1");
1210 Assert.AreSame (DBNull.Value, dr [dc0], "#E2");
1211 Assert.IsTrue (dr.IsNull (dc0), "#E3");
1212 Assert.AreEqual (personC, dr [dc1], "#E4");
1213 Assert.IsFalse (dr.IsNull (dc1), "#E5");
1215 Assert.AreSame (DBNull.Value, dr [dc0], "#E6");
1216 Assert.IsTrue (dr.IsNull (dc0), "#E7");
1217 Assert.AreEqual (personC, dr [dc1], "#E8");
1218 Assert.IsFalse (dr.IsNull (dc1), "#E9");
1220 Assert.AreEqual (7, _eventsFired.Count, "#E10");
1222 Assert.AreEqual (8, _eventsFired.Count, "#E10");
1225 dr [dc1] = DBNull.Value;
1227 Assert.AreEqual (9, _eventsFired.Count, "#F1");
1229 Assert.AreEqual (10, _eventsFired.Count, "#F1");
1231 Assert.AreSame (DBNull.Value, dr [dc0], "#F2");
1232 Assert.IsTrue (dr.IsNull (dc0), "#F3");
1233 Assert.AreSame (DBNull.Value, dr [dc1], "#F4");
1234 Assert.IsTrue (dr.IsNull (dc1), "#F5");
1236 Assert.AreEqual (9, _eventsFired.Count, "#F6");
1238 Assert.AreEqual (10, _eventsFired.Count, "#F6");
1243 Assert.AreEqual (11, _eventsFired.Count, "#G1");
1245 Assert.AreEqual (12, _eventsFired.Count, "#G1");
1247 Assert.AreSame (DBNull.Value, dr [dc0], "#G2");
1248 Assert.IsTrue (dr.IsNull (dc0), "#G3");
1249 Assert.AreSame (DBNull.Value, dr [dc1], "#G4");
1250 Assert.IsTrue (dr.IsNull (dc1), "#G5");
1251 Assert.AreSame (DBNull.Value, dr [dc2], "#G6");
1252 Assert.IsTrue (dr.IsNull (dc2), "#G7");
1254 Assert.AreEqual (11, _eventsFired.Count, "#G8");
1256 Assert.AreEqual (12, _eventsFired.Count, "#G8");
1259 dr [dc2] = DBNull.Value;
1261 Assert.AreEqual (13, _eventsFired.Count, "#H1");
1263 Assert.AreEqual (14, _eventsFired.Count, "#H1");
1265 Assert.AreSame (DBNull.Value, dr [dc0], "#H2");
1266 Assert.IsTrue (dr.IsNull (dc0), "#H3");
1267 Assert.AreSame (DBNull.Value, dr [dc1], "#H4");
1268 Assert.IsTrue (dr.IsNull (dc1), "#H5");
1269 Assert.AreSame (DBNull.Value, dr [dc2], "#H6");
1270 Assert.IsTrue (dr.IsNull (dc2), "#H7");
1272 Assert.AreEqual (13, _eventsFired.Count, "#H8");
1274 Assert.AreEqual (14, _eventsFired.Count, "#H8");
1279 evt = (EventInfo) _eventsFired [index++];
1280 Assert.AreEqual ("ColumnChanging", evt.Name, "#I1");
1281 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1282 Assert.AreSame (dc0, colChangeArgs.Column, "#I2");
1283 Assert.IsNull (colChangeArgs.ProposedValue, "#I3");
1284 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#I4");
1286 evt = (EventInfo) _eventsFired [index++];
1287 Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
1288 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1289 Assert.AreSame (dc1, colChangeArgs.Column, "#J2");
1290 Assert.IsNull (colChangeArgs.ProposedValue, "#J3");
1291 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
1294 evt = (EventInfo) _eventsFired [index++];
1295 Assert.AreEqual ("ColumnChanging", evt.Name, "#K1");
1296 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1297 Assert.AreSame (dc1, colChangeArgs.Column, "#K2");
1298 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#K3");
1299 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
1302 evt = (EventInfo) _eventsFired [index++];
1303 Assert.AreEqual ("ColumnChanged", evt.Name, "#L1");
1304 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1305 Assert.AreSame (dc1, colChangeArgs.Column, "#L2");
1307 Assert.IsNull (colChangeArgs.ProposedValue, "#L3");
1309 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#L3");
1311 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#L4");
1313 evt = (EventInfo) _eventsFired [index++];
1314 Assert.AreEqual ("ColumnChanging", evt.Name, "#M1");
1315 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1316 Assert.AreSame (dc0, colChangeArgs.Column, "#M2");
1317 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#M3");
1318 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#M4");
1320 evt = (EventInfo) _eventsFired [index++];
1321 Assert.AreEqual ("ColumnChanged", evt.Name, "#N1");
1322 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1323 Assert.AreSame (dc0, colChangeArgs.Column, "#N2");
1324 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#N3");
1325 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#N4");
1327 evt = (EventInfo) _eventsFired [index++];
1328 Assert.AreEqual ("ColumnChanging", evt.Name, "#O1");
1329 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1330 Assert.AreSame (dc1, colChangeArgs.Column, "#O2");
1331 Assert.AreSame (personC, colChangeArgs.ProposedValue, "#O3");
1332 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#O4");
1334 evt = (EventInfo) _eventsFired [index++];
1335 Assert.AreEqual ("ColumnChanged", evt.Name, "#P1");
1336 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1337 Assert.AreSame (dc1, colChangeArgs.Column, "#P2");
1338 Assert.AreSame (personC, colChangeArgs.ProposedValue, "#P3");
1339 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#P4");
1341 evt = (EventInfo) _eventsFired [index++];
1342 Assert.AreEqual ("ColumnChanging", evt.Name, "#Q1");
1343 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1344 Assert.AreSame (dc1, colChangeArgs.Column, "#Q2");
1345 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#Q3");
1346 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#Q4");
1348 evt = (EventInfo) _eventsFired [index++];
1349 Assert.AreEqual ("ColumnChanged", evt.Name, "#R1");
1350 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1351 Assert.AreSame (dc1, colChangeArgs.Column, "#R2");
1352 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#R3");
1353 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#R4");
1355 evt = (EventInfo) _eventsFired [index++];
1356 Assert.AreEqual ("ColumnChanging", evt.Name, "#S1");
1357 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1358 Assert.AreSame (dc2, colChangeArgs.Column, "#S2");
1359 Assert.IsNull (colChangeArgs.ProposedValue, "#S3");
1360 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#S4");
1362 evt = (EventInfo) _eventsFired [index++];
1363 Assert.AreEqual ("ColumnChanged", evt.Name, "#T1");
1364 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1365 Assert.AreSame (dc2, colChangeArgs.Column, "#T2");
1366 Assert.IsNull (colChangeArgs.ProposedValue, "#T3");
1367 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#T4");
1369 evt = (EventInfo) _eventsFired [index++];
1370 Assert.AreEqual ("ColumnChanging", evt.Name, "#U1");
1371 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1372 Assert.AreSame (dc2, colChangeArgs.Column, "#U2");
1373 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#U3");
1374 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#U4");
1376 evt = (EventInfo) _eventsFired [index++];
1377 Assert.AreEqual ("ColumnChanged", evt.Name, "#V1");
1378 colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1379 Assert.AreSame (dc2, colChangeArgs.Column, "#V2");
1380 Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#V3");
1381 Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#V4");
1384 [Test] // Object this [Int32]
1385 public void Indexer2 ()
1387 DataTable dt = new DataTable ();
1388 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1389 dt.Columns.Add (dc0);
1390 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1391 dt.Columns.Add (dc1);
1393 Person personA = new Person ("Miguel");
1394 Address addressA = new Address ("X", 5);
1395 Person personB = new Person ("Chris");
1396 Address addressB = new Address ("Y", 4);
1397 Person personC = new Person ("Jackson");
1398 Address addressC = new Address ("Z", 3);
1400 dt.Rows.Add (new object [] { addressA, personA });
1401 dt.Rows.Add (new object [] { addressB, personB });
1405 Assert.AreEqual (addressA, dr [0], "#A1");
1406 Assert.AreSame (personA, dr [1], "#A2");
1409 Assert.AreEqual (addressB, dr [0], "#B1");
1410 Assert.AreSame (personB, dr [1], "#B2");
1414 Assert.AreEqual (addressC, dr [0], "#C1");
1415 Assert.AreSame (personA, dr [1], "#C2");
1420 Assert.AreEqual (addressB, dr [0], "#D1");
1421 Assert.AreSame (personC, dr [1], "#D2");
1423 Assert.AreEqual (addressB, dr [0], "#D3");
1424 Assert.AreSame (personC, dr [1], "#D4");
1429 Assert.AreEqual (addressB, dr [0], "#E1");
1430 Assert.AreSame (personA, dr [1], "#E2");
1432 Assert.AreEqual (addressC, dr [0], "#E3");
1433 Assert.AreSame (personA, dr [1], "#E4");
1436 [Test] // Object this [Int32]
1437 public void Indexer2_Value_Null ()
1439 DataTable dt = new DataTable ();
1440 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1441 dt.Columns.Add (dc0);
1442 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1443 dt.Columns.Add (dc1);
1445 Person personA = new Person ("Miguel");
1446 Address addressA = new Address ("X", 5);
1447 Person personB = new Person ("Chris");
1448 Address addressB = new Address ("Y", 4);
1449 Person personC = new Person ("Jackson");
1450 Address addressC = new Address ("Z", 3);
1452 dt.Rows.Add (new object [] { addressA, personA });
1453 dt.Rows.Add (new object [] { addressB, personB });
1455 DataRow dr = dt.Rows [0];
1459 Assert.Fail ("#A1");
1460 } catch (ArgumentException ex) {
1461 // Cannot set Column 'Col0' to be null.
1462 // Please use DBNull instead
1463 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1464 Assert.IsNull (ex.InnerException, "#A3");
1465 Assert.IsNotNull (ex.Message, "#A4");
1466 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1467 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1470 Assert.AreEqual (addressA, dr [0], "#B1");
1471 Assert.IsFalse (dr.IsNull (0), "#B2");
1472 Assert.AreSame (personA, dr [1], "#B3");
1473 Assert.IsFalse (dr.IsNull (1), "#B4");
1480 Assert.Fail ("#B1");
1481 } catch (ArgumentException ex) {
1482 // Cannot set Column 'Col1' to be null.
1483 // Please use DBNull instead
1484 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1485 Assert.IsNull (ex.InnerException, "#B3");
1486 Assert.IsNotNull (ex.Message, "#B4");
1487 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1488 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1490 dr [1] = DBNull.Value;
1493 Assert.AreEqual (addressA, dr [0], "#C1");
1494 Assert.IsFalse (dr.IsNull (0), "#C2");
1495 Assert.AreSame (DBNull.Value, dr [1], "#C3");
1496 Assert.IsTrue (dr.IsNull (1), "#C4");
1498 dr [0] = DBNull.Value;
1500 Assert.AreSame (DBNull.Value, dr [0], "#D1");
1501 Assert.IsTrue (dr.IsNull (0), "#D2");
1502 Assert.AreSame (DBNull.Value, dr [1], "#D3");
1503 Assert.IsTrue (dr.IsNull (1), "#D4");
1507 Assert.AreSame (DBNull.Value, dr [0], "#E1");
1508 Assert.IsTrue (dr.IsNull (0), "#E2");
1509 Assert.AreEqual (personC, dr [1], "#E3");
1510 Assert.IsFalse (dr.IsNull (1), "#E4");
1512 Assert.AreSame (DBNull.Value, dr [0], "#E5");
1513 Assert.IsTrue (dr.IsNull (0), "#E6");
1514 Assert.AreEqual (personC, dr [1], "#E7");
1515 Assert.IsFalse (dr.IsNull (1), "#E8");
1517 dr [1] = DBNull.Value;
1519 Assert.AreSame (DBNull.Value, dr [0], "#F1");
1520 Assert.IsTrue (dr.IsNull (0), "#F2");
1521 Assert.AreSame (DBNull.Value, dr [1], "#F3");
1522 Assert.IsTrue (dr.IsNull (1), "#F4");
1525 [Test] // Object this [String]
1526 public void Indexer3 ()
1528 DataTable dt = new DataTable ();
1529 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1530 dt.Columns.Add (dc0);
1531 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1532 dt.Columns.Add (dc1);
1534 Person personA = new Person ("Miguel");
1535 Address addressA = new Address ("X", 5);
1536 Person personB = new Person ("Chris");
1537 Address addressB = new Address ("Y", 4);
1538 Person personC = new Person ("Jackson");
1539 Address addressC = new Address ("Z", 3);
1541 dt.Rows.Add (new object [] { addressA, personA });
1542 dt.Rows.Add (new object [] { addressB, personB });
1546 Assert.AreEqual (addressA, dr ["Col0"], "#A1");
1547 Assert.AreSame (personA, dr ["Col1"], "#A2");
1550 Assert.AreEqual (addressB, dr ["Col0"], "#B1");
1551 Assert.AreSame (personB, dr ["Col1"], "#B2");
1554 dr ["Col0"] = addressC;
1555 Assert.AreEqual (addressC, dr ["Col0"], "#C1");
1556 Assert.AreSame (personA, dr ["Col1"], "#C2");
1560 dr ["Col1"] = personC;
1561 Assert.AreEqual (addressB, dr ["Col0"], "#D1");
1562 Assert.AreSame (personC, dr ["Col1"], "#D2");
1564 Assert.AreEqual (addressB, dr ["Col0"], "#D3");
1565 Assert.AreSame (personC, dr ["Col1"], "#D4");
1569 dr ["Col0"] = addressB;
1570 Assert.AreEqual (addressB, dr ["Col0"], "#E1");
1571 Assert.AreSame (personA, dr ["Col1"], "#E2");
1573 Assert.AreEqual (addressC, dr ["Col0"], "#E3");
1574 Assert.AreSame (personA, dr ["Col1"], "#E4");
1577 [Test] // Object this [String]
1578 public void Indexer3_ColumnName_Empty ()
1580 DataTable dt = new DataTable ("Persons");
1581 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1582 dt.Columns.Add (dc0);
1583 DataColumn dc1 = new DataColumn (string.Empty, typeof (Person));
1584 dt.Columns.Add (dc1);
1586 Person personA = new Person ("Miguel");
1587 Address addressA = new Address ("X", 5);
1588 Person personB = new Person ("Chris");
1590 dt.Rows.Add (new object [] { addressA, personA });
1592 DataRow dr = dt.Rows [0];
1595 object value = dr [string.Empty];
1596 Assert.Fail ("#A1:" + value);
1597 } catch (ArgumentException ex) {
1598 // Column '' does not belong to table Persons
1599 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1600 Assert.IsNull (ex.InnerException, "#A3");
1601 Assert.IsNotNull (ex.Message, "#A4");
1602 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A5");
1603 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#A6");
1604 Assert.IsNull (ex.ParamName, "#A7");
1608 dr [string.Empty] = personB;
1609 Assert.Fail ("#B1");
1610 } catch (ArgumentException ex) {
1611 // Column '' does not belong to table Persons
1612 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1613 Assert.IsNull (ex.InnerException, "#B3");
1614 Assert.IsNotNull (ex.Message, "#B4");
1615 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B5");
1616 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#B6");
1617 Assert.IsNull (ex.ParamName, "#B7");
1621 [Test] // Object this [String]
1622 public void Indexer3_ColumnName_Null ()
1624 DataTable dt = new DataTable ();
1625 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1626 dt.Columns.Add (dc0);
1627 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1628 dt.Columns.Add (dc1);
1630 Person personA = new Person ("Miguel");
1631 Address addressA = new Address ("X", 5);
1632 Person personB = new Person ("Chris");
1634 dt.Rows.Add (new object [] { addressA, personA });
1636 DataRow dr = dt.Rows [0];
1639 object value = dr [(string) null];
1640 Assert.Fail ("#A1:" + value);
1641 } catch (ArgumentNullException ex) {
1642 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1643 Assert.IsNull (ex.InnerException, "#A3");
1644 Assert.IsNotNull (ex.Message, "#A4");
1646 Assert.AreEqual ("name", ex.ParamName, "#A5");
1648 Assert.AreEqual ("key", ex.ParamName, "#A5");
1653 dr [(string) null] = personB;
1654 Assert.Fail ("#B1");
1655 } catch (ArgumentNullException ex) {
1656 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1657 Assert.IsNull (ex.InnerException, "#B3");
1658 Assert.IsNotNull (ex.Message, "#B4");
1660 Assert.AreEqual ("name", ex.ParamName, "#B5");
1662 Assert.AreEqual ("key", ex.ParamName, "#B5");
1667 [Test] // Object this [String]
1668 public void Indexer3_Value_Null ()
1670 DataTable dt = new DataTable ();
1671 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1672 dt.Columns.Add (dc0);
1673 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1674 dt.Columns.Add (dc1);
1676 Person personA = new Person ("Miguel");
1677 Address addressA = new Address ("X", 5);
1678 Person personB = new Person ("Chris");
1679 Address addressB = new Address ("Y", 4);
1680 Person personC = new Person ("Jackson");
1681 Address addressC = new Address ("Z", 3);
1683 dt.Rows.Add (new object [] { addressA, personA });
1684 dt.Rows.Add (new object [] { addressB, personB });
1686 DataRow dr = dt.Rows [0];
1690 Assert.Fail ("#A1");
1691 } catch (ArgumentException ex) {
1692 // Cannot set Column 'Col0' to be null.
1693 // Please use DBNull instead
1694 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1695 Assert.IsNull (ex.InnerException, "#A3");
1696 Assert.IsNotNull (ex.Message, "#A4");
1697 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1698 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1701 Assert.AreEqual (addressA, dr ["Col0"], "#B1");
1702 Assert.IsFalse (dr.IsNull ("Col0"), "#B2");
1703 Assert.AreSame (personA, dr ["Col1"], "#B3");
1704 Assert.IsFalse (dr.IsNull ("Col1"), "#B4");
1711 Assert.Fail ("#B1");
1712 } catch (ArgumentException ex) {
1713 // Cannot set Column 'Col1' to be null.
1714 // Please use DBNull instead
1715 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1716 Assert.IsNull (ex.InnerException, "#B3");
1717 Assert.IsNotNull (ex.Message, "#B4");
1718 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1719 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1721 dr ["Col1"] = DBNull.Value;
1724 Assert.AreEqual (addressA, dr ["Col0"], "#C1");
1725 Assert.IsFalse (dr.IsNull ("Col0"), "#C2");
1726 Assert.AreSame (DBNull.Value, dr ["Col1"], "#C3");
1727 Assert.IsTrue (dr.IsNull ("Col1"), "#C4");
1729 dr ["Col0"] = DBNull.Value;
1731 Assert.AreSame (DBNull.Value, dr ["Col0"], "#D1");
1732 Assert.IsTrue (dr.IsNull ("Col0"), "#D2");
1733 Assert.AreSame (DBNull.Value, dr ["Col1"], "#D3");
1734 Assert.IsTrue (dr.IsNull ("Col1"), "#D4");
1736 dr ["Col1"] = personC;
1738 Assert.AreSame (DBNull.Value, dr ["Col0"], "#E1");
1739 Assert.IsTrue (dr.IsNull ("Col0"), "#E2");
1740 Assert.AreEqual (personC, dr ["Col1"], "#E3");
1741 Assert.IsFalse (dr.IsNull ("Col1"), "#E4");
1744 dr ["Col1"] = DBNull.Value;
1746 Assert.AreSame (DBNull.Value, dr ["Col0"], "#F1");
1747 Assert.IsTrue (dr.IsNull ("Col0"), "#F2");
1748 Assert.AreSame (DBNull.Value, dr ["Col1"], "#F3");
1749 Assert.IsTrue (dr.IsNull ("Col1"), "#F4");
1752 [Test] // Object this [DataColumn, DataRowVersion]
1753 public void Indexer4 ()
1755 DataTable dt = new DataTable ();
1756 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1757 dt.Columns.Add (dc0);
1758 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1759 dt.Columns.Add (dc1);
1761 Person personA = new Person ("Miguel");
1762 Address addressA = new Address ("X", 5);
1763 Person personB = new Person ("Chris");
1764 Address addressB = new Address ("Y", 4);
1765 Person personC = new Person ("Jackson");
1766 Address addressC = new Address ("Z", 3);
1768 dt.Rows.Add (new object [] { addressA, personA });
1769 dt.Rows.Add (new object [] { addressB, personB });
1773 Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Current], "#A1");
1774 Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#A2");
1775 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#A3");
1776 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#A4");
1777 Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#A5");
1778 Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#A6");
1779 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#A7");
1780 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#A8");
1783 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#B1");
1784 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#B2");
1785 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#B3");
1786 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#B4");
1787 Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#B5");
1788 Assert.AreSame (personB, dr [dc1, DataRowVersion.Default], "#B6");
1789 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#B7");
1790 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#B8");
1793 dr [dc0] = addressC;
1794 Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#C1");
1795 Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#C2");
1796 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#C3");
1797 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#C4");
1798 Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#C5");
1799 Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#C6");
1800 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#C7");
1801 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#C8");
1806 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D1");
1807 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D2");
1808 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D3");
1809 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Proposed], "#D4");
1810 Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#D5");
1811 Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D6");
1812 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D7");
1813 Assert.AreSame (personC, dr [dc1, DataRowVersion.Proposed], "#D8");
1815 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D9");
1816 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D10");
1817 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D11");
1818 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D12");
1819 Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D13");
1820 Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D14");
1821 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D15");
1822 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D16");
1823 dr.AcceptChanges ();
1824 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D17");
1825 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D18");
1826 Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Original], "#D19");
1827 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D20");
1828 Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D21");
1829 Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D22");
1830 Assert.AreEqual (personC, dr [dc1, DataRowVersion.Original], "#D23");
1831 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D24");
1835 dr [dc0] = addressA;
1836 Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E1");
1837 Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#E2");
1838 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E3");
1839 Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Proposed], "#E4");
1840 Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E5");
1841 Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E6");
1842 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E7");
1843 Assert.AreSame (personA, dr [dc1, DataRowVersion.Proposed], "#E8");
1845 Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E9");
1846 Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#E10");
1847 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E11");
1848 Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#E12");
1849 Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E13");
1850 Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E14");
1851 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E15");
1852 Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#E16");
1856 public void Indexer4_Column_NotInTable ()
1858 DataTable dtA = new DataTable ("TableA");
1859 DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1860 dtA.Columns.Add (dcA1);
1861 DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1862 dtA.Columns.Add (dcA2);
1864 DataTable dtB = new DataTable ("TableB");
1865 DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1866 dtB.Columns.Add (dcB1);
1867 DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1868 dtB.Columns.Add (dcB2);
1870 Person personA = new Person ("Miguel");
1871 Address addressA = new Address ("X", 5);
1873 dtA.Rows.Add (new object [] { addressA, personA });
1874 DataRow dr = dtA.Rows [0];
1877 object value = dr [dcB1, DataRowVersion.Default];
1878 Assert.Fail ("#A1:" + value);
1879 } catch (ArgumentException ex) {
1880 // Column 'Col0' does not belong to table TableA
1881 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1882 Assert.IsNull (ex.InnerException, "#A3");
1883 Assert.IsNotNull (ex.Message, "#A4");
1884 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1885 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1889 object value = dr [new DataColumn ("ZZZ"), DataRowVersion.Default];
1890 Assert.Fail ("#B1:" + value);
1891 } catch (ArgumentException ex) {
1892 // Column 'Col0' does not belong to table TableA
1893 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1894 Assert.IsNull (ex.InnerException, "#B3");
1895 Assert.IsNotNull (ex.Message, "#B4");
1896 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1897 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1900 dtA.Columns.Remove (dcA2);
1903 object value = dr [dcA2, DataRowVersion.Default];
1904 Assert.Fail ("#C1:" + value);
1905 } catch (ArgumentException ex) {
1906 // Column 'Col0' does not belong to table TableA
1907 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1908 Assert.IsNull (ex.InnerException, "#C3");
1909 Assert.IsNotNull (ex.Message, "#C4");
1910 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1911 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1915 [Test] // Object this [DataColumn, DataRowVersion]
1916 public void Indexer4_Column_Null ()
1918 DataTable dt = new DataTable ();
1919 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1920 dt.Columns.Add (dc0);
1921 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1922 dt.Columns.Add (dc1);
1924 Person personA = new Person ("Miguel");
1925 Address addressA = new Address ("X", 5);
1926 Person personB = new Person ("Chris");
1928 dt.Rows.Add (new object [] { addressA, personA });
1929 DataRow dr = dt.Rows [0];
1932 object value = dr [(DataColumn) null, DataRowVersion.Default];
1933 Assert.Fail ("#1:" + value);
1934 } catch (ArgumentNullException ex) {
1935 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1936 Assert.IsNull (ex.InnerException, "#3");
1937 Assert.IsNotNull (ex.Message, "#4");
1938 Assert.AreEqual ("column", ex.ParamName, "#5");
1942 [Test] // Object this [DataColumn, DataRowVersion]
1943 public void Indexer4_Version_Invalid ()
1945 DataTable dt = new DataTable ();
1946 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1947 dt.Columns.Add (dc0);
1948 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1949 dt.Columns.Add (dc1);
1951 Person personA = new Person ("Miguel");
1952 Address addressA = new Address ("X", 5);
1953 Person personB = new Person ("Chris");
1955 dt.Rows.Add (new object [] { addressA, personA });
1956 DataRow dr = dt.Rows [0];
1959 object value = dr [dc0, (DataRowVersion) 666];
1960 Assert.Fail ("#1:" + value);
1961 } catch (DataException ex) {
1962 // Version must be Original, Current, or Proposed
1963 Assert.AreEqual (typeof (DataException), ex.GetType (), "#2");
1964 Assert.IsNull (ex.InnerException, "#3");
1965 Assert.IsNotNull (ex.Message, "#4");
1966 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#5");
1967 Assert.IsTrue (ex.Message.IndexOf ("Current") != -1, "#6");
1968 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#7");
1969 Assert.IsFalse (ex.Message.IndexOf ("Default") != -1, "#8");
1973 [Test] // Object this [DataColumn, DataRowVersion]
1974 public void Indexer4_Version_NotFound ()
1976 DataTable dt = new DataTable ();
1977 DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1978 dt.Columns.Add (dc0);
1979 DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1980 dt.Columns.Add (dc1);
1982 Person personA = new Person ("Miguel");
1983 Address addressA = new Address ("X", 5);
1984 Person personB = new Person ("Chris");
1986 dt.Rows.Add (new object [] { addressA, personA });
1987 DataRow dr = dt.Rows [0];
1990 object value = dr [dc0, DataRowVersion.Original];
1991 Assert.Fail ("#A1:" + value);
1992 } catch (VersionNotFoundException ex) {
1993 // There is no Original data to access
1994 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#A2");
1995 Assert.IsNull (ex.InnerException, "#A3");
1996 Assert.IsNotNull (ex.Message, "#A4");
1997 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#A5");
2001 object value = dr [dc0, DataRowVersion.Proposed];
2002 Assert.Fail ("#B1:" + value);
2003 } catch (VersionNotFoundException ex) {
2004 // There is no Proposed data to access
2005 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#B2");
2006 Assert.IsNull (ex.InnerException, "#B3");
2007 Assert.IsNotNull (ex.Message, "#B4");
2008 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#B5");
2012 [Test] public void IsNull_ByDataColumn()
2014 DataTable dt = new DataTable();
2015 DataColumn dc0 = new DataColumn("Col0",typeof(int));
2016 DataColumn dc1 = new DataColumn("Col1",typeof(int));
2017 dt.Columns.Add(dc0);
2018 dt.Columns.Add(dc1);
2019 dt.Rows.Add(new object[] {1234});
2020 DataRow dr = dt.Rows[0];
2023 Assert.AreEqual(false , dr.IsNull(dc0) , "DRW85");
2026 Assert.AreEqual(true , dr.IsNull(dc1) , "DRW86");
2029 [Test] public void IsNull_ByDataColumnDataRowVersion()
2031 DataTable dt = new DataTable();
2032 DataColumn dc0 = new DataColumn("Col0",typeof(int));
2033 DataColumn dc1 = new DataColumn("Col1",typeof(int));
2034 dt.Columns.Add(dc0);
2035 dt.Columns.Add(dc1);
2036 dt.Rows.Add(new object[] {1234});
2037 DataRow dr = dt.Rows[0];
2039 // IsNull - col0 Current
2040 Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Current) , "DRW87");
2042 // IsNull - col1 Current
2043 Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Current) , "DRW88");
2045 // IsNull - col0 Default
2046 Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Default) , "DRW89");
2047 // IsNull - col1 Default
2048 Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Default) , "DRW90");
2051 dr[0] = 9; //Change value, Create RowVersion Proposed
2053 // IsNull - col0 Proposed
2054 Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Proposed) , "DRW91");
2055 // IsNull - col1 Proposed
2056 Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Proposed) , "DRW92");
2061 // IsNull - col0 Original
2062 Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Original) , "DRW93");
2065 [Test] public void IsNull_ByIndex()
2067 DataTable dt = new DataTable();
2068 DataColumn dc0 = new DataColumn("Col0",typeof(int));
2069 DataColumn dc1 = new DataColumn("Col1",typeof(int));
2070 dt.Columns.Add(dc0);
2071 dt.Columns.Add(dc1);
2072 dt.Rows.Add(new object[] {1234});
2073 DataRow dr = dt.Rows[0];
2076 Assert.AreEqual(false , dr.IsNull(0) , "DRW94");
2079 Assert.AreEqual(true , dr.IsNull(1) , "DRW95");
2083 public void IsNull_ByName()
2085 DataTable dt = new DataTable();
2086 DataColumn dc0 = new DataColumn("Col0",typeof(int));
2087 DataColumn dc1 = new DataColumn("Col1",typeof(int));
2088 dt.Columns.Add(dc0);
2089 dt.Columns.Add(dc1);
2090 dt.Rows.Add(new object[] {1234});
2091 DataRow dr = dt.Rows[0];
2093 #region --- assignment ----
2095 Assert.AreEqual(false, dr.IsNull("Col0"), "DRW96");
2098 Assert.AreEqual(true, dr.IsNull("Col1"), "DRW97");
2101 #region --- bug 3124 ---
2104 MemoryStream st = new MemoryStream();
2105 StreamWriter sw = new StreamWriter(st);
2106 sw.Write("<?xml version=\"1.0\" standalone=\"yes\"?><NewDataSet>");
2107 sw.Write("<Table><EmployeeNo>9</EmployeeNo></Table>");
2108 sw.Write("</NewDataSet>");
2111 DataSet ds = new DataSet();
2113 // Here we add the expression column
2114 ds.Tables[0].Columns.Add("ValueListValueMember", typeof(object), "EmployeeNo");
2116 foreach( DataRow row in ds.Tables[0].Rows )
2118 Console.WriteLine(row["ValueListValueMember"].ToString() + " " );
2119 if( row.IsNull("ValueListValueMember") == true )
2120 Assert.AreEqual("Failed", "SubTest", "DRW98");
2122 Assert.AreEqual("Passed", "Passed", "DRW99");
2128 [Test] public void Item()
2130 // init table with columns
2131 DataTable myTable = new DataTable("myTable");
2133 myTable.Columns.Add(new DataColumn("Id",typeof(int)));
2134 myTable.Columns.Add(new DataColumn("Name",typeof(string)));
2135 DataColumn dc = myTable.Columns[0];
2137 myTable.Rows.Add(new object[] {1,"Ofer"});
2138 myTable.Rows.Add(new object[] {2,"Ofer"});
2140 myTable.AcceptChanges();
2142 DataRow myRow = myTable.Rows[0];
2147 Assert.AreEqual(1 , (int)myRow[0] , "DRW100");
2150 Assert.AreEqual(1 , (int)myRow["Id"] , "DRW101");
2153 Assert.AreEqual(1 , (int)myRow[dc] , "DRW102");
2155 // Item - index,Current
2156 Assert.AreEqual(1 , (int)myRow[0,DataRowVersion.Current ] , "DRW103");
2158 // Item - string,Current
2159 Assert.AreEqual(1 , (int)myRow["Id",DataRowVersion.Current] , "DRW104");
2161 // Item - columnn,Current
2162 Assert.AreEqual(1 , (int)myRow[dc,DataRowVersion.Current] , "DRW105");
2167 /*public void testMore()
2169 DataTable dt = DataProvider.CreateParentDataTable();
2170 dt.Rows[0].BeginEdit();
2172 dt.Rows[0].EndEdit();
2176 [Test] public void RejectChanges()
2178 DataTable dt = new DataTable();
2179 DataColumn dc0 = new DataColumn("Col0",typeof(int));
2180 DataColumn dc1 = new DataColumn("Col1",typeof(int));
2181 dt.Columns.Add(dc0);
2182 dt.Columns.Add(dc1);
2183 dt.Rows.Add(new object[] {1234});
2185 DataRow dr = dt.Rows[0];
2191 // RejectChanges - row 0
2192 Assert.AreEqual(1234 , (int)dr[0], "DRW106");
2194 // RejectChanges - row 1
2195 Assert.AreEqual(DBNull.Value , dr[1] , "DRW107");
2200 // RejectChanges - count
2201 Assert.AreEqual(1 , dt.Rows.Count , "DRW108");
2204 [Test] public void RowState()
2206 DataTable myTable = new DataTable("myTable");
2207 DataColumn dc = new DataColumn("Name",typeof(string));
2208 myTable.Columns.Add(dc);
2211 // Create a new DataRow.
2212 myRow = myTable.NewRow();
2217 Assert.AreEqual(DataRowState.Detached , myRow.RowState , "DRW109");
2219 myTable.Rows.Add(myRow);
2223 Assert.AreEqual(DataRowState.Added , myRow.RowState , "DRW110");
2225 myTable.AcceptChanges();
2229 Assert.AreEqual(DataRowState.Unchanged , myRow.RowState , "DRW111");
2231 myRow["Name"] = "Scott";
2235 Assert.AreEqual(DataRowState.Modified , myRow.RowState , "DRW112");
2241 Assert.AreEqual(DataRowState.Deleted , myRow.RowState , "DRW113");
2244 [Test] public void SetColumnError_ByDataColumnError()
2246 string sColErr = "Error!";
2247 DataTable dt = new DataTable("myTable");
2248 DataColumn dc = new DataColumn("Column1");
2250 DataRow dr = dt.NewRow();
2253 Assert.AreEqual(String.Empty, dr.GetColumnError(dc) , "DRW114");
2255 dr.SetColumnError(dc,sColErr );
2258 Assert.AreEqual(sColErr, dr.GetColumnError(dc) , "DRW115");
2261 [Test] public void SetColumnError_ByIndexError()
2263 string sColErr = "Error!";
2264 DataTable dt = new DataTable("myTable");
2265 DataColumn dc = new DataColumn("Column1");
2267 DataRow dr = dt.NewRow();
2270 Assert.AreEqual(String.Empty , dr.GetColumnError(0) , "DRW116");
2272 dr.SetColumnError(0,sColErr );
2275 Assert.AreEqual(sColErr , dr.GetColumnError(0) , "DRW117");
2276 dr.SetColumnError (0, "");
2277 Assert.AreEqual("", dr.GetColumnError (0) , "DRW118");
2280 [Test] public void SetColumnError_ByColumnNameError()
2282 string sColErr = "Error!";
2283 DataTable dt = new DataTable("myTable");
2284 DataColumn dc = new DataColumn("Column1");
2286 DataRow dr = dt.NewRow();
2289 Assert.AreEqual(String.Empty, dr.GetColumnError("Column1") , "DRW118");
2291 dr.SetColumnError("Column1",sColErr );
2294 Assert.AreEqual(sColErr, dr.GetColumnError("Column1") , "DRW119");
2297 [Test] public void SetParentRow_ByDataRow()
2299 DataRow drParent,drChild;
2300 DataRow drArrExcepted,drArrResult;
2301 DataTable dtChild,dtParent;
2302 DataSet ds = new DataSet();
2304 dtChild = DataProvider.CreateChildDataTable();
2305 dtParent= DataProvider.CreateParentDataTable();
2306 //Add tables to dataset
2307 ds.Tables.Add(dtChild);
2308 ds.Tables.Add(dtParent);
2310 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2311 ds.Relations.Add(dRel);
2313 drParent = dtParent.Rows[0];
2314 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2316 drChild.SetParentRow(drParent);
2318 //Get Excepted result
2319 drArrExcepted = drParent;
2320 //Get Result DataRowVersion.Current
2321 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2324 Assert.AreEqual(drArrExcepted , drArrResult, "DRW120");
2328 public void testMore()
2330 DataSet ds = DataProvider.CreateForigenConstraint();
2331 DataRow drParent = ds.Tables[0].Rows[0];
2332 //DataRow[] drArray = ds.Tables[1].Rows[0].GetParentRows(ds.Tables[1].ParentRelations[0]);
2333 ds.Tables[1].Rows[0].SetParentRow(drParent);
2339 // test SetParentRow
2340 DataTable parent = DataProvider.CreateParentDataTable();
2341 DataTable child = DataProvider.CreateChildDataTable();
2342 DataRow dr = parent.Rows[0];
2344 parent.AcceptChanges();
2346 child.Rows[0].SetParentRow(dr);
2349 public void checkForLoops()
2351 DataSet ds = new DataSet();
2353 DataTable dtChild = DataProvider.CreateChildDataTable();
2354 DataTable dtParent= DataProvider.CreateParentDataTable();
2355 //Add tables to dataset
2356 ds.Tables.Add(dtChild);
2357 ds.Tables.Add(dtParent);
2359 dtChild.Rows.Clear();
2360 dtParent.Rows.Clear();
2362 dtParent.ChildRelations.Add(dtParent.Columns[0],dtChild.Columns[0]);
2363 dtChild.ChildRelations.Add(dtChild.Columns[0],dtParent.Columns[0]);
2365 dtChild.Rows[0].SetParentRow(dtParent.Rows[0]);
2366 dtParent.Rows[0].SetParentRow(dtChild.Rows[0]);
2369 public void checkForLoopsAdvenced()
2372 DataTable dtChild = new DataTable();
2373 dtChild.Columns.Add("Col1",typeof(int));
2374 dtChild.Columns.Add("Col2",typeof(int));
2376 DataRelation drl = new DataRelation("drl1",dtChild.Columns[0],dtChild.Columns[1]);
2377 dtChild.ChildRelations.Add(drl);
2378 dtChild.Rows[0].SetParentRow(dtChild.Rows[1]);
2379 dtChild.Rows[1].SetParentRow(dtChild.Rows[0]);
2382 [Test] public void SetParentRow_ByDataRowDataRelation()
2384 DataRow drParent,drChild;
2385 DataRow drArrExcepted,drArrResult;
2386 DataTable dtChild,dtParent;
2387 DataSet ds = new DataSet();
2389 dtChild = DataProvider.CreateChildDataTable();
2390 dtParent= DataProvider.CreateParentDataTable();
2391 //Add tables to dataset
2392 ds.Tables.Add(dtChild);
2393 ds.Tables.Add(dtParent);
2395 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2396 ds.Relations.Add(dRel);
2398 drParent = dtParent.Rows[0];
2399 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2401 drChild.SetParentRow(drParent ,dRel);
2403 //Get Excepted result
2404 drArrExcepted = drParent;
2405 //Get Result DataRowVersion.Current
2406 drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2409 Assert.AreEqual(drArrExcepted , drArrResult, "DRW121");
2412 [Test] public void Table()
2415 dt2 = new DataTable("myTable");
2416 DataRow dr = dt2.NewRow();
2420 Assert.AreEqual(dt2, dt1 , "DRW122");
2423 [Test] public new void ToString()
2427 dtParent= DataProvider.CreateParentDataTable();
2428 dr = dtParent.Rows[0];
2431 Assert.AreEqual(true, dr.ToString().ToLower().StartsWith("system.data.datarow") , "DRW123");
2434 [Test] public void DataRow_RowError()
2436 DataTable dt = new DataTable ("myTable");
2437 DataRow dr = dt.NewRow ();
2439 Assert.AreEqual ( dr.RowError, string.Empty );
2441 dr.RowError = "Err";
2442 Assert.AreEqual ( dr.RowError , "Err" );
2446 [ExpectedException (typeof (ConstraintException))]
2447 public void DataRow_RowError2()
2449 DataTable dt1 = DataProvider.CreateUniqueConstraint();
2451 dt1.BeginLoadData();
2453 DataRow dr = dt1.NewRow();
2460 [ExpectedException (typeof (ConstraintException))]
2461 public void DataRow_RowError3()
2463 DataSet ds= DataProvider.CreateForigenConstraint();
2464 ds.Tables[0].BeginLoadData();
2465 ds.Tables[0].Rows[0][0] = 10;
2466 ds.Tables[0].EndLoadData(); //Foreign constraint violation
2471 public void TestRowErrors ()
2473 DataTable table = new DataTable ();
2474 DataColumn col1 = table.Columns.Add ("col1", typeof (int));
2475 DataColumn col2 = table.Columns.Add ("col2", typeof (int));
2476 DataColumn col3 = table.Columns.Add ("col3", typeof (int));
2478 col1.AllowDBNull = false;
2479 table.Constraints.Add ("uc", new DataColumn[] {col2,col3}, false);
2480 table.BeginLoadData ();
2481 table.Rows.Add (new object[] {null,1,1});
2482 table.Rows.Add (new object[] {1,1,1});
2484 table.EndLoadData ();
2486 } catch (ConstraintException) {}
2487 Assert.IsTrue (table.HasErrors, "#1");
2488 DataRow[] rows = table.GetErrors ();
2490 Assert.AreEqual (2, rows.Length, "#2");
2491 Assert.AreEqual ("Column 'col1' does not allow DBNull.Value.", table.Rows [0].RowError, "#3");
2492 Assert.AreEqual ("Column 'col2, col3' is constrained to be unique. Value '1, 1' is already present."
2493 , table.Rows [1].RowError, "#4");
2495 Assert.AreEqual (table.Rows [0].RowError, table.Rows [0].GetColumnError (0), "#5");
2496 Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (1), "#6");
2497 Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (2), "#7");
2499 Assert.AreEqual ("", table.Rows [1].GetColumnError (0), "#8");
2500 Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (1), "#9");
2501 Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (2), "#10");
2505 public void BeginEdit()
2507 DataTable myTable = new DataTable("myTable");
2508 DataColumn dc = new DataColumn("Id",typeof(int));
2510 myTable.Columns.Add(dc);
2511 myTable.Rows.Add(new object[] {1});
2512 myTable.Rows.Add(new object[] {2});
2513 myTable.Rows.Add(new object[] {3});
2515 DataRow myRow = myTable.Rows[0];
2519 myRow[0] = 2; //row[0] now conflict with row[1]
2520 Assert.Fail("DRW121: failed to throw ConstraintException");
2522 catch (ConstraintException) {}
2523 catch (AssertionException exc) {throw exc;}
2524 catch (Exception exc)
2526 Assert.Fail("DRW122: Add. Wrong exception type. Got:" + exc);
2529 //Will NOT! throw exception
2531 myRow[0] = 2; //row[0] now conflict with row[1]
2533 DataTable dt = DataProvider.CreateParentDataTable();
2534 DataRow dr = dt.Rows[0];
2539 Assert.Fail("DRW123: failed to throw DeletedRowInaccessibleException");
2541 catch (DeletedRowInaccessibleException) {}
2542 catch (AssertionException exc) {throw exc;}
2543 catch (Exception exc)
2545 Assert.Fail("DRW124: Add. Wrong exception type. Got:" + exc);
2550 public void GetChildRows_DataRelation()
2553 DataRow[] drArrExcepted,drArrResult;
2554 DataTable dtChild,dtParent;
2555 DataSet ds = new DataSet();
2558 dtChild = DataProvider.CreateChildDataTable();
2559 dtParent= DataProvider.CreateParentDataTable();
2561 //Add tables to dataset
2562 ds.Tables.Add(dtChild);
2563 ds.Tables.Add(dtParent);
2564 dr = dtParent.Rows[0];
2567 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2568 ds.Relations.Add(dRel);
2569 //Get Excepted result
2570 drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
2572 drArrResult = dr.GetChildRows(dRel);
2574 Assert.AreEqual(drArrExcepted, drArrResult, "DRW125");
2578 public void GetParentRows_DataRelation_DataRowVersion()
2580 DataRow drParent,drChild;
2581 DataRow[] drArrExcepted,drArrResult;
2582 DataTable dtChild,dtParent;
2583 DataSet ds = new DataSet();
2585 dtChild = DataProvider.CreateChildDataTable();
2586 dtParent= DataProvider.CreateParentDataTable();
2587 //Add tables to dataset
2588 ds.Tables.Add(dtChild);
2589 ds.Tables.Add(dtParent);
2591 drParent = dtParent.Rows[0];
2592 drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2594 //Duplicate several rows in order to create Many to Many relation
2595 dtParent.ImportRow(drParent);
2596 dtParent.ImportRow(drParent);
2597 dtParent.ImportRow(drParent);
2600 DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
2601 ds.Relations.Add(dRel);
2603 //Get Excepted result
2604 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
2605 //Get Result DataRowVersion.Current
2606 drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Current);
2607 Assert.AreEqual(drArrExcepted, drArrResult, "DRW126");
2609 //Get Excepted result
2610 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
2611 //Get Result DataRowVersion.Current
2612 drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Original );
2613 Assert.AreEqual(drArrExcepted, drArrResult, "DRW127");
2615 //Get Excepted result, in this case Current = Default
2616 drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
2617 //Get Result DataRowVersion.Current
2618 drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Default );
2619 Assert.AreEqual(drArrExcepted, drArrResult, "DRW128");
2623 DataTable dtOtherParent = DataProvider.CreateParentDataTable();
2624 DataTable dtOtherChild = DataProvider.CreateChildDataTable();
2626 DataRelation drl = new DataRelation("newRelation",dtOtherParent.Columns[0],dtOtherChild.Columns[0]);
2627 drChild.GetParentRows(drl,DataRowVersion.Current);
2628 Assert.Fail("DRW129: failed to throw ArgumentException");
2630 catch (ArgumentException) {}
2631 catch (AssertionException exc) {throw exc;}
2632 catch (Exception exc)
2634 Assert.Fail("DRW130: Add. Wrong exception type. Got:" + exc);
2639 public void ItemArray()
2641 DataTable dt = GetDataTable();
2642 DataRow dr = dt.Rows[0];
2644 Assert.AreEqual(1, (int)dr.ItemArray[0] , "DRW131" );
2646 Assert.AreEqual("Ofer", (string)dr.ItemArray[1] , "DRW132" );
2648 dt = GetDataTable();
2652 //Changing row via itemArray
2654 dt.Rows[0].ItemArray = new object[] {2,"Oren"};
2656 Assert.AreEqual(2, (Int32)dr.ItemArray[0] , "DRW133" );
2657 Assert.AreEqual("Oren", (string)dr.ItemArray[1] , "DRW134" );
2661 dt.Rows[0].ItemArray = new object[] {2,"Oren","some1else"};
2662 Assert.Fail("DRW135: failed to throw ArgumentException");
2664 catch (ArgumentException) {}
2665 catch (AssertionException exc) {throw exc;}
2666 catch (Exception exc)
2668 Assert.Fail("DRW136: Add. Wrong exception type. Got:" + exc);
2673 public void ItemArray_NewTable ()
2675 DataTable dt = new DataTable("Customers");
2677 dt.Columns.Add("name", typeof (string));
2678 dt.Columns.Add("address", typeof (string));
2679 dt.Columns.Add("phone", typeof (string));
2681 DataRow dr = dt.NewRow();
2682 dr["name"] = "myName";
2683 dr["address"] = "myAddress";
2684 dr["phone"] = "myPhone";
2686 // Should not throw RowNotInTableException
2687 object[] obj = dr.ItemArray;
2690 private DataTable GetDataTable()
2692 DataTable dt = new DataTable("myTable");
2693 dt.Columns.Add("Id",typeof(int));
2694 dt.Columns.Add("Name",typeof(string));
2696 DataRow dr = dt.NewRow();
2697 dr.ItemArray = new object[] {1,"Ofer"};
2705 public void RowError()
2707 DataTable dt = new DataTable("myTable");
2708 DataRow dr = dt.NewRow();
2710 Assert.AreEqual(string.Empty , dr.RowError, "DRW137");
2712 dr.RowError = "Err";
2714 Assert.AreEqual("Err", dr.RowError , "DRW138" );
2716 DataTable dt1 = DataProvider.CreateUniqueConstraint();
2720 dt1.BeginLoadData();
2726 Assert.Fail("DRW139: failed to throw ConstraintException");
2728 catch (ConstraintException)
2730 Assert.AreEqual(2,dt1.GetErrors().Length,"DRW141");
2731 Assert.AreEqual(true,dt1.GetErrors()[0].RowError.Length > 10,"DRW142");
2732 Assert.AreEqual(true,dt1.GetErrors()[1].RowError.Length > 10,"DRW143");
2734 catch (AssertionException exc) {throw exc;}
2735 catch (Exception exc)
2737 Assert.Fail("DRW144: Wrong exception type. Got:" + exc);
2744 ds= DataProvider.CreateForigenConstraint();
2745 ds.Tables[0].BeginLoadData();
2746 ds.Tables[0].Rows[0][0] = 10; //Forigen constraint violation
2747 //ds.Tables[0].AcceptChanges();
2748 ds.Tables[0].EndLoadData();
2749 Assert.Fail("DRW139: failed to throw ConstraintException");
2751 catch (ConstraintException)
2753 Assert.AreEqual(3,ds.Tables[1].GetErrors().Length,"DRW145");
2754 for(int index=0;index<3;index++)
2756 Assert.AreEqual(true,ds.Tables[1].GetErrors()[index].RowError.Length > 10,"RDW146");
2759 catch (AssertionException exc) {throw exc;}
2760 catch (Exception exc)
2762 Assert.Fail("DRW147: Wrong exception type. Got:" + exc);
2767 public void bug78885 ()
2769 DataSet ds = new DataSet ();
2770 DataTable t = ds.Tables.Add ("table");
2773 id = t.Columns.Add ("userID", Type.GetType ("System.Int32"));
2774 id.AutoIncrement = true;
2775 t.Columns.Add ("name", Type.GetType ("System.String"));
2776 t.Columns.Add ("address", Type.GetType ("System.String"));
2777 t.Columns.Add ("zipcode", Type.GetType ("System.Int32"));
2778 t.PrimaryKey = new DataColumn [] { id };
2781 tempRow = t.NewRow ();
2782 tempRow ["name"] = "Joan";
2783 tempRow ["address"] = "Balmes 152";
2784 tempRow ["zipcode"] = "1";
2785 t.Rows.Add (tempRow);
2787 t.RowChanged += new DataRowChangeEventHandler (RowChangedHandler);
2789 /* neither of the calls to EndEdit below generate a RowChangedHandler on MS. the first one does on mono */
2790 t.DefaultView [0].BeginEdit ();
2791 t.DefaultView [0].EndEdit (); /* this generates a call to the row changed handler */
2792 t.DefaultView [0].EndEdit (); /* this doesn't */
2794 Assert.IsFalse (_rowChanged);
2797 private void RowChangedHandler (object sender, DataRowChangeEventArgs e)
2804 public void SetAdded_test()
2806 DataTable table = new DataTable();
2808 DataRow row = table.NewRow();
2812 } catch (InvalidOperationException e) {
2815 table.Columns.Add("col1", typeof(int));
2816 table.Columns.Add("col2", typeof(int));
2817 table.Columns.Add("col3", typeof(int));
2819 row = table.Rows.Add(new object[] { 1, 2, 3 });
2820 Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2824 } catch (InvalidOperationException e) {
2826 Assert.AreEqual(DataRowState.Added, row.RowState, "#2");
2828 row.AcceptChanges();
2830 Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2834 } catch (InvalidOperationException e) {
2837 row.AcceptChanges();
2838 Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2840 Assert.AreEqual(DataRowState.Added, row.RowState, "#4");
2844 public void setAdded_testRollback ()
2846 DataTable table = new DataTable ();
2847 table.Columns.Add ("col1", typeof (int));
2848 table.Columns.Add ("col2", typeof (int));
2850 table.Rows.Add (new object[] {1,1});
2851 table.AcceptChanges ();
2853 table.Rows [0].SetAdded ();
2854 table.RejectChanges ();
2855 Assert.AreEqual (0, table.Rows.Count, "#1");
2859 public void SetModified_test()
2861 DataTable table = new DataTable();
2863 DataRow row = table.NewRow();
2866 } catch (InvalidOperationException) {}
2868 table.Columns.Add("col1", typeof(int));
2869 table.Columns.Add("col2", typeof(int));
2870 table.Columns.Add("col3", typeof(int));
2872 row = table.Rows.Add(new object[] { 1, 2, 3 });
2873 Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2877 } catch (InvalidOperationException e) {
2878 // Never premise English.
2879 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2882 row.AcceptChanges();
2884 Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2888 } catch (InvalidOperationException e) {
2889 // Never premise English.
2890 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2893 row.AcceptChanges();
2894 Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2896 Assert.AreEqual(DataRowState.Modified, row.RowState, "#4");
2900 public void setModified_testRollback()
2902 DataTable table = new DataTable();
2903 table.Columns.Add("col1", typeof(int));
2904 table.Columns.Add("col2", typeof(int));
2906 DataRow row = table.Rows.Add(new object[] { 1, 1 });
2907 table.AcceptChanges();
2910 Assert.AreEqual(row.RowState, DataRowState.Modified, "#0");
2911 Assert.AreEqual(1, row [0, DataRowVersion.Current], "#1");
2912 Assert.AreEqual(1, row [0, DataRowVersion.Original], "#2");
2913 table.RejectChanges ();
2914 Assert.AreEqual(row.RowState, DataRowState.Unchanged, "#3");
2918 public void DataRowExpressionDefaultValueTest ()
2920 DataSet ds = new DataSet ();
2921 DataTable custTable = ds.Tables.Add ("CustTable");
2923 DataColumn column = new DataColumn ("units", typeof (int));
2924 column.AllowDBNull = false;
2925 column.Caption = "Units";
2926 column.DefaultValue = 1;
2927 custTable.Columns.Add (column);
2929 column = new DataColumn ("price", typeof (decimal));
2930 column.AllowDBNull = false;
2931 column.Caption = "Price";
2932 column.DefaultValue = 25;
2933 custTable.Columns.Add (column);
2935 column = new DataColumn ("total", typeof (string));
2936 column.Caption = "Total";
2937 column.Expression = "price*units";
2938 custTable.Columns.Add (column);
2940 DataRow row = custTable.NewRow ();
2942 Assert.AreEqual (DBNull.Value, row["Total"] , "#1 Should be System.DBNull");
2943 custTable.Rows.Add (row);
2945 Assert.AreEqual ("25", row["Total"] , "#2 Should not be emptry string");
2948 void ColumnChanged (object sender, DataColumnChangeEventArgs e)
2950 _eventsFired.Add (new EventInfo ("ColumnChanged", e));
2953 void ColumnChanging (object sender, DataColumnChangeEventArgs e)
2955 _eventsFired.Add (new EventInfo ("ColumnChanging", e));
2960 public EventInfo (string name, EventArgs args)
2966 public string Name {
2967 get { return name; }
2970 public EventArgs Args {
2971 get { return args; }
2974 private readonly string name;
2975 private readonly EventArgs args;
2978 static bool AssertNotFound (DataRow rc, DataColumn dc, DataRowVersion version)
2981 object value = rc [dc, version];
2983 } catch (VersionNotFoundException) {
2990 public Person (string name)
2996 public Address HomeAddress;
3001 public Address (string street, int houseNumber)
3004 HouseNumber = houseNumber;
3007 public override bool Equals (object o)
3009 if (!(o is Address))
3012 Address address = (Address) o;
3013 if (address.HouseNumber != HouseNumber)
3015 if (address.Street != Street)
3020 public override int GetHashCode ()
3023 return HouseNumber.GetHashCode ();
3024 return (Street.GetHashCode () ^ HouseNumber.GetHashCode ());
3027 public override string ToString ()
3030 return HouseNumber.ToString (CultureInfo.InvariantCulture);
3032 return string.Concat (Street, HouseNumber.ToString (CultureInfo.InvariantCulture));
3035 public string Street;
3036 public int HouseNumber;