Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/fots_driver 
into lp:zorba.

Commit message:
minor improvements + comments + cosmetic changes in fots_driver

Requested reviews:
  Markos Zaharioudakis (markos-za)
Related bugs:
  Bug #918156 in Zorba: "fots driver for Zorba"
  https://bugs.launchpad.net/zorba/+bug/918156
  Bug #956460 in Zorba: "Zorba FOTS driver: assert-serialization aka assert-xml 
bug"
  https://bugs.launchpad.net/zorba/+bug/956460
  Bug #967173 in Zorba: "Zorba FOTS driver: assert-any-of bug"
  https://bugs.launchpad.net/zorba/+bug/967173
  Bug #973410 in Zorba: "Zorba FOTS driver: assert-deep-eq bug"
  https://bugs.launchpad.net/zorba/+bug/973410
  Bug #973412 in Zorba: "Zorba FOTS driver: assert-permutation bug"
  https://bugs.launchpad.net/zorba/+bug/973412
  Bug #973416 in Zorba: "Zorba FOTS driver: assert-assert bug"
  https://bugs.launchpad.net/zorba/+bug/973416
  Bug #973417 in Zorba: "Zorba FOTS driver: assert-serialization-error bug"
  https://bugs.launchpad.net/zorba/+bug/973417
  Bug #973434 in Zorba: "Zorba FOTS driver: assert-error bug"
  https://bugs.launchpad.net/zorba/+bug/973434
  Bug #1017386 in Zorba: "Zorba FOTS driver: improve debugging support"
  https://bugs.launchpad.net/zorba/+bug/1017386
  Bug #1017389 in Zorba: "Zorba FOTS driver: improve statistics reporting"
  https://bugs.launchpad.net/zorba/+bug/1017389
  Bug #1052856 in Zorba: "URI resolvers in Zorba FOTS driver"
  https://bugs.launchpad.net/zorba/+bug/1052856
  Bug #1079033 in Zorba: "FOTS: correct misleading name for param for FOTS 
driver"
  https://bugs.launchpad.net/zorba/+bug/1079033

For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/fots_driver/+merge/144209

minor improvements + comments + cosmetic changes in fots_driver
-- 
https://code.launchpad.net/~zorba-coders/zorba/fots_driver/+merge/144209
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'test/fots_driver/cli.xq'
--- test/fots_driver/cli.xq	2012-12-12 08:18:55 +0000
+++ test/fots_driver/cli.xq	2013-01-22 03:57:22 +0000
@@ -21,60 +21,137 @@
 
 import module namespace d =
   "http://www.zorba-xquery.com/fots-driver"; at "fots-driver.xq";
+
 import module namespace r =
   "http://www.zorba-xquery.com/fots-driver/reporting"; at "reporting.xq";
 
-(:~ path to the place where FOTS can be found :)
+
+(:~
+  Path to the FOTS catalog.xml file. If the path is relative, it will be 
+  resolved relative to the directory containing this cli.xq file.
+:)
 declare variable $fotsPath as xs:string external := "";
 
-(:~ path to the place where the FOTS Zorba manifest can be found :)
+
+(:~ 
+  Path to the FOTSZorbaManifest.xml file. If the path is relative, it will be
+  resolved relative to the diractory containing this cli.xq file
+:)
 declare variable $fotsZorbaManifestPath as xs:string external :=
   "FOTSZorbaManifest.xml";
 
-(:~ Path to the results from a previous run :)
+
+(:~
+  Path to the results from a previous run. Used when we just want to generate
+  a report based on some previous run, i.e., without running the tests again. 
+:)
 declare variable $failuresFilePath as xs:string external := "";
 
-(:~ choose the CLI option you want to run :)
+
+(:~
+  Path to the ExpectedFailures file.
+:)
+declare variable $expectedFailuresPath  as xs:string external :="";
+
+
+(:~ 
+  The CLI command you want to run.
+:)
 declare variable $mode as xs:string external := "";
 
-(:~ name/criteria for the test sets :)
+
+(:~ 
+  A list of comma-seperated prefixes. Only test-sets whose name starts with
+  a prefix in this list are going to be proccesed. An empty string means no
+  filtering of test-sets.
+:)
 declare variable $testSetPrefixes as xs:string external := "";
 
-(:~ name/criteria for the test cases :)
+
+(:~ 
+  A list of comma-seperated prefixes. Only test-cases whose name starts with
+  a prefix in this list are going to be proccesed. An empty string means no
+  filtering of test-cases.
+:)
 declare variable $testCasePrefixes as xs:string external := "";
 
-(:~ name for the test set :)
+
+(:~
+ : Name of the test-set containing a test-case to process. Used only for the
+ : "run-test-case" command.
+:)
 declare variable $testSetName as xs:string external := "";
 
