System.Data.Tests.DataRowTest2.Indexer4 C# (CSharp) Method

Indexer4() private method

private Indexer4 ( ) : void
return void
        public void Indexer4()
        {
            DataTable dt = new DataTable();
            DataColumn dc0 = new DataColumn("Col0", typeof(Address));
            dt.Columns.Add(dc0);
            DataColumn dc1 = new DataColumn("Col1", typeof(Person));
            dt.Columns.Add(dc1);

            Person personA = new Person("Miguel");
            Address addressA = new Address("X", 5);
            Person personB = new Person("Chris");
            Address addressB = new Address("Y", 4);
            Person personC = new Person("Jackson");
            Address addressC = new Address("Z", 3);

            dt.Rows.Add(new object[] { addressA, personA });
            dt.Rows.Add(new object[] { addressB, personB });
            DataRow dr;

            dr = dt.Rows[0];
            Assert.Equal(addressA, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressA, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personA, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personA, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));

            dr = dt.Rows[1];
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personB, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personB, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));

            dr = dt.Rows[0];
            dr[dc0] = addressC;
            Assert.Equal(addressC, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressC, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personA, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personA, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));

            dr = dt.Rows[1];
            dr.BeginEdit();
            dr[dc1] = personC;
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Proposed]);
            Assert.Same(personB, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personC, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.Same(personC, dr[dc1, DataRowVersion.Proposed]);
            dr.EndEdit();
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personC, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personC, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));
            dr.AcceptChanges();
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Default]);
            Assert.Equal(addressB, dr[dc0, DataRowVersion.Original]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personC, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personC, dr[dc1, DataRowVersion.Default]);
            Assert.Equal(personC, dr[dc1, DataRowVersion.Original]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));

            dr = dt.Rows[0];
            dr.BeginEdit();
            dr[dc0] = addressA;
            Assert.Equal(addressC, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressA, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.Equal(addressA, dr[dc0, DataRowVersion.Proposed]);
            Assert.Same(personA, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personA, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.Same(personA, dr[dc1, DataRowVersion.Proposed]);
            dr.CancelEdit();
            Assert.Equal(addressC, dr[dc0, DataRowVersion.Current]);
            Assert.Equal(addressC, dr[dc0, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc0, DataRowVersion.Proposed));
            Assert.Same(personA, dr[dc1, DataRowVersion.Current]);
            Assert.Same(personA, dr[dc1, DataRowVersion.Default]);
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Original));
            Assert.True(AssertNotFound(dr, dc1, DataRowVersion.Proposed));
        }
DataRowTest2