A script to generate function-signature-tests for xquery functions in eXist-db

functionSignatureTests.xquery

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) 
}; 

generateFunctionSignatureTests.xquery

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)

results.xml

<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:&#xD;&#xA;document-uri($document-node as node()?) xs:anyURI?&#xD;&#xA;"/>
        </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:&#xD;&#xA;nilled($arg as node()?) xs:boolean?&#xD;&#xA;"/>
        </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:&#xD;&#xA;round($arg as numeric?) numeric&#xD;&#xA;"/>
        </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:&#xD;&#xA;trace($value as item()*, $label as xs:string) item()*&#xD;&#xA;"/>
        </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:&#xD;&#xA;map:merge($maps as map(*)*) map(*)&#xD;&#xA;"/>
        </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>

273 tests are executed, there are 102 failures....

There are two types of issues:

• in math:tan#1 the cardinality is not OK
• fn:uri-collection#1" functions are yet missing