Fix regression bug introduced in v0.4.0-RC (#38)

* revert to x:output-expect from v0.3.0 #26 #30 #33

- use x:output-expect from v0.3.0 to fix regression bugs in #26 #30 #33
- remove attributes assert and context of x:expect as assert seems a duplicate of test and there is no documentation on how these attributes should behave
- in the test suite remove x:expect for tests using attribute assert as they are all duplicates of test
- add more tests to cover #26 #30 #33

src/compiler/generate-xspec-tests.xsl

@@ -285,123 +285,8 @@
   <xsl:call-template name="x:compile-scenarios"/>
 </xsl:template>
 
-<!--
-    Generate the following:
-
-        TODO: Review if it is still ok, regarding the below new description...
-
-        <template name="x:...">
-           <param name="x:result" required="yes"/>       # if not pending
-           <message>
-              Running (pending?) assertion...
-           </message>
-           # if not pending
-              <variable name="impl:expected" ...>   # depend on content, @href and @select
-              # if @context, change the context to the result of evaluating it
-              #   if no @context, the result is the context (if exactly one item)
-              # if @assert, evaluate it, the result must be boolean
-              # if @test, evaluate it with result as context node then
-              #   if it is not a boolean, compare it to $impl:expected
-              # if no @test, compare result to $impl:expected
-           # fi
-           <x:test>
-              ...
-           </x:test>
-        </template>
-
-    By assertion
-    @assert
-    @assert, @context
-
-    By comparing nodes
-    content
-    content, @context
-
-    By comparing atomic values
-    @select
-    @select, @context
-
-    Old-school (result wrapped into doc node)
-    @test             (= @assert)
-    @test, @context   (= @assert, @context)
-    content, @test    (= content, @context)
-      -> actually, that's not exctly what has been implemented
-         now we evaluate @test, and if it results to one boolean,
-         then that's an assert, if not it is compared to content
-
-    Context: if multiple items, loop as current item ($x:result still full result)
-      - with @assert, assertion eval'd once for each
-      - with content, compare the whole sequence
-      - with @select, compare the whole sequence
-
-    IF @context
-      set context (@context)
-    ELIF @test AND content
-      set context (@test)
-    ELSE
-      set context ($result)
-
-    IF @assert
-      assert (@assert)
-    ELIF content
-      compare (content)
-    ELIF @select
-      compare (@select)
-    ELIF @test AND content
-      compare (content)
-    ELIF @test
-      assert (@test)
-
-    set context (@context):
-      variable with-context := true
-      variable context
-        if count($result) <= 1
-          eval @context with $result as context
-        else
-          eval @context without any context
-        -> must be ONE item
-
-    set context (@test):
-      variable with-context := true
-      variable context
-        like set context (@context), but if node()+, then wrap in doc node
-
-    set context ($result):
-      variable with-context := true
-      variable context
-        no context                  if count($result) ne 1
-        like set context (@context) if no @test
-        like set context (@test)    if @test
-
-    no context:
-      variable with-context := false
-      variable context      := ()
-
-    assert (@assert):
-      if $with-context
-        evaluate assert with $context
-      else
-        evaluate assert without context
-
-    compare (content):
-      if $with-context
-        compare $context to content
-      else
-        compare $result to content
-
-    compare (@select):
-      if $with-context
-        compare $context to content
-      else
-        compare $result to content
-
-    assert (@test):
-      if $with-context
-        evaluate @test with $context
-      else
-        evaluate @test without context
--->
-<xsl:template name="x:output-expect-FIXME-TOREMOVE">
+
+<xsl:template name="x:output-expect">
   <xsl:param name="pending" select="()"    tunnel="yes" as="node()?"/>
   <xsl:param name="context" required="yes" tunnel="yes" as="element(x:context)?"/>
   <xsl:param name="call"    required="yes" tunnel="yes" as="element(x:call)?"/>
@@ -508,248 +393,6 @@
  </template>
 </xsl:template>
 
- <xsl:template name="x:output-expect">
-   <xsl:param name="pending" select="()"    tunnel="yes" as="node()?"/>
-   <xsl:param name="context" required="yes" tunnel="yes" as="element(x:context)?"/>
-   <xsl:param name="call"    required="yes" tunnel="yes" as="element(x:call)?"/>
-   <xsl:param name="params"  required="yes"              as="element(param)*"/>
-   <xsl:variable name="pending-p" select="exists($pending) and empty(ancestor::*/@focus)"/>
-   <template name="x:{generate-id()}">
-      <xsl:for-each select="$params">
-         <param name="{ @name }" required="{ @required }"/>
-      </xsl:for-each>
-      <message>
-         <xsl:if test="$pending-p">
-            <xsl:text>PENDING: </xsl:text>
-            <xsl:if test="normalize-space($pending) != ''">
-               <xsl:text>(</xsl:text>
-               <xsl:value-of select="normalize-space($pending)"/>
-               <xsl:text>) </xsl:text>
-            </xsl:if>
-         </xsl:if>
-         <xsl:value-of select="normalize-space(x:label(.))"/>
-      </message>
-      <xsl:variable name="is-assert" select="empty(node()|@select)"/>
-      <xsl:if test="not($pending-p)">
-         <xsl:variable name="version" as="xs:double" select="
-             ( ancestor-or-self::*[@xslt-version]/@xslt-version, 2.0 )[1]"/>
-
-         <!--
-             CONTEXT
-
-             IF @context
-               set context (@context)
-             ELIF @test AND content
-               set context (@test)
-             ELIF count($result) = 1
-               set context ($result)
-             ELSE
-               no context
-         -->
-         <xsl:choose>
-            <xsl:when test="exists(@context)">
-               <variable name="impl:with-context" select="true()"/>
-               <variable name="impl:context" as="item()?">
-                  <choose>
-                     <!-- aka "count($x:result) le 1" (so if empty, context is empty too) -->
-                     <when test="empty($x:result[2])">
-                        <for-each select="$x:result">
-                           <sequence select="{ @context }"/>
-                        </for-each>
-                     </when>
-                     <!-- when count($x:result) ge 2 -->
-                     <otherwise>
-                        <!-- no context node set here -->
-                        <sequence select="{ @context }"/>
-                     </otherwise>
-                  </choose>
-               </variable>
-            </xsl:when>
-            <xsl:when test="exists(@test) and exists(node())">
-               <variable name="impl:with-context" select="true()"/>
-               <variable name="impl:context-tmp" as="item()*">
-                  <choose>
-                     <!-- aka "count($x:result) le 1" (so if empty, context is empty too) -->
-                     <when test="empty($x:result[2])">
-                        <for-each select="$x:result">
-                           <sequence select="{ @test }"/>
-                        </for-each>
-                     </when>
-                     <!-- when count($x:result) ge 2 -->
-                     <otherwise>
-                        <!-- no context node set here -->
-                        <sequence select="{ @test }"/>
-                     </otherwise>
-                  </choose>
-               </variable>
-               <variable name="impl:context" as="item()?">
-                  <choose>
-                     <when test="$impl:context-tmp instance of node()+">
-                        <document>
-                           <sequence select="$impl:context-tmp"/>
-                        </document>
-                     </when>
-                     <otherwise>
-                        <sequence select="$impl:context-tmp"/>
-                     </otherwise>
-                  </choose>
-               </variable>
-            </xsl:when>
-            <xsl:otherwise>
-               <xsl:choose>
-                  <xsl:when test="exists(@test)">
-                     <variable name="impl:just-nodes" select="
-                         $x:result instance of node()+"/>
-                     <!-- aka "count($x:result) eq 1 or ..." -->
-                     <variable name="impl:with-context" select="
-                         exists($x:result) and empty($x:result[2]) or $impl:just-nodes"/>
-                     <variable name="impl:context" as="item()?">
-                        <choose>
-                           <when test="$impl:just-nodes">
-                              <document>
-                                 <sequence select="$x:result"/>
-                              </document>
-                           </when>
-                           <when test="$impl:with-context">
-                              <sequence select="$x:result"/>
-                           </when>
-                           <otherwise/>
-                        </choose>
-                     </variable>
-                  </xsl:when>
-                  <xsl:otherwise>
-                     <!-- aka "count($x:result) eq 1" -->
-                     <variable name="impl:with-context" select="
-                         exists($x:result) and empty($x:result[2])"/>
-                     <variable name="impl:context" as="item()?">
-                        <choose>
-                           <when test="$impl:with-context">
-                              <sequence select="$x:result"/>
-                           </when>
-                           <otherwise/>
-                        </choose>
-                     </variable>
-                  </xsl:otherwise>
-               </xsl:choose>
-            </xsl:otherwise>
-         </xsl:choose>
-
-         <!--
-             ASSERT & COMPARE
-
-             IF content|@select
-               compare (content|@select)
-             ELIF @assert|@test
-               assert (@assert|@test)
-             ELSE
-               compilation error
-
-             every branch of this xsl:choose generates the variable $impl:successful,
-             which is a boolean with the outcome of the test case (either passed or
-             failed), and which is used later on in the generated code
-         -->
-         <xsl:choose>
-            <xsl:when test="not($is-assert)">
-               <!-- check there is exactly one of node()|@select -->
-               <xsl:if test="exists(node()) and exists(@select)">
-                  <xsl:message terminate="yes">
-                     <xsl:text>ERROR in scenario "</xsl:text>
-                     <xsl:value-of select="x:label(.)"/>
-                     <xsl:text>": can't have both @select and context at the same time</xsl:text>
-                  </xsl:message>
-               </xsl:if>
-               <xsl:apply-templates select="." mode="test:generate-variable-declarations">
-                  <xsl:with-param name="var" select="'impl:expected'"/>
-               </xsl:apply-templates>
-               <variable name="impl:successful" as="xs:boolean" select="
-                   test:deep-equal(
-                     $impl:expected,
-                     if ( $impl:with-context ) then $impl:context else $x:result,
-                     { $version })"/>
-            </xsl:when>
-            <xsl:when test="exists(@assert|@test)">
-               <!-- check there is exactly one of @assert|@test -->
-               <xsl:if test="exists(@assert) and exists(@test)">
-                  <xsl:message terminate="yes">
-                     <xsl:text>ERROR in scenario "</xsl:text>
-                     <xsl:value-of select="x:label(.)"/>
-                     <xsl:text>": can't have both @context and @test at the same time</xsl:text>
-                  </xsl:message>
-               </xsl:if>
-               <variable name="impl:assert" as="item()*">
-                  <choose>
-                     <when test="$impl:with-context">
-                        <for-each select="$impl:context">
-                           <sequence select="{ @assert|@test }"/>
-                        </for-each>
-                     </when>
-                     <otherwise>
-                        <sequence select="{ @assert|@test }"/>
-                     </otherwise>
-                  </choose>
-               </variable>
-               <if test="not($impl:assert instance of xs:boolean)">
-                  <!-- TODO: For now, generate an error, make the test fails instead? -->
-                  <message terminate="yes">
-                     <xsl:text>ERROR in scenario "</xsl:text>
-                     <xsl:value-of select="x:label(.)"/>
-                     <!-- TODO: Generate the SequenceType of $impl:assert. -->
-                     <xsl:text>": @assert|@test did not return a boolean</xsl:text>
-                  </message>
-               </if>
-               <variable name="impl:successful" as="xs:boolean" select="$impl:assert"/>
-            </xsl:when>
-            <xsl:otherwise>
-               <xsl:message terminate="yes">
-                  <xsl:text>ERROR in scenario "</xsl:text>
-                  <xsl:value-of select="x:label(.)"/>
-                  <xsl:text>": unknown expect combination</xsl:text>
-                  <xsl:text>&#10;    content : </xsl:text>
-                  <xsl:value-of select="exists(node())"/>
-                  <xsl:text>&#10;    @context: </xsl:text>
-                  <xsl:value-of select="exists(@context)"/>
-                  <xsl:text>&#10;    @assert : </xsl:text>
-                  <xsl:value-of select="exists(@assert)"/>
-                  <xsl:text>&#10;    @select : </xsl:text>
-                  <xsl:value-of select="exists(@select)"/>
-                  <xsl:text>&#10;    @test   : </xsl:text>
-                  <xsl:value-of select="exists(@test)"/>
-               </xsl:message>
-            </xsl:otherwise>
-         </xsl:choose>
-         <if test="not($impl:successful)">
-            <message>
-               <xsl:text>      FAILED</xsl:text>
-            </message>
-         </if>
-      </xsl:if>
-      <x:test>
-         <xsl:choose>
-            <xsl:when test="$pending-p">
-               <xsl:attribute name="pending" select="$pending"/>
-            </xsl:when>
-            <xsl:otherwise>
-               <xsl:attribute name="successful" select="'{ $impl:successful }'"/>
-            </xsl:otherwise>
-         </xsl:choose>
-         <xsl:sequence select="x:label(.)"/>
-         <xsl:if test="not($pending-p)">
-            <call-template name="test:report-value">
-               <with-param name="value"        select="$x:result"/>
-               <with-param name="wrapper-name" select="'x:result'"/>
-               <with-param name="wrapper-ns"   select="'{ $xspec-ns }'"/>
-            </call-template>
-            <xsl:if test="not($is-assert)">
-               <call-template name="test:report-value">
-                  <with-param name="value"        select="$impl:expected"/>
-                  <with-param name="wrapper-name" select="'x:expect'"/>
-                  <with-param name="wrapper-ns"   select="'{ $xspec-ns }'"/>
-               </call-template>
-            </xsl:if>
-         </xsl:if>
-      </x:test>
-   </template>
-</xsl:template>
 
 <!-- *** x:generate-declarations *** -->
 <!-- Code to generate parameter declarations -->

test/generate-tests-utils.xspec

@@ -8,101 +8,83 @@
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <?oxygen RNGSchema="http://xspec.googlecode.com/svn/trunk/xspec.rnc" type="compact"?>
 <t:description xmlns:t="http://www.jenitennison.com/xslt/xspec" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:test="http://www.jenitennison.com/xslt/unit-test" query="http://www.jenitennison.com/xslt/unit-test" query-at="../src/compiler/generate-query-utils.xql" stylesheet="../src/compiler/generate-tests-utils.xsl">
-	<!--
+  <!--
 	   Test the source files generate-tests-utils.xsl and generate-query-utils.xql.
    -->
   <!--
 	   Function test:deep-equal($seq1, $seq2).
    -->
   <t:scenario label="test:deep-equal($seq1, $seq2)">
-
-	  <t:scenario label="Identical Sequences">
-		  <t:call function="test:deep-equal">
-			  <t:param select="1, 2"/>
-			  <t:param select="1, 2"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq true()"/>
-		  <t:expect label="the result" assert="$x:result eq true()"/>
-	  </t:scenario>
-
-	  <t:scenario label="Non-Identical Sequences">
-		  <t:call function="test:deep-equal">
-			  <t:param select="1, 2"/>
-			  <t:param select="1, 3"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq false()"/>
-		  <t:expect label="the result" assert="$x:result eq false()"/>
-	  </t:scenario>
-
-	  <t:scenario label="Sequences with Same Items in Different Orders">
-		  <t:call function="test:deep-equal">
-			  <t:param select="1, 2"/>
-			  <t:param select="2, 1"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq false()"/>
-		  <t:expect label="the result" assert="$x:result eq false()"/>
-	  </t:scenario>
-
-	  <t:scenario label="Empty Sequences">
-		  <t:call function="test:deep-equal">
-			  <t:param select="()"/>
-			  <t:param select="()"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq true()"/>
-		  <t:expect label="the result" assert="$x:result eq true()"/>
-	  </t:scenario>
-
-	  <t:scenario label="One empty sequence">
-		  <t:call function="test:deep-equal">
-			  <t:param select="()"/>
-			  <t:param select="1"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq false()"/>
-		  <t:expect label="the result" assert="$x:result eq false()"/>
-	  </t:scenario>
-
-	  <t:scenario label="A text node and several text nodes">
-		  <t:variable name="elems" as="element()+">
-			  <e>foo</e>
-			  <e>bar</e>
-		  </t:variable>
-		  <t:call function="test:deep-equal">
-			  <t:param as="text()">foobar</t:param>
-			  <t:param select="$elems/text()"/>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq true()"/>
-		  <t:expect label="the result" assert="$x:result eq true()"/>
-	  </t:scenario>
-
+    <t:scenario label="Identical Sequences">
+      <t:call function="test:deep-equal">
+        <t:param select="1, 2"/>
+        <t:param select="1, 2"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq true()"/>
+    </t:scenario>
+    <t:scenario label="Non-Identical Sequences">
+      <t:call function="test:deep-equal">
+        <t:param select="1, 2"/>
+        <t:param select="1, 3"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq false()"/>
+    </t:scenario>
+    <t:scenario label="Sequences with Same Items in Different Orders">
+      <t:call function="test:deep-equal">
+        <t:param select="1, 2"/>
+        <t:param select="2, 1"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq false()"/>
+    </t:scenario>
+    <t:scenario label="Empty Sequences">
+      <t:call function="test:deep-equal">
+        <t:param select="()"/>
+        <t:param select="()"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq true()"/>
+    </t:scenario>
+    <t:scenario label="One empty sequence">
+      <t:call function="test:deep-equal">
+        <t:param select="()"/>
+        <t:param select="1"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq false()"/>
+    </t:scenario>
+    <t:scenario label="A text node and several text nodes">
+      <t:variable name="elems" as="element()+">
+        <e>foo</e>
+        <e>bar</e>
+      </t:variable>
+      <t:call function="test:deep-equal">
+        <t:param as="text()">foobar</t:param>
+        <t:param select="$elems/text()"/>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq true()"/>
+    </t:scenario>
   </t:scenario>
-
   <!--
 	   Function test:node-deep-equal($seq1, $seq2).
    -->
   <t:scenario label="test:node-deep-equal($seq1, $seq2)">
-
-	  <t:scenario label="Identical Element Sequences">
-		  <t:call function="test:node-deep-equal">
-			  <t:param name="node1">foobar</t:param>
-			  <t:param name="node2">foobar</t:param>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq true()"/>
-	  </t:scenario>
-
-	  <t:scenario label="Identical Attribute Sequences">
-		  <t:call function="test:node-deep-equal">
-			  <t:param name="node1" select="/node/@attribute" as="node()">
-				  <node attribute="foobar"/>
-			  </t:param>
-			  <t:param name="node2" select="/node/@attribute" as="node()">
-				  <node attribute="foobar"/>
-			  </t:param>
-		  </t:call>
-		  <t:expect label="the result" test="$x:result eq true()"/>
-	  </t:scenario>
-
+    <t:scenario label="Identical Element Sequences">
+      <t:call function="test:node-deep-equal">
+        <t:param name="node1">foobar</t:param>
+        <t:param name="node2">foobar</t:param>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq true()"/>
+    </t:scenario>
+    <t:scenario label="Identical Attribute Sequences">
+      <t:call function="test:node-deep-equal">
+        <t:param name="node1" select="/node/@attribute" as="node()">
+          <node attribute="foobar"/>
+        </t:param>
+        <t:param name="node2" select="/node/@attribute" as="node()">
+          <node attribute="foobar"/>
+        </t:param>
+      </t:call>
+      <t:expect label="the result" test="$x:result eq true()"/>
+    </t:scenario>
   </t:scenario>
-
 </t:description>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->

test/generate-xspec-tests.xspec

@@ -6,60 +6,36 @@
 <!--  Tags:                                                                -->
 <!--    Copyright (c) 2010 Jeni Tennsion (see end of file.)                -->
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
-
-
-<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec"
-               xmlns:xs="http://www.w3.org/2001/XMLSchema"
-               xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-               stylesheet="../src/compiler/generate-xspec-tests.xsl">
-
-   <!--
+<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" stylesheet="../src/compiler/generate-xspec-tests.xsl">
+  <!--
        Test the source file generate-xspec-tests.xsl.
    -->
-
-   <t:scenario label="test:deep-equal($seq1, $seq2)">
-
-      <!--t:scenario label="FIRST TEST.......">
-         <t:variable name="ctxt" as="document-node()">
-            <t:description>
-               <t:scenario/>
-            </t:description>
-         </t:variable>
-         <t:apply select="$ctxt"/>
-         <t:expect label="the result" test="$t:result instance of document-node()"/>
-         <t:expect label="the result" assert="$t:result instance of document-node()"/>
-      </t:scenario-->
-
-      <t:scenario label="FIRST TEST.......">
-         <t:context mode="t:compile">
-            <t:scenario label="my label"/>
-         </t:context>
-         <t:expect label="is a template" test="$t:result instance of element(xsl:template)"/>
-         <!-- test also it is a QName in the namespace x:* -->
-         <t:expect label="the name" test="exists($t:result/@name)"/>
-         <t:expect label="the name is a QName" test="
-             namespace-uri-from-QName(resolve-QName($t:result/@name, $t:result))
-               eq 'http://www.jenitennison.com/xslt/xspec'"/>
-         <t:expect label="the label message" test="$t:result/xsl:message eq 'my label'"/>
-         <t:expect label="the scenario" test="exists($t:result/t:scenario)"/>
-         <t:expect label="the scenario label" test="$t:result/t:scenario/t:label eq 'my label'"/>
-         <!-- TODO: Use @assert instead of @test... -->
-         <t:expect label="is a template" assert="$t:result instance of element(xsl:template)"/>
-         <!-- test also it is a QName in the namespace x:* -->
-         <t:expect label="the name" assert="exists($t:result/@name)"/>
-         <t:expect label="the name is a QName" assert="
-             namespace-uri-from-QName(resolve-QName($t:result/@name, $t:result))
-               eq 'http://www.jenitennison.com/xslt/xspec'"/>
-         <t:expect label="the label message" assert="$t:result/xsl:message eq 'my label'"/>
-         <t:expect label="the scenario" assert="exists($t:result/t:scenario)"/>
-         <t:expect label="the scenario label" assert="$t:result/t:scenario/t:label eq 'my label'"/>
-      </t:scenario>
-
-   </t:scenario>
-
+  <t:scenario label="test:deep-equal($seq1, $seq2)">
+    <!--
+    <t:scenario label="FIRST TEST.......">
+      <t:variable name="ctxt" as="document-node()">
+        <t:description>
+          <t:scenario/>
+        </t:description>
+      </t:variable>
+      <t:apply select="$ctxt"/>
+      <t:expect label="the result" test="$t:result instance of document-node()"/>
+    </t:scenario>
+    -->
+    <t:scenario label="FIRST TEST.......">
+      <t:context mode="t:compile">
+        <t:scenario label="my label"/>
+      </t:context>
+      <t:expect label="is a template" test="$t:result instance of element(xsl:template)"/>
+      <!-- test also it is a QName in the namespace x:* -->
+      <t:expect label="the name" test="exists($t:result/@name)"/>
+      <t:expect label="the name is a QName" test="              namespace-uri-from-QName(resolve-QName($t:result/@name, $t:result))                eq 'http://www.jenitennison.com/xslt/xspec'"/>
+      <t:expect label="the label message" test="$t:result/xsl:message eq 'my label'"/>
+      <t:expect label="the scenario" test="exists($t:result/t:scenario)"/>
+      <t:expect label="the scenario label" test="$t:result/t:scenario/t:label eq 'my label'"/>
+    </t:scenario>
+  </t:scenario>
 </t:description>
-
-
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
 <!--                                                                       -->

test/unit-expect-xsl.xspec

@@ -22,15 +22,8 @@
       <t:expect test="false()"/>
     </t:context>
     <t:expect label="is a template" test="$t:result instance of element(xsl:template)"/>
-    <!-- 
     <t:expect label="@test must be transformed to @select" test="$t:result/xsl:variable[@name eq 'impl:test-result']/*/xsl:otherwise/*"> 
       <xsl:sequence select="false()" version="..."/>
     </t:expect> 
-    -->
-    <t:expect label="is a template" assert="$t:result instance of element(xsl:template)"/>
-    <!-- 
-    <t:expect label="@test must be transformed to @select" context="$t:result/xsl:variable[@name eq 'impl:test-result']/*/xsl:otherwise/*">
-    <xsl:sequence select="false()" version="..."/>
-    </t:expect> -->
   </t:scenario>
 </t:description>

test/xspec-26.xsl

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  exclude-result-prefixes="xs"
+  version="2.0">
+
+  <xsl:template match="document">
+    <container>
+      <xsl:apply-templates/>
+    </container>
+  </xsl:template>
+
+  <xsl:template match="heading">
+    <child>
+      <xsl:apply-templates/>
+    </child>
+  </xsl:template>
+
+</xsl:stylesheet>

test/xspec-26.xspec

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- full description at https://github.com/xspec/xspec/26 -->
+<x:description xmlns:x="http://www.jenitennison.com/xslt/xspec" stylesheet="xspec-26.xsl">
+  <x:scenario label="When converting heading element">
+    <x:context>
+      <document>
+        <heading>Some Text</heading>
+      </document>
+    </x:context>
+    <x:expect label="Wrap it in a container element">
+      <container>...</container>
+    </x:expect>
+    <x:expect label="With a child" test="container/child[1]">
+      <child>Some Text</child>
+    </x:expect>
+  </x:scenario>
+</x:description>

test/xspec-30.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<foo/>

test/xspec-30.xsl

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:template as="document-node()" match="document-node()">
+        <xsl:sequence select="." />
+    </xsl:template>
+</xsl:stylesheet>

test/xspec-30.xspec

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- full description at https://github.com/xspec/xspec/issues/30 -->
+<x:description xmlns:x="http://www.jenitennison.com/xslt/xspec" stylesheet="xspec-30.xsl">
+  <x:scenario label="When an XML is passed via the href attribute of x:context">
+    <x:context href="xspec-30.xml"/>
+    <x:expect href="xspec-30.xml" label="the href attribute of x:expect works"/>
+  </x:scenario>
+</x:description>

test/xspec-33.xsl

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet exclude-result-prefixes="#all" version="2.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:template as="node()" match="node()">
+        <xsl:sequence select="." />
+    </xsl:template>
+</xsl:stylesheet>

test/xspec-33.xspec

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<x:description xmlns:x="http://www.jenitennison.com/xslt/xspec" stylesheet="xspec-33.xsl">
+  <x:scenario label="When context contains descendant">
+    <x:context>
+      <foo>
+        <bar>
+          <baz>original-text</baz>
+        </bar>
+      </foo>
+    </x:context>
+    <x:expect label="descendant is picked up correctly using XPath in @test" test="descendant::baz">
+      <baz>original-text</baz>
+    </x:expect>
+  </x:scenario>
+</x:description>

test/xspec-focus-1.xspec

@@ -18,14 +18,12 @@
       <t:param select="3"/>
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
   </t:scenario>
   <t:scenario label="pending must fail">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="the type" test="$x:result instance of xs:string"/>
-    <t:expect label="the type" assert="$x:result instance of xs:string"/>
   </t:scenario>
   <!--
        Focused on scenarios.
@@ -35,14 +33,12 @@
       <t:param select="3"/>
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
   </t:scenario>
   <t:scenario label="focus must fail">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="the type" test="$x:result instance of xs:string"/>
-    <t:expect label="the type" assert="$x:result instance of xs:string"/>
   </t:scenario>
 </t:description>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

test/xspec-focus-2.xspec

@@ -6,89 +6,60 @@
 <!--  Tags:                                                                -->
 <!--    Copyright (c) 2010 Jeni Tennsion (see end of file.)                -->
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
-
-
 <?oxygen RNGSchema="http://xspec.googlecode.com/svn/trunk/xspec.rnc" type="compact"?>
-
-<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec"
-               xmlns:xs="http://www.w3.org/2001/XMLSchema"
-               xmlns:my="http://example.org/ns/my"
-               query="http://example.org/ns/my"
-               query-at="xspec-tested.xql"
-               stylesheet="xspec-tested.xsl">
-
-   <!--
+<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:my="http://example.org/ns/my" query="http://example.org/ns/my" query-at="xspec-tested.xql" stylesheet="xspec-tested.xsl">
+  <!--
        Test @focus and pending toghether (both @pending and t:pending).
    -->
-
-   <!--
+  <!--
        Test x:pending.
    -->
-   <t:pending label="testing pending element">
-
-      <t:scenario label="pending call (element)">
-         <t:call function="my:square">
-            <t:param select="3"/>
-         </t:call>
-         <t:expect label="the result" test="$x:result eq 9"/>
-         <t:expect label="the result" assert="$x:result eq 9"/>
-      </t:scenario>
-
-      <t:scenario label="pending call (element) + focus" focus="focus">
-         <t:call function="my:square">
-            <t:param select="3"/>
-         </t:call>
-         <t:expect label="the result" test="$x:result eq 9"/>
-         <t:expect label="the result" assert="$x:result eq 9"/>
-      </t:scenario>
-
-   </t:pending>
-
-   <!--
-       Non-pending scenarios.
-   -->
-   <t:scenario label="call">
+  <t:pending label="testing pending element">
+    <t:scenario label="pending call (element)">
       <t:call function="my:square">
-         <t:param select="3"/>
+        <t:param select="3"/>
       </t:call>
       <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
-   </t:scenario>
-
-   <t:scenario label="call + focus" focus="focus">
+    </t:scenario>
+    <t:scenario label="pending call (element) + focus" focus="focus">
       <t:call function="my:square">
-         <t:param select="3"/>
+        <t:param select="3"/>
       </t:call>
       <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
-   </t:scenario>
-
-   <!--
+    </t:scenario>
+  </t:pending>
+  <!--
+       Non-pending scenarios.
+   -->
+  <t:scenario label="call">
+    <t:call function="my:square">
+      <t:param select="3"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq 9"/>
+  </t:scenario>
+  <t:scenario label="call + focus" focus="focus">
+    <t:call function="my:square">
+      <t:param select="3"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq 9"/>
+  </t:scenario>
+  <!--
        Test @pending.
    -->
-   <t:scenario label="pending call (attribute)"
-               pending="testing pending attribute">
-      <t:call function="my:square">
-         <t:param select="3"/>
-      </t:call>
-      <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
-   </t:scenario>
-
-   <!-- does not make sense, really, but to see how the implem reacts -->
-   <t:scenario label="pending call (attribute) + focus"
-               pending="testing pending attribute"
-               focus="focus">
-      <t:call function="my:square">
-         <t:param select="3"/>
-      </t:call>
-      <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
-   </t:scenario>
-
+  <t:scenario label="pending call (attribute)" pending="testing pending attribute">
+    <t:call function="my:square">
+      <t:param select="3"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq 9"/>
+  </t:scenario>
+  <!-- does not make sense, really, but to see how the implem reacts -->
+  <t:scenario label="pending call (attribute) + focus" pending="testing pending attribute" focus="focus">
+    <t:call function="my:square">
+      <t:param select="3"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq 9"/>
+  </t:scenario>
 </t:description>
-
-
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
 <!--                                                                       -->

test/xspec-function.xspec

@@ -14,15 +14,12 @@
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
     <t:expect label="the type" test="$x:result instance of xs:integer"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
-    <t:expect label="the type" assert="$x:result instance of xs:integer"/>
   </t:scenario>
   <t:scenario label="must fail">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="wrong result" test="$x:result eq 42"/>
-    <t:expect label="wrong result" assert="$x:result eq 42"/>
   </t:scenario>
 </t:description>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

test/xspec-import.xspec

@@ -6,40 +6,23 @@
 <!--  Tags:                                                                -->
 <!--    Copyright (c) 2010 Jeni Tennsion (see end of file.)                -->
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
-
-
 <?oxygen RNGSchema="http://xspec.googlecode.com/svn/trunk/xspec.rnc" type="compact"?>
-
-<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec"
-               xmlns:xs="http://www.w3.org/2001/XMLSchema"
-               xmlns:my="http://example.org/ns/my"
-               query="http://example.org/ns/my"
-               query-at="xspec-tested.xql"
-               stylesheet="xspec-tested.xsl">
-
-   <t:import href="xspec-imported.xspec"/>
-
-   <t:scenario label="call">
-      <t:call function="my:square">
-         <t:param select="3"/>
-      </t:call>
-      <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the type"   test="$x:result instance of xs:integer"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
-      <t:expect label="the type"   assert="$x:result instance of xs:integer"/>
-   </t:scenario>
-
-   <t:scenario label="must fail">
-      <t:call function="my:square">
-         <t:param select="2"/>
-      </t:call>
-      <t:expect label="the type" test="$x:result instance of xs:string"/>
-      <t:expect label="the type" assert="$x:result instance of xs:string"/>
-   </t:scenario>
-
+<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:my="http://example.org/ns/my" query="http://example.org/ns/my" query-at="xspec-tested.xql" stylesheet="xspec-tested.xsl">
+  <t:import href="xspec-imported.xspec"/>
+  <t:scenario label="call">
+    <t:call function="my:square">
+      <t:param select="3"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq 9"/>
+    <t:expect label="the type" test="$x:result instance of xs:integer"/>
+  </t:scenario>
+  <t:scenario label="must fail">
+    <t:call function="my:square">
+      <t:param select="2"/>
+    </t:call>
+    <t:expect label="the type" test="$x:result instance of xs:string"/>
+  </t:scenario>
 </t:description>
-
-
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
 <!--                                                                       -->

test/xspec-imported.xspec

@@ -13,14 +13,12 @@
       <t:param select="3"/>
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
   </t:scenario>
   <t:scenario label="must fail">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="wrong result" test="$x:result eq 42"/>
-    <t:expect label="wrong result" assert="$x:result eq 42"/>
   </t:scenario>
 </t:description>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

test/xspec-pending.xspec

@@ -20,14 +20,12 @@
         <t:param select="3"/>
       </t:call>
       <t:expect label="the result" test="$x:result eq 9"/>
-      <t:expect label="the result" assert="$x:result eq 9"/>
     </t:scenario>
     <t:scenario label="pending must fail (element)">
       <t:call function="my:square">
         <t:param select="2"/>
       </t:call>
       <t:expect label="the type" test="$x:result instance of xs:string"/>
-      <t:expect label="the type" assert="$x:result instance of xs:string"/>
     </t:scenario>
   </t:pending>
   <!--
@@ -38,14 +36,12 @@
       <t:param select="3"/>
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
   </t:scenario>
   <t:scenario label="must fail">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="the type" test="$x:result instance of xs:string"/>
-    <t:expect label="the type" assert="$x:result instance of xs:string"/>
   </t:scenario>
   <!--
        Test @pending.
@@ -55,14 +51,12 @@
       <t:param select="3"/>
     </t:call>
     <t:expect label="the result" test="$x:result eq 9"/>
-    <t:expect label="the result" assert="$x:result eq 9"/>
   </t:scenario>
   <t:scenario label="pending must fail (attribute)" pending="testing pending attribute">
     <t:call function="my:square">
       <t:param select="2"/>
     </t:call>
     <t:expect label="the type" test="$x:result instance of xs:string"/>
-    <t:expect label="the type" assert="$x:result instance of xs:string"/>
   </t:scenario>
 </t:description>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

test/xspec-variable.xspec

@@ -6,47 +6,31 @@
 <!--  Tags:                                                                -->
 <!--    Copyright (c) 2010 Jeni Tennsion (see end of file.)                -->
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
-
-
 <?oxygen RNGSchema="http://xspec.googlecode.com/svn/trunk/xspec.rnc" type="compact"?>
-
-<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec"
-               xmlns:xs="http://www.w3.org/2001/XMLSchema"
-               xmlns:my="http://example.org/ns/my"
-               query="http://example.org/ns/my"
-               query-at="xspec-tested.xql"
-               stylesheet="xspec-tested.xsl">
-
-   <t:variable name="test-data" href="xspec-variable.xml"/>
-   <t:variable name="test-3"    select="$test-data/*/test[xs:integer(@num) eq 3]"/>
-
-   <t:scenario label="call global var">
-      <t:call function="my:square">
-         <t:param select="$test-3/@num"/>
-      </t:call>
-      <t:expect label="the result" test="$x:result eq $test-3/xs:integer(@value)"/>
-      <t:expect label="the result" assert="$x:result eq $test-3/xs:integer(@value)"/>
-   </t:scenario>
-
-   <!--
+<t:description xmlns:t="http://www.jenitennison.com/xslt/xspec" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:my="http://example.org/ns/my" query="http://example.org/ns/my" query-at="xspec-tested.xql" stylesheet="xspec-tested.xsl">
+  <t:variable name="test-data" href="xspec-variable.xml"/>
+  <t:variable name="test-3" select="$test-data/*/test[xs:integer(@num) eq 3]"/>
+  <t:scenario label="call global var">
+    <t:call function="my:square">
+      <t:param select="$test-3/@num"/>
+    </t:call>
+    <t:expect label="the result" test="$x:result eq $test-3/xs:integer(@value)"/>
+  </t:scenario>
+  <!--
        TODO: For now, x:call and x:context are pulled first, then
        templates are applied to other x:scenario/*.  So the order is
        not respected, and the variable declaration is compiled after
        the call/appling!
    -->
-   <t:scenario label="call local var">
-      <t:variable name="param" select="$test-3/@num"/>
-      <t:call function="my:square">
-         <t:param select="$param"/>
-      </t:call>
-      <t:variable name="result" select="$test-3/@value"/>
-      <t:expect label="the result" test="$x:result eq xs:integer($result)"/>
-      <t:expect label="the result" assert="$x:result eq xs:integer($result)"/>
-   </t:scenario>
-
+  <t:scenario label="call local var">
+    <t:variable name="param" select="$test-3/@num"/>
+    <t:call function="my:square">
+      <t:param select="$param"/>
+    </t:call>
+    <t:variable name="result" select="$test-3/@value"/>
+    <t:expect label="the result" test="$x:result eq xs:integer($result)"/>
+  </t:scenario>
 </t:description>
-
-
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
 <!--                                                                       -->