-(:~ name for the test case :)
+
+(:~ 
+ : Name of the test-case to process. Used only for the "run-test-case" command.
+:)
 declare variable $testCaseName as xs:string external := "";
 
-(:~ Enable or disable verbose output :)
-declare variable $verbose as xs:string external := "true";
-
-(:~ assertion type :)
-declare variable $assertType as xs:string external := "";
-
-(:~ dependency: used in 'list-test-cases' and 'run-test-sets' modes:)
+
+(:~ 
+  A dependency used in the 'list-test-cases' and 'run-test-sets' commands to
+  filter the test-cases that will actually be listed/run. Only test-cases whose
+  applicable dependencies contain at least one dependency the matches this
+  user-specified dependency will be processed. The filtering dependency is
+  given as a string of the form "depValue_depSatisfied" (for example, 
+  "XQ30+_true"), or just "depValue" (in which case "true" is assumed as the
+  value of the satisfied attribute). If $dependency is set to the empty string,
+  no filtering is done.
+:)
 declare variable $dependency as xs:string external := "";
 
-(:~ regex for the tests in the 'list-matching-test-cases' option :)
+
+(:~ 
+  List of assertion types used in the 'list-test-cases' and 'run-test-sets'
+  commands to filter the test-cases that will actually be listed/run. A test
+  case qualifies if there is at least one element node under the <result>
+  node of the <test-case> whose local name is equal to one of the strings
+  in the filtering set. If $assrtType is set to the empty sequence, no
+  filtering is done.
+:)
+declare variable $assertType as xs:string* external := ();
+
+
+(:~ 
+  Regex to be used by the 'list-matching-test-cases' command.  
+:)
 declare variable $pattern as xs:string external := "";
 
-(:~ flags for the tests in the 'list-matching-test-cases' option :)
+
+(:~ 
+  Flags to be used by the 'list-matching-test-cases' command.
+:)
 declare variable $flags as xs:string external := "";
 
-(:~ Path to the ExpectedFailures file :)
-declare variable $expectedFailuresPath  as xs:string external :="";
-
-(:~ Tokenize comma or empty string :)
-declare %private function local:tokenize(
-  $input as xs:string
-) as xs:string*
-{
-  let $tokens := tokenize($input, ",")
-  return if (exists($tokens)) then $tokens else ""
-};
+
+(:~
+  The test cases in this list have bugs assigned and should not be run.
+:)
+declare variable $exceptedTestCases := (
+  "cbcl-subsequence-011",
+  "cbcl-subsequence-012",
+  "cbcl-subsequence-013",
+  "cbcl-subsequence-014"        (:see bug lp:1069794 :)
+, "re00975",
+  "re00976",
+  "re00976a"                    (:see bug lp:1070533 :)
+, "fn-unparsed-text-lines-052"  (:see bug lp:1073175 :)
+);
+
+
+(:~
+  The test in this list have bugs assigned already and should not be run
+:)
+declare variable $exceptedTestSets := ();
+
+
+(:~ 
+  Enable or disable verbose output 
+:)
+declare variable $verbose as xs:string external := "true";
+
+
 
 declare function local:usage() as xs:string
 {
@@ -109,88 +186,113 @@
     ), "&#xA;")
 };
 
-(:~ The test cases in this list have bugs assigned and should not be run :)
-variable $exceptedTestCases := (
-"cbcl-subsequence-011", "cbcl-subsequence-012", "cbcl-subsequence-013",
-"cbcl-subsequence-014"                                  (:see bug lp:1069794 :)
-, "re00975", "re00976", "re00976a"                      (:see bug lp:1070533 :)
-, "fn-unparsed-text-lines-052"                          (:see bug lp:1073175 :)
-);
-
-(:~  The test in this list have bugs assigned already and should not be run :)
-variable $exceptedTestSets := ();
+
+(:~
+  Tokenize comma or empty string
+:)
+declare %private function local:tokenize(
+  $input as xs:string
+) as xs:string*
+{
+  tokenize($input, ",")
+};
+
+
+variable $fotsPathMsg := "The path to FOTS catalog.xml was set to: ";
+
+variable $testSetPrefixesMsg := "'testSetPrefixes' was set to: ";
+
+variable $testCasePrefixesMsg := "'testCasePrefixes' was set to: ";
+
 
 switch ($mode)
+
 case "list-test-sets"
-  return
-    string-join(
-      (d:list-test-sets(
-        trace($fotsPath, "Path to FOTS catalog.xml set to: "),
-        local:tokenize(trace($testSetPrefixes, "'testSetPrefixes' set to: ")))),
-       "&#xA;")
+return
+  string-join
+  (
+  (
+    d:list-test-sets(trace($fotsPath, $fotsPathMsg),
+                     local:tokenize(trace($testSetPrefixes, $testSetPrefixesMsg)))
+  ),
+  "&#xA;"
+  )
+
 case "list-test-cases"
