intermediate.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--  This file is part of the SPFE Open Toolkit. See the accompanying license.txt file -->
<!--  for applicable licenses. -->
<!--  (c) Copyright Analecta Communications Inc. 2015 All Rights Reserved. -->
<!--  Need test for unicode characters and numbers in names. -->
<tests xml:lang="en">
<title>SAM Parser Tests</title>

<description>
<p>This document is the output of the test document processed by test.xslt. That stylesheet attempt to validate the outcome of tests by generating a string version of the markup under the <code language="sam">markup:</code> heading and comparing it to the text of the expected result as shown under the <code>result:</code> heading in the test file. This is not a perfect test. Two issues are known:</p>
<ol>
<li>
<p>Test are done on whitespace normalized versions of the XML markup strings. As such, they do not validly test situations where whitespace should be retained, such as in codeblocks and at the beginning of lines.</p>
</li>
<li>
<p>The SAM parser outputs attributes in alphabetical order. (From an XML point of view, the order of attributes does not matter.) Test should be written such that the attributes in the <code>result:</code> section are in alphabetical order. If not, the test will fail even though the XML is semantically identical.</p>
</li>
</ol>
<p>When running this test you should receive one SAM Parser Warning:</p>
<codeblock language="terminal">
SAM parser warning: Unannotated phrase found: {should be reported} If you are trying to insert curly braces into the document, use \{should be reported}.
</codeblock>
<p>This is a test to make sure unannotated phrases are being reported correctly.</p>
<p>The following lines exist to anchor ids used for idref examples in the tests:</p>
<line id="cit">Cit</line>
<line id="MobyDick">Moby Dick</line>
<line id="bing">bing</line>
<line id="my-table">my-table</line>
</description>
<test>
<title>Includes</title>

<description>
<p>Include content from another SAM file.</p>
</description>
<case>
<title>Simple include</title>

<description>
<p>An include statement.</p>
</description>
<source>
<codeblock language="sam">
&lt;&lt;&lt;(includeme.sam)
</codeblock>
</source>
<markup>
<message>
<title>Hello World.</title>

<p>This is the "include" test -- file.</p>
<grid>
<row>
<cell>foo</cell>
<cell>bar</cell>
</row>
<row>
<cell>baz</cell>
<cell>bat</cell>
</row>
</grid>
<p>Annotation lookup test: <phrase><annotation type="test">test phrase</annotation></phrase>.</p>
</message>
</markup>
<result>
<codeblock language="xml">
&lt;message&gt;
&lt;title&gt;Hello World.&lt;/title&gt;
&lt;p&gt;This is the "include" test -- file.&lt;/p&gt;
&lt;grid&gt;
&lt;row&gt;
&lt;cell&gt;foo&lt;/cell&gt;
&lt;cell&gt;bar&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;baz&lt;/cell&gt;
&lt;cell&gt;bat&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
&lt;p&gt;Annotation lookup test: &lt;phrase&gt;&lt;annotation type="test"&gt;test phrase&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
&lt;/message&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested includes</title>

<description>
<p>Including a file that itself includes a file.</p>
</description>
<source>
<codeblock language="sam">
&lt;&lt;&lt;(includeme1.sam)
</codeblock>
</source>
<markup>
<message>
<p>This file includes another file.</p>
<p>Nested includes work! Yipee!</p>
</message>
</markup>
<result>
<codeblock language="xml">
&lt;message&gt;
&lt;p&gt;This file includes another file.&lt;/p&gt;
&lt;p&gt;Nested includes work! Yipee!&lt;/p&gt;
&lt;/message&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Blocks</title>

<description>
<p>Blocks are the basic building block of a SAM file. This whole document is a test case for blocks.</p>
</description>
<case>
<title>Language metadata</title>

<description>
<p>A block with language metadata.</p>
</description>
<source>
<codeblock language="sam">
section:(!es)
    Feliz Navidad
</codeblock>
</source>
<markup>
<section xml:lang="es">
<p>Feliz Navidad</p>
</section>
</markup>
<result>
<codeblock language="xml">
&lt;section xml:lang="es"&gt;
    &lt;p&gt;Feliz Navidad&lt;/p&gt;
&lt;/section&gt;
</codeblock>
</result>
</case>
<case>
<title>Citations</title>

<description>
<p>A citation on the block.</p>
</description>
<source>
<codeblock language="sam">
section:(!es)[Mother McCree] Greeting
    Feliz Navidad
</codeblock>
</source>
<markup>
<section xml:lang="es">
<citation>Mother McCree</citation>
<title>Greeting</title>

<p>Feliz Navidad</p>
</section>
</markup>
<result>
<codeblock language="xml">
&lt;section xml:lang="es"&gt;
    &lt;citation&gt;Mother McCree&lt;/citation&gt;
    &lt;title&gt;Greeting&lt;/title&gt;
    &lt;p&gt;Feliz Navidad&lt;/p&gt;
&lt;/section&gt;
</codeblock>
</result>
</case>
<case>
<title>Escaping block syntax</title>

<description>
<p>Escape colon to prevent single word followed by colon being recognized as a block.</p>
</description>
<source>
<codeblock language="sam">
and\:
</codeblock>
</source>
<markup>
<p>and:</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;and:&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Complex block structure</title>

