<?xml version="1.0"?>
<!--
  Tests dependency graph

  Copyright (C) 2014-2023 Ryan Specialty, LLC.

    This file is part of TAME.

    TAME 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 3 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, see
    <http://www.gnu.org/licenses/>.
-->
<description xmlns="http://www.jenitennison.com/xslt/xspec"
             xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
             xmlns:x="http://www.jenitennison.com/xslt/xspec"
             xmlns:graph="http://www.lovullo.com/tame/graph"
             xmlns:preproc="http://www.lovullo.com/rater/preproc"
             xmlns:foo="http://www.lovullo.com/_junk"
             stylesheet="graph-test.xsl">


  <scenario label="graph:make-from-vertices">
    <scenario label="with no vertices">
      <call function="graph:make-from-vertices">
        <param name="vertices"
               select="()" />
      </call>

      <expect label="produces an empty graph">
        <preproc:sym-deps />
      </expect>
    </scenario>


    <scenario label="with vertices">
      <call function="graph:make-from-vertices">
        <param name="vertices"
               select="$foo:graph-vtwo/preproc:sym-dep" />
      </call>

      <expect label="produces a graph containing those vertices"
              select="$foo:graph-vtwo" />
    </scenario>


    <scenario label="with duplicate vertices">
      <call function="graph:make-from-vertices">
        <param name="vertices"
               select="$foo:graph-with-dupes/preproc:sym-dep" />
      </call>

      <expect label="removes duplicate vertices and edges"
              select="$foo:graph-deduped" />
    </scenario>
  </scenario>


  <scenario label="graph:reverse on a disconnected DAG">
    <call function="graph:reverse">
      <param name="graph"
             select="$foo:reverse-graph" />
    </call>

    <!-- "root" (walk=0) vertices are used by nothing -->

    <expect label="reverses walk=0 edges (A)"
            test="empty(
                    $x:result/preproc:sym-dep[ @name = 'A' ]/* )" />

    <expect label="reverses walk=0 edges (X)"
            test="empty(
                    $x:result/preproc:sym-dep[ @name = 'X' ]/* )" />


    <expect label="reverses edges recursively (B-A)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'B' ]
                            /preproc:sym-ref[ @name = 'A' ] )" />

    <!-- circular -->
    <expect label="reverses edges recursively (B-D)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'B' ]
                            /preproc:sym-ref[ @name = 'D' ] )" />

    <expect label="reverses edges recursively (C-A)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'C' ]
                            /preproc:sym-ref[ @name = 'A' ] )" />

    <expect label="reverses edges recursively (C-B)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'C' ]
                            /preproc:sym-ref[ @name = 'B' ] )" />

    <expect label="reverses edges recursively (D-C)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'D' ]
                            /preproc:sym-ref[ @name = 'C' ] )" />

    <expect label="reverses walk=1 edges (Z-X)"
            test="exists( $x:result/preproc:sym-dep[ @name = 'Z' ]
                            /preproc:sym-ref[ @name = 'X' ] )" />


    <!-- if done properly, we should have no new edges (the direction
         on existing edges should just be reversed): the new graph
         should be an isomorphism of the original  -->
    <expect label="does not produce any additional edges"
            test="count( $x:result//preproc:sym-ref )
                    = count( $foo:reverse-graph//preproc:sym-ref )" />

    <expect label="does not produce any additional vertices"
            test="count( distinct-values( $x:result//preproc:*/@name ) )
                    = count( distinct-values(
                        $foo:reverse-graph//preproc:*/@name ) )" />

    <expect label="copies union of edge attributes to new edges"
            test="every $edge in $x:result//preproc:sym-ref
                      [ ancestor::preproc:sym-dep[ @name = 'C' ] ]
                    satisfies
                      $edge/@cattr = 'cvalue'
                        and $edge/@cattr2 = 'cvalue2'" />
  </scenario>


  <scenario label="graph:union">
    <scenario label="given nothing">
      <call function="graph:union">
        <param name="graphs"
               select="()" />
      </call>

      <expect label="produces an empty graph"
              select="$foo:graph-empty" />
    </scenario>


    <scenario label="given two empty graphs">
      <call function="graph:union">
        <param name="graphs"
               select="( $foo:graph-empty, $foo:graph-empty )" />
      </call>

      <expect label="produces an empty graph"
              select="$foo:graph-empty" />
    </scenario>


    <scenario label="given graph with empty">
      <call function="graph:union">
        <param name="graphs"
               select="( $foo:graph-empty, $foo:graph-vtwo )" />
      </call>

      <expect label="produces the non-empty graph"
              select="$foo:graph-vtwo" />
    </scenario>


    <scenario label="given two different graphs">
      <call function="graph:union">
        <param name="graphs"
               select="( $foo:graph-vtwo, $foo:graph-vthree )" />
      </call>

      <expect label="merges vertices and edges of unique vertices"
              select="$foo:graph-vtwo-vthree" />
    </scenario>


    <scenario label="given single graph with duplicate vertices">
      <call function="graph:union">
        <param name="graphs"
               select="$foo:graph-with-dupes" />
      </call>

      <expect label="mergs duplicates"
              select="$foo:graph-deduped" />
    </scenario>
  </scenario>



  <scenario label="graph:dep-lookup">
    <scenario label="given a symbol">
      <scenario label="in the same package">
        <scenario label="where dependencies exist">
          <call function="graph:dep-lookup">
            <param name="lookup" select="()" />

            <param name="graph"
                   select="$foo:document/preproc:sym-deps" />

            <param name="symbol"
                   select="$foo:document/preproc:symtable
                             /preproc:sym[ @name='local' ]" />
          </call>

          <expect label="returns local dependencies"
                  test="$x:result is
                          $foo:document/preproc:sym-deps/preproc:sym-dep[
                            @name='local' ]" />
        </scenario>


        <scenario label="with external @src but local deps">
          <call function="graph:dep-lookup">
            <param name="lookup" select="()" />

            <param name="graph"
                   select="$foo:document/preproc:sym-deps" />

            <param name="symbol"
                   select="$foo:document/preproc:symtable
                             /preproc:sym[ @name='external-but-not' ]" />
          </call>

          <expect label="returns local dependencies"
                  test="$x:result is
                          $foo:document/preproc:sym-deps/preproc:sym-dep[
                            @name='external-but-not' ]" />
        </scenario>


        <scenario label="where dependencies are missing">
          <call function="graph:dep-lookup">
            <param name="lookup" select="()" />

            <param name="graph"
                   select="$foo:document/preproc:sym-deps" />


            <param name="symbol"
                   select="$foo:document/preproc:symtable
                             /preproc:sym[ @name='missing-deps' ]" />
          </call>

          <expect label="return empty sequence"
                  test="empty( $x:result )" />
        </scenario>
      </scenario>


      <scenario label="in a separate package">
        <scenario label="where dependencies exist">
          <call function="graph:dep-lookup">
            <param name="lookup"
                   select="foo:lookup( $foo:expected-lookup )" />

            <param name="graph"
                   select="$foo:document/preproc:sym-deps" />

            <param name="symbol"
                   select="$foo:document/preproc:symtable
                             /preproc:sym[ @name='external' ]" />
          </call>

          <expect label="returns external dependenices"
                  test="deep-equal( $x:result/*, $foo:expected-lookup )" />
        </scenario>
      </scenario>
    </scenario>
  </scenario>


  <scenario label="graph:make-from-deps">
    <call function="graph:make-from-deps">
      <param name="lookup"
             select="foo:lookup-sym( $foo:expected-lookup )" />

      <param name="symbols"
             select="$foo:sym-list" />
    </call>

    <expect label="produces a graph"
            test="$x:result instance of element( preproc:sym-deps )" />

    <expect label="looks up each symbol"
            test="every $vertex in $x:result/preproc:sym-dep
                    satisfies
                      deep-equal( $vertex/*, $foo:expected-lookup )" />
  </scenario>


  <scenario label="graph:lookup-from-doc">
    <variable name="expected-doc" as="document-node()"
              select="document( 'graph-doc.xml', root() )" />

    <scenario label="given a known external symbol">
      <call function="graph:lookup-from-doc">
        <param name="doc-ext"
               select="'xml'" />

        <param name="rel-node"
               select="root()" />

        <param name="symbol"
               select="$foo:document/preproc:symtable
                         /preproc:sym[ @name = 'doc-sym' ]" />
      </call>

      <expect label="looks up subgraph from document"
              test="deep-equal( $x:result,
                                $expected-doc/*/preproc:sym-deps )" />
    </scenario>


    <!-- since we're looking up the graph, we don't really care if the symbol
         exissts in it or not (that is a caller concern) -->
    <scenario label="given an unknown external symbol">
      <call function="graph:lookup-from-doc">
        <param name="doc-ext"
               select="'xml'" />

        <param name="rel-node"
               select="root()" />

        <param name="symbol"
               select="$foo:document/preproc:symtable
                         /preproc:sym[ @name = 'doc-sym-unknown' ]" />
      </call>

      <expect label="looks up subgraph from document"
              test="deep-equal( $x:result,
                                $expected-doc/*/preproc:sym-deps )" />
    </scenario>


    <scenario label="given a symbol with no @src">
      <call function="graph:lookup-from-doc">
        <param name="doc-ext"
               select="'xml'" />

        <param name="rel-node"
               select="root()" />

        <param name="symbol"
               select="$foo:document/preproc:symtable
                         /preproc:sym[ @name = 'local' ]" />
      </call>

      <expect label="produces empty sequence"
              test="empty( $x:result )" />
    </scenario>
  </scenario>
</description>