-  return
-    string-join(
-      (d:list-test-cases( trace($fotsPath,
-                                "Path to FOTS catalog.xml set to: "),
-                          local:tokenize(trace($testSetPrefixes,
-                                          "'testSetPrefixes' set to: ")),
-                          "",
-                          trace($dependency,
-                                "'dependency' set to:"),
-                          trace($assertType,
-                                "'assertType' set to: "))),
-               "&#xA;")
+return
+  string-join
+  (
+  (
+    d:list-test-cases(trace($fotsPath, $fotsPathMsg),
+                      local:tokenize(trace($testSetPrefixes, $testSetPrefixesMsg)),
+                      trace($dependency, "'dependency' set to:"),
+                      trace($assertType, "'assertType' set to: "))
+  ),
+  "&#xA;"
+  )
+
 case "list-matching-test-cases"
-  return string-join((d:list-matching-test-cases(
-                            trace($fotsPath,
-                                  "Path to FOTS catalog.xml set to: "),
-                            trace($pattern,
-                                  "pattern set to: "),
-                            trace($flags,
-                                  "flags were set to: ")), ""),
-                     "&#xA;")
+return 
+  string-join
+  (
+  (
+    d:list-matching-test-cases(trace($fotsPath, $fotsPathMsg),
+                               trace($pattern, "pattern set to: "),
+                               trace($flags, "flags were set to: ")), ""
+  ),
+  "&#xA;"
+  )
+
 case "run-test-sets"
-  return d:run-fots($fotsPath,
-                    $fotsZorbaManifestPath,
-                    d:list-test-sets($fotsPath,
-                                     local:tokenize(trace($testSetPrefixes,
-                                       "'testSetPrefixes' set to: "))),
-                    d:list-test-cases($fotsPath,
-                                      local:tokenize($testSetPrefixes),
-                                      local:tokenize(trace($testCasePrefixes,
-                                        "'testCasePrefixes' set to: ")),
-                                      trace($dependency,
-                                        "'dependency' set to:"),
-                                      trace($assertType,
-                                         "'assertType' set to: ")),
-                    $exceptedTestCases,
-                    $exceptedTestSets,
-                    xs:boolean($verbose),
-                    $expectedFailuresPath)
+return 
+  d:run-fots($fotsPath,
+             $fotsZorbaManifestPath,
+             d:list-test-sets($fotsPath,
+                              local:tokenize(trace($testSetPrefixes,
+                                                   $testSetPrefixesMsg))),
+             d:list-test-cases($fotsPath,
+                               local:tokenize($testSetPrefixes),
+                               local:tokenize(trace($testCasePrefixes,
+                                                    $testCasePrefixesMsg)),
+                               trace($dependency, "'dependency' set to:"),
+                               trace($assertType, "'assertType' set to: ")),
+             $exceptedTestCases,
+             $exceptedTestSets,
+             xs:boolean($verbose),
+             $expectedFailuresPath)
+
 case "run-test-case"
-  return d:run-fots($fotsPath,
-                    $fotsZorbaManifestPath,
-                    trace($testSetName, "'testSetName' set to: "),
-                    trace($testCaseName,"'testCaseName' set to: "),
-                    $exceptedTestCases,
-                    $exceptedTestSets,
-                    xs:boolean($verbose),
-                    $expectedFailuresPath)
+return 
+  d:run-fots($fotsPath,
+             $fotsZorbaManifestPath,
+             trace($testSetName, "'testSetName' set to: "),
+             trace($testCaseName,"'testCaseName' set to: "),
+             $exceptedTestCases,
+             $exceptedTestSets,
+             xs:boolean($verbose),
+             $expectedFailuresPath)
+
 case "run-and-report"
-  return r:run-and-report($fotsPath,
-                          $fotsZorbaManifestPath,
-                          $exceptedTestCases,
-                          $exceptedTestSets,
+return 
+  r:run-and-report($fotsPath,
+                   $fotsZorbaManifestPath,
+                   $exceptedTestCases,
+                   $exceptedTestSets,
         (: the reports to W3C are always generated with verbose set to false:)
-                          fn:false())
+                   fn:false())
+
 case "report"
-  return r:report($fotsPath,
-                  $failuresFilePath,
-                  $exceptedTestCases,
-                  $exceptedTestSets,
-                  xs:boolean($verbose))
+return
+  r:report($fotsPath,
+           $failuresFilePath,
+           $exceptedTestCases,
+           $exceptedTestSets,
+           xs:boolean($verbose))
+
 case "generate-expected-failures"