<description>
<p>A complex block with various structures inside.</p>
</description>
<source>
<codeblock language="sam">
document:
    head:(#foo)
        foo: barney {and}(conjunction) betty
        baz: bat
        $name=fred {and}(conjunction) wilma
        history:: date, author, comment, status
            2014-06-23, mbaker, New\, Topic, In progress
            2016-07-01, mbaker, Revision, In progress
        index:: type, term
            feature, fragment
            feature, fragments
    body: How Fragments Work
        Stuff on how fragments work.
</codeblock>
</source>
<markup>
<document>
<head name="foo">
<foo>barney <phrase><annotation type="conjunction">and</annotation></phrase> betty</foo>
<baz>bat</baz>
<variable name="name">fred <phrase><annotation type="conjunction">and</annotation></phrase> wilma</variable>
<history>
<record>
<date>2014-06-23</date>
<author>mbaker</author>
<comment>New, Topic</comment>
<status>In progress</status>
</record>
<record>
<date>2016-07-01</date>
<author>mbaker</author>
<comment>Revision</comment>
<status>In progress</status>
</record>
</history>
<index>
<record>
<type>feature</type>
<term>fragment</term>
</record>
<record>
<type>feature</type>
<term>fragments</term>
</record>
</index>
</head>
<body>
<title>How Fragments Work</title>

<p>Stuff on how fragments work.</p>
</body>
</document>
</markup>
<result>
<codeblock language="xml">
&lt;document&gt;
&lt;head name="foo"&gt;
&lt;foo&gt;barney &lt;phrase&gt;&lt;annotation type="conjunction"&gt;and&lt;/annotation&gt;&lt;/phrase&gt; betty&lt;/foo&gt;
&lt;baz&gt;bat&lt;/baz&gt;
&lt;variable name="name"&gt;fred &lt;phrase&gt;&lt;annotation type="conjunction"&gt;and&lt;/annotation&gt;&lt;/phrase&gt; wilma&lt;/variable&gt;
&lt;history&gt;
&lt;record&gt;
&lt;date&gt;2014-06-23&lt;/date&gt;
&lt;author&gt;mbaker&lt;/author&gt;
&lt;comment&gt;New, Topic&lt;/comment&gt;
&lt;status&gt;In progress&lt;/status&gt;
&lt;/record&gt;
&lt;record&gt;
&lt;date&gt;2016-07-01&lt;/date&gt;
&lt;author&gt;mbaker&lt;/author&gt;
&lt;comment&gt;Revision&lt;/comment&gt;
&lt;status&gt;In progress&lt;/status&gt;
&lt;/record&gt;
&lt;/history&gt;
&lt;index&gt;
&lt;record&gt;
&lt;type&gt;feature&lt;/type&gt;
&lt;term&gt;fragment&lt;/term&gt;
&lt;/record&gt;
&lt;record&gt;
&lt;type&gt;feature&lt;/type&gt;
&lt;term&gt;fragments&lt;/term&gt;
&lt;/record&gt;
&lt;/index&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;title&gt;How Fragments Work&lt;/title&gt;
&lt;p&gt;Stuff on how fragments work.&lt;/p&gt;
&lt;/body&gt;
&lt;/document&gt;
</codeblock>
</result>
</case>
<case>
<title>Paragraph with colon in first word</title>

<description>
<p>Case related to issue #94.</p>
</description>
<source>
<codeblock language="sam">
article: Foo

    foo{bar}(http://www.example.com/).

    `foo::bar` baz.
</codeblock>
</source>
<markup>
<article>
<title>Foo</title>

<p>foo<phrase><annotation type="link" specifically="http://www.example.com/">bar</annotation></phrase>.</p>
<p><code>foo::bar</code> baz.</p>
</article>
</markup>
<result>
<codeblock language="xml">
&lt;article&gt;
&lt;title&gt;Foo&lt;/title&gt;
&lt;p&gt;foo&lt;phrase&gt;&lt;annotation type="link" specifically="http://www.example.com/"&gt;bar&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;foo::bar&lt;/code&gt; baz.&lt;/p&gt;
&lt;/article&gt;
</codeblock>
</result>
</case>
</test>
<!--  FIXME: Need tests for comments. -->
<test>
<title>Remarks</title>

<description>
<p>Remarks are a type of comment that is attributed to an author and is used for commenting editorially on the document.</p>
</description>
<case>
<title>Simple remark</title>

<description>
<p>Just a simple remark. Nothing fancy.</p>
</description>
<source>
<codeblock language="sam">
!!!(mbaker)
    This is a remark.
</codeblock>
</source>
<markup>
<remark attribution="mbaker">
<p>This is a remark.</p>
</remark>
</markup>
<result>
<codeblock language="xml">
&lt;remark attribution="mbaker"&gt;
&lt;p&gt;This is a remark.&lt;/p&gt;
&lt;/remark&gt;
</codeblock>
</result>
</case>
<case>
<title>Complex remark</title>

<description>
<p>A little bit more complex.</p>
</description>
<source>
<codeblock language="sam">
!!!(Charles André Joseph Marie de Gaulle !@#$%^&amp;*(((({}":&lt;&gt;)(*cdg1)(!fr)
    This is a remark.
</codeblock>
</source>
<markup>
<remark attribution="Charles André Joseph Marie de Gaulle !@#$%^&amp;*(((({}&quot;:&lt;&gt;" id="cdg1" xml:lang="fr">
<p>This is a remark.</p>
</remark>
</markup>
<result>
<codeblock language="xml">
&lt;remark attribution="Charles André Joseph Marie de Gaulle !@#$%^&amp;amp;*(((({}&amp;quot;:&amp;lt;&amp;gt;" id="cdg1" xml:lang="fr"&gt;
&lt;p&gt;This is a remark.&lt;/p&gt;
&lt;/remark&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Fields</title>

<description>
<p>A field is a block without children. A field value does not get wrapped in a title element. It is simple the value of the field.</p>
</description>
<case>
<title>Nested fields</title>

<description>
<p>Nested fields. Anything with a child, of course, is a block, not a field.</p>
</description>
<source>
<codeblock language="sam">
address:
    name: Fred Flintstone
    address: Bedrock
    era: Stone Age
</codeblock>
</source>
<markup>
<address>
<name>Fred Flintstone</name>
<address>Bedrock</address>
<era>Stone Age</era>
</address>
</markup>
<result>
<codeblock language="xml">
&lt;address&gt;
&lt;name&gt;Fred Flintstone&lt;/name&gt;
&lt;address&gt;Bedrock&lt;/address&gt;
&lt;era&gt;Stone Age&lt;/era&gt;
&lt;/address&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Paragraphs</title>

<description>
<p>A paragraph is a block of text over consecutive lines.</p>
</description>
<case>
<title>Paragraph</title>

<description>
<p>A simple multi-line paragraph ending with a blank space.</p>
</description>
<source>
<codeblock language="sam">
Wafting zephyrs
quickly vexed
Jumbo.
</codeblock>
</source>
<markup>
<p>Wafting zephyrs quickly vexed Jumbo.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Wafting zephyrs quickly vexed Jumbo.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>With annotated phrase</title>

<description>
<p>A paragraph over multiple lines with an annotated phrase.</p>
</description>
<source>
<codeblock language="sam">
This is a {paragraph}(foo)
that wraps across
multiple lines.
</codeblock>
</source>
<markup>
<p>This is a <phrase><annotation type="foo">paragraph</annotation></phrase> that wraps across multiple lines.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This is a &lt;phrase&gt;&lt;annotation type="foo"&gt;paragraph&lt;/annotation&gt;&lt;/phrase&gt; that wraps across multiple lines.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Ordered lists</title>

<description>
<p>Ordered lists are created by starting a line with a number followed by a period. Exact numbers are not retained.</p>
</description>
<case>
<title>Ordered list with spaces</title>

<description>
<p>Ordered lists can have blank lines between the items.</p>
</description>
<source>
<codeblock language="sam">
0. One

0. Two

99999. Three
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two</p>
</li>
<li>
<p>Three</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Ordered list no spaces</title>

<description>
<p>List are also recognized without space between items. List items can wrap to another line if more indented than the number. Additional paragraphs can be included if more indented than the number.</p>
</description>
<source>
<codeblock language="sam">
0. One
0. Two this
   paragraph wraps.

   This is another para in the list item.
99999. Three
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two this paragraph wraps.</p>
<p>This is another para in the list item.</p>
</li>
<li>
<p>Three</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two this paragraph wraps.&lt;/p&gt;
&lt;p&gt;This is another para in the list item.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Ordered list mixed spacing</title>

<description>
<p>Ordered list with inconsistent spacing.</p>
</description>
<source>
<codeblock language="sam">
0. One

0. Two
99999. Three

7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two</p>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested ordered list with spaces</title>

<description>
<p>Ordered lists at different indents, with spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One

0. Two x

    5. Two and a quarter x

    6. Two and a half

    9. Two and three quarters

99999. Three

7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two x</p>
<ol>
<li>
<p>Two and a quarter x</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ol>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two x&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter x&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested ordered lists with no spaces</title>

<description>
<p>Ordered lists at different indents, with no spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One
0. Two z
    5. Two and a quarter z
    6. Two and a half
    9. Two and three quarters
99999. Three
7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two z</p>
<ol>
<li>
<p>Two and a quarter z</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ol>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two z&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter z&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested ordered list with mixed spacing</title>

<description>
<p>Ordered lists at different indents, with some spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One
0. Two r
    5. Two and a quarter r

    6. Two and a half
    9. Two and three quarters

99999. Three

7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two r</p>
<ol>
<li>
<p>Two and a quarter r</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ol>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two r&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter r&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Unordered lists</title>

<description>
<p>Unordered lists are indicated by starting a line with <code>*</code>.</p>
</description>
<case>
<title>Unordered list with spaces</title>

<description>
<p>A list with spaces between the lines.</p>
</description>
<source>
<codeblock language="sam">
* One

* Two t

* Three
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two t</p>
</li>
<li>
<p>Three</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two t&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Unordered list no spaces</title>

<description>
<p>A list with no spaces between the lines.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two y
* Three
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two y</p>
</li>
<li>
<p>Three</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two y&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Unordered list mixed spacing</title>

<description>
<p>A list with mixed spacing between the lines.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two u

* Three
* Four
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two u</p>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two u&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested list with spaces</title>

<description>
<p>Nested lists separated by spaces.</p>
</description>
<source>
<codeblock language="sam">
* One

* Two i

    * Two and a quarter

    * Two and a half

    * Two and three quarters

* Three

* Four
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two i</p>
<ul>
<li>
<p>Two and a quarter</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two i&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested unordered list with no spaces</title>

<description>
<p>Nested lists not separated by spaces.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two k
    * Two and a quarter
    * Two and a half
    * Two and three quarters
* Three
* Four
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two k</p>
<ul>
<li>
<p>Two and a quarter</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two k&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested unordered list with mixed spacing</title>

<description>
<p>Nested lists separated by some spaces.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two p
    * Two and a quarter p

    * Two and a half
    * Two and three quarters

* Three
* Four
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two p</p>
<ul>
<li>
<p>Two and a quarter p</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two p&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter p&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Mixed lists</title>

<description>
<p>You can nest ordered and unordered lists inside each other or follow a list of one type with a list of another type.</p>
</description>
<case>
<title>Nested mixed lists with spaces</title>

<description>
<p>Unordered inside ordered list, spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One

0. Two a

    * Two and a quarter

    * Two and a half

    * Two and three quarters

99999. Three

7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two a</p>
<ul>
<li>
<p>Two and a quarter</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two a&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested mixed lists with no spaces</title>

<description>
<p>Unordered inside ordered list, no spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One
0. Two s
    * Two and a quarter
    * Two and a half
    * Two and three quarters
99999. Three
7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two s</p>
<ul>
<li>
<p>Two and a quarter</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two s&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Nested numbered lists with mixed spacing</title>

<description>
<p>Unordered inside ordered list, some spaces between lines.</p>
</description>
<source>
<codeblock language="sam">
0. One

0. Two d
    * Two and a quarter

    * Two and a half
    * Two and three quarters
99999. Three times
       three is nine.

       Four times four is sixteen.

       Five time five is twenty five.


7. Four
</codeblock>
</source>
<markup>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two d</p>
<ul>
<li>
<p>Two and a quarter</p>
</li>
<li>
<p>Two and a half</p>
</li>
<li>
<p>Two and three quarters</p>
</li>
</ul>
</li>
<li>
<p>Three times three is nine.</p>
<p>Four times four is sixteen.</p>
<p>Five time five is twenty five.</p>
</li>
<li>
<p>Four</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two d&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Two and a quarter&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and a half&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two and three quarters&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three times three is nine.&lt;/p&gt;
&lt;p&gt;Four times four is sixteen.&lt;/p&gt;
&lt;p&gt;Five time five is twenty five.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Four&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Space between lists</title>

<description>
<p>An ordered list can follow an unordered list directly and vice versa.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two f
* Three

1. One
2. Two g
3. Three
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two f</p>
</li>
<li>
<p>Three</p>
</li>
</ul>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two g</p>
</li>
<li>
<p>Three</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two f&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two g&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>No space between lists</title>

<description>
<p>An unordered list followed by an ordered list with no space between them.</p>
</description>
<source>
<codeblock language="sam">
* One
* Two h
* Three
1. One
2. Two j
3. Three
</codeblock>
</source>
<markup>
<ul>
<li>
<p>One</p>
</li>
<li>
<p>Two h</p>
</li>
<li>
<p>Three</p>
</li>
</ul>
<ol>
<li>
<p>One</p>
</li>
<li>
<p>Two j</p>
</li>
<li>
<p>Three</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two h&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;One&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Two j&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Three&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Literal lists</title>

<description>
<p>Ordered lists have the number stripped away and are renumbered on output. Unordered list have their <code>*</code> stripped away and replaced with the style of bullet specified on output processing. If you want to preserve actual numbers and bullets in your lists, you need to escape them so that the lines are not recognized as lists items.</p>
</description>
<case>
<title>Literal numbered list using <code>\</code> to escape <code>.</code></title>

<description>
<p>To have a list number recognized as a literal, escape the period following the number (not the number itself). Because these are now paragraphs, not lists, you must put spaces between items or they will be run together into one paragraph.</p>
</description>
<source>
<codeblock language="sam">
2\. This is just a paragraph

4\. This is just a paragraph

9\. This is just a paragraph
</codeblock>
</source>
<markup>
<p>2. This is just a paragraph</p>
<p>4. This is just a paragraph</p>
<p>9. This is just a paragraph</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;2. This is just a paragraph&lt;/p&gt;
&lt;p&gt;4. This is just a paragraph&lt;/p&gt;
&lt;p&gt;9. This is just a paragraph&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Literal unordered list using <code>\</code> to escape <code>*</code></title>

<description>
<p>To have a list number recognized as a literal, escape the <code>*</code>. Because these are now paragraphs, not lists, you must put spaces between items or they will be run together into one paragraph.</p>
</description>
<source>
<codeblock language="sam">
\* This is just a paragraph

\* This is just a paragraph

\* This is just a paragraph
</codeblock>
</source>
<markup>
<p>* This is just a paragraph</p>
<p>* This is just a paragraph</p>
<p>* This is just a paragraph</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;* This is just a paragraph&lt;/p&gt;
&lt;p&gt;* This is just a paragraph&lt;/p&gt;
&lt;p&gt;* This is just a paragraph&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Labeled lists</title>

<description>
<p>You can create lists with labels rather than bullets. The label is contained between two pipe characters. There must be no space between the opening pipe and the first character of the label (otherwise it will be parsed as a line).</p>
</description>
<case>
<title>Simple labeled list</title>

<description>
<p>A labeled list.</p>
</description>
<source>
<codeblock language="sam">
|Do| a deer,
     a female deer
|Re| a drop of
     golden sun

     Is it a particle or a wave?
|Me| a name I call myself
|Fa| a long long way to run
|So| a needle pulling thread
|La| a note to follow so
|Te| a drink with jam and bread
</codeblock>
</source>
<markup>
<ll>
<li>
<label>Do</label>

<p>a deer, a female deer</p>
</li>
<li>
<label>Re</label>

<p>a drop of golden sun</p>
<p>Is it a particle or a wave?</p>
</li>
<li>
<label>Me</label>

<p>a name I call myself</p>
</li>
<li>
<label>Fa</label>

<p>a long long way to run</p>
</li>
<li>
<label>So</label>

<p>a needle pulling thread</p>
</li>
<li>
<label>La</label>

<p>a note to follow so</p>
</li>
<li>
<label>Te</label>

<p>a drink with jam and bread</p>
</li>
</ll>
</markup>
<result>
<codeblock language="xml">
&lt;ll&gt;
&lt;li&gt;
&lt;label&gt;Do&lt;/label&gt;
&lt;p&gt;a deer, a female deer&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Re&lt;/label&gt;
&lt;p&gt;a drop of golden sun&lt;/p&gt;
&lt;p&gt;Is it a particle or a wave?&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Me&lt;/label&gt;
&lt;p&gt;a name I call myself&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Fa&lt;/label&gt;
&lt;p&gt;a long long way to run&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;So&lt;/label&gt;
&lt;p&gt;a needle pulling thread&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;La&lt;/label&gt;
&lt;p&gt;a note to follow so&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Te&lt;/label&gt;
&lt;p&gt;a drink with jam and bread&lt;/p&gt;
&lt;/li&gt;
&lt;/ll&gt;
</codeblock>
</result>
</case>
<case>
<title>XML markup characters in list labels</title>

<description>
<p>Making sure that the contents of a list label are properly escaped when generating XML.</p>
</description>
<source>
<codeblock language="sam">
|foo1 &amp; bar1| foobar1
|foo2 &amp; bar2| foobar2
|foo3 &amp; bar3| foobar3
</codeblock>
</source>
<markup>
<ll>
<li>
<label>foo1 &amp; bar1</label>

<p>foobar1</p>
</li>
<li>
<label>foo2 &amp; bar2</label>

<p>foobar2</p>
</li>
<li>
<label>foo3 &amp; bar3</label>

<p>foobar3</p>
</li>
</ll>
</markup>
<result>
<codeblock language="xml">
&lt;ll&gt;
&lt;li&gt;
&lt;label&gt;foo1 &amp;amp; bar1&lt;/label&gt;
&lt;p&gt;foobar1&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;foo2 &amp;amp; bar2&lt;/label&gt;
&lt;p&gt;foobar2&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;foo3 &amp;amp; bar3&lt;/label&gt;
&lt;p&gt;foobar3&lt;/p&gt;
&lt;/li&gt;
&lt;/ll&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Record sets</title>

<description>
<p>Record sets are a structure similar to a database table. They record data in rows with identical column names. Column names are specified in the records set header.</p>
</description>
<case>
<title>Recordset</title>

<description>
<p>Test that recordsets are recognized correctly. Includes a test that character escapes are recognized in records and commas can be escaped.</p>
</description>
<source>
<codeblock language="sam">
history:: date, author, comment, status
    2014-06-23, mbaker, New\, Topic, In progress
    2016-07-01, mbaker, Revision, In progress
</codeblock>
</source>
<markup>
<history>
<record>
<date>2014-06-23</date>
<author>mbaker</author>
<comment>New, Topic</comment>
<status>In progress</status>
</record>
<record>
<date>2016-07-01</date>
<author>mbaker</author>
<comment>Revision</comment>
<status>In progress</status>
</record>
</history>
</markup>
<result>
<codeblock language="xml">
&lt;history&gt;
&lt;record&gt;
&lt;date&gt;2014-06-23&lt;/date&gt;
&lt;author&gt;mbaker&lt;/author&gt;
&lt;comment&gt;New, Topic&lt;/comment&gt;
&lt;status&gt;In progress&lt;/status&gt;
&lt;/record&gt;
&lt;record&gt;
&lt;date&gt;2016-07-01&lt;/date&gt;
&lt;author&gt;mbaker&lt;/author&gt;
&lt;comment&gt;Revision&lt;/comment&gt;
&lt;status&gt;In progress&lt;/status&gt;
&lt;/record&gt;
&lt;/history&gt;
</codeblock>
</result>
</case>
<case>
<title>Recordset with only one field name</title>

<description>
<p>Test that a recordset works correctly with only one field.</p>
</description>
<source>
<codeblock language="sam">
filmography:: film
    Rio Bravo
    The Shootish
</codeblock>
</source>
<markup>
<filmography>
<record>
<film>Rio Bravo</film>
</record>
<record>
<film>The Shootish</film>
</record>
</filmography>
</markup>
<result>
<codeblock language="xml">
&lt;filmography&gt;
&lt;record&gt;
&lt;film&gt;Rio Bravo&lt;/film&gt;
&lt;/record&gt;
&lt;record&gt;
&lt;film&gt;The Shootish&lt;/film&gt;
&lt;/record&gt;
&lt;/filmography&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Grids</title>

<description>
<p>Grids are a simple form of table. They are purely a layout device with no semantic value. They have no table heads or row or column spanning. More complex tables can be modeled using explicit blocks. Labeled lists can be modeled using the labeled list structure. Database-like tables can be modeled using record sets.</p>
</description>
<case>
<title>Grid with heads</title>

<description>
<p>Table heads are simulated using bold in the top row of the grid.</p>
</description>
<source>
<codeblock language="sam">
+++
    *Type*  | *Term*    | *Notes*
    feature | fragment  | bing
    feature | fragments | bang
</codeblock>
</source>
<markup>
<grid>
<row>
<cell><phrase><annotation type="bold">Type</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Term</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Notes</annotation></phrase></cell>
</row>
<row>
<cell>feature</cell>
<cell>fragment</cell>
<cell>bing</cell>
</row>
<row>
<cell>feature</cell>
<cell>fragments</cell>
<cell>bang</cell>
</row>
</grid>
</markup>
<result>
<codeblock language="xml">
&lt;grid&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Type&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Term&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Notes&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;feature&lt;/cell&gt;
&lt;cell&gt;fragment&lt;/cell&gt;
&lt;cell&gt;bing&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;feature&lt;/cell&gt;
&lt;cell&gt;fragments&lt;/cell&gt;
&lt;cell&gt;bang&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
</codeblock>
</result>
</case>
<case>
<title>Grid with management domain attributes</title>

<description>
<p>The same grid only with management domain attributes attached to the grid header.</p>
<p>Note that SAM Parser sorts block attributes alphabetically for output, which makes it possible to test them with a simple string comparison (such as that performed by test.xslt). However, this is behavior of this parser, not a SAM language requirement.</p>
</description>
<source>
<codeblock language="sam">
+++(*foom)(#bar)(?baz)
    *Type*  | *Term*    | *Notes*

    feature | fragment  | bing

    feature | fragments | bang
</codeblock>
</source>
<markup>
<grid conditions="baz" id="foom" name="bar">
<row>
<cell><phrase><annotation type="bold">Type</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Term</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Notes</annotation></phrase></cell>
</row>
<row>
<cell>feature</cell>
<cell>fragment</cell>
<cell>bing</cell>
</row>
<row>
<cell>feature</cell>
<cell>fragments</cell>
<cell>bang</cell>
</row>
</grid>
</markup>
<result>
<codeblock language="xml">
&lt;grid conditions="baz" id="foom" name="bar"&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Type&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Term&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Notes&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;feature&lt;/cell&gt;
&lt;cell&gt;fragment&lt;/cell&gt;
&lt;cell&gt;bing&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;feature&lt;/cell&gt;
&lt;cell&gt;fragments&lt;/cell&gt;
&lt;cell&gt;bang&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
</codeblock>
</result>
</case>
<case>
<title>Grid with bold row</title>

<description>
<p>Make an lower row bold.</p>
</description>
<source>
<codeblock language="sam">
+++
    *Type*    | *Term*      | *Notes*
    feature   | fragment    | bing
    *feature* | *fragments* | *bang*
</codeblock>
</source>
<markup>
<grid>
<row>
<cell><phrase><annotation type="bold">Type</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Term</annotation></phrase></cell>
<cell><phrase><annotation type="bold">Notes</annotation></phrase></cell>
</row>
<row>
<cell>feature</cell>
<cell>fragment</cell>
<cell>bing</cell>
</row>
<row>
<cell><phrase><annotation type="bold">feature</annotation></phrase></cell>
<cell><phrase><annotation type="bold">fragments</annotation></phrase></cell>
<cell><phrase><annotation type="bold">bang</annotation></phrase></cell>
</row>
</grid>
</markup>
<result>
<codeblock language="xml">
&lt;grid&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Type&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Term&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Notes&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;feature&lt;/cell&gt;
&lt;cell&gt;fragment&lt;/cell&gt;
&lt;cell&gt;bing&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;feature&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;fragments&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;bang&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
</codeblock>
</result>
</case>
<case>
<title>Grid with side heads</title>

<description>
<p>Grid with row headings rather than column headings.</p>
</description>
<source>
<codeblock language="sam">
+++
    *Type*    | Term      | Notes
    *feature* | fragment  | bing
    *feature* | fragments | bang
</codeblock>
</source>
<markup>
<grid>
<row>
<cell><phrase><annotation type="bold">Type</annotation></phrase></cell>
<cell>Term</cell>
<cell>Notes</cell>
</row>
<row>
<cell><phrase><annotation type="bold">feature</annotation></phrase></cell>
<cell>fragment</cell>
<cell>bing</cell>
</row>
<row>
<cell><phrase><annotation type="bold">feature</annotation></phrase></cell>
<cell>fragments</cell>
<cell>bang</cell>
</row>
</grid>
</markup>
<result>
<codeblock language="xml">
&lt;grid&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;Type&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;Term&lt;/cell&gt;
&lt;cell&gt;Notes&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;feature&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;fragment&lt;/cell&gt;
&lt;cell&gt;bing&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;&lt;phrase&gt;&lt;annotation type="bold"&gt;feature&lt;/annotation&gt;&lt;/phrase&gt;&lt;/cell&gt;
&lt;cell&gt;fragments&lt;/cell&gt;
&lt;cell&gt;bang&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Blockquotes</title>

<description>
<p>Blockquotes are introduced by three quotations marke (single or double). The content of a blockquote is normal SAM markup.</p>
</description>
<case>
<title>Blockquote</title>

<description>
<p>A blockquote with management domain metadata.</p>
</description>
<source>
<codeblock language="sam">
After this paragraph, there is a blockquote:

"""(*foo)(#bar)(?baz)
    The quick brown fox jumps over the lazy dog.

    And the {cow}(beast "bovine")[Mother Goose] jumps over the moon.
</codeblock>
</source>
<markup>
<p>After this paragraph, there is a blockquote:</p>
<blockquote conditions="baz" id="foo" name="bar">
<p>The quick brown fox jumps over the lazy dog.</p>
<p>And the <phrase><annotation type="beast" specifically="bovine">cow</annotation><citation>Mother Goose</citation></phrase> jumps over the moon.</p>
</blockquote>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;After this paragraph, there is a blockquote:&lt;/p&gt;
&lt;blockquote conditions="baz" id="foo" name="bar"&gt;
&lt;p&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;
&lt;p&gt;And the &lt;phrase&gt;&lt;annotation type="beast" specifically="bovine"&gt;cow&lt;/annotation&gt;&lt;citation&gt;Mother Goose&lt;/citation&gt;&lt;/phrase&gt; jumps over the moon.&lt;/p&gt;
&lt;/blockquote&gt;
</codeblock>
</result>
</case>
<case>
<title>Alternate block quote</title>

<description>
<p>Blockquote with single quotes. Includes multiple citations.</p>
</description>
<source>
<codeblock language="sam">
This is another paragraph. Then there is an alternate blockquote:

'''( #foo5)[Mother Goose](?bar)(?baz)[Father Time][*foo page 2][%key.bar12 page 22]
    The quick brown fox jumps over the lazy dog.

'''
    This is a blockquote without a citation.
</codeblock>
</source>
<markup>
<p>This is another paragraph. Then there is an alternate blockquote:</p>
<blockquote conditions="bar,baz" name="foo5">
<citation>Mother Goose</citation>
<citation>Father Time</citation>
<citation idref="foo">page 2</citation>
<citation keyref="key.bar12">page 22</citation>
<p>The quick brown fox jumps over the lazy dog.</p>
</blockquote>
<blockquote>
<p>This is a blockquote without a citation.</p>
</blockquote>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This is another paragraph. Then there is an alternate blockquote:&lt;/p&gt;
&lt;blockquote conditions="bar,baz" name="foo5"&gt;
&lt;citation&gt;Mother Goose&lt;/citation&gt;
&lt;citation&gt;Father Time&lt;/citation&gt;
&lt;citation idref="foo"&gt;page 2&lt;/citation&gt;
&lt;citation keyref="key.bar12"&gt;page 22&lt;/citation&gt;
&lt;p&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;This is a blockquote without a citation.&lt;/p&gt;
&lt;/blockquote&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Codeblocks</title>

<description>
<p>A codeblock is a block of program code. A codeblock is treated as plain text and is not parsed as SAM markup. It will be copied to output exactly as it occurs in the source. Codeblocks are denoted by three back ticks at the start of a line. Codeblocks have a special annotation. The first word of an annotation on a codeblock is the language of the code.</p>
</description>
<case>
<title>Simple codeblock</title>

<description>
<p>A simple codeblock.</p>
</description>
<source>
<codeblock language="sam">
```(pyt&amp;#x68;on)(?foo)(!en)
    def escape_for_xml(s):
        t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
        try:
            return s.translate(t)
        except AttributeError:
            return s
</codeblock>
</source>
<markup>
<codeblock conditions="foo" language="python" xml:lang="en">
def escape_for_xml(s):
    t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
</codeblock>
</markup>
<result>
<codeblock language="xml">
&lt;codeblock conditions="foo" language="python" xml:lang="en"&gt;
def escape_for_xml(s):
    t = dict(zip([ord('&amp;lt;'), ord('&amp;gt;'), ord('&amp;amp;')], ['&amp;amp;lt;', '&amp;amp;gt;', '&amp;amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
&lt;/codeblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Blank lines in codeblock</title>

<description>
<p>Blank lines in a code block. The display of the result will be confusing here because the result is whitespace normalized for ease of comparison with the generated XML.</p>
</description>
<source>
<codeblock language="sam">
```(sam)
    warnings:
        warning:(#warn_danger_domestic)
            title: Danger

            Be very very careful. This could kill you.

        warning:(#warn_danger_foreign)
            title: Look out!

            Pay close attention. You could really hurt yourself.
</codeblock>
</source>
<markup>
<codeblock language="sam">
warnings:
    warning:(#warn_danger_domestic)
        title: Danger

        Be very very careful. This could kill you.

    warning:(#warn_danger_foreign)
        title: Look out!

        Pay close attention. You could really hurt yourself.
</codeblock>
</markup>
<result>
<codeblock language="xml">
&lt;codeblock language="sam"&gt;
warnings:
    warning:(#warn_danger_domestic)
        title: Danger

        Be very very careful. This could kill you.

    warning:(#warn_danger_foreign)
        title: Look out!

        Pay close attention. You could really hurt yourself.
&lt;/codeblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Codeblock with citation</title>

<description>
<p>A codeblock with a citation.</p>
</description>
<source>
<codeblock language="sam">
```(python)(?foo)[demos/foo.py]
    def escape_for_xml(s):
        t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
        try:
            return s.translate(t)
        except AttributeError:
            return s
</codeblock>
</source>
<markup>
<codeblock conditions="foo" language="python">
<citation>demos/foo.py</citation>
def escape_for_xml(s):
    t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
</codeblock>
</markup>
<result>
<codeblock language="xml">
&lt;codeblock conditions="foo" language="python"&gt;
&lt;citation&gt;demos/foo.py&lt;/citation&gt;
def escape_for_xml(s):
    t = dict(zip([ord('&amp;lt;'), ord('&amp;gt;'), ord('&amp;amp;')], ['&amp;amp;lt;', '&amp;amp;gt;', '&amp;amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
&lt;/codeblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Invalid blockstart in codeblock</title>

<description>
<p>This is an construct that raise an error in an actual document. Curious because lots of valid block starts in other codeblocks did not cause a problem. But this one raised an invalid block name error. Turns out this was caused by tabs instead of spaces used to indent the line, which promoted it to a higher level of the document hierarchy and thus outside the codeblock. But the test is worth keeping to make sure that the contents of codeblocks are not being interpreted as SAM markup.</p>
</description>
<source>
<codeblock language="sam">
```
    first-ordered-list-item =
        {fontx: 12pt "Century Schoolbook"}&lt;count=1&gt;.[tab]
    ordered-list-item =
        {fonty: 12pt "Century Schoolbook"}&lt;++count&gt;.[tab]
</codeblock>
</source>
<markup>
<codeblock>
first-ordered-list-item =
    {fontx: 12pt "Century Schoolbook"}&lt;count=1&gt;.[tab]
ordered-list-item =
    {fonty: 12pt "Century Schoolbook"}&lt;++count&gt;.[tab]
</codeblock>
</markup>
<result>
<codeblock language="xml">
&lt;codeblock&gt;
first-ordered-list-item =
    {fontx: 12pt "Century Schoolbook"}&amp;lt;count=1&amp;gt;.[tab]
ordered-list-item =
    {fonty: 12pt "Century Schoolbook"}&amp;lt;++count&amp;gt;.[tab]
&lt;/codeblock&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Embedblock</title>

<description>
<p>An embed is a block of markup or code in another language that is intended to be interpreted rather than displayed. For instance, it can be used to include an equation using LaTeX or a diagram using SVG.</p>
</description>
<case>
<title>Simple embed</title>

<description>
<p>Simple embed of an equation using LaTeX.</p>
</description>
<source>
<codeblock language="sam">
```(=latexmathml)(*id13)(#name)(?a)(?b)
    n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k
</codeblock>
</source>
<markup>
<embedblock conditions="a,b" encoding="latexmathml" id="id13" name="name">
n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k
</embedblock>
</markup>
<result>
<codeblock language="xml">
&lt;embedblock conditions="a,b" encoding="latexmathml" id="id13" name="name"&gt; n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k &lt;/embedblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Embedded XML</title>

<description>
<p>A chunk of XML.</p>
</description>
<source>
<codeblock language="sam">
```(=xml)
    &lt;?xml version="1.0" encoding="UTF-8"?&gt;
    &lt;foo bar="bat"&gt;
        &lt;boo/&gt;
        &lt;hoo/&gt;
    &lt;/foo&gt;
</codeblock>
</source>
<markup>
<embedblock encoding="xml">
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;foo bar="bat"&gt;
    &lt;boo/&gt;
    &lt;hoo/&gt;
&lt;/foo&gt;
</embedblock>
</markup>
<result>
<codeblock language="xml">
&lt;embedblock encoding="xml"&gt;
    &amp;lt;?xml version="1.0" encoding="UTF-8"?&amp;gt; 
    &amp;lt;foo bar="bat"&amp;gt; 
    &amp;lt;boo/&amp;gt; 
    &amp;lt;hoo/&amp;gt; 
    &amp;lt;/foo&amp;gt;
&lt;/embedblock&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Lines</title>

<description>
<p>Lines allows you to create text with specific line breaks. Lines are created by beginning each line on a new line and starting with a <code>|</code> character. There must be one space after the <code>|</code>, which is discarded. All other spaces after <code>|</code> are retained. (Retained spaces are not tested for in text.xslt because the test normalize space.)</p>
</description>
<case>
<title>Lines</title>

<description>
<p>Lines with various annotations:</p>
</description>
<source>
<codeblock language="sam">
|(#foo2) You gotta walk that lonesome valley,[*bing page 22]
| You gotta walk it by yourself,
|(?bar) Nobody here can walk it for you,
|    You gotta walk it by yourself.
</codeblock>
</source>
<markup>
<line name="foo2">You gotta walk that lonesome valley,<citation idref="bing">page 22</citation></line>
<line>You gotta walk it by yourself,</line>
<line conditions="bar">Nobody here can walk it for you,</line>
<line>   You gotta walk it by yourself.</line>
</markup>
<result>
<codeblock language="xml">
&lt;line name="foo2"&gt;You gotta walk that lonesome valley,&lt;citation idref="bing"&gt;page 22&lt;/citation&gt;&lt;/line&gt;
&lt;line&gt;You gotta walk it by yourself,&lt;/line&gt;
&lt;line conditions="bar"&gt;Nobody here can walk it for you,&lt;/line&gt;
&lt;line&gt;   You gotta walk it by yourself.&lt;/line&gt;
</codeblock>
</result>
</case>
<case>
<title>Lines inside a blockquote</title>

<description>
<p>Lines should work inside a block quote.</p>
</description>
<source>
<codeblock language="sam">
"""[*bing page 22]
    |(#foo2) You gotta walk that lonesome valley,[%bing page 22]
    | You gotta walk it by yourself,
    |(?bar) Nobody here can walk it for you,
    |    You gotta walk it by yourself.
</codeblock>
</source>
<markup>
<blockquote>
<citation idref="bing">page 22</citation>
<line name="foo2">You gotta walk that lonesome valley,<citation keyref="bing">page 22</citation></line>
<line>You gotta walk it by yourself,</line>
<line conditions="bar">Nobody here can walk it for you,</line>
<line>   You gotta walk it by yourself.</line>
</blockquote>
</markup>
<result>
<codeblock language="xml">
&lt;blockquote&gt;
&lt;citation idref="bing"&gt;page 22&lt;/citation&gt;
&lt;line name="foo2"&gt;You gotta walk that lonesome valley,&lt;citation keyref="bing"&gt;page 22&lt;/citation&gt;&lt;/line&gt;
&lt;line&gt;You gotta walk it by yourself,&lt;/line&gt;
&lt;line conditions="bar"&gt;Nobody here can walk it for you,&lt;/line&gt;
&lt;line&gt;   You gotta walk it by yourself.&lt;/line&gt;
&lt;/blockquote&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Attributes</title>

<description>
<p>SAM supports four explicit attributes: ids, names, conditions, and language. There is no general attribute mechanism such as that in XML. You can generally encode the same data in SAM using fields or annotations.</p>
<p>Attributes can be applied to blocks, phrases, and inserts. You cannot apply attributes to a paragraph, but you can wrap a paragraph in a fragment and apply attributes to the fragment.</p>
<p>Attributes are applied using annotation markup, but with a specific initial character to denote each kind of attribute:</p>
<ul>
<li>
<p><code>(*id)</code> creates an ID attribute.</p>
</li>
<li>
<p><code>(#name)</code> creates a name attribute.</p>
</li>
<li>
<p><code>(?condition)</code> creates a condition attribute.</p>
</li>
<li>
<p><code>(!en-CA)</code> creates a language attribute.</p>
</li>
</ul>
<p>You can only apply one id, name, or language attribute to a block or phrase. You can apply more than one condition attribute. On output to XML, the condition attributes will be converted to a single <code>conditions</code> attribute with the individual conditions separated by commas. (For which reason, condition statements can’t include commas.)</p>
</description>
<case>
<title>Attributes on block</title>

<description>Attributes on a block</description>
<source>
<codeblock language="sam">
block:(!en-CA)(*id2)(#name)(?a)(?b) Title

    Content of the block.
</codeblock>
</source>
<markup>
<block conditions="a,b" id="id2" name="name" xml:lang="en-CA">
<title>Title</title>

<p>Content of the block.</p>
</block>
</markup>
<result>
<codeblock language="xml">
&lt;block conditions="a,b" id="id2" name="name" xml:lang="en-CA"&gt;
&lt;title&gt;Title&lt;/title&gt;
&lt;p&gt;Content of the block.&lt;/p&gt;
&lt;/block&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on field</title>

<description>Attributes on a field</description>
<source>
<codeblock language="sam">
field:(!en-CA)(*id3)(#name)(?a)(?b) Value of the field.
</codeblock>
</source>
<markup>
<field conditions="a,b" id="id3" name="name" xml:lang="en-CA">Value of the field.</field>
</markup>
<result>
<codeblock language="xml">
&lt;field conditions="a,b" id="id3" name="name" xml:lang="en-CA"&gt;Value of the field.&lt;/field&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on fragment</title>

<description>Attributes on a fragment</description>
<source>
<codeblock language="sam">
~~~(!en-CA)(*id4)(#name)(?a)(?b)

    Content of the fragment.
</codeblock>
</source>
<markup>
<fragment conditions="a,b" id="id4" name="name" xml:lang="en-CA">
<p>Content of the fragment.</p>
</fragment>
</markup>
<result>
<codeblock language="xml">
&lt;fragment conditions="a,b" id="id4" name="name" xml:lang="en-CA"&gt;
&lt;p&gt;Content of the fragment.&lt;/p&gt;
&lt;/fragment&gt;
</codeblock>
</result>
</case>
<case>
<title>attributes on grid</title>

<description>Attributes on a grid</description>
<source>
<codeblock language="sam">
+++(!en-CA)(*id5)(#name)(?a)(?b)

    Content | of
    the     | grid.
</codeblock>
</source>
<markup>
<grid conditions="a,b" id="id5" name="name" xml:lang="en-CA">
<row>
<cell>Content</cell>
<cell>of</cell>
</row>
<row>
<cell>the</cell>
<cell>grid.</cell>
</row>
</grid>
</markup>
<result>
<codeblock language="xml">
&lt;grid conditions="a,b" id="id5" name="name" xml:lang="en-CA"&gt;
&lt;row&gt;
&lt;cell&gt;Content&lt;/cell&gt;
&lt;cell&gt;of&lt;/cell&gt;
&lt;/row&gt;
&lt;row&gt;
&lt;cell&gt;the&lt;/cell&gt;
&lt;cell&gt;grid.&lt;/cell&gt;
&lt;/row&gt;
&lt;/grid&gt;
</codeblock>
</result>
</case>
<case>
<title>attributes on record set</title>

<description>Attributes on a record set</description>
<source>
<codeblock language="sam">
recordset::(!en-CA)(*id6)(#name)(?a)(?b) foo, bar

    a, b
    c, d
</codeblock>
</source>
<markup>
<recordset conditions="a,b" id="id6" name="name" xml:lang="en-CA">
<record>
<foo>a</foo>
<bar>b</bar>
</record>
<record>
<foo>c</foo>
<bar>d</bar>
</record>
</recordset>
</markup>
<result>
<codeblock language="xml">
&lt;recordset conditions="a,b" id="id6" name="name" xml:lang="en-CA"&gt;
&lt;record&gt;
&lt;foo&gt;a&lt;/foo&gt;
&lt;bar&gt;b&lt;/bar&gt;
&lt;/record&gt;
&lt;record&gt;
&lt;foo&gt;c&lt;/foo&gt;
&lt;bar&gt;d&lt;/bar&gt;
&lt;/record&gt;
&lt;/recordset&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on unordered list</title>

<description>
<p>Attributes on an unordered list item.</p>
</description>
<source>
<codeblock language="sam">
* Fred

*(!en-CA)(*id7)(#name)(?a)(?b) Barney and
                               Betty and
                               Bam Bam.

* Wilma
</codeblock>
</source>
<markup>
<ul>
<li>
<p>Fred</p>
</li>
<li conditions="a,b" id="id7" name="name" xml:lang="en-CA">
<p>Barney and Betty and Bam Bam.</p>
</li>
<li>
<p>Wilma</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Fred&lt;/p&gt;
&lt;/li&gt;
&lt;li conditions="a,b" id="id7" name="name" xml:lang="en-CA"&gt;
&lt;p&gt;Barney and Betty and Bam Bam.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Wilma&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on ordered list</title>

<description>
<p>Attributes on an ordered list item.</p>
</description>
<source>
<codeblock language="sam">
1. Fred
2.(!en-CA)(*id8)(#name)(?a)(?b) Barney and
                                Betty and
                                Bam Bam.
3. Wilma
</codeblock>
</source>
<markup>
<ol>
<li>
<p>Fred</p>
</li>
<li conditions="a,b" id="id8" name="name" xml:lang="en-CA">
<p>Barney and Betty and Bam Bam.</p>
</li>
<li>
<p>Wilma</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Fred&lt;/p&gt;
&lt;/li&gt;
&lt;li conditions="a,b" id="id8" name="name" xml:lang="en-CA"&gt;
&lt;p&gt;Barney and Betty and Bam Bam.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Wilma&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on labeled list</title>

<description>
<p>Attributes on a labeled list item.</p>
</description>
<source>
<codeblock language="sam">
|Do|(#foo7)(?bar)(?green) a deer,
                          a female deer

|Re| a drop of
     golden sun

     Is it a particle or a wave?
|Me|(*bananas) a name I call myself
|Fa| a long long way to run
|So| a needle pulling thread
|La| a note to follow so
|Te| a drink with jam and bread
</codeblock>
</source>
<markup>
<ll>
<li conditions="bar,green" name="foo7">
<label>Do</label>

<p>a deer, a female deer</p>
</li>
<li>
<label>Re</label>

<p>a drop of golden sun</p>
<p>Is it a particle or a wave?</p>
</li>
<li id="bananas">
<label>Me</label>

<p>a name I call myself</p>
</li>
<li>
<label>Fa</label>

<p>a long long way to run</p>
</li>
<li>
<label>So</label>

<p>a needle pulling thread</p>
</li>
<li>
<label>La</label>

<p>a note to follow so</p>
</li>
<li>
<label>Te</label>

<p>a drink with jam and bread</p>
</li>
</ll>
</markup>
<result>
<codeblock language="xml">
&lt;ll&gt;
&lt;li conditions="bar,green" name="foo7"&gt;
&lt;label&gt;Do&lt;/label&gt;
&lt;p&gt;a deer, a female deer&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Re&lt;/label&gt;
&lt;p&gt;a drop of golden sun&lt;/p&gt;
&lt;p&gt;Is it a particle or a wave?&lt;/p&gt;
&lt;/li&gt;
&lt;li id="bananas"&gt;
&lt;label&gt;Me&lt;/label&gt;
&lt;p&gt;a name I call myself&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Fa&lt;/label&gt;
&lt;p&gt;a long long way to run&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;So&lt;/label&gt;
&lt;p&gt;a needle pulling thread&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;La&lt;/label&gt;
&lt;p&gt;a note to follow so&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;label&gt;Te&lt;/label&gt;
&lt;p&gt;a drink with jam and bread&lt;/p&gt;
&lt;/li&gt;
&lt;/ll&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on lines</title>

<description>
<p>Lines with annotations:</p>
</description>
<source>
<codeblock language="sam">
|(!en-CA)(*id9)(#name)(?a)(?b) You gotta walk that lonesome valley,[*bing page 22]
| You gotta walk it by yourself,
| Nobody here can walk it for you,
|    You gotta walk it by yourself.
</codeblock>
</source>
<markup>
<line conditions="a,b" id="id9" name="name" xml:lang="en-CA">You gotta walk that lonesome valley,<citation idref="bing">page 22</citation></line>
<line>You gotta walk it by yourself,</line>
<line>Nobody here can walk it for you,</line>
<line>   You gotta walk it by yourself.</line>
</markup>
<result>
<codeblock language="xml">
&lt;line conditions="a,b" id="id9" name="name" xml:lang="en-CA"&gt;You gotta walk that lonesome valley,&lt;citation idref="bing"&gt;page 22&lt;/citation&gt;&lt;/line&gt;
&lt;line&gt;You gotta walk it by yourself,&lt;/line&gt;
&lt;line&gt;Nobody here can walk it for you,&lt;/line&gt;
&lt;line&gt;   You gotta walk it by yourself.&lt;/line&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on blockquote</title>

<description>
<p>A blockquote with attributes and a citation.</p>
</description>
<source>
<codeblock language="sam">
After this paragraph, there is a blockquote:

"""(!en-CA)(*id10)(#name)(?a)(?b)[*cit]
    The quick brown fox jumps over the lazy dog.

    And the {cow}(beast "bovine")[Mother Goose] jumps over the moon.
</codeblock>
</source>
<markup>
<p>After this paragraph, there is a blockquote:</p>
<blockquote conditions="a,b" id="id10" name="name" xml:lang="en-CA">
<citation idref="cit"/>
<p>The quick brown fox jumps over the lazy dog.</p>
<p>And the <phrase><annotation type="beast" specifically="bovine">cow</annotation><citation>Mother Goose</citation></phrase> jumps over the moon.</p>
</blockquote>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;After this paragraph, there is a blockquote:&lt;/p&gt;
&lt;blockquote conditions="a,b" id="id10" name="name" xml:lang="en-CA"&gt;
&lt;citation idref="cit"/&gt;
&lt;p&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;

&lt;p&gt;And the &lt;phrase&gt;&lt;annotation type="beast" specifically="bovine"&gt;cow&lt;/annotation&gt;&lt;citation&gt;Mother Goose&lt;/citation&gt;&lt;/phrase&gt; jumps over the moon.&lt;/p&gt;
&lt;/blockquote&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on a phrase</title>

<description>
<p>Attributes on a phrase.</p>
</description>
<source>
<codeblock language="sam">
{The Duke}(actor "John Wayne")(!en-CA)(*id11)(#name)(?a)(?b)[*cit] plays Rooster Cogburn.
</codeblock>
</source>
<markup>
<p><phrase conditions="a,b" id="id11" name="name" xml:lang="en-CA"><annotation type="actor" specifically="John Wayne">The Duke</annotation><citation idref="cit"/></phrase> plays Rooster Cogburn.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;&lt;phrase conditions="a,b" id="id11" name="name" xml:lang="en-CA"&gt;&lt;annotation type="actor" specifically="John Wayne"&gt;The Duke&lt;/annotation&gt;&lt;citation idref="cit"/&gt;&lt;/phrase&gt; plays Rooster Cogburn.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on a codeblock</title>

<description>
<p>Attributes on a codeblock.</p>
</description>
<source>
<codeblock language="sam">
```(python)(*id12)(#name)(?a)(?b)
    def escape_for_xml(s):
        t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
        try:
            return s.translate(t)
        except AttributeError:
            return s
</codeblock>
</source>
<markup>
<codeblock conditions="a,b" id="id12" language="python" name="name">
def escape_for_xml(s):
    t = dict(zip([ord('&lt;'), ord('&gt;'), ord('&amp;')], ['&amp;lt;', '&amp;gt;', '&amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
</codeblock>
</markup>
<result>
<codeblock language="xml">
&lt;codeblock conditions="a,b" id="id12" language="python" name="name"&gt;
def escape_for_xml(s):
    t = dict(zip([ord('&amp;lt;'), ord('&amp;gt;'), ord('&amp;amp;')], ['&amp;amp;lt;', '&amp;amp;gt;', '&amp;amp;amp;']))
    try:
        return s.translate(t)
    except AttributeError:
        return s
&lt;/codeblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on an embed</title>

<description>
<p>Attributes on a embed.</p>
</description>
<source>
<codeblock language="sam">
```(=latexmathml)(*id14)(#name)(?a)(?b)
    n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k
</codeblock>
</source>
<markup>
<embedblock conditions="a,b" encoding="latexmathml" id="id14" name="name">
n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k
</embedblock>
</markup>
<result>
<codeblock language="xml">
&lt;embedblock conditions="a,b" encoding="latexmathml" id="id14" name="name"&gt;
n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k
&lt;/embedblock&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on inserts</title>

<description>
<p>Attributes on inserts.</p>
</description>
<source>
<codeblock language="sam">
&gt;&gt;&gt;(image foo.gif)(*id15)(#name)(?a)(?b)
</codeblock>
</source>
<markup>
<insert conditions="a,b" id="id15" item="foo.gif" name="name" type="image"/>
</markup>
<result>
<codeblock language="xml">
&lt;insert conditions="a,b" id="id15" item="foo.gif" name="name" type="image"/&gt;
</codeblock>
</result>
</case>
<case>
<title>Attributes on inserts</title>

<description>
<p>Attributes on inserts.</p>
</description>
<source>
<codeblock language="sam">
&gt;&gt;&gt;(image bar.png)(#baz)
</codeblock>
</source>
<markup>
<insert item="bar.png" name="baz" type="image"/>
</markup>
<result>
<codeblock language="xml">
&lt;insert item="bar.png" name="baz" type="image"/&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Annotations</title>

<description>
<p>A phrase can have one or more annotations or citations attached to it. On output, the text of the phrase is wrapped in the annotations and citations in the order they were specified in source.</p>
</description>
<case>
<title>Multiple annotations</title>

<description>
<p>Phrases with more than one attribute in a chain.</p>
</description>
<source>
<codeblock language="sam">
This is {very}(bold) important.

This is {very}(bold)(italic) important.

This is {very}(bold)(italic)(green) important.

This `foo`(bar) baz.
</codeblock>
</source>
<markup>
<p>This is <phrase><annotation type="bold">very</annotation></phrase> important.</p>
<p>This is <phrase><annotation type="bold"><annotation type="italic">very</annotation></annotation></phrase> important.</p>
<p>This is <phrase><annotation type="bold"><annotation type="italic"><annotation type="green">very</annotation></annotation></annotation></phrase> important.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This is &lt;phrase&gt;&lt;annotation type="bold"&gt;very&lt;/annotation&gt;&lt;/phrase&gt; important.&lt;/p&gt;
&lt;p&gt;This is &lt;phrase&gt;&lt;annotation type="bold"&gt;&lt;annotation type="italic"&gt;very&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; important.&lt;/p&gt;
&lt;p&gt;This is &lt;phrase&gt;&lt;annotation type="bold"&gt;&lt;annotation type="italic"&gt;&lt;annotation type="green"&gt;very&lt;/annotation&gt;&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; important.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Consecutive Annotations</title>

<description>
<p>Two separate annotations with no space between them.</p>
</description>
<source>
<codeblock language="sam">
{The Duke}(actor "John Wayne")(if "1969"){Jeff Bridges}(actor)(if "2010") plays Rooster Cogburn.
</codeblock>
</source>
<markup>
<p><phrase><annotation type="actor" specifically="John Wayne"><annotation type="if" specifically="1969">The Duke</annotation></annotation></phrase><phrase><annotation type="actor"><annotation type="if" specifically="2010">Jeff Bridges</annotation></annotation></phrase> plays Rooster Cogburn.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;&lt;phrase&gt;&lt;annotation type="actor" specifically="John Wayne"&gt;&lt;annotation type="if" specifically="1969"&gt;The Duke&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt;&lt;phrase&gt;&lt;annotation type="actor"&gt;&lt;annotation type="if" specifically="2010"&gt;Jeff Bridges&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; plays Rooster Cogburn.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Consecutive annotations</title>

<description>
<p>Two separate annotations with no space between them.</p>
</description>
<source>
<codeblock language="sam">
{The Duke}(actor "John Wayne")(if "1969"){Jeff Bridges}(actor)(if "2010") plays Rooster Cogburn.
</codeblock>
</source>
<markup>
<p><phrase><annotation type="actor" specifically="John Wayne"><annotation type="if" specifically="1969">The Duke</annotation></annotation></phrase><phrase><annotation type="actor"><annotation type="if" specifically="2010">Jeff Bridges</annotation></annotation></phrase> plays Rooster Cogburn.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;&lt;phrase&gt;&lt;annotation type="actor" specifically="John Wayne"&gt;&lt;annotation type="if" specifically="1969"&gt;The Duke&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt;&lt;phrase&gt;&lt;annotation type="actor"&gt;&lt;annotation type="if" specifically="2010"&gt;Jeff Bridges&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; plays Rooster Cogburn.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Annotation followed by citation</title>

<description>
<p>Observed in the wild: When an annotated phrase was followed by a phrase with a citation, the end of the annotation was not found and the two structures were recognized as one long citation.</p>
</description>
<source>
<codeblock language="sam">
When using the map approach, it is important to
think about how your content will {single
source}(concept "single sourcing") to paper-like
media and hypertext-media. Some people will output
the same map to to both media. In hyper-text media
that usually results in the map being turned into
a table of contents, often displayed in a separate
pane as in a help system. This may be fine if you
are creating a help system, but it is not how Web
content is usually displayed. Another approach to
single sourcing content that uses the assemble from
pieces approach is to create completely separate maps
-- or even to use completely different assembly
techniques that don't involve maps at all -- to produce
paper-like and hypertext outputs. This can help you
to work around some of the design limitations that
we talked about in the {single sourcing
chapter}[#single_source].
</codeblock>
</source>
<markup>
<p>When using the map approach, it is important to think about how your content will <phrase><annotation type="concept" specifically="single sourcing">single source</annotation></phrase> to paper-like media and hypertext-media. Some people will output the same map to to both media. In hyper-text media that usually results in the map being turned into a table of contents, often displayed in a separate pane as in a help system. This may be fine if you are creating a help system, but it is not how Web content is usually displayed. Another approach to single sourcing content that uses the assemble from pieces approach is to create completely separate maps – or even to use completely different assembly techniques that don’t involve maps at all – to produce paper-like and hypertext outputs. This can help you to work around some of the design limitations that we talked about in the <phrase>single sourcing chapter<citation nameref="single_source"/></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;When using the map approach, it is important to think about how your content will &lt;phrase&gt;&lt;annotation type="concept" specifically="single sourcing"&gt;single source&lt;/annotation&gt;&lt;/phrase&gt; to paper-like media and hypertext-media. Some people will output the same map to to both media. In hyper-text media that usually results in the map being turned into a table of contents, often displayed in a separate pane as in a help system. This may be fine if you are creating a help system, but it is not how Web content is usually displayed. Another approach to single sourcing content that uses the assemble from pieces approach is to create completely separate maps – or even to use completely different assembly techniques that don’t involve maps at all – to produce paper-like and hypertext outputs. This can help you to work around some of the design limitations that we talked about in the &lt;phrase&gt;single sourcing chapter&lt;citation nameref="single_source"/&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Annotation with language metadata</title>

<description>
<p>You can add language metadata to a phrase.</p>
</description>
<source>
<codeblock language="sam">
Press {Enter}(key)(!fr-CA)
</codeblock>
</source>
<markup>
<p>Press <phrase xml:lang="fr-CA"><annotation type="key">Enter</annotation></phrase></p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Press &lt;phrase xml:lang="fr-CA"&gt;&lt;annotation type="key"&gt;Enter&lt;/annotation&gt;&lt;/phrase&gt;&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Annotation with a condition</title>

<description>
<p>You can add condition metadata to a phrase.</p>
</description>
<source>
<codeblock language="sam">
Press {Enter}(key)(?foo)
</codeblock>
</source>
<markup>
<p>Press <phrase conditions="foo"><annotation type="key">Enter</annotation></phrase></p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Press &lt;phrase conditions="foo"&gt;&lt;annotation type="key"&gt;Enter&lt;/annotation&gt;&lt;/phrase&gt;&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Prior annotation lookup</title>

<description>
<p>If a phrase has no annotation or citation attached to it, the parser will attempt to find a suitable annotation by searching back up the document for the most recent case of the same phrase. If it finds one, it will copy the annotations and citations from that phrase to the current one. This prevents writers from having to write the same annotation out over and over again. If not prior phrase is found, a warning is issued.</p>
</description>
<source>
<codeblock language="sam">
This {annotation}(https://en.wikipedia.org/wiki/Annotation) is repeated {annotation}.
</codeblock>
</source>
<markup>
<p>This <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">annotation</annotation></phrase> is repeated <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">annotation</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;annotation&lt;/annotation&gt;&lt;/phrase&gt; is repeated &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;annotation&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Case insensitive lookup</title>

<description>
<p>Annotation lookup is case insensitive unless the annotation-lookup declaration is set to <code>case sensitive</code>.</p>
</description>
<source>
<codeblock language="sam">
This {annotation}(https://en.wikipedia.org/wiki/Annotation) is repeated {Annotation}.
</codeblock>
</source>
<markup>
<p>This <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">annotation</annotation></phrase> is repeated <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">Annotation</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;annotation&lt;/annotation&gt;&lt;/phrase&gt; is repeated &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;Annotation&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Case insensitive lookup with multiple annotations</title>

<description>
<p>Make sure all annotations are copied</p>
</description>
<source>
<codeblock language="sam">
This {annotation}(foo)(https://en.wikipedia.org/wiki/Annotation) is repeated {Annotation}.
</codeblock>
</source>
<markup>
<p>This <phrase><annotation type="foo"><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">annotation</annotation></annotation></phrase> is repeated <phrase><annotation type="foo"><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">Annotation</annotation></annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This &lt;phrase&gt;&lt;annotation type="foo"&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;annotation&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; is repeated &lt;phrase&gt;&lt;annotation type="foo"&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;Annotation&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Prior annotation lookup in included file</title>

<description>
<p>Look up annotations in included files.</p>
</description>
<source>
<codeblock language="sam">
Annotation lookup test: {test phrase}.
</codeblock>
</source>
<markup>
<p>Annotation lookup test: <phrase><annotation type="test">test phrase</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Annotation lookup test: &lt;phrase&gt;&lt;annotation type="test"&gt;test phrase&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Earlier para</title>

<description>
<p>The marching annotation is in an earlier paragraph in the document. (In this case, in the preceding test case).</p>
</description>
<source>
<codeblock language="sam">
This {annotation} occurs previously.
</codeblock>
</source>
<markup>
<p>This <phrase><annotation type="foo"><annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation">annotation</annotation></annotation></phrase> occurs previously.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This &lt;phrase&gt;&lt;annotation type="foo"&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/Annotation"&gt;annotation&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; occurs previously.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Failure</title>

<description>
<p>There is no previous phrase. This should generate a warning when the test is run.</p>
</description>
<source>
<codeblock language="sam">
This {should be reported}.
</codeblock>
</source>
<markup>
<p>This <phrase>should be reported</phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This &lt;phrase&gt;should be reported&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Local only annotations</title>

<description>
<p>A local-only annotation is one which applies only to the current phrase. It is not taken into consideration in annotation lookup, so the lookup search will proceed to the next phrase with the same text. Annotation lookup will occur for a phrase with a local-only annotation, and the local annotation will be added to the looked up annotations, if any.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}(language) testing {XML}+(index) testing {XML}.

Testing {XML}(language) testing {XML}+(index) testing {XML}+(language).
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="language">XML</annotation></phrase> testing <phrase><annotation type="index"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
<p>Testing <phrase><annotation type="language">XML</annotation></phrase> testing <phrase><annotation type="index"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Cancel annotations</title>

<description>
<p>A cancel annotation is one which cancels the addition of annotations of a specific type added through annotation lookup for the current phrase. It is not taken into consideration in annotation lookup, so the lookup search will proceed to the next phrase with the same text. Annotation lookup will occur for a phrase with a cancel annotation, and the cancel annotation will be subtracted from to the looked up annotations, if any.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}(language) testing {XML}-(language)+(index) testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="language">XML</annotation></phrase> testing <phrase><annotation type="index">XML</annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Cancel and replace</title>

<description>
<p>Cancel a global annotation and replace it with one of the same type.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}(language "eggs hem hell") testing {XML}-(language)+(language "heck's that smell?") testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="language" specifically="eggs hem hell">XML</annotation></phrase> testing <phrase><annotation type="language" specifically="heck's that smell?">XML</annotation></phrase> testing <phrase><annotation type="language" specifically="eggs hem hell">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="language" specifically="eggs hem hell"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language" specifically="heck's that smell?"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language" specifically="eggs hem hell"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Define, cancel, and replace</title>

<description>
<p>Define a global annotation, then cancel it and replace it with one of the same type. Not something that makes sense to do normally, but we need to define the behavior.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}(language "Hex Hem Elle") testing {XML}-(language)+(language "heck's that smell?") testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="language" specifically="Hex Hem Elle">XML</annotation></phrase> testing <phrase><annotation type="language" specifically="heck's that smell?">XML</annotation></phrase> testing <phrase><annotation type="language" specifically="Hex Hem Elle">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="language" specifically="Hex Hem Elle"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language" specifically="heck's that smell?"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language" specifically="Hex Hem Elle"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Attribute annotations</title>

<description>
<p>Attributes like ID should not be copied because they are supposed to be unique.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}(language)(*foot) testing {XML}+(index) testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase id="foot"><annotation type="language">XML</annotation></phrase> testing <phrase><annotation type="index"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase id="foot"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Mix of local and global</title>

<description>
<p>A mix of local and global annotations.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}+(foo)(language) testing {XML}+(index) testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="foo"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="index"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="foo"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Multiple local</title>

<description>
<p>Multiple local annotations.</p>
</description>
<source>
<codeblock language="sam">
Testing {XML}+(foobar)+(verbiage) testing {XML}+(index) testing {XML}.
</codeblock>
</source>
<markup>
<p>Testing <phrase><annotation type="foobar"><annotation type="verbiage"><annotation type="language">XML</annotation></annotation></annotation></phrase> testing <phrase><annotation type="index"><annotation type="language">XML</annotation></annotation></phrase> testing <phrase><annotation type="language">XML</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Testing &lt;phrase&gt;&lt;annotation type="foobar"&gt;&lt;annotation type="verbiage"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="index"&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/annotation&gt;&lt;/phrase&gt; testing &lt;phrase&gt;&lt;annotation type="language"&gt;XML&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Decorations</title>

<description>
<p>A decoration is a shortcut for a <phrase><annotation type="concept">media domain</annotation></phrase> annotation. Three decorations are supported, bold, and italic. Code looks a lot like a decoration but is actually a separate structure. Included here for completeness. The phrase for bold and code are then repeated to test that the decorations are only being applied locally.</p>
</description>
<case>
<title>Bold, italic, and code</title>

<description>
<p>One test case for all decorations.</p>
</description>
<source>
<codeblock language="sam">
This sentence contains decorations for *bold*, _italic_, and `code`. Say {bold} again. Say {code} again.
</codeblock>
</source>
<markup>
<p>This sentence contains decorations for <phrase><annotation type="bold">bold</annotation></phrase>, <phrase><annotation type="italic">italic</annotation></phrase>, and <code>code</code>. Say <phrase>bold</phrase> again. Say <phrase>code</phrase> again.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This sentence contains decorations for &lt;phrase&gt;&lt;annotation type="bold"&gt;bold&lt;/annotation&gt;&lt;/phrase&gt;, &lt;phrase&gt;&lt;annotation type="italic"&gt;italic&lt;/annotation&gt;&lt;/phrase&gt;, and &lt;code&gt;code&lt;/code&gt;. Say &lt;phrase&gt;bold&lt;/phrase&gt; again. Say &lt;phrase&gt;code&lt;/phrase&gt; again.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Unbalanced decorations and escapes</title>

<description>
<p>Unbalanced decorations and escapes</p>
</description>
<source>
<codeblock language="sam">
In Rio Bravo, \*the \`Duke (see: https://en.wikipedia.org/wiki/John_Wayne) plays *an ex-Union colonel `out for revenge.
</codeblock>
</source>
<markup>
<p>In Rio Bravo, *the `Duke (see: https://en.wikipedia.org/wiki/John_Wayne) plays *an ex-Union colonel `out for revenge.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;In Rio Bravo, *the `Duke (see: https://en.wikipedia.org/wiki/John_Wayne) plays *an ex-Union colonel `out for revenge.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Inline code</title>

<description>
<p>Inline code is a form of phrase used for phrases that are in computer languages or other encodings other than the human language of the text.</p>
</description>
<case>
<title>Inline latexmath</title>

<description>
<p>A selection of latex math to be printed.</p>
</description>
<source>
<codeblock language="sam">
This is an equation `\frac{ \sum_{t=0}^{N}f(t,k) }{N}`(latexmath)(!en) in the middle of a paragraph. 
</codeblock>
</source>
<markup>
<p>This is an equation <code language="latexmath" xml:lang="en">\frac{ \sum_{t=0}^{N}f(t,k) }{N}</code> in the middle of a paragraph.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This is an equation &lt;code language="latexmath" xml:lang="en"&gt;\frac{ \sum_{t=0}^{N}f(t,k) }{N}&lt;/code&gt; in the middle of a paragraph.&lt;/p&gt; 
</codeblock>
</result>
</case>
<case>
<title>Embedded latexmath</title>

<description>
<p>A selection of latex math to be embedded as an equation.</p>
</description>
<source>
<codeblock language="sam">
This is an equation `\frac{ \sum_{t=0}^{N}f(t,k) }{N}`(=latexmath) in the middle of a paragraph.
</codeblock>
</source>
<markup>
<p>This is an equation <embed encoding="latexmath">\frac{ \sum_{t=0}^{N}f(t,k) }{N}</embed> in the middle of a paragraph.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This is an equation &lt;embed encoding="latexmath"&gt;\frac{ \sum_{t=0}^{N}f(t,k) }{N}&lt;/embed&gt; in the middle of a paragraph.&lt;/p&gt; 
</codeblock>
</result>
</case>
</test>
<test>
<title>Links</title>

<description>
<p>Links are created with an annotation.</p>
<p>You can specify a link as a <code>link</code> annotation.</p>
<codeblock>
foo {bar}(link "http://example.com/bar") baz
</codeblock>
<p>The link annotation shortcut lets you shorten this to:</p>
<codeblock>
foo {bar}(http://example.com/bar) baz
</codeblock>
<p>However, use of the shortcut means you need to escape any parens that occur in the URL.</p>
</description>
<case>
<title>Parens not escaped</title>

<description>
<p>The parens are not escaped, causing misreading of markup. This example should be interpreted incorrectly.</p>
</description>
<source>
<codeblock language="sam">
Rio Bravo refers to the movie
(and not to {the city in Texas or
the nature reserve in
Belize}(https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)))
</codeblock>
</source>
<markup>
<p>Rio Bravo refers to the movie (and not to <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_" namespace="disambiguation">the city in Texas or the nature reserve in Belize</annotation></phrase>)</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Rio Bravo refers to the movie (and not to &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_" namespace="disambiguation"&gt;the city in Texas or the nature reserve in Belize&lt;/annotation&gt;&lt;/phrase&gt;)&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Parens escaped with backslashes</title>

<description>
<p>The parens in the URL are escaped with blackslashes. This example should be interpreted correctly.</p>
</description>
<source>
<codeblock language="sam">
Rio Bravo refers to the movie
(and not to {the city in Texas or
the nature reserve in
Belize}(https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_\(disambiguation\)))
</codeblock>
</source>
<markup>
<p>Rio Bravo refers to the movie (and not to <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)">the city in Texas or the nature reserve in Belize</annotation></phrase>)</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Rio Bravo refers to the movie (and not to &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)"&gt;the city in Texas or the nature reserve in Belize&lt;/annotation&gt;&lt;/phrase&gt;)&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Using explicit link annotation instead of shortcut</title>

<description>
<p>The link is specified using a specific link annotation so the URL is not in parens itself. This example should be interpreted correctly.</p>
</description>
<source>
<codeblock language="sam">
Rio Bravo refers to the movie
(and not to {the city in Texas or
the nature reserve in
Belize}(link "https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)"))
</codeblock>
</source>
<markup>
<p>Rio Bravo refers to the movie (and not to <phrase><annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)">the city in Texas or the nature reserve in Belize</annotation></phrase>)</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Rio Bravo refers to the movie (and not to &lt;phrase&gt;&lt;annotation type="link" specifically="https://en.wikipedia.org/wiki/R%C3%ADo_Bravo_(disambiguation)"&gt;the city in Texas or the nature reserve in Belize&lt;/annotation&gt;&lt;/phrase&gt;)&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Citations</title>

<description>
<p>A citation is a reference to a source of information. You can cite with a phrase or by reference to an ID or a name.</p>
</description>
<case>
<title>Citation on phrase</title>

<description>
<p>A citation on a phrase</p>
</description>
<source>
<codeblock language="SAM">
You can {call me Ishmael}[Melville, 1851][Daffy, 2017][%key.bar12 page 22].
</codeblock>
</source>
<markup>
<p>You can <phrase>call me Ishmael<citation>Melville, 1851</citation><citation>Daffy, 2017</citation><citation keyref="key.bar12">page 22</citation></phrase>.</p>
</markup>
<result>
<codeblock language="XML">
&lt;p&gt;You can &lt;phrase&gt;call me Ishmael&lt;citation&gt;Melville, 1851&lt;/citation&gt;&lt;citation&gt;Daffy, 2017&lt;/citation&gt;&lt;citation keyref="key.bar12"&gt;page 22&lt;/citation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Citation and annotation on one phrase</title>

<description>
<p>A citation on a phrase that also has an annotation.</p>
</description>
<source>
<codeblock language="SAM">
You can {call me Ishmael}(quote)[Melville, 1851].
</codeblock>
</source>
<markup>
<p>You can <phrase><annotation type="quote">call me Ishmael</annotation><citation>Melville, 1851</citation></phrase>.</p>
</markup>
<result>
<codeblock language="XML">
&lt;p&gt;You can &lt;phrase&gt;&lt;annotation type="quote"&gt;call me Ishmael&lt;/annotation&gt;&lt;citation&gt;Melville, 1851&lt;/citation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Citations with compound identifiers</title>

<description>
<p>A citation using a compound identifier (a name reference and an id reference) with extra text.</p>
</description>
<source>
<codeblock language="SAM">
You can {call me Ishmael}[#Melville/*MobyDick page 1].
</codeblock>
</source>
<markup>
<p>You can <phrase>call me Ishmael<citation><reference-elements><reference-element method="nameref" value="Melville"/><reference-element method="idref" value="MobyDick"/></reference-elements>page 1</citation></phrase>.</p>
</markup>
<result>
<codeblock language="XML">
&lt;p&gt;You can &lt;phrase&gt;call me Ishmael&lt;citation&gt;&lt;reference-elements&gt;&lt;reference-element method="nameref" value="Melville"/&gt;&lt;reference-element method="idref" value="MobyDick"/&gt;&lt;/reference-elements&gt;page 1&lt;/citation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Literal square brackets</title>

<description>
<p>If you want to enter literal square brackets, rather than create a citation, escape the opening square bracket with a backslash.</p>
</description>
<source>
<codeblock language="sam">
Press \[Enter].
</codeblock>
</source>
<markup>
<p>Press [Enter].</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Press [Enter].&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Multiple citations is a paragraph</title>

<description>
<p>Making sure that when there are multiple citations in a paragraph they are all detected separately.</p>
</description>
<source>
<codeblock language="sam">
Among its default processing steps, the SPFE process includes the subject-based linking algorithms described in [#chapter.linking] and the subject-based composition and architecture algorithms described in [#chapter.composition] and [#chapter.architecture], including bottom-up information architecture.
</codeblock>
</source>
<markup>
<p>Among its default processing steps, the SPFE process includes the subject-based linking algorithms described in <citation nameref="chapter.linking"/> and the subject-based composition and architecture algorithms described in <citation nameref="chapter.composition"/> and <citation nameref="chapter.architecture"/>, including bottom-up information architecture.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Among its default processing steps, the SPFE process includes the subject-based linking algorithms described in &lt;citation nameref="chapter.linking"/&gt; and the subject-based composition and architecture algorithms described in &lt;citation nameref="chapter.composition"/&gt; and &lt;citation nameref="chapter.architecture"/&gt;, including bottom-up information architecture.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Characters</title>

<description>
<p>All SAM documents are UTF-8 unicode documents. Therefore you should be able to enter any character directly. However, typing extended characters is not easy, so SAM supports character entities for entering characters that are not easy to type.</p>
</description>
<case>
<title>HTML named entities</title>

<description>
<p>All of the HTML named character entities are supported.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs &amp;pound;5.00.
</codeblock>
</source>
<markup>
<p>The doggy in the window costs £5.00.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs £5.00.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Numeric entities</title>

<description>
<p>XML-style decimal numeric character entities are supported.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs &amp;#163;5.00.
</codeblock>
</source>
<markup>
<p>The doggy in the window costs £5.00.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs £5.00.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Hexadecimal entity</title>

<description>
<p>XML-style hexadecimal numeric character entities are supported.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs &amp;#xA3;5.00.
</codeblock>
</source>
<markup>
<p>The doggy in the window costs £5.00.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs £5.00.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Character entities inside phrases and decorations</title>

<description>
<p>Make sure entities are recognized in phrases and decorations.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs *&amp;#xA3;*5.00.

The doggy in the window costs {&amp;#xA3;5.00}(money).
</codeblock>
</source>
<markup>
<p>The doggy in the window costs <phrase><annotation type="bold">£</annotation></phrase>5.00.</p>
<p>The doggy in the window costs <phrase><annotation type="money">£5.00</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs &lt;phrase&gt;&lt;annotation type="bold"&gt;£&lt;/annotation&gt;&lt;/phrase&gt;5.00.&lt;/p&gt;
&lt;p&gt;The doggy in the window costs &lt;phrase&gt;&lt;annotation type="money"&gt;£5.00&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>In code annotation shortcut:</title>

<description>
<p>In a code decoration, character entities are not expanded.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs `&amp;#xA3;`5.00.
</codeblock>
</source>
<markup>
<p>The doggy in the window costs <code>&amp;#xA3;</code>5.00.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs &lt;code&gt;&amp;amp;#xA3;&lt;/code&gt;5.00.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>In bold decoration escaped:</title>

<description>
<p>Escaped version inside a bold decoration.</p>
</description>
<source>
<codeblock language="sam">
The doggy in the window costs *\&amp;#xA3;*5.00.
</codeblock>
</source>
<markup>
<p>The doggy in the window costs <phrase><annotation type="bold">&amp;#xA3;</annotation></phrase>5.00.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The doggy in the window costs &lt;phrase&gt;&lt;annotation type="bold"&gt;&amp;amp;#xA3;&lt;/annotation&gt;&lt;/phrase&gt;5.00.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Ampersand in a sentence, escaped with \ and not escaped.</title>

<description>
<p>Unlike XML, SAM does not require that an ampersand be escaped if it is not part of a character entity. You can escape it if you want to using a backslash. Both should output in XML as <code>&amp;amp;</code></p>
</description>
<source>
<codeblock language="sam">
The cat &amp; the dog.

The cat \&amp; the dog.
</codeblock>
</source>
<markup>
<p>The cat &amp; the dog.</p>
<p>The cat &amp; the dog.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;The cat &amp;amp; the dog.&lt;/p&gt;
&lt;p&gt;The cat &amp;amp; the dog.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Character escapes</title>

<description>
<p>Character escaping</p>
</description>
<case>
<title>Escapes in explicit annotations</title>

<description>
<p>Escaping curly braces and backslashes inside a phrase.</p>
</description>
<source>
<codeblock language="sam">
There is a curly brace and two backslashes in {this \\\\\{ phrase}(bold).
</codeblock>
</source>
<markup>
<p>There is a curly brace and two backslashes in <phrase><annotation type="bold">this \\{ phrase</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;There is a curly brace and two backslashes in &lt;phrase&gt;&lt;annotation type="bold"&gt;this \\{ phrase&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Escapes in code decorations</title>

<description>
<p>Code decorations have different escaping rules. All characters are literal except that the backtick character can be escaped with a double back tick. Character entities are not translated in a code decoration. Smart quote transformations are not applied.</p>
</description>
<source>
<codeblock language="sam">
There is a backtick and two backslashes in `th\\is `` code` decoration.

There is a backslash and a curly brace in `this \{ code` decoration.

`pubwork="book"` is an attribute on the element `citetitle`.
</codeblock>
</source>
<markup>
<p>There is a backtick and two backslashes in <code>th\\is ` code</code> decoration.</p>
<p>There is a backslash and a curly brace in <code>this \{ code</code> decoration.</p>
<p><code>pubwork="book"</code> is an attribute on the element <code>citetitle</code>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;There is a backtick and two backslashes in &lt;code&gt;th\\is ` code&lt;/code&gt; decoration.&lt;/p&gt;
&lt;p&gt;There is a backslash and a curly brace in &lt;code&gt;this \{ code&lt;/code&gt; decoration.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;pubwork="book"&lt;/code&gt; is an attribute on the element &lt;code&gt;citetitle&lt;/code&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Escapes in decorations</title>

<description>
<p>Escape sequences are recognized inside decorations.</p>
</description>
<source>
<codeblock language="sam">
There is a `*` in *this \* bold* decoration.

There is a `_` in _this \_ italic_ decoration.
</codeblock>
</source>
<markup>
<p>There is a <code>*</code> in <phrase><annotation type="bold">this * bold</annotation></phrase> decoration.</p>
<p>There is a <code>_</code> in <phrase><annotation type="italic">this _ italic</annotation></phrase> decoration.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;There is a &lt;code&gt;*&lt;/code&gt; in &lt;phrase&gt;&lt;annotation type="bold"&gt;this * bold&lt;/annotation&gt;&lt;/phrase&gt; decoration.&lt;/p&gt;
&lt;p&gt;There is a &lt;code&gt;_&lt;/code&gt; in &lt;phrase&gt;&lt;annotation type="italic"&gt;this _ italic&lt;/annotation&gt;&lt;/phrase&gt; decoration.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>XML reserved characters in citation specifically attribute</title>

<description>
<p>XML reserved characters occurring within the text of a “specifically” attribute.</p>
</description>
<source>
<codeblock language="sam">
{Skimbleshanks}(animal '"Old  &lt;&gt;&amp; Possum"' (Eliott)).
</codeblock>
</source>
<markup>
<p><phrase><annotation type="animal" specifically="&quot;Old  &lt;&gt;&amp; Possum&quot;" namespace="Eliott">Skimbleshanks</annotation></phrase>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;&lt;phrase&gt;&lt;annotation type="animal" specifically="&amp;quot;Old  &amp;lt;&amp;gt;&amp;amp; Possum&amp;quot;" namespace="Eliott"&gt;Skimbleshanks&lt;/annotation&gt;&lt;/phrase&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Conditions</title>

<description>
<p>You can add conditions to block metadata using condition tokens. Condition tokens start with <code>?</code> and must not contain spaces. The application of conditions to text is up to the application layer. SAM just provided a mechanism for recording conditions.</p>
</description>
<case>
<title>Conditions on unordered list shortcut</title>

<description>
<p>A condition on an unordered list item.</p>
</description>
<source>
<codeblock language="sam">
* Fred

*(?foo) Barney and
        Betty and
        Bam Bam.

* Wilma
</codeblock>
</source>
<markup>
<ul>
<li>
<p>Fred</p>
</li>
<li conditions="foo">
<p>Barney and Betty and Bam Bam.</p>
</li>
<li>
<p>Wilma</p>
</li>
</ul>
</markup>
<result>
<codeblock language="xml">
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Fred&lt;/p&gt;
&lt;/li&gt;
&lt;li conditions="foo"&gt;
&lt;p&gt;Barney and Betty and Bam Bam.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Wilma&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</codeblock>
</result>
</case>
<case>
<title>Conditions on ordered list shortcut</title>

<description>
<p>Condition on an ordered list item.</p>
</description>
<source>
<codeblock language="sam">
1. Fred
2.(?foo) Barney and
         Betty and
         Bam Bam.
3. Wilma
</codeblock>
</source>
<markup>
<ol>
<li>
<p>Fred</p>
</li>
<li conditions="foo">
<p>Barney and Betty and Bam Bam.</p>
</li>
<li>
<p>Wilma</p>
</li>
</ol>
</markup>
<result>
<codeblock language="xml">
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Fred&lt;/p&gt;
&lt;/li&gt;
&lt;li conditions="foo"&gt;
&lt;p&gt;Barney and Betty and Bam Bam.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Wilma&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Block inserts</title>

<description>
<p>An insert creates an instruction to insert something into the document.</p>
</description>
<case>
<title>Image insert</title>

<description>
<p>Insert an image.</p>
</description>
<source>
<codeblock language="sam">
&gt;&gt;&gt;(image foo.gif)(?goo)
</codeblock>
</source>
<markup>
<insert conditions="goo" item="foo.gif" type="image"/>
</markup>
<result>
<codeblock language="xml">
&lt;insert conditions="goo" item="foo.gif" type="image"/&gt;
</codeblock>
</result>
</case>
<case>
<title>Insert by ID</title>

<description>
<p>Insert an object by ID.</p>
</description>
<source>
<codeblock language="sam">
section:(*id99)
    Hello Mars!
&gt;&gt;&gt;(*id99)
</codeblock>
</source>
<markup>
<section id="id99">
<p>Hello Mars!</p>
</section>
<insert idref="id99"/>
</markup>
<result>
<codeblock language="xml">
&lt;section id="id99"&gt;
&lt;p&gt;Hello Mars!&lt;/p&gt;
&lt;/section&gt;
&lt;insert idref="id99"/&gt;
</codeblock>
</result>
</case>
<case>
<title>Key insert</title>

<description>
<p>Insert the value of a key. Syntax for creating keys is left to the language designer. Key resolution belongs to the application layer.</p>
</description>
<source>
<codeblock language="sam">
&gt;&gt;&gt;(%glug)
</codeblock>
</source>
<markup>
<insert keyref="glug"/>
</markup>
<result>
<codeblock language="xml">
&lt;insert keyref="glug"/&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Inline inserts</title>

<description>
<p>Inline inserts are an instructions to insert something into the middle of a paragraph.</p>
</description>
<case>
<title>Inline inserts</title>

<description>
<p>Inline inserts.</p>
</description>
<source>
<codeblock language="sam">
Because you often want to &gt;(image "circle.png")(*circle)(?baz)(?bat) change some part of a text when it is being
reused, &lt;fragments&gt; &amp; fragment references can both define local {strings}(feature).
Any {string references}(feature) inside a fragment will be resolved by looking first
at local-strings defined in the &gt;(*my-table) fragment reference, then at local strings defined
in the fragment definition, and then at global strings. In effect, this means
that you can define string substitutions whenever you insert a fragment into your content.
</codeblock>
</source>
<markup>
<p>Because you often want to <inline-insert conditions="baz,bat" id="circle" item="circle.png" type="image"/> change some part of a text when it is being reused, &lt;fragments&gt; &amp; fragment references can both define local <phrase><annotation type="feature">strings</annotation></phrase>. Any <phrase><annotation type="feature">string references</annotation></phrase> inside a fragment will be resolved by looking first at local-strings defined in the <inline-insert idref="my-table"/> fragment reference, then at local strings defined in the fragment definition, and then at global strings. In effect, this means that you can define string substitutions whenever you insert a fragment into your content.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;Because you often want to &lt;inline-insert conditions="baz,bat" id="circle" item="circle.png" type="image"/&gt; change some part of a text when it is being reused, &amp;lt;fragments&amp;gt; &amp;amp; fragment references can both define local &lt;phrase&gt;&lt;annotation type="feature"&gt;strings&lt;/annotation&gt;&lt;/phrase&gt;. Any &lt;phrase&gt;&lt;annotation type="feature"&gt;string references&lt;/annotation&gt;&lt;/phrase&gt; inside a fragment will be resolved by looking first at local-strings defined in the &lt;inline-insert idref="my-table"/&gt; fragment reference, then at local strings defined in the fragment definition, and then at global strings. In effect, this means that you can define string substitutions whenever you insert a fragment into your content.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Inline insert by ID</title>

<description>
<p>Inline insert by ID of an inline element. This is mostly for testing HTML output mode which tries to resolve these.</p>
</description>
<source>
<codeblock language="sam">
There is a circle &gt;(*circle) in this sentence.
</codeblock>
</source>
<markup>
<p>There is a circle <inline-insert idref="circle"/> in this sentence.</p>
<insert idref="circle"/>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;There is a circle &lt;inline-insert idref="circle"/&gt; in this sentence.&lt;/p&gt;
&lt;insert idref="circle"/&gt;
</codeblock>
</result>
</case>
<case>
<title>Paragraph that is just an inline insert</title>

<description>
<p>An inline insert on a line by itself creates a paragraph containing an insert, rather than a standalone insert instruction.</p>
</description>
<source>
<codeblock language="sam">
&gt;(#foo8)
</codeblock>
</source>
<markup>
<p><inline-insert nameref="foo8"/></p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;&lt;inline-insert nameref="foo8"/&gt;&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Strings</title>

<description>
<p>A string is a variable that can contain text, including annotations and citations.</p>
</description>
<case>
<title>String definition</title>

<description>
<p>A string definition.</p>
</description>
<source>
<codeblock language="sam">
$foo = bar bar black sheep
</codeblock>
</source>
<markup>
<variable name="foo">bar bar black sheep</variable>
</markup>
<result>
<codeblock language="xml">
&lt;variable name="foo"&gt;bar bar black sheep&lt;/variable&gt;
</codeblock>
</result>
</case>
<case>
<title>String references</title>

<variable name="foo">bar bar black sheep</variable>
<description>
<p>Inserting the value of a string.</p>
</description>
<source>
<codeblock language="sam">
$foo = bar bar green sheep
This sentence includes a string reference &gt;($foo).
</codeblock>
</source>
<markup>
<variable name="foo">bar bar black sheep</variable>
<p>This sentence includes a string reference <inline-insert variableref="foo"/>.</p>
</markup>
<result>
<codeblock language="xml">
&lt;variable name="foo"&gt;bar bar black sheep&lt;/variable&gt;
&lt;p&gt;This sentence includes a string reference &lt;inline-insert variableref="foo"/&gt;.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>String lookup</title>

<description>
<p>This is a test for HTML output mode string lookup. It should be moved to a different test doc.</p>
</description>
<source>
<codeblock language="sam">
$str = One
$str = Un
section:(#section.foo) foo
    $str = Two

    This sentence should end with the word for 2: &gt;($str)

    $str = Four

section: bar
    This sentence should end with the word for 1: &gt;($str)

    #$str = Six

&gt;&gt;&gt;(#section.foo)
    $str = Deux

$str = Five
</codeblock>
</source>
<markup>
<variable name="str">One</variable>
<variable name="str">Un</variable>
<section name="section.foo">
<title>foo</title>

<variable name="str">Two</variable>
<p>This sentence should end with the word for 2: <inline-insert variableref="str"/></p>
<variable name="str">Four</variable>
</section>
<section>
<title>bar</title>

<p>This sentence should end with the word for 1: <inline-insert variableref="str"/></p>
<!-- $str = Six -->
</section>
<insert nameref="section.foo">
<variable name="str">Deux</variable>
</insert>
<variable name="str">Five</variable>
</markup>
<result>
<codeblock language="xml">
&lt;variable name="str"&gt;One&lt;/variable&gt;
&lt;variable name="str"&gt;Un&lt;/variable&gt;
&lt;section name="section.foo"&gt;
&lt;title&gt;foo&lt;/title&gt;
&lt;variable name="str"&gt;Two&lt;/variable&gt;
&lt;p&gt;This sentence should end with the word for 2: &lt;inline-insert variableref="str"/&gt;&lt;/p&gt;
&lt;variable name="str"&gt;Four&lt;/variable&gt;
&lt;/section&gt;
&lt;section&gt;
&lt;title&gt;bar&lt;/title&gt;
&lt;p&gt;This sentence should end with the word for 1: &lt;inline-insert variableref="str"/&gt;&lt;/p&gt;
&lt;/section&gt;
&lt;insert nameref="section.foo"&gt;
&lt;variable name="str"&gt;Deux&lt;/variable&gt;
&lt;/insert&gt;
&lt;variable name="str"&gt;Five&lt;/variable&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Fragments</title>

<description>
<p>Fragments are sequences of paragraphs that can have management metadata applied to them and that can be inserted in other places.</p>
</description>
<case>
<title>Fragment</title>

<description>
<p>A fragment definition.</p>
</description>
<source>
<codeblock language="sam">
~~~(#foo3)(?gruz-natz)
    $a=apple
    $b=banana

    This is a sentence inside a fragment.

    ~~~(#gruznatz)
        $p=peach

        This is a nested fragment.
</codeblock>
</source>
<markup>
<fragment conditions="gruz-natz" name="foo3">
<variable name="a">apple</variable>
<variable name="b">banana</variable>
<p>This is a sentence inside a fragment.</p>
<fragment name="gruznatz">
<variable name="p">peach</variable>
<p>This is a nested fragment.</p>
</fragment>
</fragment>
</markup>
<result>
<codeblock language="xml">
&lt;fragment conditions="gruz-natz" name="foo3"&gt;
&lt;variable name="a"&gt;apple&lt;/variable&gt;
&lt;variable name="b"&gt;banana&lt;/variable&gt;
&lt;p&gt;This is a sentence inside a fragment.&lt;/p&gt;
&lt;fragment name="gruznatz"&gt;
&lt;variable name="p"&gt;peach&lt;/variable&gt;
&lt;p&gt;This is a nested fragment.&lt;/p&gt;
&lt;/fragment&gt;
&lt;/fragment&gt;
</codeblock>
</result>
</case>
<case>
<title>Insert a fragment</title>

<description>
<p>An instruction to insert a fragment. Note that actually resolving and inserting the fragment is a job for the application layer.</p>
</description>
<source>
<codeblock language="sam">
&gt;&gt;&gt;(#fragment.foobar)
    $a=apricot
    $b=breadfruit
</codeblock>
</source>
<markup>
<insert nameref="fragment.foobar">
<variable name="a">apricot</variable>
<variable name="b">breadfruit</variable>
</insert>
</markup>
<result>
<codeblock language="xml">
&lt;insert nameref="fragment.foobar"&gt;
&lt;variable name="a"&gt;apricot&lt;/variable&gt;
&lt;variable name="b"&gt;breadfruit&lt;/variable&gt;
&lt;/insert&gt;
</codeblock>
</result>
</case>
</test>
<test>
<title>Smart quotes</title>

<description>
<p>Smart quotes is an optional feature of the parser, not a feature of the SAM language. It turns straight quotes into curly quotes. It raises a warning when it can’t figure out how to handle a case. The algorithm could be improved in the future to handle more cases correctly.</p>
<p>The canonical way to handle quotes in SAM is to use real curly quotes to begin with. All SAM documents are UTF-8.</p>
<Note>These tests will fail if smart quotes is not selected</Note>
<p>using the <code>-q</code> option of the parser command line or by setting the <code>smart_quotes</code> attribute of the SamParser object to <code>True</code>.</p>
</description>
<case>
<title>Smart quotes</title>

<description>
<p>Paragraphs illustrating most of the cases where smart quotes should be recognized in ordinary English.</p>
</description>
<source>
<codeblock language="sam">
"For once, 'sir' adding, 'you're making a
scene.'" and "For once, 'sir' adding,
'you're making a scene.'" In the winter
of ’65. "Yes," he said, "I met her. She's
very 'friendly.'" '"I don’t know what you
mean by 'glory,'" Alice said.' "'I don’t
know what you mean by "glory,"' Alice said."

For "the Duke", perhaps?
</codeblock>
</source>
<markup>
<p>“For once, ‘sir’ adding, ‘you’re making a scene.’” and “For once, ‘sir’ adding, ‘you’re making a scene.’” In the winter of ’65. “Yes,” he said, “I met her. She’s very ‘friendly.’” ‘“I don’t know what you mean by ‘glory,’” Alice said.’ “‘I don’t know what you mean by “glory,”’ Alice said.”</p>
<p>For “the Duke”, perhaps?</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;“For once, ‘sir’ adding, ‘you’re making a scene.’” and “For once, ‘sir’ adding, ‘you’re making a scene.’” In the winter of ’65. “Yes,” he said, “I met her. She’s very ‘friendly.’” ‘“I don’t know what you mean by ‘glory,’” Alice said.’ “‘I don’t know what you mean by “glory,”’ Alice said.”&lt;/p&gt;
&lt;p&gt;For “the Duke”, perhaps?&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Following an annotation</title>

<description>
<p>Smart quotes also need to be recognized when they follow SAM markup.</p>
</description>
<source>
<codeblock language="sam">
interpretations of the `xref`'s instruction
</codeblock>
</source>
<markup>
<p>interpretations of the <code>xref</code>’s instruction</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;interpretations of the &lt;code&gt;xref&lt;/code&gt;’s instruction&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Smart quotes with annotations</title>

<description>
<p>Smart quotes surrounding annotated phrases.</p>
</description>
<source>
<codeblock language="sam">
"For once, '{sir}(salutation)' adding, 'you're making a
scene.'" and "For once, {'sir'}(salutation) adding,
'you're making a scene.'" In the winter
of ’65. "Yes," he said, "I met her. She's
very 'friendly.'" '"I don’t know what you
mean by 'glory,'" Alice said.' "'I don’t
know what you mean by "glory,"' Alice said."
</codeblock>
</source>
<markup>
<p>“For once, ‘<phrase><annotation type="salutation">sir</annotation></phrase>’ adding, ‘you’re making a scene.’” and “For once, <phrase><annotation type="salutation">‘sir’</annotation></phrase> adding, ‘you’re making a scene.’” In the winter of ’65. “Yes,” he said, “I met her. She’s very ‘friendly.’” ‘“I don’t know what you mean by ‘glory,’” Alice said.’ “‘I don’t know what you mean by “glory,”’ Alice said.”</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;“For once, ‘&lt;phrase&gt;&lt;annotation type="salutation"&gt;sir&lt;/annotation&gt;&lt;/phrase&gt;’ adding, ‘you’re making a scene.’” and “For once, &lt;phrase&gt;&lt;annotation type="salutation"&gt;‘sir’&lt;/annotation&gt;&lt;/phrase&gt; adding, ‘you’re making a scene.’” In the winter of ’65. “Yes,” he said, “I met her. She’s very ‘friendly.’” ‘“I don’t know what you mean by ‘glory,’” Alice said.’ “‘I don’t know what you mean by “glory,”’ Alice said.”&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Adjacent to parentheses</title>

<description>
<p>Quotes inside parentheses.</p>
</description>
<source>
<codeblock language="sam">
A vector graphic program creates graphics as a collection of  objects ("vector" meaning the mathematical representation of a shape or line).

The shape of the characters (technically, "glyphs") that make up the font are stored separately in font files.
</codeblock>
</source>
<markup>
<p>A vector graphic program creates graphics as a collection of  objects (“vector” meaning the mathematical representation of a shape or line).</p>
<p>The shape of the characters (technically, “glyphs”) that make up the font are stored separately in font files.</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;A vector graphic program creates graphics as a collection of  objects (“vector” meaning the mathematical representation of a shape or line).&lt;/p&gt;
&lt;p&gt;The shape of the characters (technically, “glyphs”) that make up the font are stored separately in font files.&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Close quote followed by citation.</title>

<description>
<p>Close quote followed by citation.</p>
</description>
<source>
<codeblock language="sam">
"What is truth?"[John 18:38]
</codeblock>
</source>
<markup>
<p>“What is truth?”<citation>John 18:38</citation></p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;“What is truth?”&lt;citation&gt;John 18:38&lt;/citation&gt;&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Miscellaneous cases</title>

<description>
<p>A bunch of miscellaneous cases.</p>
</description>
<source>
<codeblock language="sam">
"title"?

{DocBook}(language)'s

{DITA}(language) and {DocBook}'s
</codeblock>
</source>
<markup>
<p>“title”?</p>
<p><phrase><annotation type="language">DocBook</annotation></phrase>’s</p>
<p><phrase><annotation type="language">DITA</annotation></phrase> and <phrase><annotation type="language">DocBook</annotation></phrase>’s</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;“title”?&lt;/p&gt;
&lt;p&gt;&lt;phrase&gt;&lt;annotation type="language"&gt;DocBook&lt;/annotation&gt;&lt;/phrase&gt;’s&lt;/p&gt;
&lt;p&gt;&lt;phrase&gt;&lt;annotation type="language"&gt;DITA&lt;/annotation&gt;&lt;/phrase&gt; and &lt;phrase&gt;&lt;annotation type="language"&gt;DocBook&lt;/annotation&gt;&lt;/phrase&gt;’s&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Escaped dumb quotes</title>

<description>
<p>If you want to enter straight quotes and have them stay straight when smart quotes are applied, you have to escape them with <code>\</code> or use the <code>&amp;quot;</code> character entity.</p>
</description>
<source>
<codeblock language="sam">
This para uses \"dumb\" quotes. Don\'t get them &amp;quot;mixed up&amp;quot;.
</codeblock>
</source>
<markup>
<p>This para uses "dumb" quotes. Don't get them "mixed up".</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This para uses "dumb" quotes. Don't get them "mixed up".&lt;/p&gt;
</codeblock>
</result>
</case>
<case>
<title>Em and en dashes</title>

<description>
<p>The smart quote feature will also transform double hyphens surrounded by spaces and triple hyphens surrounded by letters into en and em dashes respectively.</p>
</description>
<source>
<codeblock language="sam">
This para contains -- an en dash and an---em dash.

This para contains -- {an}(word) en dash and an---{em}(word) dash.

This para {contains}(word) -- an en dash and {an}(word)---em dash.

This para *contains* -- an en dash and _an_---em dash.

This para `contains` -- an en dash and "an"---em dash.

This para 'contains' -- an en dash and `an`---em dash.

x, y, z, etc. -- something else
</codeblock>
</source>
<markup>
<p>This para contains – an en dash and an—em dash.</p>
<p>This para contains – <phrase><annotation type="word">an</annotation></phrase> en dash and an—<phrase><annotation type="word">em</annotation></phrase> dash.</p>
<p>This para <phrase><annotation type="word">contains</annotation></phrase> – an en dash and <phrase><annotation type="word">an</annotation></phrase>—em dash.</p>
<p>This para <phrase><annotation type="bold">contains</annotation></phrase> – an en dash and <phrase><annotation type="italic">an</annotation></phrase>—em dash.</p>
<p>This para <code>contains</code> – an en dash and “an”—em dash.</p>
<p>This para ‘contains’ – an en dash and <code>an</code>—em dash.</p>
<p>x, y, z, etc. – something else</p>
</markup>
<result>
<codeblock language="xml">
&lt;p&gt;This para contains – an en dash and an—em dash.&lt;/p&gt;
&lt;p&gt;This para contains – &lt;phrase&gt;&lt;annotation type="word"&gt;an&lt;/annotation&gt;&lt;/phrase&gt; en dash and an—&lt;phrase&gt;&lt;annotation type="word"&gt;em&lt;/annotation&gt;&lt;/phrase&gt; dash.&lt;/p&gt;
&lt;p&gt;This para &lt;phrase&gt;&lt;annotation type="word"&gt;contains&lt;/annotation&gt;&lt;/phrase&gt; – an en dash and &lt;phrase&gt;&lt;annotation type="word"&gt;an&lt;/annotation&gt;&lt;/phrase&gt;—em dash.&lt;/p&gt;
&lt;p&gt;This para &lt;phrase&gt;&lt;annotation type="bold"&gt;contains&lt;/annotation&gt;&lt;/phrase&gt; – an en dash and &lt;phrase&gt;&lt;annotation type="italic"&gt;an&lt;/annotation&gt;&lt;/phrase&gt;—em dash.&lt;/p&gt;
&lt;p&gt;This para &lt;code&gt;contains&lt;/code&gt; – an en dash and “an”—em dash.&lt;/p&gt;
&lt;p&gt;This para ‘contains’ – an en dash and &lt;code&gt;an&lt;/code&gt;—em dash.&lt;/p&gt;
&lt;p&gt;x, y, z, etc. – something else&lt;/p&gt;
</codeblock>
</result>
</case>
</test>
</tests>
<!--  Can we have comments after the end of the document? -->
<!--  Yes we can! -->