<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:d="http://www.dpawson.co.uk/ns#"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  version="2.0"
  exclude-result-prefixes="d xs">

  <d:doc xmlns:d="http://www.dpawson.co.uk/ns#">
    <d:revhistory>
      <d:purpose>
        <d:para>This stylesheet provides user functions for testing XSLT 2.0</d:para>
      </d:purpose>
      <d:revision>
        <d:revnumber>1.0</d:revnumber>
        <d:date>2010-03-06T06:41:45Z</d:date>
        <d:authorinitials>DaveP</d:authorinitials>
        <d:revdescription>
          <d:para></d:para>
        </d:revdescription>
        <d:revremark></d:revremark>
      </d:revision>

      <d:revision>
        <d:revnumber>1.1</d:revnumber>
        <d:date>2010-03-19T13:49:09Z</d:date>
        <d:authorinitials>DaveP</d:authorinitials>
        <d:revdescription>
          <d:para>Added decimal-cmp, 3 args, added copyright</d:para>
        </d:revdescription>
        <d:revremark></d:revremark>
      </d:revision>



    </d:revhistory>
  </d:doc>
  

  <xsl:output method="xml" indent="yes" encoding="utf-8"/>


<xsl:variable name="debug" select="true()"/>

<!-- Test harness -->
  <xsl:template match="/" name="main">
    
<xsl:variable name="exp" as="item()+">
  <ent1>Value1</ent1>
  <nst>
    <item attr="atval"/>
  </nst>
</xsl:variable>

<xsl:variable name='dval' select="2.2000001" as='xs:double'/>

<!-- General tolerance spec -->
<xsl:variable name="tolerance" select="1E-6"/>

    <xsl:message>
 
      <xsl:value-of select="not(d:numeric-cmp(2,3, $tolerance)) and
                            not(d:numeric-cmp(2,2.2, $tolerance)) and 
                            not(d:numeric-cmp(2,'jj', $tolerance)) and
                            d:numeric-cmp(-2,-2.00000000001, $tolerance) and
                            d:numeric-cmp(2,'2.0', $tolerance) and
                            d:double-cmp(3.2,3.2, $tolerance) and
                            d:string-cmp('a','a') and
                            not(d:string-cmp('a', 'a ')) and
                            d:assert-equal(3.3,3.3) and
                            d:assert-equal('Hello','Hello') and
                            d:assert-equal(2,2) and 
                            not(d:assert-equal(2,3)) and
                            d:assert-equal($dval,$dval, $tolerance) and
                            d:assert-equal(true(),true()) and
                            d:assert-equal(xs:integer(3),xs:integer(3)) and
                            d:assert-equal(xs:decimal(3.0001), xs:decimal(3.0001)) and
                            d:assert-equal(xs:decimal(3.142), 
                                  xs:decimal(3.142), xs:decimal($tolerance)) and
                            d:assert-equal(xs:double(4.3e8), xs:double(4.3e8)) and
                            d:assert-equal(xs:double(4.3e8 +1E-8), 
                                     xs:double(4.3e8),$tolerance)  and
                            d:assert-equal(xs:float(2.718E-4),xs:float(2.718E-4),
                                       xs:float($tolerance)) and
                            d:assert-equal(xs:date('1999-12-31'),
                                      xs:date('1999-12-31')) and
                            d:assert-equal(xs:time('12:00:00'),xs:time('12:00:00')) and
                            d:assert-equal(xs:dateTime('1999-12-31T12:00:00'),
                                      xs:dateTime('1999-12-31T12:00:00')) and
                            d:assert-equal(xs:yearMonthDuration('P1Y2M'),
                                      xs:yearMonthDuration('P1Y2M')) and
                            d:assert-equal(xs:dayTimeDuration('P23DT10M12S'),
                                           xs:dayTimeDuration('P23DT10M12S')) and
                            d:assert-equal(xs:duration('P1YT22H'),
                                           xs:duration('P1YT22H')) and
                            d:assert-equal(xs:QName('d:temp'), xs:QName('d:temp')) and
                            d:assert-equal(xs:anyURI('http://www.dpawson.co.uk'), 
                                           xs:anyURI('http://www.dpawson.co.uk')) and
                            d:assert-equal(xs:gDay('---31+03:00'),
                                        xs:gDay('---31+03:00'))  and 
                            d:assert-equal(xs:gMonthDay('--05-31+03:00'),
                                        xs:gMonthDay('--05-31+03:00')) and
                            d:assert-equal(xs:gMonth('--06'),
                                        xs:gMonth('--06'))  and
                            d:assert-equal(xs:gYearMonth('2009-07'),
                                        xs:gYearMonth('2009-07')) and
                            d:assert-equal(xs:gYear('2008'), xs:gYear('2008')) and
                            d:assert-equal(xs:base64Binary('QSBwbGFpbiB0ZXh0IGZpbGUK'), 
                                    xs:base64Binary('QSBwbGFpbiB0ZXh0IGZpbGUK')) and
                            d:assert-equal(xs:hexBinary('BAC236D5'),
                                           xs:hexBinary('BAC236D5')) 
                            "/> 
     

    </xsl:message>

    <xsl:variable name="tv" as="item()+">
      <!--    <xsl:copy-of select="document('junit.input.xml')/*"/> -->
      <xsl:apply-templates select="document('junit.input.xml')/doc"/>
    </xsl:variable>

