Пример #1
0
        public Report CompareFiles(Log log, CsvFile csvBase, string sReportPath, ref Options options)
        {
            int iInvalids = 0;

            Report rep = new Report(sReportPath);

            log.WriteLine("Comparing \"{0}\" to \"{1}\"", _fileName, csvBase.ToString());

            rep.BaseFile    = csvBase.ToString();
            rep.CompareFile = _fileName;

            Curve      reference    = new Curve();
            Curve      compareCurve = new Curve();
            TubeReport tubeReport   = new TubeReport();
            TubeSize   size         = null;
            Tube       tube         = new Tube(size);

            switch (options.Direction)
            {
            case ToleranceDirection.X:
                userchoice = 1;     ///set to 1 for tolerenace in X axis
                break;

            case ToleranceDirection.Y:
                userchoice = 0;     ///set to 0 for tolerance in Y-axis
                break;

            default:    //Invalid mode
                Console.WriteLine(options.GetUsage());
                break;
            }

            if (userchoice == 1)
            {
                IOptions tubeOptions = new Options1(_dRangeDelta, Axes.X);
            }
            else if (userchoice == 0)
            {
                IOptions tubeOptions = new Options1(_dRangeDelta, Axes.Y);
            }
            else
            {
                Console.WriteLine("opted for wrong choice");
                Environment.ExitCode = 2;
            }


            foreach (KeyValuePair <string, List <double> > res in csvBase.Results)
            {
                if (!this.Results.ContainsKey(res.Key))
                {
                    log.Error("{0} not found in \"{1}\", skipping checks.", res.Key, this._fileName);
                    rep.Chart.Add(new Chart()
                    {
                        Title = res.Key, Errors = 1
                    });
                    Environment.ExitCode = 1;
                    continue;
                }
                else
                {
                    compareCurve = new Curve(res.Key, this.XAxis.ToArray <double>(), this.Results[res.Key].ToArray <double>());

                    if (res.Value.Count == 0)
                    {
                        log.Error("{0} has no y-Values! Maybe error during parsing? Skipping", res.Key);
                        continue;
                    }
                    reference = new Curve("Reference ", csvBase.XAxis.ToArray(), csvBase.Results[res.Key].ToArray());
                    if (!reference.ImportSuccessful)
                    {
                        log.Error("Error in the calculation of the tubes. Skipping {0}", res.Key);
                        rep.Chart.Add(new Chart()
                        {
                            Title = res.Key, Errors = 1
                        });
                        continue;
                    }

                    if (reference.X.Length < compareCurve.X.Length)
                    {
                        log.WriteLine(LogLevel.Warning, "The resolution of the base x-axis is smaller than the compare x-axis. The better the base resolution is, the better the validation result will be!");
                    }
                    else
                    {
                        log.WriteLine(LogLevel.Debug, "The resolution of the base x-axis is good.");
                    }

                    size = new TubeSize(reference, true);
                    switch (options.Method)
                    {
                    case ExecutionMethod.Relative:
                        if (userchoice == 1)
                        {
                            size.Calculate(_dRangeDelta, Axes.X, Relativity.Relative);
                        }
                        else
                        {
                            size.Calculate(_dRangeDelta, Axes.Y, Relativity.Relative);
                        }
                        break;

                    case ExecutionMethod.Absolute:
                        if (userchoice == 1)
                        {
                            size.Calculate(_dRangeDelta, Axes.X, Relativity.Absolute);
                        }
                        else
                        {
                            size.Calculate(_dRangeDelta, Axes.Y, Relativity.Absolute);
                        }
                        break;

                    default:    //Invalid mode
                        Console.WriteLine(options.GetUsage());
                        break;
                    }
                    tube       = new Tube(size);
                    tubeReport = tube.Calculate(reference);
                    tube.Validate(compareCurve);

                    if (tubeReport.Valid == Validity.Valid)
                    {
                        log.WriteLine(res.Key + " is valid");
                    }
                    else
                    {
                        log.WriteLine(LogLevel.Warning, "{0} is invalid! {1} errors have been found during validation.", res.Key,
                                      (null != tube.Report.Errors && null != tube.Report.Errors.X) ? tube.Report.Errors.X.Length : 0);
                        iInvalids++;
                        Environment.ExitCode = 1;
                    }
                }
                if (null != tube.Report)//No charts for missing reports
                {
                    PrepareCharts(reference, compareCurve, tube.Report.Errors, rep, tubeReport, res, options.UseBitmapPlots);
                }
            }
            rep.Tolerance = _dRangeDelta;

            string sResult = "na";

            if (rep.TotalErrors == 0)
            {
                sResult = "passed";
            }
            else
            {
                sResult = "failed";
            }

            if (options.ComparisonFlag)
            {
                using (TextWriter writer = File.CreateText(string.Format("{0}{1}compare_{2}.log", Path.GetDirectoryName(_fileName), Path.DirectorySeparatorChar, sResult)))
                {
                    //Content needs to be defined
                    writer.WriteLine("CSV Compare Version {0} ({1})", Info.AssemblyVersion, Assembly.GetExecutingAssembly().GetName().ProcessorArchitecture);
                    writer.WriteLine("Comparison result file for {0}", _fileName);
                    writer.WriteLine(". Time:        {0:o}", DateTime.Now);
                    writer.WriteLine(". Operation:   {0}", options.Mode);
                    writer.WriteLine(". Tolerance:   {0}", options.Tolerance);
                    writer.WriteLine(". Execution Method:   {0}", options.Method);
                    writer.WriteLine(". Direction of Tolerence:   {0}", options.Direction);
                    writer.WriteLine(". Result:      {0}", sResult);

                    if (rep.TotalErrors > 0)
                    {
                        Chart pairMax = rep.Chart.Aggregate((l, r) => l.DeltaError > r.DeltaError ? l : r);
                        if (pairMax.DeltaError > 0)
                        {
                            writer.WriteLine(". Largest error: {0}=>{1}", pairMax.Title, pairMax.DeltaError);
                            writer.WriteLine(". Failed values:");

                            foreach (Chart c in (from r in rep.Chart where r.DeltaError > 0 select r).OrderByDescending(er => er.DeltaError))
                            {
                                writer.WriteLine("{0}=>{1}", c.Title, c.DeltaError.ToString(CultureInfo.InvariantCulture));
                            }
                        }
                    }
                }
            }

            rep.WriteReport(log, (string.IsNullOrEmpty(options.ReportDir) || options.NoMetaReport) ? string.Empty : options.ReportDir, options);
            GC.Collect();//immediately forget big charts and data
            return(rep);
        }