```
""",
"""
""", # noqa: E501
True
)
def test_omitted_language(self):
"""Test when language is omitted."""
self.check_markdown(
"""
```hl_lines="1"
some
code
```
""",
"""
""",
True
)
class TestSuperFencesClassesIds(util.MdCase):
"""Test classes and ids without attribute lists."""
extension = ['pymdownx.superfences']
extension_configs = {}
def test_classes(self):
"""Test extra classes."""
self.check_markdown(
r'''
```{.python .more}
import test
```
''',
r'''
''', # noqa: E501
True
)
def test_id(self):
"""Test extra id."""
self.check_markdown(
r'''
```{.python #id}
import test
```
''',
r'''
''', # noqa: E501
True
)
def test_attr(self):
"""Test extra attributes."""
self.check_markdown(
r'''
```{.python #id attr="test"}
import test
```
''',
r'''
''', # noqa: E501
True
)
def test_attrs_alternate_form(self):
"""Test attributes with new alternate form."""
self.check_markdown(
r'''
```python {.test .class #class}
import test
```
''',
r'''
''', # noqa: E501
True
)
def test_issue_2479(self):
"""Test issue #2479."""
self.check_markdown(
"""```test_test_test_test_test_test_test_test``` test test.""",
"""
test_test_test_test_test_test_test_test test test.
""",
True
)
class TestSuperFencesClassesIdsAttrList(util.MdCase):
"""Test fence ids and classes with attribute lists."""
extension = ['pymdownx.superfences', 'markdown.extensions.attr_list']
extension_configs = {}
def test_attribute_lists_with_braces(self):
"""Test attribute lists with braces."""
self.check_markdown(
R'''
``` { .c data-copy="int main() { return 0; }" }
Try copying me for some C code
```
''',
R'''
Try copying me for some C code
import test
''',
True
)
def test_id(self):
"""Test extra id."""
self.check_markdown(
r'''
```{.python #id}
import test
```
''',
r'''
import test
''',
True
)
def test_attr(self):
"""Test extra attributes."""
self.check_markdown(
r'''
```{.python #id attr="test"}
import test
```
''',
r'''
import test
''',
True
)
class TestSuperFencesClassesIdsAttrListNoPygmentsOnPre(util.MdCase):
"""Test fence ids and classes with attribute lists and with no Pygments and classes and ids on pre."""
extension = ['pymdownx.highlight', 'pymdownx.superfences', 'markdown.extensions.attr_list']
extension_configs = {
"pymdownx.highlight": {
"use_pygments": False,
"code_attr_on_pre": True
}
}
def test_classes(self):
"""Test extra classes."""
self.check_markdown(
r'''
```{.python .more}
import test
```
''',
r'''
import test
''',
True
)
def test_id(self):
"""Test extra id."""
self.check_markdown(
r'''
```{.python #id}
import test
```
''',
r'''
import test
''',
True
)
def test_attr(self):
"""Test extra attributes."""
self.check_markdown(
r'''
```{.python #id attr="test"}
import test
```
''',
r'''
import test
''',
True
)
class TestSuperFencesBad(util.MdCase):
"""Test bad options."""
extension = ['pymdownx.superfences']
extension_configs = {}
def test_bad_options(self):
"""Test bad options."""
self.check_markdown(
r'''
```python option="bad"
import test
```
''',
r'''
python option="bad"
import test
''',
True
)
def test_bad_option_value(self):
"""Test bad option values."""
self.check_markdown(
r'''
```python hl_lines="unexpected 3" linenums="1"
"""Some file."""
import foo.bar
import boo.baz
import foo.bar.baz
```
''',
r'''
python hl_lines="unexpected 3" linenums="1"
"""Some file."""
import foo.bar
import boo.baz
import foo.bar.baz
''',
True
)
class TestSuperFencesCustom(util.MdCase):
"""Test custom validator and format."""
extension = ['pymdownx.superfences', 'attr_list']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_format,
'validator': custom_validator
}
]
}
}
def test_failure(self):
"""
Test failure of custom fence.
Fence failed, gracefully continue with any other fences that can capture this.
"""
self.check_markdown(
r'''
```test
test
```
''',
r'''
''',
True
)
def test_bad_options(self):
"""Test bad option."""
self.check_markdown(
r'''
```test bad="bad"
test
```
''',
r'''
test bad="bad"
test
''',
True
)
def test_bad_option_value(self):
"""Test option with bad value."""
self.check_markdown(
r'''
```test opt="B"
test
```
''',
r'''
test opt="B"
test
''',
True
)
def test_bad_option_no_value(self):
"""Test option with no value."""
self.check_markdown(
r'''
```test opt
test
```
''',
r'''
test opt
test
''',
True
)
def test_custom_options(self):
"""Test option with correct value."""
self.check_markdown(
r'''
```test opt="A"
test
```
''',
r'''
test
''',
True
)
def test_custom_options_attr_list(self):
"""Test option with correct value."""
self.check_markdown(
r'''
```test {opt="A"}
test
```
''',
r'''
test
''',
True
)
class TestSuperFencesCustomException(util.MdCase):
"""Test custom validator and format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_format,
'validator': custom_validator_except
}
]
}
}
def test_custom_fail_exception(self):
"""Test custom fences forced exception."""
with self.assertRaises(SuperFencesException):
self.check_markdown(
r'''
```test
test
```
''',
'',
True
)
class TestSuperFencesCustomExceptionAttrList(util.MdCase):
"""Test custom validator and format with attribute lists."""
extension = ['pymdownx.superfences', 'attr_list']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_format,
'validator': custom_validator_except
}
]
}
}
def test_custom_fail_exception(self):
"""Test custom fences forced exception with attribute lists."""
with self.assertRaises(SuperFencesException):
self.check_markdown(
r'''
```{.test}
test
```
''',
'',
True
)
class TestSuperFencesCustomDefaultValidator(util.MdCase):
"""Test custom format with default validator."""
extension = ['pymdownx.superfences', 'markdown.extensions.attr_list']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': superfences.fence_div_format,
'validator': superfences.default_validator
}
]
}
}
def test_default_validator(self):
"""Test default validator."""
self.check_markdown(
r'''
```{.test opt="A"}
test
```
''',
r'''
test
''',
True
)
class TestSuperFencesCustomArithmatex(util.MdCase):
"""Test custom Arithmatex format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.arithmatex_fenced_format(mode="mathjax")
}
]
}
}
def test_arithmatex(self):
"""Test Arithmatex formatter without preview."""
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
''',
True
)
class TestSuperFencesCustomLegacyArithmatex(util.MdCase):
"""Test custom Arithmatex format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.fence_mathjax_format
}
]
}
}
def test_legacy_arithmatex(self):
"""Test Arithmatex formatter without preview."""
with warnings.catch_warnings(record=True) as w:
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
''',
True
)
self.assertTrue(len(w) == 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
class TestSuperFencesCustomArithmatexPreview(util.MdCase):
"""Test custom Arithmatex preview format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.arithmatex_fenced_format(mode='mathjax', preview=True)
}
]
}
}
def test_arithmatex_preview(self):
"""Test Arithmatex formatter with preview."""
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
''',
True
)
class TestSuperFencesCustomLegacyArithmatexPreview(util.MdCase):
"""Test custom Arithmatex preview format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.fence_mathjax_preview_format
}
]
}
}
def test_legacy_arithmatex_preview(self):
"""Test Arithmatex formatter with preview."""
with warnings.catch_warnings(record=True) as w:
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
''',
True
)
self.assertTrue(len(w) == 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
class TestSuperFencesCustomArithmatexGeneric(util.MdCase):
"""Test custom Arithmatex generic format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.arithmatex_fenced_format(mode="generic")
}
]
}
}
def test_arithmatex_generic(self):
"""Test Arithmatex generic formatter."""
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
\[
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
\]
''',
True
)
class TestSuperFencesCustomLegacyArithmatexGeneric(util.MdCase):
"""Test custom Arithmatex generic format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.fence_generic_format
}
]
}
}
def test_legacy_arithmatex_generic(self):
"""Test Arithmatex generic formatter."""
with warnings.catch_warnings(record=True) as w:
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
''',
r'''
\[
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
\]
''',
True
)
self.assertTrue(len(w) == 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
class TestSuperFencesCustomDefault(util.MdCase):
"""Test overriding the default format."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': '*',
'class': '',
'format': default_format
},
{
'name': 'math',
'class': 'arithmatex',
'format': arithmatex.arithmatex_fenced_format(mode="generic")
}
]
}
}
def test_default_override(self):
"""Test default override."""
self.check_markdown(
r'''
```math
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
```
```python
test
```
''',
r'''
\[
E(\mathbf{v}, \mathbf{h}) = -\sum_{i,j}w_{ij}v_i h_j - \sum_i b_i v_i - \sum_j c_j h_j
\]
test
''',
True
)
class TestSuperFencesCustomBroken(util.MdCase):
"""Test custom formatter that is broken."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_exploder,
}
]
}
}
def test_broken(self):
"""Test broken fence."""
self.check_markdown(
'''
```test
doesn't matter
```
''',
'''
test
doesn't matter
''',
True
)
def test_broken_blockquote(self):
"""Test broken fence in a blockquote."""
self.check_markdown(
'''
> ```test
> doesn't matter
> ```
''',
'''
test
doesn't matter
''',
True
)
class TestSuperFencesCustomBrokenFail(util.MdCase):
"""Test custom formatter that is broken and causes a failure."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_exploder_fail,
}
]
}
}
def test_custom_fail_exception(self):
"""Test custom fences forced exception."""
with self.assertRaises(SuperFencesException):
self.check_markdown(
r'''
```test
test
```
''',
'',
True
)
def test_custom_fail_exception_blockquote(self):
"""Test custom fences forced exception in a block quote."""
with self.assertRaises(SuperFencesException):
self.check_markdown(
r'''
> ```test
> test
> ```
''',
'',
True
)
class TestSuperFencesCustomValidatorBroken(util.MdCase):
"""Test custom legacy validator that is broken."""
extension = ['pymdownx.superfences']
extension_configs = {
'pymdownx.superfences': {
'custom_fences': [
{
'name': 'test',
'class': 'test',
'format': custom_format,
'validator': custom_validator_exploder
}
]
}
}
def test_broken(self):
"""Test broken fence."""
self.check_markdown(
'''
```test
doesn't matter
```
''',
'''
''',
True
)
def test_broken_brace(self):
"""Test broken fence."""
self.check_markdown(
'''
```{.test}
doesn't matter
```
''',
'''
''',
True
)