<!-- Very simple deep-equal test of a template output -->
<!-- Expected output -->
    

    
    <xsl:message>
      <xsl:value-of select="deep-equal($tv,$exp)"/>
     </xsl:message>

  </xsl:template>

 

  <xsl:template match="doc">
    <xsl:copy-of select="*"/>
  </xsl:template>



<!-- Experimental two parameter assert-equal -->
<xsl:function name="d:assert-equal" as="xs:boolean">
   <xsl:param name="n1" />
    <xsl:param name="n2" />
    
  
   <xsl:choose xml:id="basic">
      <xsl:when test="($n1 instance of xs:string) and ($n2 instance of xs:string)">
         <xsl:sequence select="d:string-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:boolean) and ($n2 instance of xs:boolean)">
         <xsl:sequence select="d:boolean-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:integer) and ($n2 instance of xs:integer)">
         <xsl:sequence select="d:integer-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:decimal) and ($n2 instance of xs:decimal)">
         <xsl:sequence select="d:decimal-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:double) and ($n2 instance of xs:double)">
         <xsl:sequence select="d:double-cmp($n1,$n2)"/>
      </xsl:when>
   
      <xsl:when test="($n1 instance of xs:date) and ($n2 instance of xs:date)">
         <xsl:sequence select="d:date-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:time) and ($n2 instance of xs:time)">
         <xsl:sequence select="d:time-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:dateTime) and ($n2 instance of xs:dateTime)">
         <xsl:sequence select="d:dateTime-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:yearMonthDuration) and ($n2 instance of xs:yearMonthDuration)">
         <xsl:sequence select="d:yearMonthDuration-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:dayTimeDuration) and ($n2 instance of xs:dayTimeDuration)">
         <xsl:sequence select="d:dayTimeDuration-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:duration) and ($n2 instance of xs:duration)">
         <xsl:sequence select="d:duration-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:QName) and ($n2 instance of xs:QName)">
         <xsl:sequence select="d:QName-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:anyURI) and ($n2 instance of xs:anyURI)">
         <xsl:sequence select="d:anyURI-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:gDay) and ($n2 instance of xs:gDay)">
         <xsl:sequence select="d:gDay-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:gMonthDay) and ($n2 instance of xs:gMonthDay)">
         <xsl:sequence select="d:gMonthDay-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:gMonth) and ($n2 instance of xs:gMonth)">
         <xsl:sequence select="d:gMonth-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:gYearMonth) and ($n2 instance of xs:gYearMonth)">
         <xsl:sequence select="d:gYearMonth-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:gYear) and ($n2 instance of xs:gYear)">
         <xsl:sequence select="d:gYear-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:base64Binary) and ($n2 instance of xs:base64Binary)">
         <xsl:sequence select="d:base64Binary-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:hexBinary) and ($n2 instance of xs:hexBinary)">
         <xsl:sequence select="d:hexBinary-cmp($n1,$n2)"/>
      </xsl:when>
      <xsl:otherwise>
         <xsl:message terminate="yes">
          Unable to parse the type of [<xsl:value-of select="$n1"/> and <xsl:value-of select="$n2"/>]
        </xsl:message>
      </xsl:otherwise>
   </xsl:choose>
</xsl:function>