-  return r:generate-expected-failures($failuresFilePath)
+return
+  r:generate-expected-failures($failuresFilePath)
+
 default
-  return local:usage()
+return
+  local:usage()

=== modified file 'test/fots_driver/fots-driver.xq'
--- test/fots_driver/fots-driver.xq	2012-12-21 13:28:10 +0000
+++ test/fots_driver/fots-driver.xq	2013-01-22 03:57:22 +0000
@@ -27,23 +27,29 @@
 
 import module namespace xqxq =
   "http://www.zorba-xquery.com/modules/xqxq";;
+
 import module namespace datetime  =
   "http://www.zorba-xquery.com/modules/datetime";;
 
 import module namespace eval =
   "http://www.zorba-xquery.com/fots-driver/evaluate"; at "evaluate.xq";
+
 import module namespace feedback =
   "http://www.zorba-xquery.com/fots-driver/feedback"; at "feedback.xq";
+
 import module namespace env =
   "http://www.zorba-xquery.com/fots-driver/environment"; at "environment.xq";
+
 import module namespace util =
   "http://www.zorba-xquery.com/fots-driver/util"; at "util.xq";
+
 import module namespace fots-err =
   "http://www.zorba-xquery.com/fots-driver/errors"; at "errors.xq";
 
 
 declare namespace err =
   "http://www.w3.org/2005/xqt-errors";;
+
 declare namespace fots =
   "http://www.w3.org/2010/09/qt-fots-catalog";;
 
