예제 #1
0
        protected bool ParseGeometry(Target targetType, string targetText, XmlTest xmlTestItem)
        {
            IGeometry geom = null;

            try
            {
                geom = m_objReader.Read(targetText);
            }
            catch (Exception ex)
            {
                xmlTestItem.Thrown = ex;
                XmlTestExceptionManager.Publish(ex);
                return(false);
            }

            if (geom == null)
            {
                return(false);
            }

            switch (targetType)
            {
            case Target.A:
                xmlTestItem.A = geom;
                break;

            case Target.B:
                xmlTestItem.B = geom;
                break;
            }

            return(true);
        }
예제 #2
0
 public bool Run()
 {
     try
     {
         m_bSuccess = this.RunTest();
         if (!m_bSuccess)
         {
             // DEBUG ERRORS: retry to launch the test and analyze...
             Console.WriteLine();
             Console.WriteLine("Retry failed test: " + Description);
             Console.WriteLine(Argument1);
             Console.WriteLine(Argument2);
             Console.WriteLine(A);
             Console.WriteLine(B);
             Console.WriteLine("Test type: " + TestType);
             m_bSuccess = RunTest();
             Console.WriteLine(String.Format("Result expected is {0}, but was {1}", true, m_bSuccess));
             Console.WriteLine();
         }
         return(m_bSuccess);
     }
     catch (Exception ex)
     {
         m_objException = ex;
         Debug.WriteLine(ex.Message);
         Debug.WriteLine(ex.StackTrace);
         XmlTestExceptionManager.Publish(ex);
         return(false);
     }
 }
        public bool GetFiles(string directory)
        {
            if (m_listFileNames == null)
            {
                m_listFileNames = new StringCollection();
            }

            try
            {
                string[] dirs = Directory.GetFiles(directory, "*.xml");
                foreach (string dir in dirs)
                {
                    m_listFileNames.Add(dir);
                }
                return(true);
            }
            catch (Exception ex)
            {
                XmlTestExceptionManager.Publish(ex);
            }

            return(false);
        }
