. The source can be
found at .
GladTeX-2.3.1/runtests 0000775 0000000 0000000 00000000432 13171061441 0014617 0 ustar 00root root 0000000 0000000 #!/bin/sh
# change above to python, if your system doesn't have the 3 suffix for python 3
set -e
PYTHON=python
# check whether a program called "python3" exists, else use "python"
if command -v python3 >/dev/null 2>&1
then
PYTHON=python3
fi
$PYTHON -m unittest discover tests
GladTeX-2.3.1/setup.py 0000664 0000000 0000000 00000007162 13171061441 0014523 0 ustar 00root root 0000000 0000000 import distutils.command.install_scripts, distutils.command.build, distutils.command.clean
from distutils.core import setup
import os
import shutil
import sys
#pylint: disable=unused-import
try:
import py2exe # only works on windows
except ImportError:
pass
from gleetex import VERSION
class ScriptInstaller(distutils.command.install_scripts.install_scripts):
"""Custom script installer. Stript .py extension if not on Windows."""
def run(self):
distutils.command.install_scripts.install_scripts.run(self)
for script in self.get_outputs():
if script.endswith(".py") and not ('wind' in sys.platform or 'win32'
in sys.platform):
# strip file ending (if not on windows) to make it executable as
# a command
shutil.move(script, script[:-3])
#pylint: disable=attribute-defined-outside-init
class CleanCommand(distutils.command.clean.clean):
description = "clean all build files, including __pycache__ and others"
user_options = []
def initialize_options(self):
self.cwd = None
def finalize_options(self):
self.cwd = os.getcwd()
def run(self):
assert os.getcwd() == self.cwd, 'Must be in package root: %s' % self.cwd
for directory in ['build', '__pycache__', 'dist',
os.path.join('gleetex', '__pycache')]:
if os.path.exists(directory):
shutil.rmtree(directory)
if os.path.exists('gladtex.1'):
os.remove('gladtex.1')
class CustomBuild(distutils.command.build.build):
"""Also build manpage to build/gladtex.1; it is not installed
automatically."""
def initialize_options(self):
self.cwd = None
super().initialize_options()
def finalize_options(self):
self.cwd = os.getcwd()
super().finalize_options()
def run(self):
if not self.cwd:
if not 'manpage.md' in os.listdir('.'):
print("setup.py must be run from the source root")
sys.exit(91)
else:
assert os.getcwd() == self.cwd, 'Must be in package root: %s' % self.cwd
super().run()
if shutil.which('pandoc'): # only build man page, if pandoc present
self.build_manpage('manpage.md', os.path.join('build', 'gladtex.1'))
else:
print("w: pandoc not found, skipping man page conversion.")
def build_manpage(self, input_fn, output_fn):
"""Convert `input_fn` from markdown into manpage format and save it to
`output_fn`. Pandoc is required."""
import subprocess
try:
cmd = ['pandoc', input_fn, '-s', '-t', 'man', '-o', output_fn]
proc = subprocess.Popen(cmd)
ret = proc.wait()
if ret:
raise subprocess.SubprocessError("Exit status %d when running '%s'" % (ret,
' '.join(cmd)))
except FileNotFoundError:
sys.stderr.write("Pandoc was not found on the system, skipping man " +
"page creation.")
setup(name='GladTeX',
version=VERSION,
description='generate html with LaTeX equations embedded as images',
author='Sebastian Humenda',
author_email='shumenda |at| gmx |dot| de',
url='https://humenda.github.io/GladTeX',
packages=['gleetex'],
console=['gladtex.py'], # Windows-only option, use python instead of pythonw
setup_requires=['py2app'], # require py2app on Mac OS
scripts=['gladtex.py'],
license = "LGPL3.0",
cmdclass = {"install_scripts": ScriptInstaller,
'clean': CleanCommand,
'build': CustomBuild}
)
GladTeX-2.3.1/tests/ 0000775 0000000 0000000 00000000000 13171061441 0014145 5 ustar 00root root 0000000 0000000 GladTeX-2.3.1/tests/test_caching.py 0000664 0000000 0000000 00000013360 13171061441 0017155 0 ustar 00root root 0000000 0000000 #pylint: disable=too-many-public-methods,import-error,too-few-public-methods,missing-docstring,unused-variable
import os
import shutil
import tempfile
import unittest
from gleetex import caching
def write(path, content):
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
class test_caching(unittest.TestCase):
def setUp(self):
self.pos = {'height' : 8, 'depth' : 2, 'width' : 666}
self.original_directory = os.getcwd()
self.tmpdir = tempfile.mkdtemp()
os.chdir(self.tmpdir)
def tearDown(self):
os.chdir(self.original_directory)
shutil.rmtree(self.tmpdir, ignore_errors=True)
def test_differently_spaced_formulas_are_the_same(self):
form1 = r'\tau \pi'
form2 = '\tau\\pi'
self.assertTrue(caching.normalize_formula(form1),
caching.normalize_formula(form2))
def test_trailing_and_leading_spaces_and_tabs_are_no_problem(self):
u = caching.normalize_formula
form1 = ' hi'
form2 = 'hi '
form3 = '\thi'
self.assertEqual(u(form1), u(form2))
self.assertEqual(u(form1), u(form3))
def test_that_empty_braces_are_ignored(self):
u = caching.normalize_formula
form1 = r'\sin{}x'
form2 = r'\sin x'
form3 = r'\sin{} x'
self.assertEqual(u(form1), u(form2))
self.assertEqual(u(form1), u(form3))
self.assertEqual(u(form2), u(form3))
def test_empty_cache_works_fine(self):
write('foo.png', 'muha')
c = caching.ImageCache('file.png')
formula = r"f(x) = \ln(x)"
c.add_formula(formula, self.pos, 'foo.png')
self.assertTrue(c.contains(formula, False))
def test_that_invalid_cach_entries_are_detected(self):
# entry is invalid if file doesn't exist
c = caching.ImageCache()
formula = r"f(x) = \ln(x)"
self.assertRaises(OSError, c.add_formula, formula, self.pos, 'file.png')
def test_that_correct_pos_and_path_are_returned_after_writing_the_cache_back(self):
c = caching.ImageCache()
formula = r"g(x) = \ln(x)"
write('file.png', 'dummy')
c.add_formula(formula, self.pos, 'file.png', displaymath=False)
c.write()
c = caching.ImageCache()
self.assertTrue(c.contains(formula, False))
data = c.get_data_for(formula, False)
self.assertEqual(data['pos'], self.pos)
self.assertEqual(data['path'], 'file.png')
def test_formulas_are_not_added_twice(self):
form1 = r'\ln(x) \neq e^x'
write('spass.png', 'binaryBinary_binary')
c = caching.ImageCache()
for i in range(1,10):
c.add_formula(form1, self.pos, 'spass.png')
self.assertEqual(len(c), 1)
def test_that_remove_actually_removes(self):
form1 = '\\int e^x dy'
write('happyness.png', 'binaryBinary_binary')
c = caching.ImageCache()
c.add_formula(form1, self.pos, 'happyness.png')
c.remove_formula(form1, False)
self.assertEqual(len(c), 0)
def test_removal_of_non_existing_formula_raises_exception(self):
c = caching.ImageCache()
self.assertRaises(KeyError, c.remove_formula, 'Haha!', False)
def test_that_invalid_version_is_detected(self):
c = caching.ImageCache('gladtex.cache')
c._ImageCache__set_version('invalid.stuff')
c.write()
self.assertRaises(caching.JsonParserException, caching.ImageCache, 'gladtex.cache')
def test_that_invalid_style_is_detected(self):
write('foo.png', "dummy")
c = caching.ImageCache('gladtex.cache')
c.add_formula('\\tau', self.pos, 'foo.png', False)
c.add_formula('\\theta', self.pos, 'foo.png', True)
self.assertRaises(ValueError, c.add_formula, '\\gamma', self.pos, 'foo.png',
'some stuff')
def test_that_backslash_in_path_is_replaced_through_slash(self):
c = caching.ImageCache('gladtex.cache')
os.mkdir('bilder')
write(os.path.join('bilder', 'foo.png'), str(0xdeadbeef))
c.add_formula('\\tau', self.pos, 'bilder\\foo.png', False)
self.assertTrue('/' in c.get_data_for('\\tau', False)['path'])
def test_that_absolute_paths_trigger_OSError(self):
c = caching.ImageCache('gladtex.cache')
write('foo.png', "dummy")
fn = os.path.abspath('foo.png')
self.assertRaises(OSError, c.add_formula, '\\tau', self.pos,
fn, False)
def test_that_invalid_caches_are_removed_automatically_if_desired(self):
file_was_removed = lambda x: self.assertFalse(os.path.exists(x),
"expected that file %s was removed, but it still exists" % x)
write('gladtex.cache', 'some non-json rubbish')
c = caching.ImageCache('gladtex.cache', keep_old_cache=False)
file_was_removed('gladtex.cache')
# try the same in a subdirectory
os.mkdir('foo')
cache_path = os.path.join('foo', 'gladtex.cache')
eqn1_path = os.path.join('foo', 'eqn000.png')
eqn2_path = os.path.join('foo', 'eqn003.png')
write(cache_path, 'some non-json rubbish')
write(eqn1_path, 'binary')
write(eqn2_path, 'more binary')
c = caching.ImageCache(cache_path, keep_old_cache=False)
file_was_removed(cache_path)
file_was_removed(eqn1_path)
file_was_removed(eqn2_path)
def test_that_formulas_in_cache_with_no_file_raise_key_error(self):
c = caching.ImageCache('gladtex.cache', keep_old_cache=False)
write('foo.png', 'dummy')
c.add_formula('\\tau', self.pos, 'foo.png')
c.write()
os.remove('foo.png')
c = caching.ImageCache('gladtex.cache', keep_old_cache=False)
with self.assertRaises(KeyError):
c.get_data_for('foo.png', 'False')
GladTeX-2.3.1/tests/test_convenience.py 0000664 0000000 0000000 00000013712 13171061441 0020056 0 ustar 00root root 0000000 0000000 #pylint: disable=too-many-public-methods,import-error,too-few-public-methods,missing-docstring,unused-variable
import distutils
import os
import shutil
import tempfile
import unittest
from gleetex import convenience, image
from gleetex.convenience import ConversionException
from gleetex.caching import JsonParserException
def get_number_of_files(path):
return len(os.listdir(path))
def mk_eqn(eqn, count=0, pos=(1,1)):
"""Create formula. Each formula must look like this:
(eqn, pos, path, dsp, count) for self._convert_concurrently, this is a
shorthand with mocking a few values."""
return (eqn, pos, 'eqn%03d.png' % count, False, count)
def turn_into_orig_formulas(formulas):
"""Turn a list of formulas as accepted by
CachedConverter._convert_concurrently() into a list accepted by
CachedConverter._get_formulas_to_convert()."""
return [(e[1], e[3], e[0]) for e in formulas]
def write(path, content='dummy'):
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
class Tex2imgMock():
"""Could use a proper mock, but this one allows a bit more tricking."""
def __init__(self, _tex_document, output_fn, _encoding="UTF-8"):
self.output_name = output_fn
base_name = os.path.split(output_fn)[0]
if base_name and not os.path.exists(base_name):
distutils.dir_util.mkpath(base_name)
self.set_dpi = self.set_transparency = self.set_foreground_color \
= self.set_background_color = lambda x: None # do nothing
def create_dvi(self, dvi_fn):
"""
Call LaTeX to produce a dvi file with the given LaTeX document.
Temporary files will be removed, even in the case of a LaTeX error.
This method raises a SubprocessError with the helpful part of LaTeX's
error output."""
with open(dvi_fn, 'w') as f:
f.write('dummy')
def create_png(self, dvi_fn):
if os.path.exists(dvi_fn):
os.remove(dvi_fn)
write(self.output_name)
def convert(self):
self.create_png(self.output_name)
def get_positioning_info(self):
return {'depth': 9, 'height': 8, 'width': 7}
def parse_log(self, _logdata):
return {}
class TestCachedConverter(unittest.TestCase):
#pylint: disable=protected-access
def setUp(self):
self.original_directory = os.getcwd()
self.tmpdir = tempfile.mkdtemp()
os.chdir(self.tmpdir)
convenience.CachedConverter._converter = Tex2imgMock
#pylint: disable=protected-access
def tearDown(self):
# restore static reference to converter
convenience.CachedConverter._converter = image.Tex2img
os.chdir(self.original_directory)
shutil.rmtree(self.tmpdir, ignore_errors=True)
def test_that_subdirectory_is_created(self):
c = convenience.CachedConverter(os.getcwd(), 'subdirectory')
formula = '\\textbf{FOO!}'
c.convert(formula, 'subdirectory/eqn000.png')
# one directory exists
self.assertEqual(get_number_of_files('.'), 1,
"Found the following files, expected only 'subdirectory': " + \
', '.join(os.listdir('.')))
# subdirectory contains 1 image and a cache
self.assertEqual(get_number_of_files('subdirectory'), 1, "expected one"+\
" files, found only " + repr(os.listdir('subdirectory')))
def test_that_unknown_options_trigger_exception(self):
c = convenience.CachedConverter('subdirectory')
self.assertRaises(ValueError, c.set_option, 'cxzbiucxzbiuxzb', 'muh')
def test_that_invalid_caches_trigger_error_by_default(self):
with open('gladtex.cache', 'w') as f:
f.write('invalid cache')
with self.assertRaises(JsonParserException):
c = convenience.CachedConverter('')
def test_that_invalid_caches_get_removed_if_specified(self):
formulas = [mk_eqn('tau')]
with open('gladtex.cache', 'w') as f:
f.write('invalid cache')
c = convenience.CachedConverter('', keep_old_cache=False)
c._convert_concurrently(formulas)
# cache got overridden
with open('gladtex.cache') as f:
self.assertFalse('invalid' in f.read())
def test_that_converted_formulas_are_cached(self):
formulas = [mk_eqn('tau')]
c = convenience.CachedConverter('')
c._convert_concurrently(formulas)
formulas.append(mk_eqn('\\gamma'))
formulas = turn_into_orig_formulas(formulas)
self.assertTrue(len(c._get_formulas_to_convert('', formulas)), 1)
def test_that_file_names_are_correctly_picked(self):
formulas = turn_into_orig_formulas([mk_eqn('\\tau')])
write('eqn000.png')
write('eqn001.png')
c = convenience.CachedConverter('')
to_convert = c._get_formulas_to_convert('', formulas)
self.assertTrue(len(to_convert), 1)
self.assertEqual(to_convert[0][2], 'eqn002.png')
def test_that_all_converted_formulas_are_in_cache_and_meta_info_correct(self):
formulas = [mk_eqn('a_{%d}' % i, pos=(i,i), count=i) for i in range(100)]
c = convenience.CachedConverter('')
c._convert_concurrently(formulas)
# expect all formulas and a gladtex cache to exist
self.assertEqual(get_number_of_files('.'), len(formulas)+1)
for formula, pos, fn, dsp, count in formulas:
data = c.get_data_for(formula, False)
self.assertEqual(data['pos'], {'depth': 9, 'height': 8, 'width': 7},
"expected the pos as defined in the dummy class")
def test_that_inline_math_and_display_math_results_in_different_formulas(self):
# two formulas, second is displaymath
formula = r'\sum_{i=0}^n x_i'
formulas = [((1,1), False, formula), ((3,1), True, formula)]
c = convenience.CachedConverter('.')
c.convert_all('.', formulas)
# expect all formulas and a gladtex cache to exist
self.assertEqual(get_number_of_files('.'), len(formulas)+1)
GladTeX-2.3.1/tests/test_document.py 0000664 0000000 0000000 00000016644 13171061441 0017407 0 ustar 00root root 0000000 0000000 #pylint: disable=too-many-public-methods,import-error,too-few-public-methods,missing-docstring,unused-variable
import unittest
from gleetex.document import LaTeXDocument
import gleetex.document as document
class test_document(unittest.TestCase):
def test_formula_is_embedded(self):
formula = 'E = m \\cdot c^2'
doc = LaTeXDocument(formula)
self.assertTrue(formula in str(doc),
"formula must be contained in LaTeX document as it was inserted.")
def test_if_displaymath_unset_correct_env_used(self):
doc = LaTeXDocument(r'A = \pi r^2')
doc.set_displaymath(False)
self.assertTrue('\\(' in str(doc))
self.assertTrue('\\)' in str(doc))
def test_if_displaymath_is_set_correct_env_used(self):
doc = LaTeXDocument(r'A = \pi r^2')
doc.set_displaymath(True)
self.assertTrue('\\[' in str(doc))
self.assertTrue('\\]' in str(doc))
def test_preamble_is_included(self):
preamble = '\\usepackage{eurosym}'
doc = LaTeXDocument('moooo')
doc.set_preamble_string(preamble)
self.assertTrue(preamble in str(doc))
def test_obviously_wrong_encoding_trigger_exception(self):
doc = LaTeXDocument('f00')
self.assertRaises(ValueError, doc.set_encoding, 'latin1:')
self.assertRaises(ValueError, doc.set_encoding, 'utf66')
# the following passes (assertRaisesNot)
doc.set_encoding('utf-8')
def test_that_latex_maths_env_is_used(self):
doc = LaTeXDocument('f00')
doc.set_latex_environment('flalign*')
self.assertTrue(r'\begin{flalign*}' in str(doc))
self.assertTrue(r'\end{flalign*}' in str(doc))
################################################################################
class test_replace_unicode_characters(unittest.TestCase):
def test_that_ascii_strings_are_returned_verbatim(self):
for string in ['abc.\\', '`~[]}{:<>']:
textmode = document.replace_unicode_characters(string, False)
self.assertEqual(textmode, string, 'expected %s, got %s' % (string, textmode))
mathmode = document.replace_unicode_characters(string, True)
self.assertEqual(textmode, string, 'expected %s, got %s' % (string, mathmode))
def test_that_alphabetical_characters_are_replaced_by_default(self):
textmode = document.replace_unicode_characters('ö', False)
self.assertTrue('\\"' in textmode)
mathmode = document.replace_unicode_characters('ö', True)
self.assertTrue('\\ddot' in mathmode)
def test_that_alphabetical_characters_are_kept_in_text_mode_if_specified(self):
self.assertEqual(document.replace_unicode_characters('ö', False, # text mode
replace_alphabeticals=False), 'ö')
self.assertEqual(document.replace_unicode_characters('æ', False,
replace_alphabeticals=False), 'æ')
def test_that_alphanumericals_are_replaced_in_mathmode_even_if_replace_alphabeticals_set(self):
self.assertNotEqual(document.replace_unicode_characters('öäü', True,
replace_alphabeticals=True), 'öäü')
self.assertNotEqual(document.replace_unicode_characters('æø', True,
replace_alphabeticals=True), 'æø')
def test_that_charachters_not_present_in_file_raise_exception(self):
with self.assertRaises(ValueError):
document.replace_unicode_characters('€', True)
def test_that_formulas_are_replaced(self):
self.assertNotEqual(document.replace_unicode_characters('π', True),
'π')
self.assertNotEqual(document.replace_unicode_characters('π', False),
'π')
class test_get_matching_brace(unittest.TestCase):
def test_closing_brace_found_when_only_one_brace_present(self):
text = 'text{ok}'
self.assertEqual(document.get_matching_brace(text, 4), len(text) - 1)
self.assertEqual(document.get_matching_brace(text + 'foo', 4), len(text) - 1)
def test_outer_brace_found(self):
text = 'text{o, bla\\"{o}dfdx.}ds'
self.assertEqual(document.get_matching_brace(text, 4), len(text)-3)
def test_inner_brace_is_matched(self):
text = 'text{o, bla\\"{o}dfdx.}ds'
self.assertEqual(document.get_matching_brace(text, 13), 15)
def test_that_unmatched_braces_raise_exception(self):
with self.assertRaises(ValueError):
document.get_matching_brace('text{foooooooo', 4)
with self.assertRaises(ValueError):
document.get_matching_brace('text{jo\"{o....}', 4)
def test_wrong_position_for_opening_brace_raises(self):
with self.assertRaises(ValueError):
document.get_matching_brace('moo', 1)
class test_escape_unicode_in_formulas(unittest.TestCase):
"""These tests assume that the tests written above work!"""
def test_that_mathmode_and_textmode_are_treated_differently(self):
math = document.escape_unicode_in_formulas('ö')
self.assertNotEqual(math, 'ö')
text = document.escape_unicode_in_formulas('\\text{ö}')
self.assertFalse('ö' in text)
# check whether characters got transcribed differently; it's enough to
# check one character of the generated sequence, they should differ
self.assertNotEqual(math[:2], text[6:8])
def test_that_flag_to_preserve_alphas_is_passed_through(self):
res = document.escape_unicode_in_formulas('\\text{ö}',
replace_alphabeticals=False)
self.assertEqual(res, '\\text{ö}')
def test_that_all_characters_are_preserved_when_no_replacements_happen(self):
text = 'This is a \\text{test} mate.'
self.assertEqual(document.escape_unicode_in_formulas(text), text)
self.assertEqual(document.escape_unicode_in_formulas(text,
replace_alphabeticals=False), text)
text = 'But yeah but no' * 20 + ', oh my god!'
self.assertEqual(document.escape_unicode_in_formulas(text), text)
self.assertEqual(document.escape_unicode_in_formulas(text,
replace_alphabeticals=False), text)
def test_that_everything_around_surrounded_character_is_preserved(self):
text = 'This is a \\text{über} test. ;)'
result = document.escape_unicode_in_formulas(text,
replace_alphabeticals=True)
ue_pos = text.index('ü')
# text in front is unchanged
self.assertEqual(result[:ue_pos], text[:ue_pos])
# find b character, which is the start of the remaining string
b_pos = result[ue_pos:].find('b') + ue_pos
# check that text after umlaut matches
self.assertEqual(result[b_pos:], text[ue_pos+1:])
text = 'But yeah but no' * 20 + ', oh my god!ø'
o_strok_pos = text.index('ø')
res = document.escape_unicode_in_formulas(text)
self.assertEqual(res[:o_strok_pos], text[:o_strok_pos])
def test_that_unknown_unicode_characters_raise_exception(self):
# you know that Santa Clause character? Seriously, if you don't know it,
# you should have a look. LaTeX does indeed not have command for this
# (2016, one never knows)
santa = chr(127877)
with self.assertRaises(document.DocumentSerializationException):
document.escape_unicode_in_formulas(santa)
def test_that_two_text_environments_preserve_all_characters(self):
text = r'a\cdot b \text{equals} b\cdot c} \mbox{ is not equal } u^{v\cdot k}'
self.assertEqual(document.escape_unicode_in_formulas(text), text)
GladTeX-2.3.1/tests/test_htmlhandling.py 0000664 0000000 0000000 00000041664 13171061441 0020242 0 ustar 00root root 0000000 0000000 #pylint: disable=too-many-public-methods
from functools import reduce
import os, re, shutil, tempfile
import unittest
from gleetex import htmlhandling
excl_filename = htmlhandling.HtmlImageFormatter.EXCLUSION_FILE_NAME
HTML_SKELETON = '''
{1}'''
def read(file_name, mode='r', encoding='utf-8'):
"""Read the file, return the string. Close file properly."""
with open(file_name, mode, encoding=encoding) as handle:
return handle.read()
class HtmlparserTest(unittest.TestCase):
def setUp(self):
self.p = htmlhandling.EqnParser()
def test_start_tags_are_parsed_literally(self):
self.p.feed("")
self.assertEqual(self.p.get_data()[0], "
",
"The HTML parser should copy start tags literally.")
def test_that_end_tags_are_copied_literally(self):
self.p.feed("
")
self.assertEqual(''.join(self.p.get_data()), "")
def test_entities_are_unchanged(self):
self.p.feed("
")
self.assertEqual(self.p.get_data()[0], '
')
def test_charsets_are_copied(self):
self.p.feed('>→')
self.assertEqual(''.join(self.p.get_data()[0]), '>→')
def test_without_eqn_all_blocks_are_strings(self):
self.p.feed("\n42
blah
")
self.assertTrue(reduce(lambda x,y: x and isinstance(y, str),
self.p.get_data()), "all chunks have to be strings")
def test_equation_is_detected(self):
self.p.feed('foo \\pi')
self.assertTrue(isinstance(self.p.get_data()[0], (tuple, list)))
self.assertEqual(self.p.get_data()[0][2], 'foo \\pi')
def test_tag_followed_by_eqn_is_correctly_recognized(self):
self.p.feed('bar')
self.assertEqual(self.p.get_data()[0], '
')
self.assertTrue(isinstance(self.p.get_data(), list), "second item of data must be equation data list")
def test_document_with_tag_then_eqn_then_tag_works(self):
self.p.feed('
bar
baz')
eqn = None
# test should not depend on a specific position of equation, search for
# it
data = self.p.get_data()
for chunk in data:
if isinstance(chunk, (tuple, list)):
eqn = chunk
break
self.assertTrue(isinstance(data[0], str))
self.assertTrue(eqn is not None,
"No equation found, must be tuple/list object.")
self.assertTrue(isinstance(data[-1], str))
def test_equation_is_copied_literally(self):
self.p.feed('my\nlittle\n\\tau')
self.assertEqual(self.p.get_data()[0][2], 'my\nlittle\n\\tau')
def test_unclosed_eqns_are_detected(self):
self.assertRaises(htmlhandling.ParseException, self.p.feed,
'\\endless\\formula')
def test_nested_formulas_trigger_exception(self):
self.assertRaises(htmlhandling.ParseException, self.p.feed,
"\\pi")
self.assertRaises(htmlhandling.ParseException, self.p.feed,
"\\pi