class TestParser(unittest.TestCase):
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
def assertOutputs(self, inp, expected):
ast, _ = cmark.gtkdoc_to_ast(inp, self.link_resolver)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(out, expected)
def test_basic(self):
inp = u'a'
self.assertOutputs(inp, u"<p>a</p>\n")
def test_unicode(self):
inp = u'”'
self.assertOutputs(inp, u"<p>”</p>\n")
def test_input_none(self):
inp = None
with self.assertRaises(TypeError):
ast, _ = cmark.gtkdoc_to_ast(inp, self.link_resolver)
self.assertEqual(ast, None)
def test_resolver_none(self):
inp = u'a'
self.link_resolver = None
self.assertOutputs(inp, u"<p>a</p>\n")
class TestParser(unittest.TestCase):
def setUp(self):
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
def assertOutputs(self, inp, expected):
ast, _ = cmark.gtkdoc_to_ast(inp, self.link_resolver)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(out, expected)
def test_basic(self):
inp = u'a'
self.assertOutputs(inp, u"<p>a</p>\n")
def test_unicode(self):
inp = u'”'
self.assertOutputs(inp, u"<p>”</p>\n")
def test_input_none(self):
inp = None
with self.assertRaises(TypeError):
ast, _ = cmark.gtkdoc_to_ast(inp, self.link_resolver)
self.assertEqual(ast, None)
def test_resolver_none(self):
inp = u'a'
self.link_resolver = None
self.assertOutputs(inp, u"<p>a</p>\n")
def setUp(self):
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
self.link_resolver.add_link(Link("there.org", "there", "Test::test"))
self.link_resolver.add_link(Link("wherever.biz", "wherever", "bar"))
self.link_resolver.add_link(Link("whenever.net", "whenever", "Test"))
self.link_resolver.add_link(
Link("somewhere.me", "somewhere", "Test.baz"))
self.link_resolver.add_link(
Link("elsewhere.co", "elsewhere", "org.dbus.func"))
def setUp(self):
# Cruft, should be unnecessary soon
self.tag_validators = {}
self.parser = GtkDocParser(self)
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.formatter = GtkDocStringFormatter()
def test_incremental(self):
param = ParameterSymbol(
type_tokens=[Link(None, 'test-struct', 'test-struct')])
func = self.database.get_or_create_symbol(
FunctionSymbol, unique_name='test-symbol', filename='text_b.x',
parameters=[param])
func.resolve_links(self.link_resolver)
self.assertEqual(param.get_type_link().get_link(self.link_resolver), None)
struct = self.database.get_or_create_symbol(
StructSymbol, unique_name='test-struct', filename='test_a.x')
struct.resolve_links(self.link_resolver)
func.resolve_links(self.link_resolver)
# Not in a page but still
self.assertEqual(param.get_type_link().get_link(self.link_resolver), 'test-struct')
self.database.persist()
self.database.close()
self.database = Database()
self.database.setup(self.__priv_dir)
self.link_resolver = LinkResolver(self.database)
param = ParameterSymbol(
type_tokens=[Link(None, 'test-struct', 'test-struct')])
func = self.database.get_or_create_symbol(
FunctionSymbol, unique_name='test-symbol',
filename='text_b.x', parameters=[param])
func.resolve_links(self.link_resolver)
self.assertEqual(param.get_type_link().get_link(self.link_resolver), 'test-struct')
def __setup_database(self):
self.database = Database()
#self.database.comment_added_signal.connect(self.__add_default_tags)
#self.database.comment_updated_signal.connect(
# self.__add_default_tags)
self.database.setup(self.private_folder)
self.link_resolver = LinkResolver(self.database)
def setUp(self):
here = os.path.dirname(__file__)
self.__md_dir = os.path.abspath(
os.path.join(here, 'tmp-markdown-files'))
self.__priv_dir = os.path.abspath(os.path.join(here, 'tmp-private'))
self.__src_dir = os.path.abspath(os.path.join(here, 'tmp-src-files'))
self.__output_dir = os.path.abspath(os.path.join(here, 'tmp-output'))
self.__remove_tmp_dirs()
os.mkdir(self.__md_dir)
os.mkdir(self.__priv_dir)
os.mkdir(self.__src_dir)
os.mkdir(self.get_generated_doc_folder())
self.include_paths = OrderedSet([self.__md_dir])
self.include_paths.add(self.get_generated_doc_folder())
# Using the real doc database is too costly, tests should be lightning
# fast (and they are)
self.doc_database = DocDatabase()
self.doc_database.setup(self.__priv_dir)
self.link_resolver = LinkResolver(self.doc_database)
self.change_tracker = ChangeTracker()
self.sitemap_parser = SitemapParser()
self.test_ext = TestExtension(self)
self.core_ext = CoreExtension(self)
def setUp(self):
here = os.path.dirname(__file__)
self.__priv_dir = os.path.abspath(os.path.join(here, 'tmp-private'))
self.__remove_tmp_dirs()
os.mkdir(self.__priv_dir)
self.database = Database(self.__priv_dir)
self.link_resolver = LinkResolver(self.database)
def setUp(self):
# Cruft, should be unnecessary soon
self.tag_validators = {}
self.parser = GtkDocParser(self)
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.formatter = GtkDocStringFormatter()
Logger.silent = True
Logger.fatal_warnings = True
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
self.link_resolver.add_link(Link("there.org", "there", "Test::test"))
self.link_resolver.add_link(Link("wherever.biz", "wherever", "bar"))
self.link_resolver.add_link(Link("whenever.net", "whenever", "Test"))
self.link_resolver.add_link(Link("somewhere.me",
"somewhere",
"Test.baz"))
self.link_resolver.add_link(Link("elsewhere.co",
"elsewhere",
"org.dbus.func"))
def setUp(self):
here = os.path.dirname(__file__)
self.__md_dir = os.path.abspath(os.path.join(
here, 'tmp-markdown-files'))
self.private_folder = os.path.abspath(os.path.join(
here, 'tmp-private'))
self.__src_dir = os.path.abspath(os.path.join(
here, 'tmp-src-files'))
self.__output_dir = os.path.abspath(os.path.join(
here, 'tmp-output'))
self.__remove_tmp_dirs()
os.mkdir(self.__md_dir)
os.mkdir(self.private_folder)
os.mkdir(self.__src_dir)
os.mkdir(self.get_generated_doc_folder())
self.include_paths = OrderedSet([self.__md_dir])
self.include_paths.add(self.get_generated_doc_folder())
self.dependency_map = {}
# Using the real doc database is too costly, tests should be lightning
# fast (and they are)
self.database = Database(self.private_folder)
self.link_resolver = LinkResolver(self.database)
self.change_tracker = ChangeTracker()
self.sitemap_parser = SitemapParser()
self.project_name = 'test-project'
self.sanitized_name = 'test-project-0.1'
self.incremental = False
self.tree = Tree(self, self)
self.test_ext = TestExtension(self, self)
self.core_ext = CoreExtension(self, self)
cfg = Config()
self.test_ext.parse_toplevel_config(cfg)
self.test_ext.parse_config(cfg)
self.core_ext.parse_toplevel_config(cfg)
self.core_ext.parse_config(cfg)
self.subprojects = {}
self.is_toplevel = True
def setUp(self):
self._here = os.path.dirname(__file__)
self._md_dir = os.path.abspath(os.path.join(
self._here, 'tmp-markdown-files'))
self.private_folder = os.path.abspath(os.path.join(
self._here, 'tmp-private'))
self._src_dir = os.path.abspath(os.path.join(
self._here, 'tmp-src-files'))
self._output_dir = os.path.abspath(os.path.join(
self._here, 'tmp-output'))
self._remove_tmp_dirs()
os.mkdir(self._md_dir)
os.mkdir(self.private_folder)
os.mkdir(self._src_dir)
self.dependency_map = {}
self.database = Database(self.private_folder)
self.link_resolver = LinkResolver(self.database)
self.sanitized_name = 'test-project-0.1'
self.tree = Tree(self, self)
def setUp(self):
self._here = os.path.dirname(__file__)
self._md_dir = os.path.abspath(
os.path.join(self._here, 'tmp-markdown-files'))
self.private_folder = os.path.abspath(
os.path.join(self._here, 'tmp-private'))
self._src_dir = os.path.abspath(
os.path.join(self._here, 'tmp-src-files'))
self._output_dir = os.path.abspath(
os.path.join(self._here, 'tmp-output'))
self._remove_tmp_dirs()
os.mkdir(self._md_dir)
os.mkdir(self.private_folder)
os.mkdir(self._src_dir)
self.change_tracker = ChangeTracker()
self.database = Database()
self.link_resolver = LinkResolver(self.database)
self.database.setup(self.private_folder)
self.incremental = False
self.sanitized_name = 'test-project-0.1'
self.tree = Tree(self, self)
class TestGtkDocExtension(unittest.TestCase):
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
self.link_resolver.add_link(Link("there.org", "there", "Test::test"))
def assertOutputs(self, inp, expected):
ast = cmark.gtkdoc_to_ast(inp, self.link_resolver)
out = cmark.ast_to_html(ast, self.link_resolver)
self.assertEqual(out, expected)
return ast
def test_existing_link(self):
inp = u"this : #foo is a link !"
self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
def test_modified_link(self):
inp = u"this : #foo is a link !"
ast = self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
self.link_resolver.upsert_link(
Link("there.com", "ze_foo", "foo"),
overwrite_ref=True)
out = cmark.ast_to_html(ast, self.link_resolver)
self.assertEqual(
out,
u'<p>this : <a href="there.com">ze_foo</a> is a link !</p>\n')
def test_syntax_boundaries(self):
# Make sure we don't parse type links inside words
inp = u"this : yo#foo is a link !"
self.assertOutputs(
inp,
u'<p>this : yo#foo is a link !</p>\n')
# Make sure the function link syntax doesn't take precedence
# over classic links.
inp = u"this is [a link]() however"
self.assertOutputs(
inp,
u'<p>this is <a href="">a link</a> however</p>\n')
# Make sure we respect code blocks
inp = u"And `this a code block`()"
self.assertOutputs(
inp,
u'<p>And <code>this a code block</code>()</p>\n')
inp = u"And `this #too`"
self.assertOutputs(
inp,
u'<p>And <code>this #too</code></p>\n')
# Boundaries should be acceptable here
inp = u"function_link()"
self.assertOutputs(
inp,
u'<p><a href="function_link"></a></p>\n')
def test_qualified_links(self):
inp = u' #Test::test is a link'
self.assertOutputs(
inp,
u'<p><a href="there.org">there</a> is a link</p>\n')
def test_param_no_match(self):
inp = u'Should@not@match please'
self.assertOutputs(
inp,
u'<p>Should@not@match please</p>\n')
def test_param_ref(self):
inp = u'Should @match please'
self.assertOutputs(
inp,
u'<p>Should <em>match</em> please</p>\n')
def __setup_database(self):
self.database = Database(self.private_folder)
self.link_resolver = LinkResolver(self.database)
def setUp(self):
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
def setUp(self):
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.include_resolver = MockIncludeResolver()
def setUp(self):
self.database = Database()
self.link_resolver = LinkResolver(self.database)
class TestGtkDocExtension(unittest.TestCase):
def setUp(self):
self.database = Database(None)
self.link_resolver = LinkResolver(self.database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
self.link_resolver.add_link(Link("there.org", "there", "Test::test"))
self.link_resolver.add_link(Link("wherever.biz", "wherever", "bar"))
self.link_resolver.add_link(Link("whenever.net", "whenever", "Test"))
self.link_resolver.add_link(Link("somewhere.me",
"somewhere",
"Test.baz"))
self.link_resolver.add_link(Link("elsewhere.co",
"elsewhere",
"org.dbus.func"))
def assertOutputs(self, inp, expected):
ast, diagnostics = cmark.gtkdoc_to_ast(inp, self.link_resolver)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(out, expected)
return ast, diagnostics
def test_existing_link(self):
inp = u"this : #foo is a link !"
self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
def test_modified_link(self):
inp = u"this : #foo is a link !"
ast, _ = self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
self.link_resolver.upsert_link(
Link("there.com", "ze_foo", "foo"),
overwrite_ref=True)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(
out,
u'<p>this : <a href="there.com">ze_foo</a> is a link !</p>\n')
def test_code_block(self):
inp = u"|[\nfoo\n]|"
self.assertOutputs(
inp, '<pre><code>foo\n</code></pre>\n')
def test_titled_code_block(self):
inp = u"|[\nfoo\n]| something"
self.assertOutputs(
inp, '<pre><code>foo\n</code></pre>\n<p>something</p>\n')
inp = u"|[\nfoo\n ]|something"
self.assertOutputs(
inp, '<pre><code>foo\n</code></pre>\n<p>something</p>\n')
def test_syntax_boundaries(self):
# Make sure we don't parse type links inside words
inp = u"this : yo#foo is a link !"
self.assertOutputs(
inp,
u'<p>this : yo#foo is a link !</p>\n')
# Make sure the function link syntax doesn't take precedence
# over classic links.
inp = u"this is [a link]() however"
self.assertOutputs(
inp,
u'<p>this is <a href="">a link</a> however</p>\n')
# Make sure we respect code blocks
inp = u"And `this a code block`()"
self.assertOutputs(
inp,
u'<p>And <code>this a code block</code>()</p>\n')
inp = u"And `this #too`"
self.assertOutputs(
inp,
u'<p>And <code>this #too</code></p>\n')
# Boundaries should be acceptable here
inp = u"bar()"
self.assertOutputs(
inp,
u'<p><a href="wherever.biz">wherever</a></p>\n')
inp = u"Linking to #Test: cool"
self.assertOutputs(
inp,
u'<p>Linking to <a href="whenever.net">whenever</a>: cool</p>\n')
def test_dbus_function_link(self):
inp = u"org.dbus.func()\n"
self.assertOutputs(
inp,
u'<p><a href="elsewhere.co">elsewhere</a></p>\n')
def test_struct_field_link(self):
inp = u"Linking to #Test.baz yo"
self.assertOutputs(
inp,
u'<p>Linking to <a href="somewhere.me">somewhere</a> yo</p>\n')
def test_qualified_links(self):
inp = u' #Test::test is a link'
self.assertOutputs(
inp,
u'<p><a href="there.org">there</a> is a link</p>\n')
def test_param_no_match(self):
inp = u'Should@not@match please'
self.assertOutputs(
inp,
u'<p>Should@not@match please</p>\n')
def test_param_ref(self):
inp = u'Should @match please'
self.assertOutputs(
inp,
u'<p>Should <em>match</em> please</p>\n')
def test_preserve_links(self):
inp = u'Should preserve [](http://this_link.com)'
self.assertOutputs(
inp,
u'<p>Should preserve <a href="http://this_link.com"></a></p>\n')
def test_preserve_anchor_links(self):
inp = u'Should preserve [](#this-anchor-link)'
self.assertOutputs(
inp,
u'<p>Should preserve <a href="#this-anchor-link"></a></p>\n')
def test_wrong_link(self):
inp = u'this #does_not_exist'
_, diagnostics = self.assertOutputs(
inp,
u'<p>this does_not_exist</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘does_not_exist’'))
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 5)
def test_link_parsing_context(self):
inp = u'A %NULL-terminated thing'
_, diagnostics = self.assertOutputs(
inp,
u'<p>A NULL-terminated thing</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘NULL’'))
inp = u'A #Object::dashed-signal'
_, diagnostics = self.assertOutputs(
inp,
u'<p>A Object::dashed-signal</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘Object::dashed-signal’'))
def test_wrong_function_link(self):
inp = u'does_not_exist()'
_, diagnostics = self.assertOutputs(
inp,
u'<p>does_not_exist</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘does_not_exist’'))
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 0)
def test_wrong_multiline_link(self):
inp = (u'a #wrong_link\n\n'
'and #another_wrong_link\n'
'and then #yet_another_wrong_link')
_, diagnostics = cmark.gtkdoc_to_ast(inp, self.link_resolver)
self.assertEqual(len(diagnostics), 3)
diag = diagnostics[0]
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 2)
diag = diagnostics[1]
self.assertEqual(diag.lineno, 2)
self.assertEqual(diag.column, 4)
diag = diagnostics[2]
self.assertEqual(diag.lineno, 3)
self.assertEqual(diag.column, 9)
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.include_resolver = MockIncludeResolver()
class TestGtkDocExtension(unittest.TestCase):
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))
self.link_resolver.add_link(Link("there.org", "there", "Test::test"))
self.link_resolver.add_link(Link("wherever.biz", "wherever", "bar"))
self.link_resolver.add_link(Link("whenever.net", "whenever", "Test"))
self.link_resolver.add_link(Link("somewhere.me",
"somewhere",
"Test.baz"))
self.link_resolver.add_link(Link("elsewhere.co",
"elsewhere",
"org.dbus.func"))
def assertOutputs(self, inp, expected):
ast, diagnostics = cmark.gtkdoc_to_ast(inp, self.link_resolver)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(out, expected)
return ast, diagnostics
def test_existing_link(self):
inp = u"this : #foo is a link !"
self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
def test_modified_link(self):
inp = u"this : #foo is a link !"
ast, _ = self.assertOutputs(
inp, '<p>this : <a href="here.com">foo</a> is a link !</p>\n')
self.link_resolver.upsert_link(
Link("there.com", "ze_foo", "foo"),
overwrite_ref=True)
out = cmark.ast_to_html(ast, self.link_resolver)[0]
self.assertEqual(
out,
u'<p>this : <a href="there.com">ze_foo</a> is a link !</p>\n')
def test_syntax_boundaries(self):
# Make sure we don't parse type links inside words
inp = u"this : yo#foo is a link !"
self.assertOutputs(
inp,
u'<p>this : yo#foo is a link !</p>\n')
# Make sure the function link syntax doesn't take precedence
# over classic links.
inp = u"this is [a link]() however"
self.assertOutputs(
inp,
u'<p>this is <a href="">a link</a> however</p>\n')
# Make sure we respect code blocks
inp = u"And `this a code block`()"
self.assertOutputs(
inp,
u'<p>And <code>this a code block</code>()</p>\n')
inp = u"And `this #too`"
self.assertOutputs(
inp,
u'<p>And <code>this #too</code></p>\n')
# Boundaries should be acceptable here
inp = u"bar()"
self.assertOutputs(
inp,
u'<p><a href="wherever.biz">wherever</a></p>\n')
inp = u"Linking to #Test: cool"
self.assertOutputs(
inp,
u'<p>Linking to <a href="whenever.net">whenever</a>: cool</p>\n')
def test_dbus_function_link(self):
inp = u"org.dbus.func()\n"
self.assertOutputs(
inp,
u'<p><a href="elsewhere.co">elsewhere</a></p>\n')
def test_struct_field_link(self):
inp = u"Linking to #Test.baz yo"
self.assertOutputs(
inp,
u'<p>Linking to <a href="somewhere.me">somewhere</a> yo</p>\n')
def test_qualified_links(self):
inp = u' #Test::test is a link'
self.assertOutputs(
inp,
u'<p><a href="there.org">there</a> is a link</p>\n')
def test_param_no_match(self):
inp = u'Should@not@match please'
self.assertOutputs(
inp,
u'<p>Should@not@match please</p>\n')
def test_param_ref(self):
inp = u'Should @match please'
self.assertOutputs(
inp,
u'<p>Should <em>match</em> please</p>\n')
def test_preserve_links(self):
inp = u'Should preserve [](http://this_link.com)'
self.assertOutputs(
inp,
u'<p>Should preserve <a href="http://this_link.com"></a></p>\n')
def test_preserve_anchor_links(self):
inp = u'Should preserve [](#this-anchor-link)'
self.assertOutputs(
inp,
u'<p>Should preserve <a href="#this-anchor-link"></a></p>\n')
def test_wrong_link(self):
inp = u'this #does_not_exist'
_, diagnostics = self.assertOutputs(
inp,
u'<p>this does_not_exist</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘does_not_exist’'))
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 5)
def test_link_parsing_context(self):
inp = u'A %NULL-terminated thing'
_, diagnostics = self.assertOutputs(
inp,
u'<p>A NULL-terminated thing</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘NULL’'))
inp = u'A #Object::dashed-signal'
_, diagnostics = self.assertOutputs(
inp,
u'<p>A Object::dashed-signal</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘Object::dashed-signal’'))
def test_wrong_function_link(self):
inp = u'does_not_exist()'
_, diagnostics = self.assertOutputs(
inp,
u'<p>does_not_exist</p>\n')
self.assertEqual(len(diagnostics), 1)
diag = diagnostics[0]
self.assertEqual(
diag.message,
(u'Trying to link to non-existing symbol ‘does_not_exist’'))
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 0)
def test_wrong_multiline_link(self):
inp = (u'a #wrong_link\n\n'
'and #another_wrong_link\n'
'and then #yet_another_wrong_link')
_, diagnostics = cmark.gtkdoc_to_ast(inp, self.link_resolver)
self.assertEqual(len(diagnostics), 3)
diag = diagnostics[0]
self.assertEqual(diag.lineno, 0)
self.assertEqual(diag.column, 2)
diag = diagnostics[1]
self.assertEqual(diag.lineno, 2)
self.assertEqual(diag.column, 4)
diag = diagnostics[2]
self.assertEqual(diag.lineno, 3)
self.assertEqual(diag.column, 9)
def setUp(self):
self.doc_database = DocDatabase()
self.link_resolver = LinkResolver(self.doc_database)
self.link_resolver.add_link(Link("here.com", "foo", "foo"))