tests/mk_to_db.py

   1 # -*- python; coding: utf-8 -*-
   2 #
   3 # gtk-doc - GTK DocBook documentation generator.
   4 # Copyright (C) 2015 Christoph Reiter
   5 #               2017  Stefan Sauer
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20 #
  21
  22 import unittest
  23
  24 from gtkdoc import md_to_db
  25
  26
  27 class TestConverter(unittest.TestCase):
  28
  29     def setUp(self):
  30         md_to_db.Init()
  31
  32     def test_main(self):
  33         input_ = """\
  34 SUPPORTED MARKDOWN
  35 ==================
  36
  37 Atx-style Headers
  38 -----------------
  39
  40 # Header 1
  41
  42 ## Header 2 ##
  43
  44 Setext-style Headers
  45 --------------------
  46
  47 Header 1
  48 ========
  49
  50 Header 2
  51 --------
  52
  53 Ordered (unnested) Lists
  54 ------------------------
  55
  56 1. item 1
  57
  58 1. item 2 with loooong *foo*
  59    description
  60
  61 3. item 3
  62
  63 Note: we require a blank line above the list items
  64 """
  65
  66         expexted = """\
  67 <para>SUPPORTED MARKDOWN</para>
  68 <para>Atx-style Headers</para>
  69 <refsect2><title>Header 1</title><refsect3><title>Header 2</title></refsect3>
  70 <refsect3><title>Setext-style Headers</title></refsect3>
  71 </refsect2>
  72 <refsect2><title>Header 1</title><para>Header 2</para>
  73 <para>Ordered (unnested) Lists</para>
  74 <orderedlist>
  75 <listitem>
  76 <para>item 1</para>
  77 </listitem>
  78 <listitem>
  79 <para>item 2 with loooong *foo*
  80 description</para>
  81 </listitem>
  82 <listitem>
  83 <para>item 3</para>
  84 </listitem>
  85 </orderedlist>
  86 <para>Note: we require a blank line above the list items</para>
  87 </refsect2>
  88 """
  89
  90         output = md_to_db.MarkDownParse(input_, "")
  91         self.assertEqual(expexted, output)
  92
  93     def test_docbook(self):
  94         input_ = """\
  95 <itemizedlist>
  96   <listitem><para>foo</para></listitem>
  97 </itemizedlist>
  98 """
  99
 100         # docbook should stay the same
 101         output = md_to_db.MarkDownParse(input_, "")
 102         self.assertEqual(input_, output)
 103
 104     def test_header(self):
 105         input_ = """
 106 widget lifecycle, states and style.
 107
 108 # Height-for-width Geometry Management # {#geometry-management}
 109
 110 GTK+ uses a height-for-width (and wid
 111 """
 112
 113         expected = """\
 114 <para>widget lifecycle, states and style.</para>
 115 <refsect2 id="geometry-management"><title>Height-for-width Geometry Management</title><para>GTK+ uses a height-for-width (and wid</para>
 116 </refsect2>
 117 """
 118
 119         output = md_to_db.MarkDownParse(input_, "")
 120         self.assertEqual(expected, output)
 121
 122     def test_lists(self):
 123         input_ = """\
 124 bla bla
 125 bla:
 126
 127 - The channel was just created, and has not been written to or read from yet.
 128   bla
 129
 130 - The channel is write-only.
 131
 132 foo
 133 """
 134         expected = """\
 135 <para>bla bla
 136 bla:</para>
 137 <itemizedlist>
 138 <listitem>
 139 <para>The channel was just created, and has not been written to or read from yet.
 140 bla</para>
 141 </listitem>
 142 <listitem>
 143 <para>The channel is write-only.</para>
 144 </listitem>
 145 </itemizedlist>
 146 <para>foo</para>
 147 """
 148         output = md_to_db.MarkDownParse(input_, "")
 149         self.assertEqual(expected, output)
 150
 151     def test_paragraphs(self):
 152         input_ = """\
 153 foo,
 154 bar.
 155
 156 foo,
 157 bar.
 158
 159 foo,
 160 bar.
 161 """
 162         expected = """\
 163 <para>foo,
 164 bar.</para>
 165 <para>foo,
 166 bar.</para>
 167 <para>foo,
 168 bar.</para>
 169 """
 170         output = md_to_db.MarkDownParse(input_, "")
 171         self.assertEqual(expected, output)
 172
 173     def test_reference(self):
 174         input_ = """\
 175 The #GData struct is an opaque data structure to represent a
 176 [Keyed Data List][glib-Keyed-Data-Lists]. It should only be
 177 accessed via the following functions."""
 178
 179         expected = """\
 180 <para>The <link linkend="GData"><type>GData</type></link> struct is an opaque data structure to represent a
 181 <link linkend="glib-Keyed-Data-Lists">Keyed Data List</link>. It should only be
 182 accessed via the following functions.</para>
 183 """
 184
 185         output = md_to_db.MarkDownParse(input_, "")
 186         self.assertEqual(expected, output)
 187
 188     def test_reference2(self):
 189         input_ = "a [foo][bar] b [quux][baz]"
 190         expected = '<para>a <link linkend="bar">foo</link> b <link linkend="baz">quux</link></para>\n'
 191         output = md_to_db.MarkDownParse(input_, "")
 192         self.assertEqual(expected, output)
 193
 194     def test_reference_empty(self):
 195         input_ = "[][]"
 196         # expected = '<para><ulink url=""></ulink></para>\n'
 197         expected = '<para><link linkend=""></link></para>\n'
 198         output = md_to_db.MarkDownParse(input_, "")
 199         self.assertEqual(expected, output)
 200
 201     def test_inline_code(self):
 202         input_ = "a `abc`"
 203         expected = '<para>a <literal>abc</literal></para>\n'
 204         output = md_to_db.MarkDownParse(input_, "")
 205         self.assertEqual(expected, output)
 206
 207     def test_inline_code2(self):
 208         input_ = "a `[][]`"
 209         expected = '<para>a <literal>[][]</literal></para>\n'
 210         output = md_to_db.MarkDownParse(input_, "")
 211         self.assertEqual(expected, output)
 212
 213     def test_verbatim(self):
 214         input_ = "a `<child>` element"
 215         expected = '<para>a <literal>&lt;child&gt;</literal> element</para>\n'
 216         output = md_to_db.MarkDownParse(input_, "")
 217         self.assertEqual(expected, output)
 218
 219     def test_code(self):
 220         input_ = """\
 221 |[<!-- language="C" -->
 222     GdkEvent *event;
 223     GdkEventType type;
 224
 225     type = event->type;
 226 ]|
 227 """
 228
 229         expected = '''\
 230 <informalexample><programlisting role="example" language="C"><![CDATA[
 231     GdkEvent *event;
 232     GdkEventType type;
 233
 234     type = event->type;
 235 ]]></programlisting></informalexample>
 236 <para></para>
 237 '''
 238         output = md_to_db.MarkDownParse(input_, "")
 239         self.assertEqual(expected, output)
 240
 241     def test_plain(self):
 242         input_ = u"""\
 243 |[<!-- language="plain" -->
 244 frame
 245 ├── border
 246 ├── <label widget>
 247 ╰── <child>
 248 ]|
 249 """
 250
 251         expected = u"""\
 252 <informalexample><screen><![CDATA[
 253 frame
 254 ├── border
 255 ├── <label widget>
 256 ╰── <child>
 257 ]]></screen></informalexample>
 258 <para></para>
 259 """
 260
 261         output = md_to_db.MarkDownParse(input_, "")
 262         self.assertEqual(expected, output)
 263
 264
 265 if __name__ == '__main__':
 266     unittest.main()