<!-- 3 parameter assert-equal  -->
<!--  compare float | double  -->
<xsl:function name="d:assert-equal" as="xs:boolean">
   <xsl:param name="n1" />
    <xsl:param name="n2" />
    <xsl:param name="pPrecision" />
    <xsl:choose>
      <xsl:when test="($n1 instance of xs:double) and 
                      ($n2 instance of  xs:double) and
                      ($pPrecision instance of xs:double)">
        <xsl:sequence 
          select="d:double-cmp(xs:double($n1),
                  xs:double($n2),
                  xs:double($pPrecision))"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:float) and 
                      ($n2 instance of  xs:float) and
                      ($pPrecision instance of xs:float)">
        <xsl:sequence 
          select="d:float-cmp(xs:float($n1),
                  xs:float($n2),
                  xs:float($pPrecision))"/>
      </xsl:when>
      <xsl:when test="($n1 instance of xs:decimal) and 
                      ($n2 instance of  xs:decimal) and
                      ($pPrecision instance of xs:decimal)">
        <xsl:sequence 
          select="d:decimal-cmp(xs:decimal($n1),
                  xs:decimal($n2),
                  xs:decimal($pPrecision))"/>
      </xsl:when>




      <xsl:otherwise>
        <xsl:message terminate="yes">
          Unable to parse the type of [<xsl:value-of select="$n1"/> and <xsl:value-of select="$n2"/> with precision <xsl:value-of select="$pPrecision"/>]
        </xsl:message>
      </xsl:otherwise>
    </xsl:choose>

</xsl:function>




<!-- Integer compare -->
  <xsl:function name="d:int-cmp" as="xs:boolean">
    <xsl:param name="n1" as="xs:integer"/>
    <xsl:param name="n2" as="xs:integer"/>
    <xsl:if test="$debug">
      <xsl:message>
    int-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
      </xsl:message>
    </xsl:if>
    <xsl:sequence select="$n1 eq $n2"/>
  </xsl:function>




<!-- Double compare -->
 <xsl:function name="d:double-cmp" as="xs:boolean">
    <xsl:param name="n1" as="xs:double"/>
    <xsl:param name="n2" as="xs:double"/>
    <xsl:param name="tolerance" as="xs:double"/>
  <xsl:if test="$debug">
      <xsl:message>double-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
      </xsl:message>
    </xsl:if>
    <xsl:sequence select="abs($n1 - $n2) &lt;= $tolerance"/>  
  </xsl:function>


<!-- decimal compare -->
 <xsl:function name="d:decimal-cmp" as="xs:boolean">
    <xsl:param name="n1" as="xs:decimal"/>
    <xsl:param name="n2" as="xs:decimal"/>
    <xsl:param name="tolerance" as="xs:decimal"/>
  <xsl:if test="$debug">
      <xsl:message>decimal-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
      </xsl:message>
    </xsl:if>
    <xsl:sequence select="abs($n1 - $n2) &lt;= $tolerance"/>  
  </xsl:function>






<!-- item() compare -->
<xsl:function name="d:item-cmp" as="xs:boolean">
  <xsl:param name="n1" as="item()+"/>
  <xsl:param name="n2" as="item()+"/>
  <xsl:sequence select="$n1 eq $n2"/>
</xsl:function>










