public void Convert(ufDateNode node, Stream stream, bool multiples, Urls urls, Errors errors, bool reporting)
 {
     m_bReporting = reporting;
     m_oErrors = errors;
     m_oUrls = urls;
     Convert(node, stream, multiples);
 }

 void AssertSubtract(Row row, string excdColumn, string panColumn, string pctnColumn, string nexcdColumn, Errors errors)
 {
     if (row[excdColumn].ToLower() == "yes")
     {
         AssertSubtract(row, panColumn, pctnColumn, nexcdColumn, errors);
     }
 }

 public override void Test(Row row, Errors errors)
 {
     AssertSum(row, "1YR_PS_GRAD_DSAG_PTS_EARN", new[] { "1YR_PS_GRAD_ELL_PTS_EARN", "1YR_PS_GRAD_IEP_PTS_EARN", "1YR_PS_GRAD_MIN_PTS_EARN", "1YR_PS_GRAD_FRL_PTS_EARN" }, errors);
     AssertSum(row, "1YR_PS_GRAD_DSAG_PTS_ELIG", new[] { "1YR_PS_GRAD_ELL_PTS_ELIG", "1YR_PS_GRAD_IEP_PTS_ELIG", "1YR_PS_GRAD_MIN_PTS_ELIG", "1YR_PS_GRAD_FRL_PTS_ELIG" }, errors);
     AssertSum(row, "3YR_PS_GRAD_DSAG_PTS_EARN", new[] { "3YR_PS_GRAD_ELL_PTS_EARN", "3YR_PS_GRAD_IEP_PTS_EARN", "3YR_PS_GRAD_MIN_PTS_EARN", "3YR_PS_GRAD_FRL_PTS_EARN" }, errors);
     AssertSum(row, "3YR_PS_GRAD_DSAG_PTS_ELIG", new[] { "3YR_PS_GRAD_ELL_PTS_ELIG", "3YR_PS_GRAD_IEP_PTS_ELIG", "3YR_PS_GRAD_MIN_PTS_ELIG", "3YR_PS_GRAD_FRL_PTS_ELIG" }, errors);
 }

        public void When_ToString_is_called_and_the_errors_are_not_initialized_then_the_result_contains_an_empty_string()
        {
            var errors = new Errors();

            var errorsString = errors.ToString();
            Assert.IsTrue(string.IsNullOrEmpty(errorsString));
        }

 public void Add_Test2_Adding_string()
 {
     Errors target = new Errors();
     string newError = "Test";
     target.Add(newError);
     Assert.AreEqual(target[0].Message, newError);
 }

        bool CheckPointsEarned(Row row, string percentPointsColumn, string pointsEligibleColumn, string pointsEarnedColumn, Errors errors)
        {
            if (!Defined(row, percentPointsColumn, errors) &&
                (!Defined(row, pointsEligibleColumn, errors) || !Defined(row, pointsEarnedColumn, errors)))
            {
                return true;
            }

            if (!AssertDefined(row, pointsEligibleColumn, errors) || !AssertDefined(row, pointsEarnedColumn, errors))
            {
                return false;
            }

            if(!Defined(row, percentPointsColumn, errors) && (row[pointsEligibleColumn] == "0" || row[pointsEarnedColumn] == "0"))
            {
                return true;
            }

            if (AssertDefined(row, new[] { percentPointsColumn, pointsEligibleColumn, pointsEarnedColumn }, errors))
            {
                var percentPoints = double.Parse(row[percentPointsColumn]);
                var pointsEligible = double.Parse(row[pointsEligibleColumn]);
                var pointsEarned = double.Parse(row[pointsEarnedColumn]);
                var pointsEarnedExpected = percentPoints * pointsEligible / 100.0;

                return AssertTrue(row, pointsEarnedExpected.Format() == pointsEarned.Format(), percentPointsColumn + ", " + pointsEligibleColumn + ", " + pointsEarnedColumn, errors);
            }
            return false;
        }

 public void Add_Test1_Adding_string()
 {
     Errors target = new Errors(); 
     string newError = string.Empty; 
     target.Add(newError);
     Assert.AreEqual(target.Count,1);
 }

 void AssertGreaterThan(Row row, string panColumn, string pctnColumn, string excdColumn, Errors errors)
 {
     if(row[excdColumn].ToLower() == "yes")
     {
         AssertGreaterThan(row, panColumn, pctnColumn, errors);
     }
 }

        bool AssertAGP(Row row, string madeAgpColumn, string ratingColumn, string mgpColumn, Errors errors)
        {
            if(!Defined(row, madeAgpColumn, errors) && !Defined(row, ratingColumn, errors) && !Defined(row, mgpColumn, errors))
            {
                return true;
            }

            if(AssertDefined(row, madeAgpColumn, errors))
            {
                var madeMgp = row[madeAgpColumn];
                Func<double, string> rating = null;
                if (madeMgp.ToLower() == "yes") rating = RatingYes;
                if (madeMgp.ToLower() == "no") rating = RatingNo;
                if(rating != null)
                {
                    return AssertRating(row, ratingColumn, mgpColumn, rating, errors);
                }
                else
                {
                    errors.Add(row, "Unknown Made MGP State (should be 'Yes' or 'No'):" + madeMgp, GetPrettyName());
                }

            }
            return false;
        }

 internal void ReportError(ExplorerNode node, Errors error)
 {
     ErrorNode parent = (ErrorNode)this[error.ToString()];
     if (parent == null)
         parent = new ErrorNode(this, error.ToString(), getMessage(error));
     Activator.CreateInstance(node.GetType(), (ExplorerNode)parent, node);
 }

 protected override bool AssertRating(Row row, string ratingColumn, string valueColumn, Func<double, string> ratingLookup, Errors errors, bool passIfBlank = false)
 {
     if(!Defined(row, valueColumn, errors) && !Defined(row, valueColumn, errors))
     {
         return true;
     }
     return base.AssertRating(row, ratingColumn, valueColumn, ratingLookup, errors, passIfBlank);
 }

        public void Add_Test2_Adding_Non_Empty_Collection()
        {
            Errors target = new Errors();
            Errors newErrors = new Errors {"Test Error"};

            target.Add(newErrors);
            Assert.AreEqual(target.Count, 1);
        }

        public void Add_Test1_Adding_Empty_Collection()
        {
            Errors target = new Errors();
            Errors newErrors = new Errors();
 
            target.Add(newErrors);
            Assert.AreEqual(target.Count,0);
        }

        public override void Test(Row row, Errors errors)
        {
            var oneYear = new[] { "1YR_ACHIEVE_RATING", "1YR_GROWTH_RATING", "1YR_GRO_GAPS_RATING", "1YR_POST_SEC_RATING" };
            AssertRating(row, "1YR_INDICATOR_NCOUNT", oneYear, errors, GetIndicatorCount);

            var threeYear = new[] { "3YR_ACHIEVE_RATING", "3YR_GROWTH_RATING", "3YR_GRO_GAPS_RATING", "3YR_POST_SEC_RATING" };
            AssertRating(row, "3YR_INDICATOR_NCOUNT", threeYear, errors, GetIndicatorCount);
        }

 /// <summary>
 /// Report errors to the subsriber.
 /// </summary>
 /// <param name="errors"></param>
 internal virtual void NotifyError(Errors errors)
 {
     EventHandler<ErrorArgs> handler = OnError;
     if (handler != null)
     {
         handler(this, new ErrorArgs(errors));
     }
 }

        public override void Test(Row row, Errors errors)
        {
            var oneYear = new[] { "1YR_PARTIC_RATING_READ", "1YR_PARTIC_RATING_MATH", "1YR_PARTIC_RATING_WRITE", "1YR_PARTIC_RATING_SCI", "1YR_PARTIC_RATING_ACT" };
            AssertRating(row, "1YR_TEST_PARTIC_DNM_COUNT", oneYear, errors);

            var threeYear = new[] { "3YR_PARTIC_RATING_READ", "3YR_PARTIC_RATING_MATH", "3YR_PARTIC_RATING_WRITE", "3YR_PARTIC_RATING_SCI", "3YR_PARTIC_RATING_ACT" };
            AssertRating(row, "3YR_TEST_PARTIC_DNM_COUNT", threeYear, errors);
        }

        protected override bool AssertEqual(Row row, string column1, string column2, Errors errors)
        {
            if (!Defined(row, column1, errors) && !Defined(row, column2, errors))
            {
                return true;
            }

            return base.AssertEqual(row, column1, column2, errors);
        }

        protected override bool AssertSubtract(Row row, string column1, string column2, string resultColumn, Errors errors)
        {
            if(!Defined(row, resultColumn, errors))
            {
                row[resultColumn] = "0";
            }

            return base.AssertSubtract(row, column1, column2, resultColumn, errors);
        }

        bool AssertRating(Row row, string percentColumn, string ratingColumn, Dictionary<string, double[]> cutoffs, Errors errors)
        {
            if(!Defined(row, percentColumn, errors) && !Defined(row, ratingColumn, errors))
            {
                return true;
            }

            return AssertRating(row, ratingColumn, percentColumn, v => GetRating(row.Level, v, cutoffs), errors);
        }

        public override void Test(Row row, Errors errors)
        {
            if (row.Type == EDataType.School || row.Level != "A")
            {
                return;
            }

            Columns.ForEach(t => AssertRating(row, t.Item1, t.Item2, RatingDistrict, errors));
        }