Exemplo n.º 1
0
        /// <summary>
        /// Checks wheter a given DateTime is an invalid date. A check whether it is an undefined DateTime is always performed.
        /// </summary>
        /// <returns>Null if validation succeeded, otherwise a <see cref="TVerificationResult" /> is
        /// returned that contains details about the problem.</returns>
        public static TVerificationResult IsNotInvalidDate(DateTime?ADate, String ADescription,
                                                           TVerificationResultCollection AVerificationResultCollection, bool ATreatNullAsInvalid = false,
                                                           object AResultContext = null, System.Data.DataColumn AResultColumn = null)
        {
            TVerificationResult VerificationResult;

            if (FDelegateSharedGetDateVerificationResult != null)
            {
                VerificationResult = TDateChecks.IsNotUndefinedDateTime(ADate,
                                                                        ADescription, ATreatNullAsInvalid, AResultContext, AResultColumn);

                // Remove Verification Result that would have been recorded earlier for the same DataColumn
                TVerificationResult OtherRecordedVerificationResult = AVerificationResultCollection.FindBy(AResultColumn);

                if (OtherRecordedVerificationResult != null)
                {
                    AVerificationResultCollection.Remove(OtherRecordedVerificationResult);
                }
            }
            else
            {
                VerificationResult = TDateChecks.IsNotUndefinedDateTime(ADate,
                                                                        ADescription, ATreatNullAsInvalid, AResultContext, AResultColumn);
            }

            return(VerificationResult);
        }
        public void TestRemove()
        {
            TVerificationResult           res0, res1, res4, res5, res6, res7;
            TVerificationResultCollection coll = new TVerificationResultCollection();

            res0 = new TVerificationResult(null, "test0", TResultSeverity.Resv_Noncritical);
            coll.Add(res0);
            res1 = new TVerificationResult(null, "test1", TResultSeverity.Resv_Noncritical);
            coll.Add(res1);
            DataColumn col = new DataColumn("test", typeof(int));

            res4 = new TScreenVerificationResult(null, col, "test4", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res4);
            DataTable  tab  = new DataTable("test");
            DataColumn col2 = new DataColumn("test2", typeof(string));

            tab.Columns.Add(col2);
            DataColumn col3 = new DataColumn("test3", typeof(string));

            tab.Columns.Add(col3);
            res5 = new TScreenVerificationResult(null, col2, "test5", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res5);
            res6 = new TScreenVerificationResult(null, col, "test6", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res6);
            res7 = new TScreenVerificationResult(null, col3, "test7", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res7);

            Assert.AreEqual(6, coll.Count, "should be 6 elements at the start of the test");

            // Remove(DataColumn)
            coll.Remove(col);
            Assert.AreEqual(5, coll.Count, "only one element should be removed, even if there are 2 results with column col");
            Assert.AreEqual(2, coll.IndexOf(res5), "res4 was removed");
            coll.Insert(2, res4);
            coll.Remove(new DataColumn("test"));
            Assert.AreEqual(6, coll.Count, "nothing happens when trying to remove unknown column");

            // Remove(IResultInterface value)
            coll.Remove(res1);
            Assert.AreEqual(5, coll.Count, "res1 should have been removed");
            coll.Insert(1, res1);
            Assert.Throws(typeof(ArgumentException),
                          delegate { coll.Remove(new TVerificationResult(null, "test3", TResultSeverity.Resv_Info)); },
                          "trying to remove unknown verification result throws ArgumentException");

            // Remove(String AResultColumnName)
            coll.Remove("nonexisting");
            Assert.AreEqual(6, coll.Count, "nothing happens when trying to remove unknown resultcolumnname");
            coll.Remove(col.ColumnName);
            Assert.AreEqual(5, coll.Count, "should have removed res4");
            Assert.AreEqual(res6, coll.FindBy(col), "first result with col should be res6");
            coll.Insert(4, res4);
        }
        public void TestRemoveAt()
        {
            TVerificationResult           res0, res1, res2, res3;
            TVerificationResultCollection coll = new TVerificationResultCollection();

            res0 = new TVerificationResult(null, "test0", TResultSeverity.Resv_Noncritical);
            coll.Add(res0);
            res1 = new TVerificationResult(null, "test1", TResultSeverity.Resv_Noncritical);
            coll.Add(res1);
            res2 = new TVerificationResult(null, "test2", TResultSeverity.Resv_Noncritical);
            coll.Add(res2);
            res3 = new TVerificationResult(null, "test3", TResultSeverity.Resv_Noncritical);
            coll.Add(res3);

            // RemoveAt(index)
            Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { coll.RemoveAt(4); }, "there is no verification result at index 4");
            // remove from the middle
            coll.RemoveAt(1);
            Assert.AreEqual(res0, coll.FindBy(0), "res0 should be at position 0");
            Assert.AreEqual(res2, coll.FindBy(1), "res2 should be at position 1");
            Assert.AreEqual(res3, coll.FindBy(2), "res3 should be at position 2");
            // remove from the front
            coll.RemoveAt(0);
            Assert.AreEqual(res2, coll.FindBy(0), "res2 should be at position 0");
            Assert.AreEqual(res3, coll.FindBy(1), "res3 should be at position 1");
            // remove from the back
            coll.RemoveAt(1);
            Assert.AreEqual(res2, coll.FindBy(0), "res2 should be at position 0");
            Assert.AreEqual(1, coll.Count, "only one element should be left");
        }
        public void TestFindBy()
        {
            TVerificationResult           res0, res1, res2, res3, res4, res5, res6, res7;
            TVerificationResultCollection coll = new TVerificationResultCollection();

            res0 = new TVerificationResult(null, "test0", TResultSeverity.Resv_Noncritical);
            coll.Add(res0);
            res1 = new TVerificationResult(null, "test1", TResultSeverity.Resv_Noncritical);
            coll.Add(res1);
            res2 = new TVerificationResult("stringobject2", "test2", TResultSeverity.Resv_Noncritical);
            coll.Add(res2);
            res3 = new TVerificationResult("stringobject3", "test3", TResultSeverity.Resv_Noncritical);
            coll.Add(res3);
            DataColumn col = new DataColumn("test", typeof(int));

            res4 = new TScreenVerificationResult(null, col, "test4", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res4);
            DataTable  tab  = new DataTable("test");
            DataColumn col2 = new DataColumn("test2", typeof(string));

            tab.Columns.Add(col2);
            DataColumn col3 = new DataColumn("test3", typeof(string));

            tab.Columns.Add(col3);
            res5 = new TScreenVerificationResult(null, col2, "test5", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res5);
            res6 = new TScreenVerificationResult(null, col, "test6", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res6);
            res7 = new TScreenVerificationResult(null, col3, "test7", null, TResultSeverity.Resv_Noncritical);
            coll.Add(res7);

            // FindBy(index)
            Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { coll.FindBy(20); }, "there is no verification result at index 20");

            for (int i = 0; i < 8; i++)
            {
                TVerificationResult v = null;

                switch (i)
                {
                case 0: v = res0; break;

                case 1: v = res1; break;

                case 2: v = res2; break;

                case 3: v = res3; break;

                case 4: v = res4; break;

                case 5: v = res5; break;

                case 6: v = res6; break;

                case 7: v = res7; break;
                }

                Assert.AreEqual(v, coll.FindBy(i), "res" + i.ToString() + " should be at index " + i.ToString());
            }

            // FindBy(object AResultContext)
            Assert.AreEqual(res2, coll.FindBy("stringobject2"), "should find res2 by resultcontext");
            Assert.AreEqual(res3, coll.FindBy("stringobject3"), "should find res3 by resultcontext");
            Assert.AreEqual(null, coll.FindBy("stringobject4"), "there is no verification result with resultcontext stringobject4");
            Assert.AreEqual(null, coll.FindBy(null), "looking for null returns null");

            // FindBy(DataColumn AResultColumn)
            Assert.AreEqual(res4, coll.FindBy(col), "should find res4 by column (first result with that column)");
            Assert.AreEqual(res5, coll.FindBy(col2), "should find res5 by column");
            Assert.AreEqual(res7, coll.FindBy(col3), "should find res7 by column");
            Assert.AreEqual(null, coll.FindBy(new DataColumn("test")), "should not find an unknown column");

            // FindAllBy(DataColumn AResultColumn)
            List <TScreenVerificationResult> result = coll.FindAllBy(col);

            Assert.AreEqual(2, result.Count, "FindAllBy Column should find 2 objects");
            Assert.AreEqual(res4, result[0], "first object should be res4");
            Assert.AreEqual(res6, result[1], "second object should be res6");

            result = coll.FindAllBy(new DataColumn("test"));
            Assert.IsNull(result, "FindAllBy returns null for unknown column");

            // FindAllBy(DataTable ADataTable)
            result = coll.FindAllBy(tab);
            Assert.AreEqual(2, result.Count, "FindAllBy Table should find 2 objects");
            Assert.AreEqual(res5, result[0], "first object should be res5");
            Assert.AreEqual(res7, result[1], "second object should be res7");

            result = coll.FindAllBy(new DataTable("test"));
            Assert.IsNull(result, "FindAllBy returns null for unknown table");
        }