示例#1
0
        public bool compareExpectedError(XdmNode assertion)
        {
            string expectedError = assertion.GetAttributeValue(new QName("code"));
            QName  expectedErrorQ;

            if (expectedError.Equals("*"))
            {
                expectedErrorQ = null;
            }
            else if (expectedError.StartsWith("Q{"))
            {
                expectedErrorQ = QName.FromEQName(expectedError);
            }
            else
            {
                expectedErrorQ = new QName("err", JNamespaceConstant.ERR, expectedError);
            }
            //noinspection ThrowableResultOfMethodCallIgnored
            bool ok = (expectedError.Equals("*") ||
                       (GetErrorCode() != null &&
                        GetErrorCode().LocalName.Equals(expectedErrorQ.LocalName)) ||
                       (HasReportedError(new QName(expectedError))));

            if (ok)
            {
                wrongError = null;
            }
            else if (expectedErrorQ != null && errorsReported != null && errorsReported.Count != 0)
            {
                JFastStringBuffer fsb = new JFastStringBuffer(100);
                fsb.append("Expected ");
                fsb.append(expectedErrorQ.LocalName);
                fsb.append("; got ");
                foreach (QName e in errorsReported)
                {
                    fsb.append(e.LocalName);
                    fsb.append("|");
                }
                fsb.setLength(fsb.length() - 1);
                wrongError = fsb.ToString();
            }
            return(ok);
        }
示例#2
0
 private bool AssertstringValue(XdmNode assertion, SingleResultDoc result, bool debug)
 {
     if (IsException())
     {
         return(false);
     }
     else
     {
         string resultstring;
         string assertionstring = assertion.StringValue;
         if (result.value is XdmItem)
         {
             resultstring = ((XdmItem)result.value).Simplify.ToString();
         }
         else
         {
             bool first = true;
             net.sf.saxon.tree.util.FastStringBuffer fsb = new net.sf.saxon.tree.util.FastStringBuffer(256);
             foreach (XdmItem item in result.value)
             {
                 if (first)
                 {
                     first = false;
                 }
                 else
                 {
                     fsb.append(' ');
                 }
                 fsb.append(item.Simplify.ToString());
             }
             resultstring = fsb.ToString();
         }
         string normalizeAtt = assertion.GetAttributeValue(new QName("normalize-space"));
         if (normalizeAtt != null && (normalizeAtt.Trim().Equals("true") || normalizeAtt.Trim().Equals("1")))
         {
             assertionstring = JWhitespace.collapseWhitespace(assertionstring).ToString();
             resultstring    = JWhitespace.collapseWhitespace(resultstring).ToString();
         }
         if (resultstring.Equals(assertionstring))
         {
             return(true);
         }
         else
         {
             if (debug)
             {
                 if (resultstring.Length != assertionstring.Length)
                 {
                     driver.println("Result length " + resultstring.Length + "; expected length " + assertionstring.Length);
                 }
                 int len = Math.Min(resultstring.Length, assertionstring.Length);
                 for (int i = 0; i < len; i++)
                 {
                     if (resultstring[i] != assertionstring[i])
                     {
                         driver.println("Results differ at index " + i +
                                        "(\"" + resultstring.Substring(i, (i + 10 > len ? len : i + 10)) + "\") vs (\"" +
                                        assertionstring.Substring(i, (i + 10 > len ? len : i + 10)) + "\")");
                         break;
                     }
                 }
             }
             return(false);
         }
     }
 }
