Last active
October 23, 2020 19:39
-
-
Save dizzzz/48d545c5660f2c2220a19c9b154fe5f9 to your computer and use it in GitHub Desktop.
A script to generate function-signature-tests for xquery functions in eXist-db
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
xquery version "3.1"; | |
module namespace xqfunctions="http://exist-db.org/xquery/test/xqfunctions"; | |
import module namespace inspect="http://exist-db.org/xquery/inspection" at "java:org.exist.xquery.functions.inspect.InspectionModule"; | |
declare namespace test="http://exist-db.org/xquery/xqsuite"; | |
declare function xqfunctions:cardinality($cardinality as xs:string) as xs:string { | |
switch ($cardinality) | |
case "exactly one" return ("") | |
case "zero or more" return ("*") | |
case "one or more" return ("+") | |
case "empty" return ("empty-sequence()") | |
case "zero or one" return ("?") | |
default return ("oops") | |
}; | |
declare function xqfunctions:describe($element as element() ) as xs:string { | |
data($element/@type) || xqfunctions:cardinality(data($element/@cardinality)) | |
}; | |
declare function xqfunctions:inspect($function as function(*)) as xs:string* { | |
let $function := inspect:inspect-function($function) | |
let $args := $function//argument | |
return (data($function/@name) || "#" || count($args) , for $arg in $args return xqfunctions:describe($arg), xqfunctions:describe($function/returns)) | |
}; | |
(: ------------------------- :) | |
(: Test for "fn:node-name#0" :) | |
declare %test:assertEquals( "node-name#0" ,"xs:QName?") | |
function xqfunctions:fn_node-name_0() | |
{ | |
xqfunctions:inspect(fn:node-name#0) | |
}; | |
(: Test for "fn:node-name#1" :) | |
declare %test:assertEquals( "node-name#1", "node()?" ,"xs:QName?") | |
function xqfunctions:fn_node-name_1() | |
{ | |
xqfunctions:inspect(fn:node-name#1) | |
}; | |
(: Test for "fn:nilled#0" :) | |
declare %test:assertEquals( "nilled#0" ,"xs:boolean?") | |
function xqfunctions:fn_nilled_0() | |
{ | |
xqfunctions:inspect(fn:nilled#0) | |
}; | |
(: Test for "fn:nilled#1" :) | |
declare %test:assertEquals( "nilled#1", "node()?" ,"xs:boolean?") | |
function xqfunctions:fn_nilled_1() | |
{ | |
xqfunctions:inspect(fn:nilled#1) | |
}; | |
(: Test for "fn:string#0" :) | |
declare %test:assertEquals( "string#0" ,"xs:string") | |
function xqfunctions:fn_string_0() | |
{ | |
xqfunctions:inspect(fn:string#0) | |
}; | |
(: Test for "fn:string#1" :) | |
declare %test:assertEquals( "string#1", "item()?" ,"xs:string") | |
function xqfunctions:fn_string_1() | |
{ | |
xqfunctions:inspect(fn:string#1) | |
}; | |
(: Test for "fn:data#0" :) | |
declare %test:assertEquals( "data#0" ,"xs:anyAtomicType*") | |
function xqfunctions:fn_data_0() | |
{ | |
xqfunctions:inspect(fn:data#0) | |
}; | |
(: Test for "fn:data#1" :) | |
declare %test:assertEquals( "data#1", "item()*" ,"xs:anyAtomicType*") | |
function xqfunctions:fn_data_1() | |
{ | |
xqfunctions:inspect(fn:data#1) | |
}; | |
(: Test for "fn:base-uri#0" :) | |
declare %test:assertEquals( "base-uri#0" ,"xs:anyURI?") | |
function xqfunctions:fn_base-uri_0() | |
{ | |
xqfunctions:inspect(fn:base-uri#0) | |
}; | |
(: Test for "fn:base-uri#1" :) | |
declare %test:assertEquals( "base-uri#1", "node()?" ,"xs:anyURI?") | |
function xqfunctions:fn_base-uri_1() | |
{ | |
xqfunctions:inspect(fn:base-uri#1) | |
}; | |
(: Test for "fn:document-uri#0" :) | |
declare %test:assertEquals( "document-uri#0" ,"xs:anyURI?") | |
function xqfunctions:fn_document-uri_0() | |
{ | |
xqfunctions:inspect(fn:document-uri#0) | |
}; | |
(: Test for "fn:document-uri#1" :) | |
declare %test:assertEquals( "document-uri#1", "node()?" ,"xs:anyURI?") | |
function xqfunctions:fn_document-uri_1() | |
{ | |
xqfunctions:inspect(fn:document-uri#1) | |
}; | |
(: Test for "fn:error#0" :) | |
declare %test:assertEquals( "error#0" ,"none") | |
function xqfunctions:fn_error_0() | |
{ | |
xqfunctions:inspect(fn:error#0) | |
}; | |
(: Test for "fn:error#1" :) | |
declare %test:assertEquals( "error#1", "xs:QName?" ,"none") | |
function xqfunctions:fn_error_1() | |
{ | |
xqfunctions:inspect(fn:error#1) | |
}; | |
(: Test for "fn:error#2" :) | |
declare %test:assertEquals( "error#2", "xs:QName?" , "xs:string" ,"none") | |
function xqfunctions:fn_error_2() | |
{ | |
xqfunctions:inspect(fn:error#2) | |
}; | |
(: Test for "fn:error#3" :) | |
declare %test:assertEquals( "error#3", "xs:QName?" , "xs:string" , "item()*" ,"none") | |
function xqfunctions:fn_error_3() | |
{ | |
xqfunctions:inspect(fn:error#3) | |
}; | |
(: Test for "fn:trace#1" :) | |
declare %test:assertEquals( "trace#1", "item()*" ,"item()*") | |
function xqfunctions:fn_trace_1() | |
{ | |
xqfunctions:inspect(fn:trace#1) | |
}; | |
(: Test for "fn:trace#2" :) | |
declare %test:assertEquals( "trace#2", "item()*" , "xs:string" ,"item()*") | |
function xqfunctions:fn_trace_2() | |
{ | |
xqfunctions:inspect(fn:trace#2) | |
}; | |
(: Test for "fn:abs#1" :) | |
declare %test:assertEquals( "abs#1", "xs:numeric?" ,"xs:numeric?") | |
function xqfunctions:fn_abs_1() | |
{ | |
xqfunctions:inspect(fn:abs#1) | |
}; | |
(: Test for "fn:ceiling#1" :) | |
declare %test:assertEquals( "ceiling#1", "xs:numeric?" ,"xs:numeric?") | |
function xqfunctions:fn_ceiling_1() | |
{ | |
xqfunctions:inspect(fn:ceiling#1) | |
}; | |
(: Test for "fn:floor#1" :) | |
declare %test:assertEquals( "floor#1", "xs:numeric?" ,"xs:numeric?") | |
function xqfunctions:fn_floor_1() | |
{ | |
xqfunctions:inspect(fn:floor#1) | |
}; | |
(: Test for "fn:round#1" :) | |
declare %test:assertEquals( "round#1", "xs:numeric?" ,"xs:numeric?") | |
function xqfunctions:fn_round_1() | |
{ | |
xqfunctions:inspect(fn:round#1) | |
}; | |
(: Test for "fn:round#2" :) | |
declare %test:assertEquals( "round#2", "xs:numeric?" , "xs:integer" ,"xs:numeric?") | |
function xqfunctions:fn_round_2() | |
{ | |
xqfunctions:inspect(fn:round#2) | |
}; | |
(: Test for "fn:round-half-to-even#1" :) | |
declare %test:assertEquals( "round-half-to-even#1", "xs:numeric?" ,"xs:numeric?") | |
function xqfunctions:fn_round-half-to-even_1() | |
{ | |
xqfunctions:inspect(fn:round-half-to-even#1) | |
}; | |
(: Test for "fn:round-half-to-even#2" :) | |
declare %test:assertEquals( "round-half-to-even#2", "xs:numeric?" , "xs:integer" ,"xs:numeric?") | |
function xqfunctions:fn_round-half-to-even_2() | |
{ | |
xqfunctions:inspect(fn:round-half-to-even#2) | |
}; | |
(: Test for "fn:format-integer#2" :) | |
declare %test:assertEquals( "format-integer#2", "xs:integer?" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_format-integer_2() | |
{ | |
xqfunctions:inspect(fn:format-integer#2) | |
}; | |
(: Test for "fn:format-integer#3" :) | |
declare %test:assertEquals( "format-integer#3", "xs:integer?" , "xs:string" , "xs:string?" ,"xs:string") | |
function xqfunctions:fn_format-integer_3() | |
{ | |
xqfunctions:inspect(fn:format-integer#3) | |
}; | |
(: Test for "fn:format-number#2" :) | |
declare %test:assertEquals( "format-number#2", "xs:numeric?" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_format-number_2() | |
{ | |
xqfunctions:inspect(fn:format-number#2) | |
}; | |
(: Test for "fn:format-number#3" :) | |
declare %test:assertEquals( "format-number#3", "xs:numeric?" , "xs:string" , "xs:string?" ,"xs:string") | |
function xqfunctions:fn_format-number_3() | |
{ | |
xqfunctions:inspect(fn:format-number#3) | |
}; | |
(: Test for "math:pi#0" :) | |
declare %test:assertEquals( "pi#0" ,"xs:double") | |
function xqfunctions:math_pi_0() | |
{ | |
xqfunctions:inspect(math:pi#0) | |
}; | |
(: Test for "math:exp#1" :) | |
declare %test:assertEquals( "exp#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_exp_1() | |
{ | |
xqfunctions:inspect(math:exp#1) | |
}; | |
(: Test for "math:exp10#1" :) | |
declare %test:assertEquals( "exp10#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_exp10_1() | |
{ | |
xqfunctions:inspect(math:exp10#1) | |
}; | |
(: Test for "math:log#1" :) | |
declare %test:assertEquals( "log#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_log_1() | |
{ | |
xqfunctions:inspect(math:log#1) | |
}; | |
(: Test for "math:log10#1" :) | |
declare %test:assertEquals( "log10#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_log10_1() | |
{ | |
xqfunctions:inspect(math:log10#1) | |
}; | |
(: Test for "math:sqrt#1" :) | |
declare %test:assertEquals( "sqrt#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_sqrt_1() | |
{ | |
xqfunctions:inspect(math:sqrt#1) | |
}; | |
(: Test for "math:pow#2" :) | |
declare %test:assertEquals( "pow#2", "xs:double?" , "xs:numeric" ,"xs:double?") | |
function xqfunctions:math_pow_2() | |
{ | |
xqfunctions:inspect(math:pow#2) | |
}; | |
(: Test for "math:sin#1" :) | |
declare %test:assertEquals( "sin#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_sin_1() | |
{ | |
xqfunctions:inspect(math:sin#1) | |
}; | |
(: Test for "math:cos#1" :) | |
declare %test:assertEquals( "cos#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_cos_1() | |
{ | |
xqfunctions:inspect(math:cos#1) | |
}; | |
(: Test for "math:tan#1" :) | |
declare %test:assertEquals( "tan#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_tan_1() | |
{ | |
xqfunctions:inspect(math:tan#1) | |
}; | |
(: Test for "math:asin#1" :) | |
declare %test:assertEquals( "asin#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_asin_1() | |
{ | |
xqfunctions:inspect(math:asin#1) | |
}; | |
(: Test for "math:acos#1" :) | |
declare %test:assertEquals( "acos#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_acos_1() | |
{ | |
xqfunctions:inspect(math:acos#1) | |
}; | |
(: Test for "math:atan#1" :) | |
declare %test:assertEquals( "atan#1", "xs:double?" ,"xs:double?") | |
function xqfunctions:math_atan_1() | |
{ | |
xqfunctions:inspect(math:atan#1) | |
}; | |
(: Test for "math:atan2#2" :) | |
declare %test:assertEquals( "atan2#2", "xs:double" , "xs:double" ,"xs:double") | |
function xqfunctions:math_atan2_2() | |
{ | |
xqfunctions:inspect(math:atan2#2) | |
}; | |
(: Test for "fn:codepoints-to-string#1" :) | |
declare %test:assertEquals( "codepoints-to-string#1", "xs:integer*" ,"xs:string") | |
function xqfunctions:fn_codepoints-to-string_1() | |
{ | |
xqfunctions:inspect(fn:codepoints-to-string#1) | |
}; | |
(: Test for "fn:string-to-codepoints#1" :) | |
declare %test:assertEquals( "string-to-codepoints#1", "xs:string?" ,"xs:integer*") | |
function xqfunctions:fn_string-to-codepoints_1() | |
{ | |
xqfunctions:inspect(fn:string-to-codepoints#1) | |
}; | |
(: Test for "fn:compare#2" :) | |
declare %test:assertEquals( "compare#2", "xs:string?" , "xs:string?" ,"xs:integer?") | |
function xqfunctions:fn_compare_2() | |
{ | |
xqfunctions:inspect(fn:compare#2) | |
}; | |
(: Test for "fn:compare#3" :) | |
declare %test:assertEquals( "compare#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:integer?") | |
function xqfunctions:fn_compare_3() | |
{ | |
xqfunctions:inspect(fn:compare#3) | |
}; | |
(: Test for "fn:codepoint-equal#2" :) | |
declare %test:assertEquals( "codepoint-equal#2", "xs:string?" , "xs:string?" ,"xs:boolean?") | |
function xqfunctions:fn_codepoint-equal_2() | |
{ | |
xqfunctions:inspect(fn:codepoint-equal#2) | |
}; | |
(: Test for "fn:concat#3" :) | |
declare %test:assertEquals( "concat#3", "xs:anyAtomicType?" , "xs:anyAtomicType?" , "xs:anyAtomicType?" ,"xs:string") | |
function xqfunctions:fn_concat_3() | |
{ | |
xqfunctions:inspect(fn:concat#3) | |
}; | |
(: Test for "fn:string-join#1" :) | |
declare %test:assertEquals( "string-join#1", "xs:anyAtomicType*" ,"xs:string") | |
function xqfunctions:fn_string-join_1() | |
{ | |
xqfunctions:inspect(fn:string-join#1) | |
}; | |
(: Test for "fn:string-join#2" :) | |
declare %test:assertEquals( "string-join#2", "xs:anyAtomicType*" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_string-join_2() | |
{ | |
xqfunctions:inspect(fn:string-join#2) | |
}; | |
(: Test for "fn:substring#2" :) | |
declare %test:assertEquals( "substring#2", "xs:string?" , "xs:double" ,"xs:string") | |
function xqfunctions:fn_substring_2() | |
{ | |
xqfunctions:inspect(fn:substring#2) | |
}; | |
(: Test for "fn:substring#3" :) | |
declare %test:assertEquals( "substring#3", "xs:string?" , "xs:double" , "xs:double" ,"xs:string") | |
function xqfunctions:fn_substring_3() | |
{ | |
xqfunctions:inspect(fn:substring#3) | |
}; | |
(: Test for "fn:string-length#0" :) | |
declare %test:assertEquals( "string-length#0" ,"xs:integer") | |
function xqfunctions:fn_string-length_0() | |
{ | |
xqfunctions:inspect(fn:string-length#0) | |
}; | |
(: Test for "fn:string-length#1" :) | |
declare %test:assertEquals( "string-length#1", "xs:string?" ,"xs:integer") | |
function xqfunctions:fn_string-length_1() | |
{ | |
xqfunctions:inspect(fn:string-length#1) | |
}; | |
(: Test for "fn:normalize-space#0" :) | |
declare %test:assertEquals( "normalize-space#0" ,"xs:string") | |
function xqfunctions:fn_normalize-space_0() | |
{ | |
xqfunctions:inspect(fn:normalize-space#0) | |
}; | |
(: Test for "fn:normalize-space#1" :) | |
declare %test:assertEquals( "normalize-space#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_normalize-space_1() | |
{ | |
xqfunctions:inspect(fn:normalize-space#1) | |
}; | |
(: Test for "fn:normalize-unicode#1" :) | |
declare %test:assertEquals( "normalize-unicode#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_normalize-unicode_1() | |
{ | |
xqfunctions:inspect(fn:normalize-unicode#1) | |
}; | |
(: Test for "fn:normalize-unicode#2" :) | |
declare %test:assertEquals( "normalize-unicode#2", "xs:string?" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_normalize-unicode_2() | |
{ | |
xqfunctions:inspect(fn:normalize-unicode#2) | |
}; | |
(: Test for "fn:upper-case#1" :) | |
declare %test:assertEquals( "upper-case#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_upper-case_1() | |
{ | |
xqfunctions:inspect(fn:upper-case#1) | |
}; | |
(: Test for "fn:lower-case#1" :) | |
declare %test:assertEquals( "lower-case#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_lower-case_1() | |
{ | |
xqfunctions:inspect(fn:lower-case#1) | |
}; | |
(: Test for "fn:translate#3" :) | |
declare %test:assertEquals( "translate#3", "xs:string?" , "xs:string" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_translate_3() | |
{ | |
xqfunctions:inspect(fn:translate#3) | |
}; | |
(: Test for "fn:encode-for-uri#1" :) | |
declare %test:assertEquals( "encode-for-uri#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_encode-for-uri_1() | |
{ | |
xqfunctions:inspect(fn:encode-for-uri#1) | |
}; | |
(: Test for "fn:iri-to-uri#1" :) | |
declare %test:assertEquals( "iri-to-uri#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_iri-to-uri_1() | |
{ | |
xqfunctions:inspect(fn:iri-to-uri#1) | |
}; | |
(: Test for "fn:escape-html-uri#1" :) | |
declare %test:assertEquals( "escape-html-uri#1", "xs:string?" ,"xs:string") | |
function xqfunctions:fn_escape-html-uri_1() | |
{ | |
xqfunctions:inspect(fn:escape-html-uri#1) | |
}; | |
(: Test for "fn:contains#2" :) | |
declare %test:assertEquals( "contains#2", "xs:string?" , "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_contains_2() | |
{ | |
xqfunctions:inspect(fn:contains#2) | |
}; | |
(: Test for "fn:contains#3" :) | |
declare %test:assertEquals( "contains#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_contains_3() | |
{ | |
xqfunctions:inspect(fn:contains#3) | |
}; | |
(: Test for "fn:starts-with#2" :) | |
declare %test:assertEquals( "starts-with#2", "xs:string?" , "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_starts-with_2() | |
{ | |
xqfunctions:inspect(fn:starts-with#2) | |
}; | |
(: Test for "fn:starts-with#3" :) | |
declare %test:assertEquals( "starts-with#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_starts-with_3() | |
{ | |
xqfunctions:inspect(fn:starts-with#3) | |
}; | |
(: Test for "fn:ends-with#2" :) | |
declare %test:assertEquals( "ends-with#2", "xs:string?" , "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_ends-with_2() | |
{ | |
xqfunctions:inspect(fn:ends-with#2) | |
}; | |
(: Test for "fn:ends-with#3" :) | |
declare %test:assertEquals( "ends-with#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_ends-with_3() | |
{ | |
xqfunctions:inspect(fn:ends-with#3) | |
}; | |
(: Test for "fn:substring-before#2" :) | |
declare %test:assertEquals( "substring-before#2", "xs:string?" , "xs:string?" ,"xs:string") | |
function xqfunctions:fn_substring-before_2() | |
{ | |
xqfunctions:inspect(fn:substring-before#2) | |
}; | |
(: Test for "fn:substring-before#3" :) | |
declare %test:assertEquals( "substring-before#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_substring-before_3() | |
{ | |
xqfunctions:inspect(fn:substring-before#3) | |
}; | |
(: Test for "fn:substring-after#2" :) | |
declare %test:assertEquals( "substring-after#2", "xs:string?" , "xs:string?" ,"xs:string") | |
function xqfunctions:fn_substring-after_2() | |
{ | |
xqfunctions:inspect(fn:substring-after#2) | |
}; | |
(: Test for "fn:substring-after#3" :) | |
declare %test:assertEquals( "substring-after#3", "xs:string?" , "xs:string?" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_substring-after_3() | |
{ | |
xqfunctions:inspect(fn:substring-after#3) | |
}; | |
(: Test for "fn:matches#2" :) | |
declare %test:assertEquals( "matches#2", "xs:string?" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_matches_2() | |
{ | |
xqfunctions:inspect(fn:matches#2) | |
}; | |
(: Test for "fn:matches#3" :) | |
declare %test:assertEquals( "matches#3", "xs:string?" , "xs:string" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_matches_3() | |
{ | |
xqfunctions:inspect(fn:matches#3) | |
}; | |
(: Test for "fn:replace#3" :) | |
declare %test:assertEquals( "replace#3", "xs:string?" , "xs:string" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_replace_3() | |
{ | |
xqfunctions:inspect(fn:replace#3) | |
}; | |
(: Test for "fn:replace#4" :) | |
declare %test:assertEquals( "replace#4", "xs:string?" , "xs:string" , "xs:string" , "xs:string" ,"xs:string") | |
function xqfunctions:fn_replace_4() | |
{ | |
xqfunctions:inspect(fn:replace#4) | |
}; | |
(: Test for "fn:tokenize#1" :) | |
declare %test:assertEquals( "tokenize#1", "xs:string?" ,"xs:string*") | |
function xqfunctions:fn_tokenize_1() | |
{ | |
xqfunctions:inspect(fn:tokenize#1) | |
}; | |
(: Test for "fn:tokenize#2" :) | |
declare %test:assertEquals( "tokenize#2", "xs:string?" , "xs:string" ,"xs:string*") | |
function xqfunctions:fn_tokenize_2() | |
{ | |
xqfunctions:inspect(fn:tokenize#2) | |
}; | |
(: Test for "fn:tokenize#3" :) | |
declare %test:assertEquals( "tokenize#3", "xs:string?" , "xs:string" , "xs:string" ,"xs:string*") | |
function xqfunctions:fn_tokenize_3() | |
{ | |
xqfunctions:inspect(fn:tokenize#3) | |
}; | |
(: Test for "fn:analyze-string#2" :) | |
declare %test:assertEquals( "analyze-string#2", "xs:string?" , "xs:string" ,"element(fn:analyze-string-result)") | |
function xqfunctions:fn_analyze-string_2() | |
{ | |
xqfunctions:inspect(fn:analyze-string#2) | |
}; | |
(: Test for "fn:analyze-string#3" :) | |
declare %test:assertEquals( "analyze-string#3", "xs:string?" , "xs:string" , "xs:string" ,"element(fn:analyze-string-result)") | |
function xqfunctions:fn_analyze-string_3() | |
{ | |
xqfunctions:inspect(fn:analyze-string#3) | |
}; | |
(: Test for "fn:contains-token#2" :) | |
declare %test:assertEquals( "contains-token#2", "xs:string*" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_contains-token_2() | |
{ | |
xqfunctions:inspect(fn:contains-token#2) | |
}; | |
(: Test for "fn:contains-token#3" :) | |
declare %test:assertEquals( "contains-token#3", "xs:string*" , "xs:string" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_contains-token_3() | |
{ | |
xqfunctions:inspect(fn:contains-token#3) | |
}; | |
(: Test for "fn:resolve-uri#1" :) | |
declare %test:assertEquals( "resolve-uri#1", "xs:string?" ,"xs:anyURI?") | |
function xqfunctions:fn_resolve-uri_1() | |
{ | |
xqfunctions:inspect(fn:resolve-uri#1) | |
}; | |
(: Test for "fn:resolve-uri#2" :) | |
declare %test:assertEquals( "resolve-uri#2", "xs:string?" , "xs:string" ,"xs:anyURI?") | |
function xqfunctions:fn_resolve-uri_2() | |
{ | |
xqfunctions:inspect(fn:resolve-uri#2) | |
}; | |
(: Test for "fn:true#0" :) | |
declare %test:assertEquals( "true#0" ,"xs:boolean") | |
function xqfunctions:fn_true_0() | |
{ | |
xqfunctions:inspect(fn:true#0) | |
}; | |
(: Test for "fn:false#0" :) | |
declare %test:assertEquals( "false#0" ,"xs:boolean") | |
function xqfunctions:fn_false_0() | |
{ | |
xqfunctions:inspect(fn:false#0) | |
}; | |
(: Test for "fn:boolean#1" :) | |
declare %test:assertEquals( "boolean#1", "item()*" ,"xs:boolean") | |
function xqfunctions:fn_boolean_1() | |
{ | |
xqfunctions:inspect(fn:boolean#1) | |
}; | |
(: Test for "fn:not#1" :) | |
declare %test:assertEquals( "not#1", "item()*" ,"xs:boolean") | |
function xqfunctions:fn_not_1() | |
{ | |
xqfunctions:inspect(fn:not#1) | |
}; | |
(: Test for "fn:years-from-duration#1" :) | |
declare %test:assertEquals( "years-from-duration#1", "xs:duration?" ,"xs:integer?") | |
function xqfunctions:fn_years-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:years-from-duration#1) | |
}; | |
(: Test for "fn:months-from-duration#1" :) | |
declare %test:assertEquals( "months-from-duration#1", "xs:duration?" ,"xs:integer?") | |
function xqfunctions:fn_months-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:months-from-duration#1) | |
}; | |
(: Test for "fn:days-from-duration#1" :) | |
declare %test:assertEquals( "days-from-duration#1", "xs:duration?" ,"xs:integer?") | |
function xqfunctions:fn_days-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:days-from-duration#1) | |
}; | |
(: Test for "fn:hours-from-duration#1" :) | |
declare %test:assertEquals( "hours-from-duration#1", "xs:duration?" ,"xs:integer?") | |
function xqfunctions:fn_hours-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:hours-from-duration#1) | |
}; | |
(: Test for "fn:minutes-from-duration#1" :) | |
declare %test:assertEquals( "minutes-from-duration#1", "xs:duration?" ,"xs:integer?") | |
function xqfunctions:fn_minutes-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:minutes-from-duration#1) | |
}; | |
(: Test for "fn:seconds-from-duration#1" :) | |
declare %test:assertEquals( "seconds-from-duration#1", "xs:duration?" ,"xs:decimal?") | |
function xqfunctions:fn_seconds-from-duration_1() | |
{ | |
xqfunctions:inspect(fn:seconds-from-duration#1) | |
}; | |
(: Test for "fn:dateTime#2" :) | |
declare %test:assertEquals( "dateTime#2", "xs:date?" , "xs:time?" ,"xs:dateTime?") | |
function xqfunctions:fn_dateTime_2() | |
{ | |
xqfunctions:inspect(fn:dateTime#2) | |
}; | |
(: Test for "fn:year-from-dateTime#1" :) | |
declare %test:assertEquals( "year-from-dateTime#1", "xs:dateTime?" ,"xs:integer?") | |
function xqfunctions:fn_year-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:year-from-dateTime#1) | |
}; | |
(: Test for "fn:month-from-dateTime#1" :) | |
declare %test:assertEquals( "month-from-dateTime#1", "xs:dateTime?" ,"xs:integer?") | |
function xqfunctions:fn_month-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:month-from-dateTime#1) | |
}; | |
(: Test for "fn:day-from-dateTime#1" :) | |
declare %test:assertEquals( "day-from-dateTime#1", "xs:dateTime?" ,"xs:integer?") | |
function xqfunctions:fn_day-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:day-from-dateTime#1) | |
}; | |
(: Test for "fn:hours-from-dateTime#1" :) | |
declare %test:assertEquals( "hours-from-dateTime#1", "xs:dateTime?" ,"xs:integer?") | |
function xqfunctions:fn_hours-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:hours-from-dateTime#1) | |
}; | |
(: Test for "fn:minutes-from-dateTime#1" :) | |
declare %test:assertEquals( "minutes-from-dateTime#1", "xs:dateTime?" ,"xs:integer?") | |
function xqfunctions:fn_minutes-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:minutes-from-dateTime#1) | |
}; | |
(: Test for "fn:seconds-from-dateTime#1" :) | |
declare %test:assertEquals( "seconds-from-dateTime#1", "xs:dateTime?" ,"xs:decimal?") | |
function xqfunctions:fn_seconds-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:seconds-from-dateTime#1) | |
}; | |
(: Test for "fn:timezone-from-dateTime#1" :) | |
declare %test:assertEquals( "timezone-from-dateTime#1", "xs:dateTime?" ,"xs:dayTimeDuration?") | |
function xqfunctions:fn_timezone-from-dateTime_1() | |
{ | |
xqfunctions:inspect(fn:timezone-from-dateTime#1) | |
}; | |
(: Test for "fn:year-from-date#1" :) | |
declare %test:assertEquals( "year-from-date#1", "xs:date?" ,"xs:integer?") | |
function xqfunctions:fn_year-from-date_1() | |
{ | |
xqfunctions:inspect(fn:year-from-date#1) | |
}; | |
(: Test for "fn:month-from-date#1" :) | |
declare %test:assertEquals( "month-from-date#1", "xs:date?" ,"xs:integer?") | |
function xqfunctions:fn_month-from-date_1() | |
{ | |
xqfunctions:inspect(fn:month-from-date#1) | |
}; | |
(: Test for "fn:day-from-date#1" :) | |
declare %test:assertEquals( "day-from-date#1", "xs:date?" ,"xs:integer?") | |
function xqfunctions:fn_day-from-date_1() | |
{ | |
xqfunctions:inspect(fn:day-from-date#1) | |
}; | |
(: Test for "fn:timezone-from-date#1" :) | |
declare %test:assertEquals( "timezone-from-date#1", "xs:date?" ,"xs:dayTimeDuration?") | |
function xqfunctions:fn_timezone-from-date_1() | |
{ | |
xqfunctions:inspect(fn:timezone-from-date#1) | |
}; | |
(: Test for "fn:hours-from-time#1" :) | |
declare %test:assertEquals( "hours-from-time#1", "xs:time?" ,"xs:integer?") | |
function xqfunctions:fn_hours-from-time_1() | |
{ | |
xqfunctions:inspect(fn:hours-from-time#1) | |
}; | |
(: Test for "fn:minutes-from-time#1" :) | |
declare %test:assertEquals( "minutes-from-time#1", "xs:time?" ,"xs:integer?") | |
function xqfunctions:fn_minutes-from-time_1() | |
{ | |
xqfunctions:inspect(fn:minutes-from-time#1) | |
}; | |
(: Test for "fn:seconds-from-time#1" :) | |
declare %test:assertEquals( "seconds-from-time#1", "xs:time?" ,"xs:decimal?") | |
function xqfunctions:fn_seconds-from-time_1() | |
{ | |
xqfunctions:inspect(fn:seconds-from-time#1) | |
}; | |
(: Test for "fn:timezone-from-time#1" :) | |
declare %test:assertEquals( "timezone-from-time#1", "xs:time?" ,"xs:dayTimeDuration?") | |
function xqfunctions:fn_timezone-from-time_1() | |
{ | |
xqfunctions:inspect(fn:timezone-from-time#1) | |
}; | |
(: Test for "fn:adjust-dateTime-to-timezone#1" :) | |
declare %test:assertEquals( "adjust-dateTime-to-timezone#1", "xs:dateTime?" ,"xs:dateTime?") | |
function xqfunctions:fn_adjust-dateTime-to-timezone_1() | |
{ | |
xqfunctions:inspect(fn:adjust-dateTime-to-timezone#1) | |
}; | |
(: Test for "fn:adjust-dateTime-to-timezone#2" :) | |
declare %test:assertEquals( "adjust-dateTime-to-timezone#2", "xs:dateTime?" , "xs:dayTimeDuration?" ,"xs:dateTime?") | |
function xqfunctions:fn_adjust-dateTime-to-timezone_2() | |
{ | |
xqfunctions:inspect(fn:adjust-dateTime-to-timezone#2) | |
}; | |
(: Test for "fn:adjust-date-to-timezone#1" :) | |
declare %test:assertEquals( "adjust-date-to-timezone#1", "xs:date?" ,"xs:date?") | |
function xqfunctions:fn_adjust-date-to-timezone_1() | |
{ | |
xqfunctions:inspect(fn:adjust-date-to-timezone#1) | |
}; | |
(: Test for "fn:adjust-date-to-timezone#2" :) | |
declare %test:assertEquals( "adjust-date-to-timezone#2", "xs:date?" , "xs:dayTimeDuration?" ,"xs:date?") | |
function xqfunctions:fn_adjust-date-to-timezone_2() | |
{ | |
xqfunctions:inspect(fn:adjust-date-to-timezone#2) | |
}; | |
(: Test for "fn:adjust-time-to-timezone#1" :) | |
declare %test:assertEquals( "adjust-time-to-timezone#1", "xs:time?" ,"xs:time?") | |
function xqfunctions:fn_adjust-time-to-timezone_1() | |
{ | |
xqfunctions:inspect(fn:adjust-time-to-timezone#1) | |
}; | |
(: Test for "fn:adjust-time-to-timezone#2" :) | |
declare %test:assertEquals( "adjust-time-to-timezone#2", "xs:time?" , "xs:dayTimeDuration?" ,"xs:time?") | |
function xqfunctions:fn_adjust-time-to-timezone_2() | |
{ | |
xqfunctions:inspect(fn:adjust-time-to-timezone#2) | |
}; | |
(: Test for "fn:format-dateTime#2" :) | |
declare %test:assertEquals( "format-dateTime#2", "xs:dateTime?" , "xs:string" ,"xs:string?") | |
function xqfunctions:fn_format-dateTime_2() | |
{ | |
xqfunctions:inspect(fn:format-dateTime#2) | |
}; | |
(: Test for "fn:format-dateTime#5" :) | |
declare %test:assertEquals( "format-dateTime#5", "xs:dateTime?" , "xs:string" , "xs:string?" , "xs:string?" , "xs:string?" ,"xs:string?") | |
function xqfunctions:fn_format-dateTime_5() | |
{ | |
xqfunctions:inspect(fn:format-dateTime#5) | |
}; | |
(: Test for "fn:format-date#2" :) | |
declare %test:assertEquals( "format-date#2", "xs:date?" , "xs:string" ,"xs:string?") | |
function xqfunctions:fn_format-date_2() | |
{ | |
xqfunctions:inspect(fn:format-date#2) | |
}; | |
(: Test for "fn:format-date#5" :) | |
declare %test:assertEquals( "format-date#5", "xs:date?" , "xs:string" , "xs:string?" , "xs:string?" , "xs:string?" ,"xs:string?") | |
function xqfunctions:fn_format-date_5() | |
{ | |
xqfunctions:inspect(fn:format-date#5) | |
}; | |
(: Test for "fn:format-time#2" :) | |
declare %test:assertEquals( "format-time#2", "xs:time?" , "xs:string" ,"xs:string?") | |
function xqfunctions:fn_format-time_2() | |
{ | |
xqfunctions:inspect(fn:format-time#2) | |
}; | |
(: Test for "fn:format-time#5" :) | |
declare %test:assertEquals( "format-time#5", "xs:time?" , "xs:string" , "xs:string?" , "xs:string?" , "xs:string?" ,"xs:string?") | |
function xqfunctions:fn_format-time_5() | |
{ | |
xqfunctions:inspect(fn:format-time#5) | |
}; | |
(: Test for "fn:parse-ietf-date#1" :) | |
declare %test:assertEquals( "parse-ietf-date#1", "xs:string?" ,"xs:dateTime?") | |
function xqfunctions:fn_parse-ietf-date_1() | |
{ | |
xqfunctions:inspect(fn:parse-ietf-date#1) | |
}; | |
(: Test for "fn:resolve-QName#2" :) | |
declare %test:assertEquals( "resolve-QName#2", "xs:string?" , "element()" ,"xs:QName?") | |
function xqfunctions:fn_resolve-QName_2() | |
{ | |
xqfunctions:inspect(fn:resolve-QName#2) | |
}; | |
(: Test for "fn:QName#2" :) | |
declare %test:assertEquals( "QName#2", "xs:string?" , "xs:string" ,"xs:QName") | |
function xqfunctions:fn_QName_2() | |
{ | |
xqfunctions:inspect(fn:QName#2) | |
}; | |
(: Test for "fn:prefix-from-QName#1" :) | |
declare %test:assertEquals( "prefix-from-QName#1", "xs:QName?" ,"xs:NCName?") | |
function xqfunctions:fn_prefix-from-QName_1() | |
{ | |
xqfunctions:inspect(fn:prefix-from-QName#1) | |
}; | |
(: Test for "fn:local-name-from-QName#1" :) | |
declare %test:assertEquals( "local-name-from-QName#1", "xs:QName?" ,"xs:NCName?") | |
function xqfunctions:fn_local-name-from-QName_1() | |
{ | |
xqfunctions:inspect(fn:local-name-from-QName#1) | |
}; | |
(: Test for "fn:namespace-uri-from-QName#1" :) | |
declare %test:assertEquals( "namespace-uri-from-QName#1", "xs:QName?" ,"xs:anyURI?") | |
function xqfunctions:fn_namespace-uri-from-QName_1() | |
{ | |
xqfunctions:inspect(fn:namespace-uri-from-QName#1) | |
}; | |
(: Test for "fn:namespace-uri-for-prefix#2" :) | |
declare %test:assertEquals( "namespace-uri-for-prefix#2", "xs:string?" , "element()" ,"xs:anyURI?") | |
function xqfunctions:fn_namespace-uri-for-prefix_2() | |
{ | |
xqfunctions:inspect(fn:namespace-uri-for-prefix#2) | |
}; | |
(: Test for "fn:in-scope-prefixes#1" :) | |
declare %test:assertEquals( "in-scope-prefixes#1", "element()" ,"xs:string*") | |
function xqfunctions:fn_in-scope-prefixes_1() | |
{ | |
xqfunctions:inspect(fn:in-scope-prefixes#1) | |
}; | |
(: Test for "fn:name#0" :) | |
declare %test:assertEquals( "name#0" ,"xs:string") | |
function xqfunctions:fn_name_0() | |
{ | |
xqfunctions:inspect(fn:name#0) | |
}; | |
(: Test for "fn:name#1" :) | |
declare %test:assertEquals( "name#1", "node()?" ,"xs:string") | |
function xqfunctions:fn_name_1() | |
{ | |
xqfunctions:inspect(fn:name#1) | |
}; | |
(: Test for "fn:local-name#0" :) | |
declare %test:assertEquals( "local-name#0" ,"xs:string") | |
function xqfunctions:fn_local-name_0() | |
{ | |
xqfunctions:inspect(fn:local-name#0) | |
}; | |
(: Test for "fn:local-name#1" :) | |
declare %test:assertEquals( "local-name#1", "node()?" ,"xs:string") | |
function xqfunctions:fn_local-name_1() | |
{ | |
xqfunctions:inspect(fn:local-name#1) | |
}; | |
(: Test for "fn:namespace-uri#0" :) | |
declare %test:assertEquals( "namespace-uri#0" ,"xs:anyURI") | |
function xqfunctions:fn_namespace-uri_0() | |
{ | |
xqfunctions:inspect(fn:namespace-uri#0) | |
}; | |
(: Test for "fn:namespace-uri#1" :) | |
declare %test:assertEquals( "namespace-uri#1", "node()?" ,"xs:anyURI") | |
function xqfunctions:fn_namespace-uri_1() | |
{ | |
xqfunctions:inspect(fn:namespace-uri#1) | |
}; | |
(: Test for "fn:number#0" :) | |
declare %test:assertEquals( "number#0" ,"xs:double") | |
function xqfunctions:fn_number_0() | |
{ | |
xqfunctions:inspect(fn:number#0) | |
}; | |
(: Test for "fn:number#1" :) | |
declare %test:assertEquals( "number#1", "xs:anyAtomicType?" ,"xs:double") | |
function xqfunctions:fn_number_1() | |
{ | |
xqfunctions:inspect(fn:number#1) | |
}; | |
(: Test for "fn:lang#1" :) | |
declare %test:assertEquals( "lang#1", "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_lang_1() | |
{ | |
xqfunctions:inspect(fn:lang#1) | |
}; | |
(: Test for "fn:lang#2" :) | |
declare %test:assertEquals( "lang#2", "xs:string?" , "node()" ,"xs:boolean") | |
function xqfunctions:fn_lang_2() | |
{ | |
xqfunctions:inspect(fn:lang#2) | |
}; | |
(: Test for "fn:path#0" :) | |
declare %test:assertEquals( "path#0" ,"xs:string?") | |
function xqfunctions:fn_path_0() | |
{ | |
xqfunctions:inspect(fn:path#0) | |
}; | |
(: Test for "fn:path#1" :) | |
declare %test:assertEquals( "path#1", "node()?" ,"xs:string?") | |
function xqfunctions:fn_path_1() | |
{ | |
xqfunctions:inspect(fn:path#1) | |
}; | |
(: Test for "fn:root#0" :) | |
declare %test:assertEquals( "root#0" ,"node()") | |
function xqfunctions:fn_root_0() | |
{ | |
xqfunctions:inspect(fn:root#0) | |
}; | |
(: Test for "fn:root#1" :) | |
declare %test:assertEquals( "root#1", "node()?" ,"node()?") | |
function xqfunctions:fn_root_1() | |
{ | |
xqfunctions:inspect(fn:root#1) | |
}; | |
(: Test for "fn:has-children#0" :) | |
declare %test:assertEquals( "has-children#0" ,"xs:boolean") | |
function xqfunctions:fn_has-children_0() | |
{ | |
xqfunctions:inspect(fn:has-children#0) | |
}; | |
(: Test for "fn:has-children#1" :) | |
declare %test:assertEquals( "has-children#1", "node()?" ,"xs:boolean") | |
function xqfunctions:fn_has-children_1() | |
{ | |
xqfunctions:inspect(fn:has-children#1) | |
}; | |
(: Test for "fn:innermost#1" :) | |
declare %test:assertEquals( "innermost#1", "node()*" ,"node()*") | |
function xqfunctions:fn_innermost_1() | |
{ | |
xqfunctions:inspect(fn:innermost#1) | |
}; | |
(: Test for "fn:outermost#1" :) | |
declare %test:assertEquals( "outermost#1", "node()*" ,"node()*") | |
function xqfunctions:fn_outermost_1() | |
{ | |
xqfunctions:inspect(fn:outermost#1) | |
}; | |
(: Test for "fn:index-of#2" :) | |
declare %test:assertEquals( "index-of#2", "xs:anyAtomicType*" , "xs:anyAtomicType" ,"xs:integer*") | |
function xqfunctions:fn_index-of_2() | |
{ | |
xqfunctions:inspect(fn:index-of#2) | |
}; | |
(: Test for "fn:index-of#3" :) | |
declare %test:assertEquals( "index-of#3", "xs:anyAtomicType*" , "xs:anyAtomicType" , "xs:string" ,"xs:integer*") | |
function xqfunctions:fn_index-of_3() | |
{ | |
xqfunctions:inspect(fn:index-of#3) | |
}; | |
(: Test for "fn:empty#1" :) | |
declare %test:assertEquals( "empty#1", "item()*" ,"xs:boolean") | |
function xqfunctions:fn_empty_1() | |
{ | |
xqfunctions:inspect(fn:empty#1) | |
}; | |
(: Test for "fn:exists#1" :) | |
declare %test:assertEquals( "exists#1", "item()*" ,"xs:boolean") | |
function xqfunctions:fn_exists_1() | |
{ | |
xqfunctions:inspect(fn:exists#1) | |
}; | |
(: Test for "fn:distinct-values#1" :) | |
declare %test:assertEquals( "distinct-values#1", "xs:anyAtomicType*" ,"xs:anyAtomicType*") | |
function xqfunctions:fn_distinct-values_1() | |
{ | |
xqfunctions:inspect(fn:distinct-values#1) | |
}; | |
(: Test for "fn:distinct-values#2" :) | |
declare %test:assertEquals( "distinct-values#2", "xs:anyAtomicType*" , "xs:string" ,"xs:anyAtomicType*") | |
function xqfunctions:fn_distinct-values_2() | |
{ | |
xqfunctions:inspect(fn:distinct-values#2) | |
}; | |
(: Test for "fn:insert-before#3" :) | |
declare %test:assertEquals( "insert-before#3", "item()*" , "xs:integer" , "item()*" ,"item()*") | |
function xqfunctions:fn_insert-before_3() | |
{ | |
xqfunctions:inspect(fn:insert-before#3) | |
}; | |
(: Test for "fn:remove#2" :) | |
declare %test:assertEquals( "remove#2", "item()*" , "xs:integer" ,"item()*") | |
function xqfunctions:fn_remove_2() | |
{ | |
xqfunctions:inspect(fn:remove#2) | |
}; | |
(: Test for "fn:head#1" :) | |
declare %test:assertEquals( "head#1", "item()*" ,"item()?") | |
function xqfunctions:fn_head_1() | |
{ | |
xqfunctions:inspect(fn:head#1) | |
}; | |
(: Test for "fn:tail#1" :) | |
declare %test:assertEquals( "tail#1", "item()*" ,"item()*") | |
function xqfunctions:fn_tail_1() | |
{ | |
xqfunctions:inspect(fn:tail#1) | |
}; | |
(: Test for "fn:reverse#1" :) | |
declare %test:assertEquals( "reverse#1", "item()*" ,"item()*") | |
function xqfunctions:fn_reverse_1() | |
{ | |
xqfunctions:inspect(fn:reverse#1) | |
}; | |
(: Test for "fn:subsequence#2" :) | |
declare %test:assertEquals( "subsequence#2", "item()*" , "xs:double" ,"item()*") | |
function xqfunctions:fn_subsequence_2() | |
{ | |
xqfunctions:inspect(fn:subsequence#2) | |
}; | |
(: Test for "fn:subsequence#3" :) | |
declare %test:assertEquals( "subsequence#3", "item()*" , "xs:double" , "xs:double" ,"item()*") | |
function xqfunctions:fn_subsequence_3() | |
{ | |
xqfunctions:inspect(fn:subsequence#3) | |
}; | |
(: Test for "fn:unordered#1" :) | |
declare %test:assertEquals( "unordered#1", "item()*" ,"item()*") | |
function xqfunctions:fn_unordered_1() | |
{ | |
xqfunctions:inspect(fn:unordered#1) | |
}; | |
(: Test for "fn:zero-or-one#1" :) | |
declare %test:assertEquals( "zero-or-one#1", "item()*" ,"item()?") | |
function xqfunctions:fn_zero-or-one_1() | |
{ | |
xqfunctions:inspect(fn:zero-or-one#1) | |
}; | |
(: Test for "fn:one-or-more#1" :) | |
declare %test:assertEquals( "one-or-more#1", "item()*" ,"item()+") | |
function xqfunctions:fn_one-or-more_1() | |
{ | |
xqfunctions:inspect(fn:one-or-more#1) | |
}; | |
(: Test for "fn:exactly-one#1" :) | |
declare %test:assertEquals( "exactly-one#1", "item()*" ,"item()") | |
function xqfunctions:fn_exactly-one_1() | |
{ | |
xqfunctions:inspect(fn:exactly-one#1) | |
}; | |
(: Test for "fn:deep-equal#2" :) | |
declare %test:assertEquals( "deep-equal#2", "item()*" , "item()*" ,"xs:boolean") | |
function xqfunctions:fn_deep-equal_2() | |
{ | |
xqfunctions:inspect(fn:deep-equal#2) | |
}; | |
(: Test for "fn:deep-equal#3" :) | |
declare %test:assertEquals( "deep-equal#3", "item()*" , "item()*" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_deep-equal_3() | |
{ | |
xqfunctions:inspect(fn:deep-equal#3) | |
}; | |
(: Test for "fn:count#1" :) | |
declare %test:assertEquals( "count#1", "item()*" ,"xs:integer") | |
function xqfunctions:fn_count_1() | |
{ | |
xqfunctions:inspect(fn:count#1) | |
}; | |
(: Test for "fn:avg#1" :) | |
declare %test:assertEquals( "avg#1", "xs:anyAtomicType*" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_avg_1() | |
{ | |
xqfunctions:inspect(fn:avg#1) | |
}; | |
(: Test for "fn:max#1" :) | |
declare %test:assertEquals( "max#1", "xs:anyAtomicType*" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_max_1() | |
{ | |
xqfunctions:inspect(fn:max#1) | |
}; | |
(: Test for "fn:max#2" :) | |
declare %test:assertEquals( "max#2", "xs:anyAtomicType*" , "xs:string" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_max_2() | |
{ | |
xqfunctions:inspect(fn:max#2) | |
}; | |
(: Test for "fn:min#1" :) | |
declare %test:assertEquals( "min#1", "xs:anyAtomicType*" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_min_1() | |
{ | |
xqfunctions:inspect(fn:min#1) | |
}; | |
(: Test for "fn:min#2" :) | |
declare %test:assertEquals( "min#2", "xs:anyAtomicType*" , "xs:string" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_min_2() | |
{ | |
xqfunctions:inspect(fn:min#2) | |
}; | |
(: Test for "fn:sum#1" :) | |
declare %test:assertEquals( "sum#1", "xs:anyAtomicType*" ,"xs:anyAtomicType") | |
function xqfunctions:fn_sum_1() | |
{ | |
xqfunctions:inspect(fn:sum#1) | |
}; | |
(: Test for "fn:sum#2" :) | |
declare %test:assertEquals( "sum#2", "xs:anyAtomicType*" , "xs:anyAtomicType?" ,"xs:anyAtomicType?") | |
function xqfunctions:fn_sum_2() | |
{ | |
xqfunctions:inspect(fn:sum#2) | |
}; | |
(: Test for "fn:id#1" :) | |
declare %test:assertEquals( "id#1", "xs:string*" ,"element()*") | |
function xqfunctions:fn_id_1() | |
{ | |
xqfunctions:inspect(fn:id#1) | |
}; | |
(: Test for "fn:id#2" :) | |
declare %test:assertEquals( "id#2", "xs:string*" , "node()" ,"element()*") | |
function xqfunctions:fn_id_2() | |
{ | |
xqfunctions:inspect(fn:id#2) | |
}; | |
(: Test for "fn:element-with-id#1" :) | |
declare %test:assertEquals( "element-with-id#1", "xs:string*" ,"element()*") | |
function xqfunctions:fn_element-with-id_1() | |
{ | |
xqfunctions:inspect(fn:element-with-id#1) | |
}; | |
(: Test for "fn:element-with-id#2" :) | |
declare %test:assertEquals( "element-with-id#2", "xs:string*" , "node()" ,"element()*") | |
function xqfunctions:fn_element-with-id_2() | |
{ | |
xqfunctions:inspect(fn:element-with-id#2) | |
}; | |
(: Test for "fn:idref#1" :) | |
declare %test:assertEquals( "idref#1", "xs:string*" ,"node()*") | |
function xqfunctions:fn_idref_1() | |
{ | |
xqfunctions:inspect(fn:idref#1) | |
}; | |
(: Test for "fn:idref#2" :) | |
declare %test:assertEquals( "idref#2", "xs:string*" , "node()" ,"node()*") | |
function xqfunctions:fn_idref_2() | |
{ | |
xqfunctions:inspect(fn:idref#2) | |
}; | |
(: Test for "fn:doc#1" :) | |
declare %test:assertEquals( "doc#1", "xs:string?" ,"document-node()?") | |
function xqfunctions:fn_doc_1() | |
{ | |
xqfunctions:inspect(fn:doc#1) | |
}; | |
(: Test for "fn:doc-available#1" :) | |
declare %test:assertEquals( "doc-available#1", "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_doc-available_1() | |
{ | |
xqfunctions:inspect(fn:doc-available#1) | |
}; | |
(: Test for "fn:collection#0" :) | |
declare %test:assertEquals( "collection#0" ,"item()*") | |
function xqfunctions:fn_collection_0() | |
{ | |
xqfunctions:inspect(fn:collection#0) | |
}; | |
(: Test for "fn:collection#1" :) | |
declare %test:assertEquals( "collection#1", "xs:string?" ,"item()*") | |
function xqfunctions:fn_collection_1() | |
{ | |
xqfunctions:inspect(fn:collection#1) | |
}; | |
(: Test for "fn:uri-collection#0" :) | |
declare %test:assertEquals( "uri-collection#0" ,"xs:anyURI*") | |
function xqfunctions:fn_uri-collection_0() | |
{ | |
xqfunctions:inspect(fn:uri-collection#0) | |
}; | |
(: Test for "fn:uri-collection#1" :) | |
declare %test:assertEquals( "uri-collection#1", "xs:string?" ,"xs:anyURI*") | |
function xqfunctions:fn_uri-collection_1() | |
{ | |
xqfunctions:inspect(fn:uri-collection#1) | |
}; | |
(: Test for "fn:unparsed-text#1" :) | |
declare %test:assertEquals( "unparsed-text#1", "xs:string?" ,"xs:string?") | |
function xqfunctions:fn_unparsed-text_1() | |
{ | |
xqfunctions:inspect(fn:unparsed-text#1) | |
}; | |
(: Test for "fn:unparsed-text#2" :) | |
declare %test:assertEquals( "unparsed-text#2", "xs:string?" , "xs:string" ,"xs:string?") | |
function xqfunctions:fn_unparsed-text_2() | |
{ | |
xqfunctions:inspect(fn:unparsed-text#2) | |
}; | |
(: Test for "fn:unparsed-text-lines#1" :) | |
declare %test:assertEquals( "unparsed-text-lines#1", "xs:string?" ,"xs:string*") | |
function xqfunctions:fn_unparsed-text-lines_1() | |
{ | |
xqfunctions:inspect(fn:unparsed-text-lines#1) | |
}; | |
(: Test for "fn:unparsed-text-lines#2" :) | |
declare %test:assertEquals( "unparsed-text-lines#2", "xs:string?" , "xs:string" ,"xs:string*") | |
function xqfunctions:fn_unparsed-text-lines_2() | |
{ | |
xqfunctions:inspect(fn:unparsed-text-lines#2) | |
}; | |
(: Test for "fn:unparsed-text-available#1" :) | |
declare %test:assertEquals( "unparsed-text-available#1", "xs:string?" ,"xs:boolean") | |
function xqfunctions:fn_unparsed-text-available_1() | |
{ | |
xqfunctions:inspect(fn:unparsed-text-available#1) | |
}; | |
(: Test for "fn:unparsed-text-available#2" :) | |
declare %test:assertEquals( "unparsed-text-available#2", "xs:string?" , "xs:string" ,"xs:boolean") | |
function xqfunctions:fn_unparsed-text-available_2() | |
{ | |
xqfunctions:inspect(fn:unparsed-text-available#2) | |
}; | |
(: Test for "fn:environment-variable#1" :) | |
declare %test:assertEquals( "environment-variable#1", "xs:string" ,"xs:string?") | |
function xqfunctions:fn_environment-variable_1() | |
{ | |
xqfunctions:inspect(fn:environment-variable#1) | |
}; | |
(: Test for "fn:available-environment-variables#0" :) | |
declare %test:assertEquals( "available-environment-variables#0" ,"xs:string*") | |
function xqfunctions:fn_available-environment-variables_0() | |
{ | |
xqfunctions:inspect(fn:available-environment-variables#0) | |
}; | |
(: Test for "fn:generate-id#0" :) | |
declare %test:assertEquals( "generate-id#0" ,"xs:string") | |
function xqfunctions:fn_generate-id_0() | |
{ | |
xqfunctions:inspect(fn:generate-id#0) | |
}; | |
(: Test for "fn:generate-id#1" :) | |
declare %test:assertEquals( "generate-id#1", "node()?" ,"xs:string") | |
function xqfunctions:fn_generate-id_1() | |
{ | |
xqfunctions:inspect(fn:generate-id#1) | |
}; | |
(: Test for "fn:parse-xml#1" :) | |
declare %test:assertEquals( "parse-xml#1", "xs:string?" ,"document-node(element(*))?") | |
function xqfunctions:fn_parse-xml_1() | |
{ | |
xqfunctions:inspect(fn:parse-xml#1) | |
}; | |
(: Test for "fn:parse-xml-fragment#1" :) | |
declare %test:assertEquals( "parse-xml-fragment#1", "xs:string?" ,"document-node()?") | |
function xqfunctions:fn_parse-xml-fragment_1() | |
{ | |
xqfunctions:inspect(fn:parse-xml-fragment#1) | |
}; | |
(: Test for "fn:serialize#1" :) | |
declare %test:assertEquals( "serialize#1", "item()*" ,"xs:string") | |
function xqfunctions:fn_serialize_1() | |
{ | |
xqfunctions:inspect(fn:serialize#1) | |
}; | |
(: Test for "fn:serialize#2" :) | |
declare %test:assertEquals( "serialize#2", "item()*" , "item()?" ,"xs:string") | |
function xqfunctions:fn_serialize_2() | |
{ | |
xqfunctions:inspect(fn:serialize#2) | |
}; | |
(: Test for "fn:position#0" :) | |
declare %test:assertEquals( "position#0" ,"xs:integer") | |
function xqfunctions:fn_position_0() | |
{ | |
xqfunctions:inspect(fn:position#0) | |
}; | |
(: Test for "fn:last#0" :) | |
declare %test:assertEquals( "last#0" ,"xs:integer") | |
function xqfunctions:fn_last_0() | |
{ | |
xqfunctions:inspect(fn:last#0) | |
}; | |
(: Test for "fn:current-dateTime#0" :) | |
declare %test:assertEquals( "current-dateTime#0" ,"xs:dateTimeStamp") | |
function xqfunctions:fn_current-dateTime_0() | |
{ | |
xqfunctions:inspect(fn:current-dateTime#0) | |
}; | |
(: Test for "fn:current-date#0" :) | |
declare %test:assertEquals( "current-date#0" ,"xs:date") | |
function xqfunctions:fn_current-date_0() | |
{ | |
xqfunctions:inspect(fn:current-date#0) | |
}; | |
(: Test for "fn:current-time#0" :) | |
declare %test:assertEquals( "current-time#0" ,"xs:time") | |
function xqfunctions:fn_current-time_0() | |
{ | |
xqfunctions:inspect(fn:current-time#0) | |
}; | |
(: Test for "fn:implicit-timezone#0" :) | |
declare %test:assertEquals( "implicit-timezone#0" ,"xs:dayTimeDuration") | |
function xqfunctions:fn_implicit-timezone_0() | |
{ | |
xqfunctions:inspect(fn:implicit-timezone#0) | |
}; | |
(: Test for "fn:default-collation#0" :) | |
declare %test:assertEquals( "default-collation#0" ,"xs:string") | |
function xqfunctions:fn_default-collation_0() | |
{ | |
xqfunctions:inspect(fn:default-collation#0) | |
}; | |
(: Test for "fn:default-language#0" :) | |
declare %test:assertEquals( "default-language#0" ,"xs:language") | |
function xqfunctions:fn_default-language_0() | |
{ | |
xqfunctions:inspect(fn:default-language#0) | |
}; | |
(: Test for "fn:static-base-uri#0" :) | |
declare %test:assertEquals( "static-base-uri#0" ,"xs:anyURI?") | |
function xqfunctions:fn_static-base-uri_0() | |
{ | |
xqfunctions:inspect(fn:static-base-uri#0) | |
}; | |
(: Test for "fn:function-lookup#2" :) | |
declare %test:assertEquals( "function-lookup#2", "xs:QName" , "xs:integer" ,"function(*)?") | |
function xqfunctions:fn_function-lookup_2() | |
{ | |
xqfunctions:inspect(fn:function-lookup#2) | |
}; | |
(: Test for "fn:function-name#1" :) | |
declare %test:assertEquals( "function-name#1", "function(*)" ,"xs:QName?") | |
function xqfunctions:fn_function-name_1() | |
{ | |
xqfunctions:inspect(fn:function-name#1) | |
}; | |
(: Test for "fn:function-arity#1" :) | |
declare %test:assertEquals( "function-arity#1", "function(*)" ,"xs:integer") | |
function xqfunctions:fn_function-arity_1() | |
{ | |
xqfunctions:inspect(fn:function-arity#1) | |
}; | |
(: Test for "fn:for-each#2" :) | |
declare %test:assertEquals( "for-each#2", "item()*" , "function(item()) as item()*" ,"item()*") | |
function xqfunctions:fn_for-each_2() | |
{ | |
xqfunctions:inspect(fn:for-each#2) | |
}; | |
(: Test for "fn:filter#2" :) | |
declare %test:assertEquals( "filter#2", "item()*" , "function(item()) as xs:boolean" ,"item()*") | |
function xqfunctions:fn_filter_2() | |
{ | |
xqfunctions:inspect(fn:filter#2) | |
}; | |
(: Test for "fn:fold-left#3" :) | |
declare %test:assertEquals( "fold-left#3", "item()*" , "item()*" , "function(item()*, item()) as item()*" ,"item()*") | |
function xqfunctions:fn_fold-left_3() | |
{ | |
xqfunctions:inspect(fn:fold-left#3) | |
}; | |
(: Test for "fn:fold-right#3" :) | |
declare %test:assertEquals( "fold-right#3", "item()*" , "item()*" , "function(item(), item()*) as item()*" ,"item()*") | |
function xqfunctions:fn_fold-right_3() | |
{ | |
xqfunctions:inspect(fn:fold-right#3) | |
}; | |
(: Test for "fn:for-each-pair#3" :) | |
declare %test:assertEquals( "for-each-pair#3", "item()*" , "item()*" , "function(item(), item()) as item()*" ,"item()*") | |
function xqfunctions:fn_for-each-pair_3() | |
{ | |
xqfunctions:inspect(fn:for-each-pair#3) | |
}; | |
(: Test for "fn:sort#1" :) | |
declare %test:assertEquals( "sort#1", "item()*" ,"item()*") | |
function xqfunctions:fn_sort_1() | |
{ | |
xqfunctions:inspect(fn:sort#1) | |
}; | |
(: Test for "fn:sort#2" :) | |
declare %test:assertEquals( "sort#2", "item()*" , "xs:string?" ,"item()*") | |
function xqfunctions:fn_sort_2() | |
{ | |
xqfunctions:inspect(fn:sort#2) | |
}; | |
(: Test for "fn:sort#3" :) | |
declare %test:assertEquals( "sort#3", "item()*" , "xs:string?" , "function(item()) as xs:anyAtomicType*" ,"item()*") | |
function xqfunctions:fn_sort_3() | |
{ | |
xqfunctions:inspect(fn:sort#3) | |
}; | |
(: Test for "fn:apply#2" :) | |
declare %test:assertEquals( "apply#2", "function(*)" , "array(*)" ,"item()*") | |
function xqfunctions:fn_apply_2() | |
{ | |
xqfunctions:inspect(fn:apply#2) | |
}; | |
(: Test for "map:merge#1" :) | |
declare %test:assertEquals( "merge#1", "map(*)*" ,"map(*)") | |
function xqfunctions:map_merge_1() | |
{ | |
xqfunctions:inspect(map:merge#1) | |
}; | |
(: Test for "map:merge#2" :) | |
declare %test:assertEquals( "merge#2", "map(*)*" , "map(*)" ,"map(*)") | |
function xqfunctions:map_merge_2() | |
{ | |
xqfunctions:inspect(map:merge#2) | |
}; | |
(: Test for "map:keys#1" :) | |
declare %test:assertEquals( "keys#1", "map(*)" ,"xs:anyAtomicType*") | |
function xqfunctions:map_keys_1() | |
{ | |
xqfunctions:inspect(map:keys#1) | |
}; | |
(: Test for "map:contains#2" :) | |
declare %test:assertEquals( "contains#2", "map(*)" , "xs:anyAtomicType" ,"xs:boolean") | |
function xqfunctions:map_contains_2() | |
{ | |
xqfunctions:inspect(map:contains#2) | |
}; | |
(: Test for "map:get#2" :) | |
declare %test:assertEquals( "get#2", "map(*)" , "xs:anyAtomicType" ,"item()*") | |
function xqfunctions:map_get_2() | |
{ | |
xqfunctions:inspect(map:get#2) | |
}; | |
(: Test for "map:find#2" :) | |
declare %test:assertEquals( "find#2", "item()*" , "xs:anyAtomicType" ,"array(*)") | |
function xqfunctions:map_find_2() | |
{ | |
xqfunctions:inspect(map:find#2) | |
}; | |
(: Test for "map:put#3" :) | |
declare %test:assertEquals( "put#3", "map(*)" , "xs:anyAtomicType" , "item()*" ,"map(*)") | |
function xqfunctions:map_put_3() | |
{ | |
xqfunctions:inspect(map:put#3) | |
}; | |
(: Test for "map:entry#2" :) | |
declare %test:assertEquals( "entry#2", "xs:anyAtomicType" , "item()*" ,"map(*)") | |
function xqfunctions:map_entry_2() | |
{ | |
xqfunctions:inspect(map:entry#2) | |
}; | |
(: Test for "map:remove#2" :) | |
declare %test:assertEquals( "remove#2", "map(*)" , "xs:anyAtomicType*" ,"map(*)") | |
function xqfunctions:map_remove_2() | |
{ | |
xqfunctions:inspect(map:remove#2) | |
}; | |
(: Test for "map:for-each#2" :) | |
declare %test:assertEquals( "for-each#2", "map(*)" , "function(xs:anyAtomicType, item()*) as item()*" ,"item()*") | |
function xqfunctions:map_for-each_2() | |
{ | |
xqfunctions:inspect(map:for-each#2) | |
}; | |
(: Test for "map:size#1" :) | |
declare %test:assertEquals( "size#1", "map(*)" ,"xs:integer") | |
function xqfunctions:map_size_1() | |
{ | |
xqfunctions:inspect(map:size#1) | |
}; | |
(: Test for "fn:collation-key#1" :) | |
declare %test:assertEquals( "collation-key#1", "xs:string" ,"xs:base64Binary") | |
function xqfunctions:fn_collation-key_1() | |
{ | |
xqfunctions:inspect(fn:collation-key#1) | |
}; | |
(: Test for "fn:collation-key#2" :) | |
declare %test:assertEquals( "collation-key#2", "xs:string" , "xs:string" ,"xs:base64Binary") | |
function xqfunctions:fn_collation-key_2() | |
{ | |
xqfunctions:inspect(fn:collation-key#2) | |
}; | |
(: Test for "fn:json-to-xml#1" :) | |
declare %test:assertEquals( "json-to-xml#1", "xs:string?" ,"document-node()?") | |
function xqfunctions:fn_json-to-xml_1() | |
{ | |
xqfunctions:inspect(fn:json-to-xml#1) | |
}; | |
(: Test for "fn:json-to-xml#2" :) | |
declare %test:assertEquals( "json-to-xml#2", "xs:string?" , "map(*)" ,"document-node()?") | |
function xqfunctions:fn_json-to-xml_2() | |
{ | |
xqfunctions:inspect(fn:json-to-xml#2) | |
}; | |
(: Test for "fn:xml-to-json#1" :) | |
declare %test:assertEquals( "xml-to-json#1", "node()?" ,"xs:string?") | |
function xqfunctions:fn_xml-to-json_1() | |
{ | |
xqfunctions:inspect(fn:xml-to-json#1) | |
}; | |
(: Test for "fn:xml-to-json#2" :) | |
declare %test:assertEquals( "xml-to-json#2", "node()?" , "map(*)" ,"xs:string?") | |
function xqfunctions:fn_xml-to-json_2() | |
{ | |
xqfunctions:inspect(fn:xml-to-json#2) | |
}; | |
(: Test for "fn:parse-json#1" :) | |
declare %test:assertEquals( "parse-json#1", "xs:string?" ,"item()?") | |
function xqfunctions:fn_parse-json_1() | |
{ | |
xqfunctions:inspect(fn:parse-json#1) | |
}; | |
(: Test for "fn:parse-json#2" :) | |
declare %test:assertEquals( "parse-json#2", "xs:string?" , "map(*)" ,"item()?") | |
function xqfunctions:fn_parse-json_2() | |
{ | |
xqfunctions:inspect(fn:parse-json#2) | |
}; | |
(: Test for "fn:json-doc#1" :) | |
declare %test:assertEquals( "json-doc#1", "xs:string?" ,"item()?") | |
function xqfunctions:fn_json-doc_1() | |
{ | |
xqfunctions:inspect(fn:json-doc#1) | |
}; | |
(: Test for "fn:json-doc#2" :) | |
declare %test:assertEquals( "json-doc#2", "xs:string?" , "map(*)" ,"item()?") | |
function xqfunctions:fn_json-doc_2() | |
{ | |
xqfunctions:inspect(fn:json-doc#2) | |
}; | |
(: Test for "array:size#1" :) | |
declare %test:assertEquals( "size#1", "array(*)" ,"xs:integer") | |
function xqfunctions:array_size_1() | |
{ | |
xqfunctions:inspect(array:size#1) | |
}; | |
(: Test for "array:get#2" :) | |
declare %test:assertEquals( "get#2", "array(*)" , "xs:integer" ,"item()*") | |
function xqfunctions:array_get_2() | |
{ | |
xqfunctions:inspect(array:get#2) | |
}; | |
(: Test for "array:put#3" :) | |
declare %test:assertEquals( "put#3", "array(*)" , "xs:integer" , "item()*" ,"array(*)") | |
function xqfunctions:array_put_3() | |
{ | |
xqfunctions:inspect(array:put#3) | |
}; | |
(: Test for "array:append#2" :) | |
declare %test:assertEquals( "append#2", "array(*)" , "item()*" ,"array(*)") | |
function xqfunctions:array_append_2() | |
{ | |
xqfunctions:inspect(array:append#2) | |
}; | |
(: Test for "array:join#1" :) | |
declare %test:assertEquals( "join#1", "array(*)*" ,"array(*)") | |
function xqfunctions:array_join_1() | |
{ | |
xqfunctions:inspect(array:join#1) | |
}; | |
(: Test for "array:subarray#2" :) | |
declare %test:assertEquals( "subarray#2", "array(*)" , "xs:integer" ,"array(*)") | |
function xqfunctions:array_subarray_2() | |
{ | |
xqfunctions:inspect(array:subarray#2) | |
}; | |
(: Test for "array:subarray#3" :) | |
declare %test:assertEquals( "subarray#3", "array(*)" , "xs:integer" , "xs:integer" ,"array(*)") | |
function xqfunctions:array_subarray_3() | |
{ | |
xqfunctions:inspect(array:subarray#3) | |
}; | |
(: Test for "array:remove#2" :) | |
declare %test:assertEquals( "remove#2", "array(*)" , "xs:integer*" ,"array(*)") | |
function xqfunctions:array_remove_2() | |
{ | |
xqfunctions:inspect(array:remove#2) | |
}; | |
(: Test for "array:insert-before#3" :) | |
declare %test:assertEquals( "insert-before#3", "array(*)" , "xs:integer" , "item()*" ,"array(*)") | |
function xqfunctions:array_insert-before_3() | |
{ | |
xqfunctions:inspect(array:insert-before#3) | |
}; | |
(: Test for "array:head#1" :) | |
declare %test:assertEquals( "head#1", "array(*)" ,"item()*") | |
function xqfunctions:array_head_1() | |
{ | |
xqfunctions:inspect(array:head#1) | |
}; | |
(: Test for "array:tail#1" :) | |
declare %test:assertEquals( "tail#1", "array(*)" ,"array(*)") | |
function xqfunctions:array_tail_1() | |
{ | |
xqfunctions:inspect(array:tail#1) | |
}; | |
(: Test for "array:reverse#1" :) | |
declare %test:assertEquals( "reverse#1", "array(*)" ,"array(*)") | |
function xqfunctions:array_reverse_1() | |
{ | |
xqfunctions:inspect(array:reverse#1) | |
}; | |
(: Test for "array:for-each#2" :) | |
declare %test:assertEquals( "for-each#2", "array(*)" , "function(item()*) as item()*" ,"array(*)") | |
function xqfunctions:array_for-each_2() | |
{ | |
xqfunctions:inspect(array:for-each#2) | |
}; | |
(: Test for "array:filter#2" :) | |
declare %test:assertEquals( "filter#2", "array(*)" , "function(item()*) as xs:boolean" ,"array(*)") | |
function xqfunctions:array_filter_2() | |
{ | |
xqfunctions:inspect(array:filter#2) | |
}; | |
(: Test for "array:fold-left#3" :) | |
declare %test:assertEquals( "fold-left#3", "array(*)" , "item()*" , "function(item()*, item()*) as item()*" ,"item()*") | |
function xqfunctions:array_fold-left_3() | |
{ | |
xqfunctions:inspect(array:fold-left#3) | |
}; | |
(: Test for "array:fold-right#3" :) | |
declare %test:assertEquals( "fold-right#3", "array(*)" , "item()*" , "function(item()*, item()*) as item()*" ,"item()*") | |
function xqfunctions:array_fold-right_3() | |
{ | |
xqfunctions:inspect(array:fold-right#3) | |
}; | |
(: Test for "array:for-each-pair#3" :) | |
declare %test:assertEquals( "for-each-pair#3", "array(*)" , "array(*)" , "function(item()*, item()*) as item()*" ,"array(*)") | |
function xqfunctions:array_for-each-pair_3() | |
{ | |
xqfunctions:inspect(array:for-each-pair#3) | |
}; | |
(: Test for "array:sort#1" :) | |
declare %test:assertEquals( "sort#1", "array(*)" ,"array(*)") | |
function xqfunctions:array_sort_1() | |
{ | |
xqfunctions:inspect(array:sort#1) | |
}; | |
(: Test for "array:sort#2" :) | |
declare %test:assertEquals( "sort#2", "array(*)" , "xs:string?" ,"array(*)") | |
function xqfunctions:array_sort_2() | |
{ | |
xqfunctions:inspect(array:sort#2) | |
}; | |
(: Test for "array:sort#3" :) | |
declare %test:assertEquals( "sort#3", "array(*)" , "xs:string?" , "function(item()*) as xs:anyAtomicType*" ,"array(*)") | |
function xqfunctions:array_sort_3() | |
{ | |
xqfunctions:inspect(array:sort#3) | |
}; | |
(: Test for "array:flatten#1" :) | |
declare %test:assertEquals( "flatten#1", "item()*" ,"item()*") | |
function xqfunctions:array_flatten_1() | |
{ | |
xqfunctions:inspect(array:flatten#1) | |
}; | |
(: Test for "fn:load-xquery-module#1" :) | |
declare %test:assertEquals( "load-xquery-module#1", "xs:string" ,"map(*)") | |
function xqfunctions:fn_load-xquery-module_1() | |
{ | |
xqfunctions:inspect(fn:load-xquery-module#1) | |
}; | |
(: Test for "fn:load-xquery-module#2" :) | |
declare %test:assertEquals( "load-xquery-module#2", "xs:string" , "map(*)" ,"map(*)") | |
function xqfunctions:fn_load-xquery-module_2() | |
{ | |
xqfunctions:inspect(fn:load-xquery-module#2) | |
}; | |
(: Test for "fn:transform#1" :) | |
declare %test:assertEquals( "transform#1", "map(*)" ,"map(*)") | |
function xqfunctions:fn_transform_1() | |
{ | |
xqfunctions:inspect(fn:transform#1) | |
}; | |
(: Test for "fn:random-number-generator#0" :) | |
declare %test:assertEquals( "random-number-generator#0" ,"map(xs:string, item())") | |
function xqfunctions:fn_random-number-generator_0() | |
{ | |
xqfunctions:inspect(fn:random-number-generator#0) | |
}; | |
(: Test for "fn:random-number-generator#1" :) | |
declare %test:assertEquals( "random-number-generator#1", "xs:anyAtomicType?" ,"map(xs:string, item())") | |
function xqfunctions:fn_random-number-generator_1() | |
{ | |
xqfunctions:inspect(fn:random-number-generator#1) | |
}; | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
xquery version "3.1"; | |
declare namespace fos="http://www.w3.org/xpath-functions/spec/namespace"; | |
declare function local:writeHeader() as xs:string { | |
' | |
xquery version "3.1"; | |
module namespace xqfunctions="http://exist-db.org/xquery/test/xqfunctions"; | |
import module namespace inspect="http://exist-db.org/xquery/inspection" at "java:org.exist.xquery.functions.inspect.InspectionModule"; | |
declare namespace test="http://exist-db.org/xquery/xqsuite"; | |
declare function xqfunctions:cardinality($cardinality as xs:string) as xs:string { | |
switch ($cardinality) | |
case "exactly one" return ("") | |
case "zero or more" return ("*") | |
case "one or more" return ("+") | |
case "empty" return ("empty-sequence()") | |
case "zero or one" return ("?") | |
default return ("oops") | |
}; | |
declare function xqfunctions:describe($element as element() ) as xs:string { | |
data($element/@type) || xqfunctions:cardinality(data($element/@cardinality)) | |
}; | |
declare function xqfunctions:inspect($function as function(*)) as xs:string* { | |
let $function := inspect:inspect-function($function) | |
let $args := $function//argument | |
let $name := data($function/@name) | |
let $modName := if(contains($name, ":")) then substring-after($name,":") else $name | |
return ($modName || "#" || count($args) , for $arg in $args return xqfunctions:describe($arg), xqfunctions:describe($function/returns)) | |
}; | |
(: ------------------------- :) | |
' | |
}; | |
declare function local:writeTests() as xs:string* { | |
for $container in doc('https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/function-catalog.xml')//fos:functions/fos:function[@prefix = ("fn","math", "map", "array")] | |
return | |
for $proto in $container/fos:signatures/fos:proto | |
let $protoname := data($proto/@name) | |
let $prefix := data($container/@prefix) | |
let $nrargs := count($proto//fos:arg) | |
let $nicename := $protoname || "_" || $nrargs | |
let $HOFname := $protoname || "#" || $nrargs | |
let $returnType := data($proto/@return-type) | |
let $parameters := string-join(for $arg in $proto//fos:arg return ', "' || $arg/@type || '"', " ") | |
return | |
' | |
(: Test for "' || $prefix || ":" || $HOFname || '" :) | |
declare %test:assertEquals( "' || $HOFname || '"' || $parameters || ' ,"' || $returnType || '") | |
function xqfunctions:' || $prefix || "_" || $nicename || '() | |
{ | |
xqfunctions:inspect(' || $prefix || ":" || $HOFname || ') | |
}; | |
' | |
}; | |
let $document := local:writeHeader() || string-join(local:writeTests()) | |
return xmldb:store("/db", "functionSignatureTests.xq", $document) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<testsuites> | |
<testsuite package="http://exist-db.org/xquery/test/xqfunctions" timestamp="2018-02-03T15:28:32.686+01:00" failures="102" pending="0" tests="273" time="PT0.152S"> | |
<testcase name="array_append_2" class="xqfunctions:array_append_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">append#2 array(*) item()* array(*)</failure> | |
<output>array:append#2 array(*) item()* array(*)*</output> | |
</testcase> | |
<testcase name="array_filter_2" class="xqfunctions:array_filter_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">filter#2 array(*) function(item()*) as xs:boolean array(*)</failure> | |
<output>array:filter#2 array(*) function(*) array(*)</output> | |
</testcase> | |
<testcase name="array_flatten_1" class="xqfunctions:array_flatten_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">flatten#1 item()* item()*</failure> | |
<output>array:flatten#1 item()* item()*</output> | |
</testcase> | |
<testcase name="array_fold-left_3" class="xqfunctions:array_fold-left_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">fold-left#3 array(*) item()* function(item()*, item()*) as item()* item()*</failure> | |
<output>array:fold-left#3 array(*) item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="array_fold-right_3" class="xqfunctions:array_fold-right_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">fold-right#3 array(*) item()* function(item()*, item()*) as item()* item()*</failure> | |
<output>array:fold-right#3 array(*) item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="array_for-each-pair_3" class="xqfunctions:array_for-each-pair_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">for-each-pair#3 array(*) array(*) function(item()*, item()*) as item()* array(*)</failure> | |
<output>array:for-each-pair#3 array(*) array(*) function(*) array(*)</output> | |
</testcase> | |
<testcase name="array_for-each_2" class="xqfunctions:array_for-each_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">for-each#2 array(*) function(item()*) as item()* array(*)</failure> | |
<output>array:for-each#2 array(*) function(*) array(*)</output> | |
</testcase> | |
<testcase name="array_get_2" class="xqfunctions:array_get_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">get#2 array(*) xs:integer item()*</failure> | |
<output>array:get#2 array(*) xs:integer xs:integer*</output> | |
</testcase> | |
<testcase name="array_head_1" class="xqfunctions:array_head_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">head#1 array(*) item()*</failure> | |
<output>array:head#1 array(*) item()*</output> | |
</testcase> | |
<testcase name="array_insert-before_3" class="xqfunctions:array_insert-before_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">insert-before#3 array(*) xs:integer item()* array(*)</failure> | |
<output>array:insert-before#3 array(*) xs:integer item()* array(*)</output> | |
</testcase> | |
<testcase name="array_join_1" class="xqfunctions:array_join_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">join#1 array(*)* array(*)</failure> | |
<output>array:join#1 array(*)* array(*)</output> | |
</testcase> | |
<testcase name="array_put_3" class="xqfunctions:array_put_3"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function array:put() is not defined in module namespace: http://www.w3.org/2005/xpath-functions/array"/> | |
</testcase> | |
<testcase name="array_remove_2" class="xqfunctions:array_remove_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">remove#2 array(*) xs:integer* array(*)</failure> | |
<output>array:remove#2 array(*) xs:integer array(*)</output> | |
</testcase> | |
<testcase name="array_reverse_1" class="xqfunctions:array_reverse_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">reverse#1 array(*) array(*)</failure> | |
<output>array:reverse#1 array(*) array(*)</output> | |
</testcase> | |
<testcase name="array_size_1" class="xqfunctions:array_size_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">size#1 array(*) xs:integer</failure> | |
<output>array:size#1 array(*) xs:integer</output> | |
</testcase> | |
<testcase name="array_sort_1" class="xqfunctions:array_sort_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function array:sort() is not defined in module namespace: http://www.w3.org/2005/xpath-functions/array"/> | |
</testcase> | |
<testcase name="array_sort_2" class="xqfunctions:array_sort_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function array:sort() is not defined in module namespace: http://www.w3.org/2005/xpath-functions/array"/> | |
</testcase> | |
<testcase name="array_sort_3" class="xqfunctions:array_sort_3"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function array:sort() is not defined in module namespace: http://www.w3.org/2005/xpath-functions/array"/> | |
</testcase> | |
<testcase name="array_subarray_2" class="xqfunctions:array_subarray_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">subarray#2 array(*) xs:integer array(*)</failure> | |
<output>array:subarray#2 array(*) xs:integer array(*)</output> | |
</testcase> | |
<testcase name="array_subarray_3" class="xqfunctions:array_subarray_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">subarray#3 array(*) xs:integer xs:integer array(*)</failure> | |
<output>array:subarray#3 array(*) xs:integer xs:integer array(*)</output> | |
</testcase> | |
<testcase name="array_tail_1" class="xqfunctions:array_tail_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">tail#1 array(*) array(*)</failure> | |
<output>array:tail#1 array(*) array(*)</output> | |
</testcase> | |
<testcase name="fn_QName_2" class="xqfunctions:fn_QName_2"/> | |
<testcase name="fn_abs_1" class="xqfunctions:fn_abs_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">abs#1 xs:numeric? xs:numeric?</failure> | |
<output>abs#1 numeric? numeric</output> | |
</testcase> | |
<testcase name="fn_adjust-date-to-timezone_1" class="xqfunctions:fn_adjust-date-to-timezone_1"/> | |
<testcase name="fn_adjust-date-to-timezone_2" class="xqfunctions:fn_adjust-date-to-timezone_2"/> | |
<testcase name="fn_adjust-dateTime-to-timezone_1" class="xqfunctions:fn_adjust-dateTime-to-timezone_1"/> | |
<testcase name="fn_adjust-dateTime-to-timezone_2" class="xqfunctions:fn_adjust-dateTime-to-timezone_2"/> | |
<testcase name="fn_adjust-time-to-timezone_1" class="xqfunctions:fn_adjust-time-to-timezone_1"/> | |
<testcase name="fn_adjust-time-to-timezone_2" class="xqfunctions:fn_adjust-time-to-timezone_2"/> | |
<testcase name="fn_analyze-string_2" class="xqfunctions:fn_analyze-string_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">analyze-string#2 xs:string? xs:string element(fn:analyze-string-result)</failure> | |
<output>analyze-string#2 xs:string? xs:string element()</output> | |
</testcase> | |
<testcase name="fn_analyze-string_3" class="xqfunctions:fn_analyze-string_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">analyze-string#3 xs:string? xs:string xs:string element(fn:analyze-string-result)</failure> | |
<output>analyze-string#3 xs:string? xs:string xs:string element()</output> | |
</testcase> | |
<testcase name="fn_apply_2" class="xqfunctions:fn_apply_2"/> | |
<testcase name="fn_available-environment-variables_0" class="xqfunctions:fn_available-environment-variables_0"/> | |
<testcase name="fn_avg_1" class="xqfunctions:fn_avg_1"/> | |
<testcase name="fn_base-uri_0" class="xqfunctions:fn_base-uri_0"/> | |
<testcase name="fn_base-uri_1" class="xqfunctions:fn_base-uri_1"/> | |
<testcase name="fn_boolean_1" class="xqfunctions:fn_boolean_1"/> | |
<testcase name="fn_ceiling_1" class="xqfunctions:fn_ceiling_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">ceiling#1 xs:numeric? xs:numeric?</failure> | |
<output>ceiling#1 numeric? numeric</output> | |
</testcase> | |
<testcase name="fn_codepoint-equal_2" class="xqfunctions:fn_codepoint-equal_2"/> | |
<testcase name="fn_codepoints-to-string_1" class="xqfunctions:fn_codepoints-to-string_1"/> | |
<testcase name="fn_collation-key_1" class="xqfunctions:fn_collation-key_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:collation-key() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_collation-key_2" class="xqfunctions:fn_collation-key_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:collation-key() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_collection_0" class="xqfunctions:fn_collection_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">collection#0 item()*</failure> | |
<output>collection#0 node()*</output> | |
</testcase> | |
<testcase name="fn_collection_1" class="xqfunctions:fn_collection_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">collection#1 xs:string? item()*</failure> | |
<output>collection#1 xs:string* node()*</output> | |
</testcase> | |
<testcase name="fn_compare_2" class="xqfunctions:fn_compare_2"/> | |
<testcase name="fn_compare_3" class="xqfunctions:fn_compare_3"/> | |
<testcase name="fn_concat_3" class="xqfunctions:fn_concat_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">concat#3 xs:anyAtomicType? xs:anyAtomicType? xs:anyAtomicType? xs:string</failure> | |
<output>concat#3 xs:anyAtomicType? xs:anyAtomicType? xs:anyAtomicType? xs:string?</output> | |
</testcase> | |
<testcase name="fn_contains-token_2" class="xqfunctions:fn_contains-token_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:contains-token() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_contains-token_3" class="xqfunctions:fn_contains-token_3"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:contains-token() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_contains_2" class="xqfunctions:fn_contains_2"/> | |
<testcase name="fn_contains_3" class="xqfunctions:fn_contains_3"/> | |
<testcase name="fn_count_1" class="xqfunctions:fn_count_1"/> | |
<testcase name="fn_current-dateTime_0" class="xqfunctions:fn_current-dateTime_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">current-dateTime#0 xs:dateTimeStamp</failure> | |
<output>current-dateTime#0 xs:dateTime</output> | |
</testcase> | |
<testcase name="fn_current-date_0" class="xqfunctions:fn_current-date_0"/> | |
<testcase name="fn_current-time_0" class="xqfunctions:fn_current-time_0"/> | |
<testcase name="fn_data_0" class="xqfunctions:fn_data_0"/> | |
<testcase name="fn_data_1" class="xqfunctions:fn_data_1"/> | |
<testcase name="fn_dateTime_2" class="xqfunctions:fn_dateTime_2"/> | |
<testcase name="fn_day-from-dateTime_1" class="xqfunctions:fn_day-from-dateTime_1"/> | |
<testcase name="fn_day-from-date_1" class="xqfunctions:fn_day-from-date_1"/> | |
<testcase name="fn_days-from-duration_1" class="xqfunctions:fn_days-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">days-from-duration#1 xs:duration? xs:integer?</failure> | |
<output>days-from-duration#1 xs:dayTimeDuration? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_deep-equal_2" class="xqfunctions:fn_deep-equal_2"/> | |
<testcase name="fn_deep-equal_3" class="xqfunctions:fn_deep-equal_3"/> | |
<testcase name="fn_default-collation_0" class="xqfunctions:fn_default-collation_0"/> | |
<testcase name="fn_default-language_0" class="xqfunctions:fn_default-language_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:default-language() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_distinct-values_1" class="xqfunctions:fn_distinct-values_1"/> | |
<testcase name="fn_distinct-values_2" class="xqfunctions:fn_distinct-values_2"/> | |
<testcase name="fn_doc-available_1" class="xqfunctions:fn_doc-available_1"/> | |
<testcase name="fn_doc_1" class="xqfunctions:fn_doc_1"/> | |
<testcase name="fn_document-uri_0" class="xqfunctions:fn_document-uri_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Unexpectedly received 0 parameter(s) in call to function 'fn:document-uri()'. Defined function signatures are:
document-uri($document-node as node()?) xs:anyURI?
"/> | |
</testcase> | |
<testcase name="fn_document-uri_1" class="xqfunctions:fn_document-uri_1"/> | |
<testcase name="fn_element-with-id_1" class="xqfunctions:fn_element-with-id_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:element-with-id() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_element-with-id_2" class="xqfunctions:fn_element-with-id_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:element-with-id() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_empty_1" class="xqfunctions:fn_empty_1"/> | |
<testcase name="fn_encode-for-uri_1" class="xqfunctions:fn_encode-for-uri_1"/> | |
<testcase name="fn_ends-with_2" class="xqfunctions:fn_ends-with_2"/> | |
<testcase name="fn_ends-with_3" class="xqfunctions:fn_ends-with_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">ends-with#3 xs:string? xs:string? xs:string xs:boolean</failure> | |
<output>ends-with#3 xs:string? xs:string? xs:string xs:boolean?</output> | |
</testcase> | |
<testcase name="fn_environment-variable_1" class="xqfunctions:fn_environment-variable_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">environment-variable#1 xs:string xs:string?</failure> | |
<output>environment-variable#1 xs:string xs:stringempty-sequence()</output> | |
</testcase> | |
<testcase name="fn_error_0" class="xqfunctions:fn_error_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">error#0 none</failure> | |
<output>error#0 empty-sequence()empty-sequence()</output> | |
</testcase> | |
<testcase name="fn_error_1" class="xqfunctions:fn_error_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">error#1 xs:QName? none</failure> | |
<output>error#1 xs:QName empty-sequence()empty-sequence()</output> | |
</testcase> | |
<testcase name="fn_error_2" class="xqfunctions:fn_error_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">error#2 xs:QName? xs:string none</failure> | |
<output>error#2 xs:QName? xs:string empty-sequence()empty-sequence()</output> | |
</testcase> | |
<testcase name="fn_error_3" class="xqfunctions:fn_error_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">error#3 xs:QName? xs:string item()* none</failure> | |
<output>error#3 xs:QName? xs:string item()* empty-sequence()empty-sequence()</output> | |
</testcase> | |
<testcase name="fn_escape-html-uri_1" class="xqfunctions:fn_escape-html-uri_1"/> | |
<testcase name="fn_exactly-one_1" class="xqfunctions:fn_exactly-one_1"/> | |
<testcase name="fn_exists_1" class="xqfunctions:fn_exists_1"/> | |
<testcase name="fn_false_0" class="xqfunctions:fn_false_0"/> | |
<testcase name="fn_filter_2" class="xqfunctions:fn_filter_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">filter#2 item()* function(item()) as xs:boolean item()*</failure> | |
<output>filter#2 item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_floor_1" class="xqfunctions:fn_floor_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">floor#1 xs:numeric? xs:numeric?</failure> | |
<output>floor#1 numeric* numeric</output> | |
</testcase> | |
<testcase name="fn_fold-left_3" class="xqfunctions:fn_fold-left_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">fold-left#3 item()* item()* function(item()*, item()) as item()* item()*</failure> | |
<output>fold-left#3 item()* item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_fold-right_3" class="xqfunctions:fn_fold-right_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">fold-right#3 item()* item()* function(item(), item()*) as item()* item()*</failure> | |
<output>fold-right#3 item()* item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_for-each-pair_3" class="xqfunctions:fn_for-each-pair_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">for-each-pair#3 item()* item()* function(item(), item()) as item()* item()*</failure> | |
<output>for-each-pair#3 item()* item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_for-each_2" class="xqfunctions:fn_for-each_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">for-each#2 item()* function(item()) as item()* item()*</failure> | |
<output>for-each#2 item()* function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_format-dateTime_2" class="xqfunctions:fn_format-dateTime_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-dateTime#2 xs:dateTime? xs:string xs:string?</failure> | |
<output>format-dateTime#2 xs:dateTime? xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_format-dateTime_5" class="xqfunctions:fn_format-dateTime_5"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-dateTime#5 xs:dateTime? xs:string xs:string? xs:string? xs:string? xs:string?</failure> | |
<output>format-dateTime#5 xs:dateTime? xs:string xs:string? xs:string? xs:string? xs:string</output> | |
</testcase> | |
<testcase name="fn_format-date_2" class="xqfunctions:fn_format-date_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-date#2 xs:date? xs:string xs:string?</failure> | |
<output>format-date#2 xs:date? xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_format-date_5" class="xqfunctions:fn_format-date_5"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-date#5 xs:date? xs:string xs:string? xs:string? xs:string? xs:string?</failure> | |
<output>format-date#5 xs:date? xs:string xs:string? xs:string? xs:string? xs:string</output> | |
</testcase> | |
<testcase name="fn_format-integer_2" class="xqfunctions:fn_format-integer_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:format-integer() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_format-integer_3" class="xqfunctions:fn_format-integer_3"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:format-integer() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_format-number_2" class="xqfunctions:fn_format-number_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-number#2 xs:numeric? xs:string xs:string</failure> | |
<output>format-number#2 numeric? xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_format-number_3" class="xqfunctions:fn_format-number_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-number#3 xs:numeric? xs:string xs:string? xs:string</failure> | |
<output>format-number#3 numeric? xs:string xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_format-time_2" class="xqfunctions:fn_format-time_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-time#2 xs:time? xs:string xs:string?</failure> | |
<output>format-time#2 xs:time? xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_format-time_5" class="xqfunctions:fn_format-time_5"> | |
<failure message="assertEquals failed." type="failure-error-code-1">format-time#5 xs:time? xs:string xs:string? xs:string? xs:string? xs:string?</failure> | |
<output>format-time#5 xs:time? xs:string xs:string? xs:string? xs:string? xs:string</output> | |
</testcase> | |
<testcase name="fn_function-arity_1" class="xqfunctions:fn_function-arity_1"/> | |
<testcase name="fn_function-lookup_2" class="xqfunctions:fn_function-lookup_2"/> | |
<testcase name="fn_function-name_1" class="xqfunctions:fn_function-name_1"/> | |
<testcase name="fn_generate-id_0" class="xqfunctions:fn_generate-id_0"/> | |
<testcase name="fn_generate-id_1" class="xqfunctions:fn_generate-id_1"/> | |
<testcase name="fn_has-children_0" class="xqfunctions:fn_has-children_0"/> | |
<testcase name="fn_has-children_1" class="xqfunctions:fn_has-children_1"/> | |
<testcase name="fn_head_1" class="xqfunctions:fn_head_1"/> | |
<testcase name="fn_hours-from-dateTime_1" class="xqfunctions:fn_hours-from-dateTime_1"/> | |
<testcase name="fn_hours-from-duration_1" class="xqfunctions:fn_hours-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">hours-from-duration#1 xs:duration? xs:integer?</failure> | |
<output>hours-from-duration#1 xs:dayTimeDuration? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_hours-from-time_1" class="xqfunctions:fn_hours-from-time_1"/> | |
<testcase name="fn_id_1" class="xqfunctions:fn_id_1"/> | |
<testcase name="fn_id_2" class="xqfunctions:fn_id_2"/> | |
<testcase name="fn_idref_1" class="xqfunctions:fn_idref_1"/> | |
<testcase name="fn_idref_2" class="xqfunctions:fn_idref_2"/> | |
<testcase name="fn_implicit-timezone_0" class="xqfunctions:fn_implicit-timezone_0"/> | |
<testcase name="fn_in-scope-prefixes_1" class="xqfunctions:fn_in-scope-prefixes_1"/> | |
<testcase name="fn_index-of_2" class="xqfunctions:fn_index-of_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">index-of#2 xs:anyAtomicType* xs:anyAtomicType xs:integer*</failure> | |
<output>index-of#2 xs:anyAtomicType* xs:anyAtomicType xs:integer?</output> | |
</testcase> | |
<testcase name="fn_index-of_3" class="xqfunctions:fn_index-of_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">index-of#3 xs:anyAtomicType* xs:anyAtomicType xs:string xs:integer*</failure> | |
<output>index-of#3 xs:anyAtomicType* xs:anyAtomicType xs:string xs:integer?</output> | |
</testcase> | |
<testcase name="fn_innermost_1" class="xqfunctions:fn_innermost_1"/> | |
<testcase name="fn_insert-before_3" class="xqfunctions:fn_insert-before_3"/> | |
<testcase name="fn_iri-to-uri_1" class="xqfunctions:fn_iri-to-uri_1"/> | |
<testcase name="fn_json-doc_1" class="xqfunctions:fn_json-doc_1"/> | |
<testcase name="fn_json-doc_2" class="xqfunctions:fn_json-doc_2"/> | |
<testcase name="fn_json-to-xml_1" class="xqfunctions:fn_json-to-xml_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:json-to-xml() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_json-to-xml_2" class="xqfunctions:fn_json-to-xml_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:json-to-xml() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_lang_1" class="xqfunctions:fn_lang_1"/> | |
<testcase name="fn_lang_2" class="xqfunctions:fn_lang_2"/> | |
<testcase name="fn_last_0" class="xqfunctions:fn_last_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">last#0 xs:integer</failure> | |
<output>last#0 xs:integer?</output> | |
</testcase> | |
<testcase name="fn_load-xquery-module_1" class="xqfunctions:fn_load-xquery-module_1"/> | |
<testcase name="fn_load-xquery-module_2" class="xqfunctions:fn_load-xquery-module_2"/> | |
<testcase name="fn_local-name-from-QName_1" class="xqfunctions:fn_local-name-from-QName_1"/> | |
<testcase name="fn_local-name_0" class="xqfunctions:fn_local-name_0"/> | |
<testcase name="fn_local-name_1" class="xqfunctions:fn_local-name_1"/> | |
<testcase name="fn_lower-case_1" class="xqfunctions:fn_lower-case_1"/> | |
<testcase name="fn_matches_2" class="xqfunctions:fn_matches_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">matches#2 xs:string? xs:string xs:boolean</failure> | |
<output>matches#2 xs:string* xs:string xs:boolean</output> | |
</testcase> | |
<testcase name="fn_matches_3" class="xqfunctions:fn_matches_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">matches#3 xs:string? xs:string xs:string xs:boolean</failure> | |
<output>matches#3 xs:string* xs:string xs:string xs:boolean</output> | |
</testcase> | |
<testcase name="fn_max_1" class="xqfunctions:fn_max_1"/> | |
<testcase name="fn_max_2" class="xqfunctions:fn_max_2"/> | |
<testcase name="fn_min_1" class="xqfunctions:fn_min_1"/> | |
<testcase name="fn_min_2" class="xqfunctions:fn_min_2"/> | |
<testcase name="fn_minutes-from-dateTime_1" class="xqfunctions:fn_minutes-from-dateTime_1"/> | |
<testcase name="fn_minutes-from-duration_1" class="xqfunctions:fn_minutes-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">minutes-from-duration#1 xs:duration? xs:integer?</failure> | |
<output>minutes-from-duration#1 xs:dayTimeDuration? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_minutes-from-time_1" class="xqfunctions:fn_minutes-from-time_1"/> | |
<testcase name="fn_month-from-dateTime_1" class="xqfunctions:fn_month-from-dateTime_1"/> | |
<testcase name="fn_month-from-date_1" class="xqfunctions:fn_month-from-date_1"/> | |
<testcase name="fn_months-from-duration_1" class="xqfunctions:fn_months-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">months-from-duration#1 xs:duration? xs:integer?</failure> | |
<output>months-from-duration#1 xs:yearMonthDuration? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_name_0" class="xqfunctions:fn_name_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">name#0 xs:string</failure> | |
<output>name#0 xs:string?</output> | |
</testcase> | |
<testcase name="fn_name_1" class="xqfunctions:fn_name_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">name#1 node()? xs:string</failure> | |
<output>name#1 node()? xs:string?</output> | |
</testcase> | |
<testcase name="fn_namespace-uri-for-prefix_2" class="xqfunctions:fn_namespace-uri-for-prefix_2"/> | |
<testcase name="fn_namespace-uri-from-QName_1" class="xqfunctions:fn_namespace-uri-from-QName_1"/> | |
<testcase name="fn_namespace-uri_0" class="xqfunctions:fn_namespace-uri_0"/> | |
<testcase name="fn_namespace-uri_1" class="xqfunctions:fn_namespace-uri_1"/> | |
<testcase name="fn_nilled_0" class="xqfunctions:fn_nilled_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Unexpectedly received 0 parameter(s) in call to function 'fn:nilled()'. Defined function signatures are:
nilled($arg as node()?) xs:boolean?
"/> | |
</testcase> | |
<testcase name="fn_nilled_1" class="xqfunctions:fn_nilled_1"/> | |
<testcase name="fn_node-name_0" class="xqfunctions:fn_node-name_0"/> | |
<testcase name="fn_node-name_1" class="xqfunctions:fn_node-name_1"/> | |
<testcase name="fn_normalize-space_0" class="xqfunctions:fn_normalize-space_0"/> | |
<testcase name="fn_normalize-space_1" class="xqfunctions:fn_normalize-space_1"/> | |
<testcase name="fn_normalize-unicode_1" class="xqfunctions:fn_normalize-unicode_1"/> | |
<testcase name="fn_normalize-unicode_2" class="xqfunctions:fn_normalize-unicode_2"/> | |
<testcase name="fn_not_1" class="xqfunctions:fn_not_1"/> | |
<testcase name="fn_number_0" class="xqfunctions:fn_number_0"/> | |
<testcase name="fn_number_1" class="xqfunctions:fn_number_1"/> | |
<testcase name="fn_one-or-more_1" class="xqfunctions:fn_one-or-more_1"/> | |
<testcase name="fn_outermost_1" class="xqfunctions:fn_outermost_1"/> | |
<testcase name="fn_parse-ietf-date_1" class="xqfunctions:fn_parse-ietf-date_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:parse-ietf-date() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_parse-json_1" class="xqfunctions:fn_parse-json_1"/> | |
<testcase name="fn_parse-json_2" class="xqfunctions:fn_parse-json_2"/> | |
<testcase name="fn_parse-xml-fragment_1" class="xqfunctions:fn_parse-xml-fragment_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">parse-xml-fragment#1 xs:string? document-node()?</failure> | |
<output>parse-xml-fragment#1 xs:string? element()*</output> | |
</testcase> | |
<testcase name="fn_parse-xml_1" class="xqfunctions:fn_parse-xml_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">parse-xml#1 xs:string? document-node(element(*))?</failure> | |
<output>parse-xml#1 xs:string? document-node()?</output> | |
</testcase> | |
<testcase name="fn_path_0" class="xqfunctions:fn_path_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:path() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_path_1" class="xqfunctions:fn_path_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:path() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_position_0" class="xqfunctions:fn_position_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">position#0 xs:integer</failure> | |
<output>position#0 xs:integer?</output> | |
</testcase> | |
<testcase name="fn_prefix-from-QName_1" class="xqfunctions:fn_prefix-from-QName_1"/> | |
<testcase name="fn_random-number-generator_0" class="xqfunctions:fn_random-number-generator_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:random-number-generator() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_random-number-generator_1" class="xqfunctions:fn_random-number-generator_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:random-number-generator() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_remove_2" class="xqfunctions:fn_remove_2"/> | |
<testcase name="fn_replace_3" class="xqfunctions:fn_replace_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">replace#3 xs:string? xs:string xs:string xs:string</failure> | |
<output>replace#3 xs:string? xs:string xs:string xs:string?</output> | |
</testcase> | |
<testcase name="fn_replace_4" class="xqfunctions:fn_replace_4"> | |
<failure message="assertEquals failed." type="failure-error-code-1">replace#4 xs:string? xs:string xs:string xs:string xs:string</failure> | |
<output>replace#4 xs:string? xs:string xs:string xs:string xs:string?</output> | |
</testcase> | |
<testcase name="fn_resolve-QName_2" class="xqfunctions:fn_resolve-QName_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">resolve-QName#2 xs:string? element() xs:QName?</failure> | |
<output>resolve-QName#2 xs:string? element() xs:QName</output> | |
</testcase> | |
<testcase name="fn_resolve-uri_1" class="xqfunctions:fn_resolve-uri_1"/> | |
<testcase name="fn_resolve-uri_2" class="xqfunctions:fn_resolve-uri_2"/> | |
<testcase name="fn_reverse_1" class="xqfunctions:fn_reverse_1"/> | |
<testcase name="fn_root_0" class="xqfunctions:fn_root_0"/> | |
<testcase name="fn_root_1" class="xqfunctions:fn_root_1"/> | |
<testcase name="fn_round-half-to-even_1" class="xqfunctions:fn_round-half-to-even_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">round-half-to-even#1 xs:numeric? xs:numeric?</failure> | |
<output>round-half-to-even#1 numeric? numeric</output> | |
</testcase> | |
<testcase name="fn_round-half-to-even_2" class="xqfunctions:fn_round-half-to-even_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">round-half-to-even#2 xs:numeric? xs:integer xs:numeric?</failure> | |
<output>round-half-to-even#2 numeric? numeric? numeric</output> | |
</testcase> | |
<testcase name="fn_round_1" class="xqfunctions:fn_round_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">round#1 xs:numeric? xs:numeric?</failure> | |
<output>round#1 numeric? numeric</output> | |
</testcase> | |
<testcase name="fn_round_2" class="xqfunctions:fn_round_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Unexpectedly received 2 parameter(s) in call to function 'fn:round()'. Defined function signatures are:
round($arg as numeric?) numeric
"/> | |
</testcase> | |
<testcase name="fn_seconds-from-dateTime_1" class="xqfunctions:fn_seconds-from-dateTime_1"/> | |
<testcase name="fn_seconds-from-duration_1" class="xqfunctions:fn_seconds-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">seconds-from-duration#1 xs:duration? xs:decimal?</failure> | |
<output>seconds-from-duration#1 xs:dayTimeDuration? xs:decimal?</output> | |
</testcase> | |
<testcase name="fn_seconds-from-time_1" class="xqfunctions:fn_seconds-from-time_1"/> | |
<testcase name="fn_serialize_1" class="xqfunctions:fn_serialize_1"/> | |
<testcase name="fn_serialize_2" class="xqfunctions:fn_serialize_2"/> | |
<testcase name="fn_sort_1" class="xqfunctions:fn_sort_1"/> | |
<testcase name="fn_sort_2" class="xqfunctions:fn_sort_2"/> | |
<testcase name="fn_sort_3" class="xqfunctions:fn_sort_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">sort#3 item()* xs:string? function(item()) as xs:anyAtomicType* item()*</failure> | |
<output>sort#3 item()* xs:string? function(*) item()*</output> | |
</testcase> | |
<testcase name="fn_starts-with_2" class="xqfunctions:fn_starts-with_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">starts-with#2 xs:string? xs:string? xs:boolean</failure> | |
<output>starts-with#2 xs:string? xs:string? xs:boolean?</output> | |
</testcase> | |
<testcase name="fn_starts-with_3" class="xqfunctions:fn_starts-with_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">starts-with#3 xs:string? xs:string? xs:string xs:boolean</failure> | |
<output>starts-with#3 xs:string? xs:string? xs:string xs:boolean?</output> | |
</testcase> | |
<testcase name="fn_static-base-uri_0" class="xqfunctions:fn_static-base-uri_0"/> | |
<testcase name="fn_string-join_1" class="xqfunctions:fn_string-join_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">string-join#1 xs:anyAtomicType* xs:string</failure> | |
<output>string-join#1 xs:string* xs:string</output> | |
</testcase> | |
<testcase name="fn_string-join_2" class="xqfunctions:fn_string-join_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">string-join#2 xs:anyAtomicType* xs:string xs:string</failure> | |
<output>string-join#2 xs:string* xs:string xs:string</output> | |
</testcase> | |
<testcase name="fn_string-length_0" class="xqfunctions:fn_string-length_0"> | |
<failure message="assertEquals failed." type="failure-error-code-1">string-length#0 xs:integer</failure> | |
<output>string-length#0 xs:integer?</output> | |
</testcase> | |
<testcase name="fn_string-length_1" class="xqfunctions:fn_string-length_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">string-length#1 xs:string? xs:integer</failure> | |
<output>string-length#1 xs:string? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_string-to-codepoints_1" class="xqfunctions:fn_string-to-codepoints_1"/> | |
<testcase name="fn_string_0" class="xqfunctions:fn_string_0"/> | |
<testcase name="fn_string_1" class="xqfunctions:fn_string_1"/> | |
<testcase name="fn_subsequence_2" class="xqfunctions:fn_subsequence_2"/> | |
<testcase name="fn_subsequence_3" class="xqfunctions:fn_subsequence_3"/> | |
<testcase name="fn_substring-after_2" class="xqfunctions:fn_substring-after_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring-after#2 xs:string? xs:string? xs:string</failure> | |
<output>substring-after#2 xs:string? xs:string? xs:string?</output> | |
</testcase> | |
<testcase name="fn_substring-after_3" class="xqfunctions:fn_substring-after_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring-after#3 xs:string? xs:string? xs:string xs:string</failure> | |
<output>substring-after#3 xs:string? xs:string? xs:string xs:string?</output> | |
</testcase> | |
<testcase name="fn_substring-before_2" class="xqfunctions:fn_substring-before_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring-before#2 xs:string? xs:string? xs:string</failure> | |
<output>substring-before#2 xs:string? xs:string? xs:string?</output> | |
</testcase> | |
<testcase name="fn_substring-before_3" class="xqfunctions:fn_substring-before_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring-before#3 xs:string? xs:string? xs:string xs:string</failure> | |
<output>substring-before#3 xs:string? xs:string? xs:string xs:string?</output> | |
</testcase> | |
<testcase name="fn_substring_2" class="xqfunctions:fn_substring_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring#2 xs:string? xs:double xs:string</failure> | |
<output>substring#2 xs:string? xs:double xs:string?</output> | |
</testcase> | |
<testcase name="fn_substring_3" class="xqfunctions:fn_substring_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">substring#3 xs:string? xs:double xs:double xs:string</failure> | |
<output>substring#3 xs:string? xs:double xs:double xs:string?</output> | |
</testcase> | |
<testcase name="fn_sum_1" class="xqfunctions:fn_sum_1"/> | |
<testcase name="fn_sum_2" class="xqfunctions:fn_sum_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">sum#2 xs:anyAtomicType* xs:anyAtomicType? xs:anyAtomicType?</failure> | |
<output>sum#2 xs:anyAtomicType* xs:anyAtomicType? xs:anyAtomicType</output> | |
</testcase> | |
<testcase name="fn_tail_1" class="xqfunctions:fn_tail_1"/> | |
<testcase name="fn_timezone-from-dateTime_1" class="xqfunctions:fn_timezone-from-dateTime_1"/> | |
<testcase name="fn_timezone-from-date_1" class="xqfunctions:fn_timezone-from-date_1"/> | |
<testcase name="fn_timezone-from-time_1" class="xqfunctions:fn_timezone-from-time_1"/> | |
<testcase name="fn_tokenize_1" class="xqfunctions:fn_tokenize_1"/> | |
<testcase name="fn_tokenize_2" class="xqfunctions:fn_tokenize_2"/> | |
<testcase name="fn_tokenize_3" class="xqfunctions:fn_tokenize_3"/> | |
<testcase name="fn_trace_1" class="xqfunctions:fn_trace_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Unexpectedly received 1 parameter(s) in call to function 'fn:trace()'. Defined function signatures are:
trace($value as item()*, $label as xs:string) item()*
"/> | |
</testcase> | |
<testcase name="fn_trace_2" class="xqfunctions:fn_trace_2"/> | |
<testcase name="fn_transform_1" class="xqfunctions:fn_transform_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:transform() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_translate_3" class="xqfunctions:fn_translate_3"/> | |
<testcase name="fn_true_0" class="xqfunctions:fn_true_0"/> | |
<testcase name="fn_unordered_1" class="xqfunctions:fn_unordered_1"/> | |
<testcase name="fn_unparsed-text-available_1" class="xqfunctions:fn_unparsed-text-available_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text-available() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_unparsed-text-available_2" class="xqfunctions:fn_unparsed-text-available_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text-available() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_unparsed-text-lines_1" class="xqfunctions:fn_unparsed-text-lines_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text-lines() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_unparsed-text-lines_2" class="xqfunctions:fn_unparsed-text-lines_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text-lines() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_unparsed-text_1" class="xqfunctions:fn_unparsed-text_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_unparsed-text_2" class="xqfunctions:fn_unparsed-text_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:unparsed-text() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_upper-case_1" class="xqfunctions:fn_upper-case_1"/> | |
<testcase name="fn_uri-collection_0" class="xqfunctions:fn_uri-collection_0"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:uri-collection() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_uri-collection_1" class="xqfunctions:fn_uri-collection_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:uri-collection() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_xml-to-json_1" class="xqfunctions:fn_xml-to-json_1"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:xml-to-json() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_xml-to-json_2" class="xqfunctions:fn_xml-to-json_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function fn:xml-to-json() is not defined in module namespace: http://www.w3.org/2005/xpath-functions"/> | |
</testcase> | |
<testcase name="fn_year-from-dateTime_1" class="xqfunctions:fn_year-from-dateTime_1"/> | |
<testcase name="fn_year-from-date_1" class="xqfunctions:fn_year-from-date_1"/> | |
<testcase name="fn_years-from-duration_1" class="xqfunctions:fn_years-from-duration_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">years-from-duration#1 xs:duration? xs:integer?</failure> | |
<output>years-from-duration#1 xs:yearMonthDuration? xs:integer?</output> | |
</testcase> | |
<testcase name="fn_zero-or-one_1" class="xqfunctions:fn_zero-or-one_1"/> | |
<testcase name="map_contains_2" class="xqfunctions:map_contains_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">contains#2 map(*) xs:anyAtomicType xs:boolean</failure> | |
<output>map:contains#2 map(*) xs:anyAtomicType xs:boolean</output> | |
</testcase> | |
<testcase name="map_entry_2" class="xqfunctions:map_entry_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">entry#2 xs:anyAtomicType item()* map(*)</failure> | |
<output>map:entry#2 xs:anyAtomicType item()* map(*)</output> | |
</testcase> | |
<testcase name="map_find_2" class="xqfunctions:map_find_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Function map:find() is not defined in module namespace: http://www.w3.org/2005/xpath-functions/map"/> | |
</testcase> | |
<testcase name="map_for-each_2" class="xqfunctions:map_for-each_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">for-each#2 map(*) function(xs:anyAtomicType, item()*) as item()* item()*</failure> | |
<output>map:for-each#2 map(*) function(*) item()*</output> | |
</testcase> | |
<testcase name="map_get_2" class="xqfunctions:map_get_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">get#2 map(*) xs:anyAtomicType item()*</failure> | |
<output>map:get#2 map(*) xs:anyAtomicType item()*</output> | |
</testcase> | |
<testcase name="map_keys_1" class="xqfunctions:map_keys_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">keys#1 map(*) xs:anyAtomicType*</failure> | |
<output>map:keys#1 map(*) xs:anyAtomicType*</output> | |
</testcase> | |
<testcase name="map_merge_1" class="xqfunctions:map_merge_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">merge#1 map(*)* map(*)</failure> | |
<output>map:merge#1 map(*)* map(*)</output> | |
</testcase> | |
<testcase name="map_merge_2" class="xqfunctions:map_merge_2"> | |
<error type="err:XPST0017" message="It is a static error if the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context. Unexpectedly received 2 parameter(s) in call to function 'map:merge()'. Defined function signatures are:
map:merge($maps as map(*)*) map(*)
"/> | |
</testcase> | |
<testcase name="map_put_3" class="xqfunctions:map_put_3"> | |
<failure message="assertEquals failed." type="failure-error-code-1">put#3 map(*) xs:anyAtomicType item()* map(*)</failure> | |
<output>map:put#3 map(*) xs:anyAtomicType item()* map(*)</output> | |
</testcase> | |
<testcase name="map_remove_2" class="xqfunctions:map_remove_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">remove#2 map(*) xs:anyAtomicType* map(*)</failure> | |
<output>map:remove#2 map(*) xs:string map(*)</output> | |
</testcase> | |
<testcase name="map_size_1" class="xqfunctions:map_size_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">size#1 map(*) xs:integer</failure> | |
<output>map:size#1 map(*) xs:integer</output> | |
</testcase> | |
<testcase name="math_acos_1" class="xqfunctions:math_acos_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">acos#1 xs:double? xs:double?</failure> | |
<output>acos#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_asin_1" class="xqfunctions:math_asin_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">asin#1 xs:double? xs:double?</failure> | |
<output>asin#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_atan2_2" class="xqfunctions:math_atan2_2"/> | |
<testcase name="math_atan_1" class="xqfunctions:math_atan_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">atan#1 xs:double? xs:double?</failure> | |
<output>atan#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_cos_1" class="xqfunctions:math_cos_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">cos#1 xs:double? xs:double?</failure> | |
<output>cos#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_exp10_1" class="xqfunctions:math_exp10_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">exp10#1 xs:double? xs:double?</failure> | |
<output>exp10#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_exp_1" class="xqfunctions:math_exp_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">exp#1 xs:double? xs:double?</failure> | |
<output>exp#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_log10_1" class="xqfunctions:math_log10_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">log10#1 xs:double? xs:double?</failure> | |
<output>log10#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_log_1" class="xqfunctions:math_log_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">log#1 xs:double? xs:double?</failure> | |
<output>log#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_pi_0" class="xqfunctions:math_pi_0"/> | |
<testcase name="math_pow_2" class="xqfunctions:math_pow_2"> | |
<failure message="assertEquals failed." type="failure-error-code-1">pow#2 xs:double? xs:numeric xs:double?</failure> | |
<output>pow#2 xs:double numeric xs:double</output> | |
</testcase> | |
<testcase name="math_sin_1" class="xqfunctions:math_sin_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">sin#1 xs:double? xs:double?</failure> | |
<output>sin#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_sqrt_1" class="xqfunctions:math_sqrt_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">sqrt#1 xs:double? xs:double?</failure> | |
<output>sqrt#1 xs:double xs:double</output> | |
</testcase> | |
<testcase name="math_tan_1" class="xqfunctions:math_tan_1"> | |
<failure message="assertEquals failed." type="failure-error-code-1">tan#1 xs:double? xs:double?</failure> | |
<output>tan#1 xs:double xs:double</output> | |
</testcase> | |
</testsuite> | |
</testsuites> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
273 tests are executed, there are 102 failures....
There are two types of issues:
math:tan#1
the cardinality is not OKfn:uri-collection#1"
functions are yet missing