예제 #4
0
        protected bool ParseResult(string result, XmlTest xmlTestItem)
        {
            switch (xmlTestItem.TestType)
            {
            // Here we expect double
            case XmlTestType.Area:
            case XmlTestType.Distance:
            case XmlTestType.Length:
            {
                try
                {
                    xmlTestItem.Result = Double.Parse(result, GetNumberFormatInfo());
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect integer
            case XmlTestType.BoundaryDimension:
            case XmlTestType.Dimension:
            case XmlTestType.NumPoints:
            case XmlTestType.SRID:
            {
                try
                {
                    xmlTestItem.Result = Int32.Parse(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect a point
            case XmlTestType.Boundary:
            case XmlTestType.Buffer:
            case XmlTestType.Centroid:
            case XmlTestType.ConvexHull:
            case XmlTestType.Difference:
            case XmlTestType.Envelope:
            case XmlTestType.InteriorPoint:
            case XmlTestType.Intersection:
            case XmlTestType.SymmetricDifference:
            case XmlTestType.Union:
            {
                try
                {
                    xmlTestItem.Result = m_objReader.Read(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect boolean
            case XmlTestType.Contains:
            case XmlTestType.Crosses:
            case XmlTestType.Disjoint:
            case XmlTestType.Equals:
            case XmlTestType.Intersects:
            case XmlTestType.IsEmpty:
            case XmlTestType.IsSimple:
            case XmlTestType.IsValid:
            case XmlTestType.IsWithinDistance:
            case XmlTestType.Overlaps:
            case XmlTestType.Relate:
            case XmlTestType.Touches:
            case XmlTestType.Within:
            case XmlTestType.Covers:
            case XmlTestType.CoveredBy:
            {
                try
                {
                    xmlTestItem.Result = Boolean.Parse(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            default:
                break;
            }
            return(false);
        }
예제 #5
0
        public bool LoadFile(string fileName)
        {
            if (!File.Exists(fileName))
            {
                throw new ArgumentException(fileName,
                                            "The file does not exits or the 'fileName' is not valid.");
            }

            try
            {
                var xmldoc = new XmlDocument();

                xmldoc.Load(fileName);

                var root = xmldoc.DocumentElement;

                // Retrieve the "desc" tag, if any.
                XmlNode desc = root["desc"];
                string  strTestDescription = string.Empty;
                if (desc != null && desc.InnerText.Length > 0)
                {
                    strTestDescription = desc.InnerText;
                }
                else
                {
                    strTestDescription = Path.GetFileNameWithoutExtension(fileName);
                }

                // Retrieve the "workspace", if any.
                XmlNode workspace = root["workspace"];
                if (workspace != null)
                {
                    var workspaceAttributes = workspace.Attributes;
                    if (workspaceAttributes != null && workspaceAttributes.Count > 0)
                    {
                        m_strTestWorkspace = workspaceAttributes["dir"].InnerText;
                    }
                }

                // Retrieve the "tolerance" attribute, if any.
                XmlNode tolerance = root["tolerance"];

                double dTolerance = 0.0;
                if (tolerance != null)
                {
                    string strTolerance = tolerance.InnerText;
                    try
                    {
                        dTolerance = double.Parse(strTolerance, GetNumberFormatInfo());
                    }
                    catch (Exception ex)
                    {
                        XmlTestExceptionManager.Publish(ex);
                    }
                }

                // Retrieve the precisionName" tag, if any.
                PrecisionModel pm        = null;
                XmlNode        precision = root["precisionModel"];
                if (precision != null)
                {
                    var precisionAttributes = precision.Attributes;
                    if (precisionAttributes != null && precisionAttributes.Count > 0)
                    {
                        var attribute = precisionAttributes["type"];
                        if (attribute != null)
                        {
                            string strPrecision = attribute.InnerText;

                            if (strPrecision == "FIXED" && precisionAttributes.Count == 4)
                            {
                                try
                                {
                                    double scale =
                                        double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo());
                                    double offsetx =
                                        double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo());
                                    double offsety =
                                        double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo());

                                    pm = new PrecisionModel(scale);
                                }
                                catch (Exception ex)
                                {
                                    XmlTestExceptionManager.Publish(ex);
                                }
                            }
                            else
                            {
                                pm = new PrecisionModel();
                            }
                        }
                        else
                        {
                            if (precisionAttributes.Count == 3)
                            {
                                double scale =
                                    double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo());
                                double offsetx =
                                    double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo());
                                double offsety =
                                    double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo());

                                pm = new PrecisionModel(scale);
                            }
                        }
                    }
                }

                if (pm == null)
                {
                    pm = new PrecisionModel();
                }

                IGeometryOperation geometryOperation = null;
                XmlNode            go = root["geometryOperation"];
                if (go != null)
                {
                    go = go.FirstChild;
                    switch (go.Value)
                    {
                    case "com.vividsolutions.jtstest.geomop.PreparedGeometryOperation":
                        geometryOperation = new PreparedGeometryOperation();
                        break;

                    case "com.vividsolutions.jtstest.geomop.BufferValidatedGeometryOperation":
                        geometryOperation = new BufferValidatedGeometryOperation();
                        break;

                    case "com.vividsolutions.jtstest.geomop.OverlayValidatedGeometryOperation":
                        geometryOperation = new OverlayValidatedGeometryOperation();
                        break;

                    default:
                        Console.WriteLine(string.Format("\n *** {0} *** \n", go.Value));
                        Console.ReadKey(true);
                        geometryOperation = new GeometryMethodOperation();
                        break;
                    }
                }

                IResultMatcher resultMatcher = null;
                XmlNode        rm            = root["resultMatcher"];
                if (rm != null)
                {
                    rm = rm.FirstChild;
                    if (rm.Value.EndsWith("BufferResultMatcher", StringComparison.InvariantCultureIgnoreCase))
                    {
                        resultMatcher = new BufferResultMatcher();
                    }
                    else
                    {
                        throw new NotSupportedException();
                    }
                }

                m_objFactory   = new XmlTestFactory(pm, geometryOperation, resultMatcher);
                m_listCurTests = new XmlTestCollection();

                m_listCurTests.Name = strTestDescription;

                // Now, handle the "case" nodes
                var elemList = xmldoc.GetElementsByTagName("case");
                for (int i = 0; i < elemList.Count; i++)
                {
                    ParseCaseNode(elemList[i], dTolerance);
                }

                m_listarrTests.Add(m_listCurTests);

                return(true);
            }
            catch (Exception ex)
            {
                XmlTestExceptionManager.Publish(ex);
                return(false);
            }
        }
        protected bool ParseResult(string result, XmlTest xmlTestItem)
        {
            switch (xmlTestItem.TestType)
            {
            // Here we expect double
            case XmlTestType.Area:
            case XmlTestType.Distance:
            case XmlTestType.Length:
            case XmlTestType.MinClearance:
            {
                try
                {
                    xmlTestItem.Result = double.Parse(result, GetNumberFormatInfo());
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect integer
            case XmlTestType.BoundaryDimension:
            case XmlTestType.Dimension:
            case XmlTestType.NumPoints:
            case XmlTestType.SRID:
            {
                try
                {
                    xmlTestItem.Result = int.Parse(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect a point
            case XmlTestType.Boundary:
            case XmlTestType.Buffer:
            case XmlTestType.BufferMitredJoin:
            case XmlTestType.Centroid:
            case XmlTestType.ConvexHull:
            case XmlTestType.Densify:
            case XmlTestType.Difference:
            case XmlTestType.Envelope:
            case XmlTestType.InteriorPoint:
            case XmlTestType.Intersection:
            case XmlTestType.SymmetricDifference:
            case XmlTestType.Union:
            case XmlTestType.MinClearanceLine:
            {
                try
                {
                    xmlTestItem.Result = _objReader.Read(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            // Here we expect boolean
            case XmlTestType.Contains:
            case XmlTestType.Crosses:
            case XmlTestType.Disjoint:
            case XmlTestType.Equals:
            case XmlTestType.Intersects:
            case XmlTestType.IsEmpty:
            case XmlTestType.IsSimple:
            case XmlTestType.IsValid:
            case XmlTestType.IsWithinDistance:
            case XmlTestType.Overlaps:
            case XmlTestType.Relate:
            case XmlTestType.Touches:
            case XmlTestType.Within:
            case XmlTestType.Covers:
            case XmlTestType.CoveredBy:
            case XmlTestType.EqualsExact:
            case XmlTestType.EqualsNorm:
            case XmlTestType.EqualsTopo:
            {
                try
                {
                    xmlTestItem.Result = bool.Parse(result);
                    return(true);
                }
                catch (Exception ex)
                {
                    XmlTestExceptionManager.Publish(ex);
                    return(false);
                }
            }

            default:
                string format = string.Format("Test not implemented: {0}", xmlTestItem.TestType);
                throw new NotImplementedException(format);
            }
        }
예제 #7
0
        public bool LoadFile(string fileName)
        {
            if (!File.Exists(fileName))
            {
                throw new ArgumentException(fileName,
                                            "The file does not exits or the 'fileName' is not valid.");
            }

            try
            {
                XmlDocument xmldoc = new XmlDocument();

                xmldoc.Load(fileName);

                XmlElement root = xmldoc.DocumentElement;

                // Retrieve the "desc" tag, if any.
                XmlNode desc = root["desc"];
                string  strTestDescription = String.Empty;
                if (desc != null && desc.InnerText.Length > 0)
                {
                    strTestDescription = desc.InnerText;
                }
                else
                {
                    strTestDescription = Path.GetFileNameWithoutExtension(fileName);
                }

                // Retrieve the "workspace", if any.
                XmlNode workspace = root["workspace"];
                if (workspace != null)
                {
                    XmlAttributeCollection workspaceAttributes = workspace.Attributes;
                    if (workspaceAttributes != null && workspaceAttributes.Count > 0)
                    {
                        m_strTestWorkspace = workspaceAttributes["dir"].InnerText;
                    }
                }

                // Retrieve the "tolerance" attribute, if any.
                XmlNode tolerance = root["tolerance"];

                double dTolerance = 0.0;
                if (tolerance != null)
                {
                    string strTolerance = tolerance.InnerText;
                    try
                    {
                        dTolerance = Double.Parse(strTolerance, GetNumberFormatInfo());
                    }
                    catch (Exception ex)
                    {
                        XmlTestExceptionManager.Publish(ex);
                    }
                }

                // Retrieve the precisionName" tag, if any.
                PrecisionModel pm        = null;
                XmlNode        precision = root["precisionModel"];
                if (precision != null)
                {
                    XmlAttributeCollection precisionAttributes = precision.Attributes;
                    if (precisionAttributes != null && precisionAttributes.Count > 0)
                    {
                        XmlAttribute attribute = precisionAttributes["type"];
                        if (attribute != null)
                        {
                            string strPrecision = attribute.InnerText;

                            if (strPrecision == "FIXED" && precisionAttributes.Count == 4)
                            {
                                try
                                {
                                    double scale =
                                        Double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo());
                                    double offsetx =
                                        Double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo());
                                    double offsety =
                                        Double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo());

                                    pm = new PrecisionModel(scale);
                                }
                                catch (Exception ex)
                                {
                                    XmlTestExceptionManager.Publish(ex);
                                }
                            }
                            else
                            {
                                pm = new PrecisionModel();
                            }
                        }
                        else
                        {
                            if (precisionAttributes.Count == 3)
                            {
                                double scale =
                                    Double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo());
                                double offsetx =
                                    Double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo());
                                double offsety =
                                    Double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo());

                                pm = new PrecisionModel(scale);
                            }
                        }
                    }
                }

                if (pm == null)
                {
                    pm = new PrecisionModel();
                }
                m_objFactory   = new XmlTestFactory(pm);
                m_listCurTests = new XmlTestCollection();

                m_listCurTests.Name = strTestDescription;

                // Now, handle the "case" nodes
                XmlNodeList elemList = xmldoc.GetElementsByTagName("case");
                for (int i = 0; i < elemList.Count; i++)
                {
                    ParseCaseNode(elemList[i], dTolerance);
                }

                m_listarrTests.Add(m_listCurTests);

                return(true);
            }
            catch (Exception ex)
            {
                XmlTestExceptionManager.Publish(ex);

                return(false);
            }
        }