<!-- Numeric compare (int, real, double etc.  -->
<!-- Convert to double -->

 <xsl:function name="d:numeric-cmp" as="xs:boolean">
    <xsl:param name="n1" as="item()"/>
    <xsl:param name="n2" as="item()"/>
    <xsl:param name="tolerance" as="xs:double"/>
    <xsl:choose>
    <xsl:when test="($n1 castable as xs:double) and 
                    ($n2 castable as xs:double)">
      <xsl:sequence select="
               abs(number($n1) - number($n2)) &lt;= $tolerance "/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:sequence select="false()"/>
    </xsl:otherwise>
  </xsl:choose>
  </xsl:function>

<!--  -->
<!--   Remainder are automatically generated by Florent Georges code -->
<!--   See /sgml/xslt2/florent-->
<!--   sax2 xs-simple-types.xml func-copy-make-whens.xsl op.xml  -->


 <!--      Compare string-->  
<xsl:function name="d:string-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:string"/>
      <xsl:param name="n2" as="xs:string"/>
      <xsl:if test="$debug">
         <xsl:message>string-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare boolean-->  
<xsl:function name="d:boolean-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:boolean"/>
      <xsl:param name="n2" as="xs:boolean"/>
      <xsl:if test="$debug">
         <xsl:message>boolean-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare decimal-->  
<!--      Compare integer-->  
<xsl:function name="d:integer-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:integer"/>
      <xsl:param name="n2" as="xs:integer"/>
      <xsl:if test="$debug">
         <xsl:message>integer-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>

   <xsl:function name="d:decimal-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:decimal"/>
      <xsl:param name="n2" as="xs:decimal"/>
      <xsl:if test="$debug">
         <xsl:message>decimal-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare double-->  
<xsl:function name="d:double-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:double"/>
      <xsl:param name="n2" as="xs:double"/>
      <xsl:if test="$debug">
         <xsl:message>double-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>

 



   <!--      Compare float-->  
<xsl:function name="d:float-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:float"/>
      <xsl:param name="n2" as="xs:float"/>
      <xsl:param name="pPrecision" as="xs:float"/>

      <xsl:if test="$debug">
         <xsl:message>float-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="abs($n1 - $n2) &lt; $pPrecision"/>
   </xsl:function>






   <!--      Compare date-->  
<xsl:function name="d:date-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:date"/>
      <xsl:param name="n2" as="xs:date"/>
      <xsl:if test="$debug">
         <xsl:message>date-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare time-->  
<xsl:function name="d:time-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:time"/>
      <xsl:param name="n2" as="xs:time"/>
      <xsl:if test="$debug">
         <xsl:message>time-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare dateTime-->  
<xsl:function name="d:dateTime-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:dateTime"/>
      <xsl:param name="n2" as="xs:dateTime"/>
      <xsl:if test="$debug">
         <xsl:message>dateTime-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare duration-->  
<!--      Compare yearMonthDuration-->  
<xsl:function name="d:yearMonthDuration-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:yearMonthDuration"/>
      <xsl:param name="n2" as="xs:yearMonthDuration"/>
      <xsl:if test="$debug">
         <xsl:message>yearMonthDuration-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare dayTimeDuration-->  
<xsl:function name="d:dayTimeDuration-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:dayTimeDuration"/>
      <xsl:param name="n2" as="xs:dayTimeDuration"/>
      <xsl:if test="$debug">
         <xsl:message>dayTimeDuration-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <xsl:function name="d:duration-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:duration"/>
      <xsl:param name="n2" as="xs:duration"/>
      <xsl:if test="$debug">
         <xsl:message>duration-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare QName-->  
<xsl:function name="d:QName-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:QName"/>
      <xsl:param name="n2" as="xs:QName"/>
      <xsl:if test="$debug">
         <xsl:message>QName-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare anyURI-->  
<xsl:function name="d:anyURI-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:anyURI"/>
      <xsl:param name="n2" as="xs:anyURI"/>
      <xsl:if test="$debug">
         <xsl:message>anyURI-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare gDay-->  
<xsl:function name="d:gDay-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:gDay"/>
      <xsl:param name="n2" as="xs:gDay"/>
      <xsl:if test="$debug">
         <xsl:message>gDay-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare gMonthDay-->  
<xsl:function name="d:gMonthDay-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:gMonthDay"/>
      <xsl:param name="n2" as="xs:gMonthDay"/>
      <xsl:if test="$debug">
         <xsl:message>gMonthDay-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare gMonth-->  
<xsl:function name="d:gMonth-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:gMonth"/>
      <xsl:param name="n2" as="xs:gMonth"/>
      <xsl:if test="$debug">
         <xsl:message>gMonth-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare gYearMonth-->  
<xsl:function name="d:gYearMonth-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:gYearMonth"/>
      <xsl:param name="n2" as="xs:gYearMonth"/>
      <xsl:if test="$debug">
         <xsl:message>gYearMonth-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare gYear-->  
<xsl:function name="d:gYear-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:gYear"/>
      <xsl:param name="n2" as="xs:gYear"/>
      <xsl:if test="$debug">
         <xsl:message>gYear-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare base64Binary-->  
<xsl:function name="d:base64Binary-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:base64Binary"/>
      <xsl:param name="n2" as="xs:base64Binary"/>
      <xsl:if test="$debug">
         <xsl:message>base64Binary-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>
   <!--      Compare hexBinary-->  
<xsl:function name="d:hexBinary-cmp" as="xs:boolean">
      <xsl:param name="n1" as="xs:hexBinary"/>
      <xsl:param name="n2" as="xs:hexBinary"/>
      <xsl:if test="$debug">
         <xsl:message>hexBinary-cmp    <xsl:value-of select="$n1"/>,<xsl:value-of select="$n2"/>
         </xsl:message>
      </xsl:if>
      <xsl:sequence select="$n1 eq $n2"/>
   </xsl:function>


</xsl:stylesheet>


<!--
 # Software distributed under the License is distributed on an "AS IS" basis,
 # WITHOUT WARRANTY OF ANY KIND, either express or implied.
 # See the License for rights and limitations under the License.
 # junit.xsl provides binary comparator functions
 # Copyright (C) 2007,2008,2009,2010  Dave Pawson
 # Contribution: Florent Georges
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or (at
 # your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 # 02110-1301, USA.
 #
 # Software distributed under the License is distributed on an "AS IS" basis,
 # WITHOUT WARRANTY OF ANY KIND, either express or implied.
 # See the License for rights and limitations under the License.
 -->