@@ -51,186 +57,265 @@
   "http://www.zorba-xquery.com/annotations";;
 
 (:~
- : Loops through the FOTS catalog and returns all available test set names.
+ : Returns the names of all qualifying test sets.
+ :
+ : A test set qualifies if its name starts with one of the prefixes listed in
+ : $testSetPrefixes. If $testSetPrefixes is the empty sequence, then all test
+ : sets qualify.
+ :
  : @param $fotsPath path to the FOTS catalog file.
- : @param $testSetPrefixes name/criteria for the test sets
- : (empty string means all).
- : @return available FOTS test sets.
+ : @param $testSetPrefixes name criteria for the test sets
+ :        (empty sequence means all).
+ : @return names of qualifying FOTS test sets.
  :)
 declare %ann:nondeterministic function driver:list-test-sets(
   $fotsPath         as xs:string,
   $testSetPrefixes  as xs:string*
-) as xs:string* {
-  let $doc := doc(resolve-uri($fotsPath))
-  return
-    if(string-join($testSetPrefixes,'') = '')
-    then
-      for $testSet in $doc/fots:catalog/fots:test-set
-      return data($testSet/@name)
-    else
-      for $prefix in $testSetPrefixes
-        for $testSet in $doc/fots:catalog/fots:test-set[starts-with(@name, $prefix)]
-        return data($testSet/@name)
-};
-
+) as xs:string*
+{
+  let $doc := doc(resolve-uri($fotsPath))
+  return
+    if (empty($testSetPrefixes))
+    then
+      for $testSet in $doc/fots:catalog/fots:test-set
+      return data($testSet/@name)
+    else
+      for $prefix in $testSetPrefixes
+      for $testSet in $doc/fots:catalog/fots:test-set[starts-with(@name, $prefix)]
+      return data($testSet/@name)
+};
+
+
+(:~
+ : Returns the names of all qualifying test cases.
+ :
+ : A test case qualifies if (a) it belongs to a qualifing test set, and (b)
+ : its applicable dependencies include a user-provided dependency, or no
+ : dependency was provided by the user, and (c) its expected-result assertions
+ : include at least one of the assertions in a user-provided set of assertions,
+ : or no expected-result assertions were provided by the user.
+ :
+ : A test set qualifies if its name starts with one of the prefixes listed in
+ : $testSetPrefixes. If $testSetPrefixes is the empty sequence, then all test
+ : sets qualify.
+ :
+ : The filtering dependency is given as a string, which may be empty (signifying
+ : no dependency) or of the form "depValue_depSatisfied" (e.g., "XQ30+_true"),
+ : or just "depValue" (in which case "true" is assumed as the value of the
+ : satisfied attribute). A test-case qualifies if it has at least one dependency
+ : whose @value and @satisfied attributes are equal to the filtering depValue
+ : and depSatisfied. 
+ :
+ : A filtering set of assertions is given as a sequence of strings. A test-case
+ : qualifies if there is at least one element node under the <result> node of
+ : the <test-case> whose local name is equal to one of the strings in the 
+ : filtering set. 
+ :
+ : @param $fotsPath path to the FOTS catalog file.
+ : @param $testSetPrefixes name criteria for the test sets
+ :        (empty sequence means all test sets).
+ : @param $dependency dependency used to filter test-cases.
+ :        (empty string means no filtering).
+ : @param $assert set of expected-result assertions used to filter test-cases.
+ :        (empty sequence means no filtering).
+ : @return names of qualifying FOTS test cases.
+ :)
+declare %ann:nondeterministic function driver:list-test-cases(
+  $fotsPath         as xs:string,
+  $testSetPrefixes  as xs:string*,
+  $dependency       as xs:string,
+  $assert           as xs:string*
+) as xs:string*
+{
+  let $doc := doc(resolve-uri($fotsPath))
+  let $baseUri:= resolve-uri(util:parent-folder($fotsPath))
+  return
+    if (empty($testSetPrefixes))
+    then
+      for $testSet in $doc/fots:catalog/fots:test-set
+      let $testSetDoc := doc(resolve-uri($testSet/@file, $baseUri))
+      return driver:list-test-cases($testSetDoc, $dependency, $assert)
+    else
+      for $prefix in $testSetPrefixes
+      for $testSet in $doc/fots:catalog/fots:test-set[starts-with(@name, $prefix)]
+      let $testSetDoc := doc(resolve-uri($testSet/@file, $baseUri))
+      return driver:list-test-cases($testSetDoc, $dependency, $assert)
+};
+
+
+(:~
+ : Returns the names of all qualifying test cases.
+ :
+ : This function is similar to the driver:list-test-cases() defined above. It 
+ : just adds the following condition to the list of condition that must be
+ : satisfied by each qualifying test case: (d) its name starts with one of the
+ : prefixes in $testCasePrefixes, or $testCasePrefixes is the empty sequence.
+ :
+ : @param $fotsPath path to the FOTS catalog file.
+ : @param $testSetPrefixes name criteria for the test sets
+ :        (empty sequence means all test sets).
+ : @param $testCasePrefixes name criteria for the test cases
+ :        (empty sequence means all test cases).
+ : @param $dependency dependency used to filter test-cases.
+ :        (empty string means no filtering).
+ : @param $assert set of expected-result assertions used to filter test-cases.
+ :        (empty sequence means no filtering).
+ : @return names of qualifying FOTS test cases.
+ :)
+declare %ann:nondeterministic function driver:list-test-cases(
+  $fotsPath         as xs:string,
+  $testSetPrefixes  as xs:string*,
+  $testCasePrefixes as xs:string*,
+  $dependency       as xs:string ,
+  $assert           as xs:string*
+) as xs:string* 
+{
+  let $doc := doc(resolve-uri($fotsPath))
+  let $baseUri:= resolve-uri(util:parent-folder($fotsPath))
+  let $testCaseNames := driver:list-test-cases($fotsPath,
+                                               $testSetPrefixes,
+                                               $dependency,
+                                               $assert)
+  return
+    if (empty($testCasePrefixes)) then
+      $testCaseNames
+    else
+      for $prefix in $testCasePrefixes
+      return
+        for $name in $testCaseNames
+        where starts-with($name, $prefix)
+        return $name
+};
+
+
+(:~
+ : Helper function. Returns the names of all qualifying test cases within a
+ : given test set. A test case qualifies if (a) its applicable dependencies
+ : include a user-provided dependency, or no dependency was provided by the
+ : user, and (b) its expected-result assertions include at least one of the
+ : assertions in a user-provided set of assertions, or no expected-result
+ : assertions were provided b the user.
+ :
+ : @param $testSetDoc root node of the xml document the specifies the test set.
+ : @param $dependency dependency used to filter test-cases.
+ :        (empty string means no filtering).
+ : @param $assert set of expected-result assertions used to filter test-cases.
+ :        (empty sequence means no filtering).
+ : @return names of qualifying FOTS test cases.
+ :)
+declare %private function driver:list-test-cases(
+  $testSetDoc as document-node(),
+  $dependency as xs:string,
+  $assert     as xs:string*
+) as xs:string*
+{
+  if ($dependency eq '' and empty($assert)) then 
+  {
+    $testSetDoc//fots:test-case/@name
+  }
+  else if ($dependency eq '') then
+  {
+    for $testCase in $testSetDoc//fots:test-case
+    where functx:value-intersect(driver:list-assertions($testCase), $assert)
+    return $testCase/@name
+  }
+  else
+  {
+    for $testCase in $testSetDoc//fots:test-case
+
+    where 
+      driver:matches-dependency(($testSetDoc/fots:test-set/fots:dependency,
+                                 $testCase/fots:dependency),
+                                $dependency)
+      and
+      (empty($assert) or
+       functx:value-intersect(driver:list-assertions($testCase), $assert))
+
+    return $testCase/@name
+  }
+};
+
+
+(:~
+ : Helper function to check whether a user-specified dependency (given as an
+ : encoded string) "matches" at least one of the dependencies in a given list
+ : of dependecies (given as a sequence of <dependency> elements)
+ :)
 declare %private function driver:matches-dependency(
   $dependencies as element(fots:dependency)*,
   $filter       as xs:string
-) as xs:boolean {
-  let $filter := tokenize($filter, '_')
-  let $depValue := $filter[1]
-  let $depSatisfied as xs:string := if(exists($filter[2]) and
-                                    ($filter[2] = 'true' or $filter[2]='false'))
-                                    then $filter[2]
-                                    else 'true'
-  return
-    if(xs:boolean($depSatisfied))
-
-    (: $depSatisfied = 'true' :)
-    then (exists($dependencies[@value = $depValue and
-                               @satisfied = $depSatisfied]) or
-          exists($dependencies[@value = $depValue and empty(@satisfied)]))
-
-    (: $depSatisfied = 'false' :)
-    else  exists($dependencies[@value = $depValue and
-                               @satisfied = $depSatisfied])
+) as xs:boolean
+{
+  if ($filter eq '')
+  then
+    fn:true()
+  else
+    let $filter := tokenize($filter, '_')
+    let $depValue := $filter[1]
+    let $depSatisfied := if ($filter[2] eq 'true' or $filter[2] eq 'false')
+                         then $filter[2]
+                         else 'true'
+    return
+      if ($depSatisfied)
+      then
+        $dependencies[@value eq $depValue and @satisfied eq $depSatisfied] or
+        $dependencies[@value eq $depValue and empty(@satisfied)]
+      else
+        $dependencies[@value eq $depValue and @satisfied eq $depSatisfied]
 };
 