示例#3
0
        private bool TestAssertion2(XdmNode assertion, SingleResultDoc result, XPathCompiler assertXpc, XPathCompiler catalogXpc, bool debug)
        {
            string tag = assertion.NodeName.LocalName;

            if (tag.Equals("assert-eq"))
            {
                return(assertEq(assertion, result, assertXpc));
            }
            else if (tag.Equals("assert-deep-eq"))
            {
                return(assertDeepEq(assertion, result, assertXpc));
            }
            else if (tag.Equals("assert-permutation"))
            {
                return(assertPermutation(assertion, result, assertXpc));
            }
            else if (tag.Equals("assert-xml"))
            {
                return(assertXml(assertion, result, assertXpc, catalogXpc, debug));
            }
            else if (tag.Equals("serialization-matches"))
            {
                return(AssertSerializationMatches(assertion, result, catalogXpc));
            }
            else if (tag.Equals("assert-serialization-error"))
            {
                return(AssertSerializationError(assertion, result, assertXpc));
            }
            else if (tag.Equals("assert-empty"))
            {
                return(assertEmpty(result.value));
            }
            else if (tag.Equals("assert-count"))
            {
                return(assertCount(assertion, result));
            }
            else if (tag.Equals("assert"))
            {
                return(AssertXPath(assertion, result, assertXpc, debug));
            }
            else if (tag.Equals("assert-string-value"))
            {
                return(AssertstringValue(assertion, result, debug));
            }
            else if (tag.Equals("assert-serialization"))
            {
                return(AssertSerialization(assertion, result, catalogXpc, debug));
            }
            else if (tag.Equals("assert-type"))
            {
                return(AssertType(assertion, result, assertXpc));
            }
            else if (tag.Equals("assert-true"))
            {
                return(AssertTrue(result));
            }
            else if (tag.Equals("assert-false"))
            {
                return(AssertFalse(result));
            }
            else if (tag.Equals("assert-warning"))
            {
                return(AssertWarning());
            }
            else if (tag.Equals("assert-message"))
            {
                XdmNode subAssertion = (XdmNode)catalogXpc.EvaluateSingle("*", assertion);
                foreach (XdmNode message in xslMessages)
                {
                    if (TestAssertion2(subAssertion, new SingleResultDoc(message, ""), assertXpc, catalogXpc, debug))
                    {
                        return(true);
                    }
                }
                return(false);
            }
            else if (tag.Equals("assert-result-document"))
            {
                XdmNode        subAssertion = (XdmNode)catalogXpc.EvaluateSingle("*", assertion);
                XmlUrlResolver res          = new XmlUrlResolver();
                Uri            uri          = new Uri(driver.getResultsDir() + "/results/output.xml");
                uri = res.ResolveUri(uri, assertion.GetAttributeValue(new QName("uri")));
                SingleResultDoc doc = GetSecondaryResult(uri);
                if (doc == null)
                {
                    System.Console.WriteLine("**** No output document found for " + uri);
                    return(false);
                }
                bool ok = TestAssertion2(subAssertion, doc, assertXpc, catalogXpc, debug);
                if (!ok)
                {
                    System.Console.WriteLine("**** Assertion failed for result-document " + uri);
                }
                return(ok);
            }
            else if (tag.Equals("error"))
            {
                bool b = false;
                try {
                    b = IsException() && compareExpectedError(assertion);
                } catch (Exception) {
                    if (GetException() is StaticError)
                    {
                        string expectedError = assertion.GetAttributeValue(new QName("code"));
                        QName  expectedErrorQ;
                        if (expectedError.Equals("*"))
                        {
                            expectedErrorQ = null;
                        }
                        else if (expectedError.StartsWith("Q{"))
                        {
                            expectedErrorQ = QName.FromEQName(expectedError);
                        }
                        else
                        {
                            expectedErrorQ = new QName("err", JNamespaceConstant.ERR, expectedError);
                        }

                        JFastStringBuffer fsb = new JFastStringBuffer(100);
                        fsb.append("Expected ");
                        fsb.append(expectedErrorQ.LocalName);
                        fsb.append("; got ");
                        fsb.append("err:XXX");
                        fsb.setLength(fsb.length() - 1);
                        wrongError = fsb.ToString();
                        return(true);
                    }
                    if (GetException() is DynamicError)
                    {
                        string expectedError = assertion.GetAttributeValue(new QName("code"));
                        QName  expectedErrorQ;
                        if (expectedError.Equals("*"))
                        {
                            expectedErrorQ = null;
                        }
                        else if (expectedError.StartsWith("Q{"))
                        {
                            expectedErrorQ = QName.FromEQName(expectedError);
                        }
                        else
                        {
                            expectedErrorQ = new QName("err", JNamespaceConstant.ERR, expectedError);
                        }

                        JFastStringBuffer fsb = new JFastStringBuffer(100);
                        fsb.append("Expected ");
                        fsb.append(expectedErrorQ.LocalName);
                        fsb.append("; got ");
                        fsb.append("err:XXX");
                        fsb.setLength(fsb.length() - 1);
                        wrongError = fsb.ToString();
                        return(true);
                    }
                }
                return(b);
            }
            else if (tag.Equals("all-of"))
            {
                foreach (XdmItem child in catalogXpc.Evaluate("*", assertion))
                {
                    if (!TestAssertion((XdmNode)child, result, assertXpc, catalogXpc, debug))
                    {
                        return(false);
                    }
                }
                return(true);
            }
            else if (tag.Equals("any-of"))
            {
                bool partialSuccess = false;
                foreach (XdmItem child in catalogXpc.Evaluate("*", assertion))
                {
                    if (TestAssertion((XdmNode)child, result, assertXpc, catalogXpc, debug))
                    {
                        if (wrongError != null)
                        {
                            partialSuccess = true;
                            continue;
                        }
                        return(true);
                    }
                }
                return(partialSuccess);
            }
            else if (tag.Equals("not"))
            {
                XdmNode subAssertion = (XdmNode)catalogXpc.EvaluateSingle("*", assertion);
                return(!TestAssertion(subAssertion, result, assertXpc, catalogXpc, debug));
            }
            throw new Exception("Unknown assertion element " + tag);
        }