simple-xspec-wrapper 0.1.0-java

data/vendor/xspec-1.0.0/src/compiler/generate-query-utils.xql

@@ -0,0 +1,263 @@
+module namespace test = "http://www.jenitennison.com/xslt/unit-test";
+
+(::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::)
+(:  File:       generate-query-utils.xql                                    :)
+(:  Author:     Jeni Tennsion                                               :)
+(:  URL:        http://github.com/xspec/xspec                               :)
+(:  Tags:                                                                   :)
+(:    Copyright (c) 2008, 2010 Jeni Tennsion (see end of file.)             :)
+(: ------------------------------------------------------------------------ :)
+
+
+declare namespace fn = "http://www.w3.org/2005/xpath-functions";
+
+declare function test:deep-equal($seq1 as item()*, $seq2 as item()*) as xs:boolean
+{
+  test:deep-equal($seq1, $seq2, 2.0)
+};
+
+declare function test:deep-equal(
+    $seq1 as item()*,
+    $seq2 as item()*,
+    $version as xs:double
+  ) as xs:boolean
+{
+  if ( $version = 1.0 ) then
+    if ( $seq1 instance of xs:string and $seq2 instance of text()+ ) then
+      test:deep-equal($seq1, fn:string-join($seq2, ''))
+    else if ( $seq1 instance of xs:double and $seq2 instance of text()+ ) then
+      test:deep-equal($seq1, xs:double(fn:string-join($seq2, '')))
+    else if ( $seq1 instance of xs:decimal and $seq2 instance of text()+ ) then
+      test:deep-equal($seq1, xs:decimal(fn:string-join($seq2, '')))
+    else if ( $seq1 instance of xs:integer and $seq2 instance of text()+ ) then
+      test:deep-equal($seq1, xs:integer(fn:string-join($seq2, '')))
+    else
+      test:deep-equal($seq1, $seq2)
+  else if ( fn:empty($seq1) or fn:empty($seq2) ) then
+    fn:empty($seq1) and fn:empty($seq2)
+  else if ( fn:count($seq1) = fn:count($seq2) ) then
+    every $i in (1 to fn:count($seq1))
+    satisfies test:item-deep-equal($seq1[$i], $seq2[$i])
+  else if ( $seq1 instance of text() and $seq2 instance of text()+ ) then
+    test:deep-equal($seq1, text { fn:string-join($seq2, '') })
+  else
+    fn:false()
+};
+
+declare function test:item-deep-equal($item1 as item(), $item2 as item()) as xs:boolean
+{
+  if ( $item1 instance of node() and $item2 instance of node() ) then
+    test:node-deep-equal($item1, $item2)
+  else if ( fn:not($item1 instance of node()) and fn:not($item2 instance of node()) ) then
+    fn:deep-equal($item1, $item2)
+  else
+    fn:false()
+};
+
+declare function test:node-deep-equal($node1 as node(), $node2 as node()) as xs:boolean
+{
+  if ( $node1 instance of document-node() and $node2 instance of document-node() ) then
+    test:deep-equal(test:sorted-children($node1), test:sorted-children($node2))
+  else if ( $node1 instance of element() and $node2 instance of element() ) then
+    if ( fn:node-name($node1) eq fn:node-name($node2) ) then
+      let $atts1 as attribute()* := test:sort-named-nodes($node1/@*)
+      let $atts2 as attribute()* := test:sort-named-nodes($node2/@*)
+        return
+          if ( test:deep-equal($atts1, $atts2) ) then
+            if ( fn:count($node1/node()) = 1 and $node1/text() = '...' ) then
+              fn:true()
+            else
+              test:deep-equal(test:sorted-children($node1), test:sorted-children($node2))
+          else
+            fn:false()
+    else
+      fn:false()
+  else if ( $node1 instance of text() and $node1 = '...' ) then
+    fn:true()
+  else if ( $node1 instance of text() and $node2 instance of text() ) then
+    fn:string($node1) eq fn:string($node2)
+  else if ( ( $node1 instance of attribute() and $node2 instance of attribute() )
+            or ( $node1 instance of processing-instruction()
+                 and $node2 instance of processing-instruction()) ) then
+    fn:node-name($node1) eq fn:node-name($node2)
+      and ( fn:string($node1) eq fn:string($node2) or fn:string($node1) = '...' )
+  else if ( $node1 instance of comment() and $node2 instance of comment() ) then
+    fn:string($node1) eq fn:string($node2) or fn:string($node1) = '...' 
+  else
+    fn:false()
+};
+
+declare function test:sorted-children($node as node()) as node()*
+{
+  $node/child::node() 
+  except ( $node/text()[fn:not(fn:normalize-space(.))], $node/test:message )
+};
+
+(: Aim to be identical to:
+ :
+ :     <xsl:perform-sort select="$nodes">
+ :        <xsl:sort select="namespace-uri(.)" />
+ :        <xsl:sort select="local-name(.)" />
+ :     </xsl:perform-sort>
+ :)
+declare function test:sort-named-nodes($nodes as node()*) as node()*
+{
+  if ( fn:empty($nodes) ) then
+    ()
+  else
+    let $idx := test:named-nodes-minimum($nodes)
+      return (
+        $nodes[$idx],
+        test:sort-named-nodes(fn:remove($nodes, $idx))
+      )
+};
+
+(: Return the "minimum" of $nodes, using the order defined by
+ : test:sort-named-nodes().
+ :)
+declare function test:named-nodes-minimum($nodes as node()+) as xs:integer
+{
+  (: if there is only one node, this is the minimum :)
+  if ( fn:empty($nodes[2]) ) then
+    1
+  (: if not, init the temp minimum on the first one, then walk through the sequence :)
+  else
+    test:named-nodes-minimum($nodes, fn:node-name($nodes[1]), 1, 2)
+};
+
+declare function test:named-nodes-minimum(
+    $nodes as node()+,
+    $min   as xs:QName,
+    $idx   as xs:integer,
+    $curr  as xs:integer
+  ) as xs:integer
+{
+  if ( $curr gt fn:count($nodes) ) then
+    $idx
+  else if ( test:qname-lt(fn:node-name($nodes[$curr]), $min) ) then
+    test:named-nodes-minimum($nodes, fn:node-name($nodes[$curr]), $curr, $curr + 1)
+  else
+    test:named-nodes-minimum($nodes, $min, $idx, $curr + 1)
+};
+
+declare function test:qname-lt($n1 as xs:QName, $n2 as xs:QName) as xs:boolean
+{
+  if ( fn:namespace-uri-from-QName($n1) eq fn:namespace-uri-from-QName($n2) ) then
+    fn:local-name-from-QName($n1) lt fn:local-name-from-QName($n2)
+  else
+    fn:namespace-uri-from-QName($n1) lt fn:namespace-uri-from-QName($n2)
+};
+
+declare function test:report-value($value as item()*, $wrapper-name as xs:string) as element()
+{
+  test:report-value($value, $wrapper-name, 'http://www.jenitennison.com/xslt/xspec')
+};
+
+declare function test:report-value(
+    $value as item()*,
+    $wrapper-name as xs:string,
+    $wrapper-ns as xs:string
+  ) as element()
+{
+  element { fn:QName($wrapper-ns, $wrapper-name) } {
+    if ( $value[1] instance of attribute() ) then (
+        attribute { 'select' } { '/*/(@* | node())' },
+        element { fn:QName($wrapper-ns, 'temp') } { $value }
+      )
+    else if ( $value instance of node()+ ) then (
+        if ( $value instance of document-node() ) then
+          attribute { 'select' } { '/' }
+        else if ( fn:not($value instance of element()+) ) then
+          attribute { 'select' } { '/node()' }
+        else
+          ()
+        ,
+        if ( fn:count($value//node()) > 1000 ) then
+          fn:error((), 'TODO: Write the value within a file...')
+        else
+          (: TODO: The original stylesheet use a mode to do a bit
+             different copy, to preserve withespaces... :)
+          $value
+      )
+    else
+      attribute { 'select' } {
+        if ( fn:empty($value) ) then
+          '()'
+        else if ( $value instance of item() ) then
+          test:report-atomic-value($value)
+        else
+          fn:concat('(', fn:string-join(for $v in $value return test:report-atomic-value($v), ', '), ')')
+      }
+  }
+};
+
+declare function test:report-atomic-value($value as item()) as xs:string
+{
+  if ( $value instance of xs:string ) then
+    fn:concat("'", fn:replace($value, "'", "''"), "'")
+  else if ( $value instance of xs:integer or
+            $value instance of xs:decimal or
+            $value instance of xs:double ) then
+    fn:string($value)
+  else if ( $value instance of xs:QName ) then
+    fn:concat("QName('",
+           fn:namespace-uri-from-QName($value),
+           "', '",
+           if ( fn:prefix-from-QName($value) ) then
+             fn:concat(fn:prefix-from-QName($value), ':') 
+           else
+             '',
+           fn:local-name-from-QName($value),
+           "')")
+  else
+    fn:concat(test:atom-type($value), '(', test:report-atomic-value(fn:string($value)), ')')
+};
+
+declare function test:atom-type($value as xs:anyAtomicType) as xs:string
+{
+  if ( $value instance of xs:string ) then
+    'xs:string'
+  else if ( $value instance of xs:boolean ) then
+    'xs:boolean'
+  else if ( $value instance of xs:double ) then
+    'xs:double'
+  else if ( $value instance of xs:anyURI ) then
+    'xs:anyURI'
+  else if ( $value instance of xs:dateTime ) then
+    'xs:dateTime'
+  else if ( $value instance of xs:date ) then
+    'xs:date'
+  else if ( $value instance of xs:time ) then
+    'xs:time'
+  else
+    'xs:anyAtomicType'
+};
+
+
+(: ------------------------------------------------------------------------ :)
+(:  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.               :)
+(:                                                                          :)
+(:  Copyright (c) 2008, 2010 Jeni Tennsion                                  :)
+(:                                                                          :)
+(:  The contents of this file are subject to the MIT License (see the URI   :)
+(:  http://www.opensource.org/licenses/mit-license.php for details).        :)
+(:                                                                          :)
+(:  Permission is hereby granted, free of charge, to any person obtaining   :)
+(:  a copy of this software and associated documentation files (the         :)
+(:  "Software"), to deal in the Software without restriction, including     :)
+(:  without limitation the rights to use, copy, modify, merge, publish,     :)
+(:  distribute, sublicense, and/or sell copies of the Software, and to      :)
+(:  permit persons to whom the Software is furnished to do so, subject to   :)
+(:  the following conditions:                                               :)
+(:                                                                          :)
+(:  The above copyright notice and this permission notice shall be          :)
+(:  included in all copies or substantial portions of the Software.         :)
+(:                                                                          :)
+(:  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,         :)
+(:  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF      :)
+(:  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  :)
+(:  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY    :)
+(:  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,    :)
+(:  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE       :)
+(:  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                  :)
+(: ------------------------------------------------------------------------ :)

data/vendor/xspec-1.0.0/src/compiler/generate-tests-helper.xsl

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ===================================================================== -->
+<!--  File:       generate-tests-helper.xsl                                -->
+<!--  Author:     Jeni Tennsion                                            -->
+<!--  URL:        http://github.com/xspec/xspec                            -->
+<!--  Tags:                                                                -->
+<!--    Copyright (c) 2008, 2010 Jeni Tennsion (see end of file.)          -->
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+
+<xsl:stylesheet version="2.0" 
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:xhtml="http://www.w3.org/1999/xhtml"
+                xmlns:test="http://www.jenitennison.com/xslt/unit-test"
+                extension-element-prefixes="test"
+                xmlns="http://www.w3.org/1999/XSL/TransformAlias"
+                xmlns:t="http://www.jenitennison.com/xslt/unit-testAlias"
+                exclude-result-prefixes="#default t xhtml"
+                xmlns:pkg="http://expath.org/ns/pkg"
+                xmlns:__x="http://www.w3.org/1999/XSL/TransformAliasAlias">
+  
+<pkg:import-uri>http://www.jenitennison.com/xslt/xspec/generate-tests-helper.xsl</pkg:import-uri>
+
+<xsl:namespace-alias stylesheet-prefix="#default" result-prefix="xsl"/>
+<xsl:namespace-alias stylesheet-prefix="t" result-prefix="test"/>
+  
+<xsl:output indent="yes" encoding="ISO-8859-1" />  
+  
+<xsl:key name="functions" 
+         match="xsl:function" 
+         use="resolve-QName(@name, .)" />
+
+<xsl:key name="named-templates" 
+         match="xsl:template[@name]"
+         use="if (contains(@name, ':'))
+	            then resolve-QName(@name, .)
+	            else QName('', @name)" />
+
+<xsl:key name="matching-templates" 
+         match="xsl:template[@match]" 
+         use="concat('match=', normalize-space(@match), '+',
+                     'mode=', normalize-space(@mode))" />
+
+
+<xsl:template match="*" mode="test:generate-variable-declarations">
+  <xsl:param name="var" as="xs:string" required="yes" />
+  <xsl:param name="type" as="xs:string" select="'variable'" />
+  <xsl:choose>
+    <xsl:when test="node() or @href">
+      <variable name="{$var}-doc" as="document-node()">
+        <xsl:choose>
+          <xsl:when test="@href">
+            <xsl:attribute name="select">
+              <xsl:text>doc('</xsl:text>
+              <xsl:value-of select="resolve-uri(@href, base-uri(.))" />
+              <xsl:text>')</xsl:text>
+            </xsl:attribute>
+          </xsl:when>
+          <xsl:otherwise>
+            <document>
+              <xsl:apply-templates mode="test:create-xslt-generator" />
+            </document>
+          </xsl:otherwise>
+        </xsl:choose>
+      </variable>
+      <xsl:element name="xsl:{$type}">
+        <xsl:copy-of select="@as"/>
+        <xsl:attribute name="name" select="$var" />
+        <xsl:attribute name="select"
+          select="if (@select) 
+                    then concat('$', $var, '-doc/(', @select, ')')
+                  else if (@href)
+                    then concat('$', $var, '-doc')
+                  else concat('$', $var, '-doc/node()')" />
+      </xsl:element>
+    </xsl:when>
+    <xsl:when test="@select">
+      <xsl:element name="xsl:{$type}">
+        <xsl:copy-of select="@as|@select"/>
+        <xsl:attribute name="name" select="$var" />
+      </xsl:element>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:element name="xsl:{$type}">
+        <xsl:copy-of select="@as"/>
+        <xsl:attribute name="name" select="$var" />
+        <xsl:attribute name="select" select="'()'" />
+      </xsl:element>
+    </xsl:otherwise>
+  </xsl:choose>        
+</xsl:template>  
+  
+
+<xsl:template match="*" mode="test:create-xslt-generator">
+   <xsl:copy>
+      <xsl:apply-templates select="@*|node()" mode="test:create-xslt-generator"/>
+   </xsl:copy>
+</xsl:template>  
+
+<xsl:template match="@*" mode="test:create-xslt-generator">
+   <xsl:copy-of select="."/>
+</xsl:template>
+  
+<xsl:template match="xsl:*" mode="test:create-xslt-generator">
+  <xsl:element name="__x:{ local-name() }">
+    <xsl:apply-templates select="@*|node()" mode="test:create-xslt-generator"/>
+  </xsl:element>
+</xsl:template>  
+
+<xsl:template match="@xsl:*" mode="test:create-xslt-generator">
+   <xsl:attribute name="__x:{ local-name() }" select="."/>
+</xsl:template>
+
+<xsl:template match="text()" mode="test:create-xslt-generator">
+  <text>
+     <xsl:value-of select="."/>
+  </text>
+</xsl:template>  
+
+<xsl:template match="comment()" mode="test:create-xslt-generator">
+  <comment>
+     <xsl:value-of select="."/>
+  </comment>
+</xsl:template>
+
+<xsl:template match="processing-instruction()" mode="test:create-xslt-generator">
+  <processing-instruction name="{name()}">
+    <xsl:value-of select="."/>
+  </processing-instruction>
+</xsl:template>
+
+<xsl:function name="test:matching-xslt-elements" as="element()*">
+  <xsl:param name="element-kind" as="xs:string"/>
+  <xsl:param name="element-id" as="item()"/>
+  <xsl:param name="stylesheet" as="document-node()"/>
+  <xsl:sequence select="key($element-kind, $element-id, $stylesheet)"/>
+</xsl:function>  
+
+</xsl:stylesheet>
+
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+<!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
+<!--                                                                       -->
+<!-- Copyright (c) 2008, 2010 Jeni Tennsion                                -->
+<!--                                                                       -->
+<!-- The contents of this file are subject to the MIT License (see the URI -->
+<!-- http://www.opensource.org/licenses/mit-license.php for details).      -->
+<!--                                                                       -->
+<!-- Permission is hereby granted, free of charge, to any person obtaining -->
+<!-- a copy of this software and associated documentation files (the       -->
+<!-- "Software"), to deal in the Software without restriction, including   -->
+<!-- without limitation the rights to use, copy, modify, merge, publish,   -->
+<!-- distribute, sublicense, and/or sell copies of the Software, and to    -->
+<!-- permit persons to whom the Software is furnished to do so, subject to -->
+<!-- the following conditions:                                             -->
+<!--                                                                       -->
+<!-- The above copyright notice and this permission notice shall be        -->
+<!-- included in all copies or substantial portions of the Software.       -->
+<!--                                                                       -->
+<!-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       -->
+<!-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    -->
+<!-- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.-->
+<!-- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  -->
+<!-- CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  -->
+<!-- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     -->
+<!-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                -->
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->