+
+(:~
+ : Helper function to return the local names of all the nodes under a <result>
+ : child of a given <test-case>.
+ :)
 declare %private function driver:list-assertions(
   $case as element(fots:test-case)
-) as xs:string* {
+) as xs:string*
+{
   distinct-values(for $assert in $case/fots:result/descendant-or-self::*
                   return local-name-from-QName(node-name($assert)))
 };
 
-(:~
- : Loops through the given test set and returns the test cases that have the
- : given dependencies defined.
- : @param $testSet test set document.
- : @param $dependency defined dependency
- : (empty string means all test cases).
- : @param $assert lists of tests that contain a certain assert-type(empty
- : string means all tests).
- : @return matching test case names.
- :)
-declare %private function driver:list-test-cases(
-  $testSetDoc as document-node(),
-  $dependency as xs:string*,
-  $assert     as xs:string*
-) as xs:string* {
-  if(string-join($dependency,'') = '')
-  then $testSetDoc//fots:test-case/@name
-  else  for $testCase in $testSetDoc//fots:test-case
-        let $matchDep := driver:matches-dependency(($testSetDoc/fots:test-set/fots:dependency,
-                                                $testCase/fots:dependency),
-                                               $dependency)
-        let $matchAssert := (($assert = '') or
-                              exists(functx:value-intersect(
-                                      driver:list-assertions($testCase),
-                                                             $assert)))
-        where ($matchDep and $matchAssert)
-        return $testCase/@name
-  
-};
-
-(:~
- : Loops through the given test sets and returns the corresponding test cases.
- : @param $fotsPath path to the FOTS catalog file.
- : @param $testSetPrefixes name/criteria for the test sets
- : (empty string means all test cases).
- : @param $dependency type of dependency that has to be met
- : (empty string means all test cases).
- : @param $assert lists of tests that contain a certain assert-type(empty
- : string means all tests).
- : @return available FOTS test cases.
- :)
-declare %ann:nondeterministic function driver:list-test-cases(
-  $fotsPath         as xs:string,
-  $testSetPrefixes  as xs:string*,
-  $dependency       as xs:string*,
-  $assert           as xs:string*
-) as xs:string* {
-  let $doc := doc(resolve-uri($fotsPath)),
-      $baseUri:= resolve-uri(util:parent-folder($fotsPath))
-  return
-    if(string-join($testSetPrefixes,'') = '')
-    then
-      for $testSet in $doc/fots:catalog/fots:test-set
-      let $testSetDoc := doc(resolve-uri($testSet/@file, $baseUri))
-      return driver:list-test-cases($testSetDoc, $dependency, $assert)
-    else
-      for $prefix in $testSetPrefixes
-        for $testSet in $doc/fots:catalog/fots:test-set[starts-with(@name, $prefix)]
-        let $testSetDoc := doc(resolve-uri($testSet/@file, $baseUri))
-        return driver:list-test-cases($testSetDoc, $dependency, $assert)
-};
-
-(:~
- : Loops through the given test sets and returns the corresponding test cases.
- : @param $fotsPath path to the FOTS catalog file.
- : @param $testSetPrefixes name/criteria for the test sets
- : (empty string means all test cases).
- : @param $testCasePrefixes name/criteria for the test cases
- : (empty string means all test cases).
- : @param $dependency type of dependency that has to be met
- : (empty string means all test cases).
- : @param $assert lists of tests that contain a certain assert-type(empty
- : string means all tests).
- : @return available FOTS test cases.
- :)
-declare %ann:nondeterministic function driver:list-test-cases(
-  $fotsPath         as xs:string,
-  $testSetPrefixes  as xs:string*,
-  $testCasePrefixes as xs:string*,
-  $dependency       as xs:string*,
-  $assert           as xs:string*
-) as xs:string* {
-  let $doc := doc(resolve-uri($fotsPath)),
-      $baseUri:= resolve-uri(util:parent-folder($fotsPath)),
-      $testCaseNames := driver:list-test-cases($fotsPath,
-                                               $testSetPrefixes,
-                                               $dependency,
-                                               $assert)
-  return
-    for $prefix in $testCasePrefixes
-    return
-      for $name in $testCaseNames
-      where starts-with($name,
-                        $prefix)
-      return $name
-};
-
-(:~
- : Loops through all the test cases and returns those that have a 'test' node
- : that matches given pattern using given flags.
+
+(:~
+ : For each qualifying test case, this functions returns its name and the full
+ : filepath of its associated test-set file..
+ :
+ : A test case qualifies if its <test> node (which contains the query text) 
+ : matches the given pattern using given flags.
+ :
  : @param $fotsPath path to the FOTS catalog file.
  : @param $pattern pattern.
  : @param $flags flags.
- : @return available FOTS test cases matching given pattern and flags.
+ : @return names of qualifying FOTS test case and the filepaths of their
+ :         containing test-set files.
  :)
 declare %ann:nondeterministic function driver:list-matching-test-cases(
   $fotsPath as xs:string,
   $pattern  as xs:string,
   $flags    as xs:string?
-) as xs:string* {
-  let $doc := doc(resolve-uri($fotsPath)),
-      $baseUri:= resolve-uri(util:parent-folder($fotsPath))
+) as xs:string*
+{
+  let $doc := doc(resolve-uri($fotsPath))
+  let $baseUri:= resolve-uri(util:parent-folder($fotsPath))
   return
     for $testSet in $doc/fots:catalog/fots:test-set
-    let $uri := resolve-uri($testSet/@file, $baseUri),
-        $testSetDoc := doc($uri)
-      for $testCase in $testSetDoc//fots:test-case
-      where matches(util:get-value($testCase, 
-                                  util:parent-folder($uri),
-                                  "test"),
-                   $pattern,
-                   $flags)
-      return
-        concat(resolve-uri($testSet/@file, $baseUri),
-              ", test name:",
-              data($testCase/@name))
+    let $uri := resolve-uri($testSet/@file, $baseUri)
+    let $testSetDoc := doc($uri)
+    for $testCase in $testSetDoc//fots:test-case
+    where matches(util:get-value($testCase, 
+                                 util:parent-folder($uri),
+                                 "test"),
+                  $pattern,
+                  $flags)
+    return
+      concat(resolve-uri($testSet/@file, $baseUri),
+             ", test name:",
+             data($testCase/@name))
 };
 
+
 (:~
  : Loops through the FOTS catalog and evaluates all test cases that have
  : a certain assert-type.
@@ -257,8 +342,10 @@
   $exceptedTestSets       as xs:string*,
   $verbose                as xs:boolean,
   $expectedFailuresPath   as xs:string
-) as element(fots:test-cases) {
-  try {
+) as element(fots:test-cases)
+{
+  try
+  {
   let $FOTSCatalog := doc(trace(resolve-uri($FOTSCatalogFilePath), 
                               "Path to FOTS catalog.xml set to: ")),
       $FOTSZorbaManifest := doc(trace(resolve-uri($FOTSZorbaManifestPath),
@@ -277,7 +364,8 @@
                     trace($verbose,         "'Verbose' parameter set to: "),
                     $expectedFailures)
   }
-  catch * {
+  catch * 
+  {
     error($err:code,
           concat("&#xA;Please make sure the passed 'fotsPath' points to the",
                  " exact location of the FOTS catalog.xml:&#xA;",
@@ -291,6 +379,7 @@
   }
 };
 
+
 (:~
  : Loops through the FOTS catalog and evaluates all test cases
  :
@@ -317,7 +406,8 @@
   $exceptedTestSets   as xs:string*,
   $verbose            as xs:boolean,
   $expectedFailures   as document-node()?
-) as element(fots:test-cases) {
+) as element(fots:test-cases)
+{
     <fots:test-cases>{
       let $catalogTestSetNames := $FOTSCatalog//fots:test-set/@name,
           $testSetNames :=  if ($testSetNames = '')
@@ -418,6 +508,7 @@
     }</fots:test-cases>
 };
 
+
 (:~
  : Creates the complete query that will be evaluated by adding the necessary
  : XQXQ URL resolvers.
@@ -435,7 +526,8 @@
   $env            as element(fots:environment)?,
   $envBaseURI     as xs:anyURI?,
   $testSetBaseURI as xs:anyURI
-) as xs:string {
+) as xs:string
+{
   let $resolver as xs:string? := env:resolver($case,
                                               $env,
                                               $envBaseURI,
@@ -465,6 +557,7 @@
   "&#xA;")
 };
 
+
 (:~
  : XQXQ invoke.
  : @param $xqxqQueryText the query that will be run.
@@ -478,7 +571,8 @@
   $case           as element(fots:test-case),
   $verbose        as xs:boolean?,
   $testSetBaseURI as xs:anyURI
-) {
+)
+{
   try {
     {
       variable $queryKey := xqxq:prepare-main-module($xqxqQueryText);

=== modified file 'test/fots_driver/util.xq'
--- test/fots_driver/util.xq	2012-11-14 14:02:58 +0000
+++ test/fots_driver/util.xq	2013-01-22 03:57:22 +0000
@@ -33,6 +33,7 @@
 
 declare namespace err =
   "http://www.w3.org/2005/xqt-errors";;
+
 declare namespace fots =
   "http://www.w3.org/2010/09/qt-fots-catalog";;
 
@@ -59,61 +60,73 @@
     <output:indent                value="yes"  />
     <output:omit-xml-declaration  value="no" />
   </output:serialization-parameters>;
-  
+
+
 (:~
- : Retrieve the value of from the given node that is either given as text node
- : or in a file attribute.
+ : Search within a given test-case for all element nodes with a given node name.
+ : For each such element node return:
+ : (a) if the node has a @file attr, the content of that file as unparsed text,
+ : or
+ : (b) the typed value of the node (assuming it is promotable to string).
  :
  : @param $case test-case element.
- : @param $path the path of the test-set.
+ : @param $node-name
+ : @param $envBaseURI
  : @return the query text.
  :)
 declare %ann:nondeterministic function util:get-value(
   $case       as element(fots:test-case),
   $envBaseURI as xs:anyURI,
   $node-name  as xs:string
-) as xs:string {
-  try {
+) as xs:string
+{
+  try
+  {
     for $node in $case/descendant-or-self::*
-    where (fn:local-name-from-QName(fn:node-name($node)) = $node-name)
+    where (fn:local-name-from-QName(fn:node-name($node)) eq $node-name)
     return
-      if(exists($node/@file))
+      if ($node/@file)
       then fn:unparsed-text(resolve-uri($node/@file, $envBaseURI))
       else fn:data($node)
-  } catch * {
+  }
+  catch *
+  {
     fn:error($fots-err:errNA, $err:description)
   }
 };
 
+
 (:~
- :  returns the parent folder of the given file path.
- :   example: util:parent-folder('/home/user/file.ext') returns '/home/user'.
+ :  Returns the parent folder of the given file path.
+ :  example: util:parent-folder('/home/user/file.ext') returns '/home/user'.
+ :
  : @param $path Path.
  : @return the parent folder of the given file.
  :)
-
 declare function util:parent-folder(
-  $path   as xs:string
-) as xs:anyURI {
-  xs:anyURI(fn:substring-before($path,
-                                file:base-name($path)))
-};
-
-declare function util:serialize-result(
-  $result    as item()*
-) as xs:string* {
-util:serialize-result($result,
-                      $util:serParamXml)
-};
-
-declare function util:serialize-result(
-  $result    as item()*,
+  $path as xs:string
+) as xs:anyURI
+{
+  xs:anyURI(fn:substring-before($path, file:base-name($path)))
+};
+
+
+declare function util:serialize-result(
+  $result as item()*
+) as xs:string*
+{
+  util:serialize-result($result, $util:serParamXml)
+};
+
+
+declare function util:serialize-result(
+  $result as item()*,
   $SerParams
-) as xs:string* {
+) as xs:string*
+{
   for $res in $result
   return
-   if($res instance of node())
-   then fn:serialize($res,
-                     $SerParams)
+   if ($res instance of node())
+   then fn:serialize($res, $SerParams)
    else fn:string($res)
 };

-- 
Mailing list: https://launchpad.net/~zorba-coders
Post to     : zorba-coders@lists.launchpad.net
Unsubscribe : https://launchpad.net/~zorba-coders
More help   : https://help.launchpad.net/ListHelp

Reply via email to