IntenseWebs/sphinx
3
0
Fork 0
mirror of https://github.com/sphinx-doc/sphinx.git synced 2025-02-25 18:55:22 -06:00
Code Issues Packages Projects Releases Wiki Activity

Fix flake8 violations

Browse Source
This commit is contained in:
Takeshi KOMIYA 2017-12-23 21:20:32 +09:00
parent 2e04c2a058
commit a9efb2517a
18 changed files with 247 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/test_autodoc.py
View File

@ -425,7 +425,7 @@ def test_get_doc():
# class has __init__ method without docstring and
# __new__ method with docstring
# class docstring: depends on config value which one is taken
class I:
class I: # NOQA
"""Class docstring"""
def __new__(cls):
"""New docstring"""

4
tests/test_build.py
View File

@ -34,8 +34,8 @@ def nonascii_srcdir(request, rootdir, sphinx_test_tempdir):
basedir = sphinx_test_tempdir / request.node.originalname
# Windows with versions prior to 3.2 (I think) doesn't support unicode on system path
# so we force a non-unicode path in that case
if sys.platform == "win32" and \
not (sys.version_info.major >= 3 and sys.version_info.minor >= 2):
if (sys.platform == "win32" and
not (sys.version_info.major >= 3 and sys.version_info.minor >= 2)):
return basedir / 'all'
try:
srcdir = basedir / test_name

2
tests/test_build_epub.py
View File

@ -245,5 +245,3 @@ def test_epub_writing_mode(app):
# vertical / writing-mode (CSS)
css = (app.outdir / '_static' / 'epub.css').text()
assert 'writing-mode: vertical-rl;' in css

1
tests/test_build_html.py
View File

@ -15,7 +15,6 @@ from itertools import cycle, chain
from six import PY3
from sphinx import __display_version__
from sphinx.util.inventory import InventoryFile
from sphinx.testing.util import remove_unicode_literals, strip_escseq
import xml.etree.cElementTree as ElementTree

3
tests/test_build_latex.py
View File

@ -773,6 +773,7 @@ def test_toctree_maxdepth_manual(app, status, warning):
assert '\\setcounter{secnumdepth}' not in result
assert '\\chapter{Foo}' in result
@pytest.mark.sphinx(
'latex', testroot='toctree-maxdepth',
confoverrides={'latex_documents': [
@ -789,6 +790,7 @@ def test_toctree_maxdepth_howto(app, status, warning):
assert '\\setcounter{secnumdepth}' not in result
assert '\\section{Foo}' in result
@pytest.mark.sphinx(
'latex', testroot='toctree-maxdepth',
confoverrides={'master_doc': 'foo'})
@ -802,6 +804,7 @@ def test_toctree_not_found(app, status, warning):
assert '\\setcounter{secnumdepth}' not in result
assert '\\chapter{Foo A}' in result
@pytest.mark.sphinx(
'latex', testroot='toctree-maxdepth',
confoverrides={'master_doc': 'bar'})

2
tests/test_docutilsconf.py
View File

@ -72,7 +72,7 @@ def test_texinfo(app, status, warning):
@pytest.mark.sphinx('html', testroot='docutilsconf',
docutilsconf='[general]\nsource_link=true\n')
@pytest.mark.skip(sys.platform == "win32" and \
@pytest.mark.skip(sys.platform == "win32" and
not (sys.version_info.major >= 3 and sys.version_info.minor >= 2),
reason="Python < 3.2 on Win32 doesn't handle non-ASCII paths right")
def test_docutils_source_link_with_nonascii_file(app, status, warning):

436
tests/test_domain_cpp.py
View File

@ -101,13 +101,13 @@ def test_fundamental_types():
if t == "std::nullptr_t":
id = "NSt9nullptr_tE"
return "1f%s" % id
check("function", "void f(%s arg)" % t, {1: makeIdV1(), 2:makeIdV2()})
check("function", "void f(%s arg)" % t, {1: makeIdV1(), 2: makeIdV2()})
def test_expressions():
def exprCheck(expr, id):
ids = 'IE1CIA%s_1aE'
check('class', 'template<> C<a[%s]>' % expr, {2:ids % expr, 3:ids % id})
check('class', 'template<> C<a[%s]>' % expr, {2: ids % expr, 3: ids % id})
# primary
exprCheck('nullptr', 'LDnE')
exprCheck('true', 'L1E')
@ -118,9 +118,9 @@ def test_expressions():
for i in ints:
for u in unsignedSuffix:
for l in longSuffix:
expr = i + u + l;
expr = i + u + l
exprCheck(expr, 'L' + expr + 'E')
expr = i + l + u;
expr = i + l + u
exprCheck(expr, 'L' + expr + 'E')
for suffix in ['', 'f', 'F', 'l', 'L']:
expr = '5.0' + suffix
@ -200,55 +200,55 @@ def test_expressions():
# a < expression that starts with something that could be a template
exprCheck('A < 42', 'lt1AL42E')
check('function', 'template<> void f(A<B, 2> &v)',
{2:"IE1fR1AI1BX2EE", 3:"IE1fR1AI1BXL2EEE"})
{2: "IE1fR1AI1BX2EE", 3: "IE1fR1AI1BXL2EEE"})
exprCheck('A<1>::value', 'N1AIXL1EEE5valueE')
check('class', "template<int T = 42> A", {2:"I_iE1A"})
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2:"1A"})
check('class', "template<int T = 42> A", {2: "I_iE1A"})
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2: "1A"})
def test_type_definitions():
check("type", "public bool b", {1:"b", 2:"1b"}, "bool b")
check("type", "bool A::b", {1:"A::b", 2:"N1A1bE"})
check("type", "bool *b", {1:"b", 2:"1b"})
check("type", "bool *const b", {1:"b", 2:"1b"})
check("type", "bool *volatile const b", {1:"b", 2:"1b"})
check("type", "bool *volatile const b", {1:"b", 2:"1b"})
check("type", "bool *volatile const *b", {1:"b", 2:"1b"})
check("type", "bool &b", {1:"b", 2:"1b"})
check("type", "bool b[]", {1:"b", 2:"1b"})
check("type", "std::pair<int, int> coord", {1:"coord", 2:"5coord"})
check("type", "long long int foo", {1:"foo", 2:"3foo"})
check("type", "public bool b", {1: "b", 2: "1b"}, "bool b")
check("type", "bool A::b", {1: "A::b", 2: "N1A1bE"})
check("type", "bool *b", {1: "b", 2: "1b"})
check("type", "bool *const b", {1: "b", 2: "1b"})
check("type", "bool *volatile const b", {1: "b", 2: "1b"})
check("type", "bool *volatile const b", {1: "b", 2: "1b"})
check("type", "bool *volatile const *b", {1: "b", 2: "1b"})
check("type", "bool &b", {1: "b", 2: "1b"})
check("type", "bool b[]", {1: "b", 2: "1b"})
check("type", "std::pair<int, int> coord", {1: "coord", 2: "5coord"})
check("type", "long long int foo", {1: "foo", 2: "3foo"})
check("type", 'std::vector<std::pair<std::string, long long>> module::blah',
{1:"module::blah", 2:"N6module4blahE"})
check("type", "std::function<void()> F", {1:"F", 2:"1F"})
check("type", "std::function<R(A1, A2)> F", {1:"F", 2:"1F"})
check("type", "std::function<R(A1, A2, A3)> F", {1:"F", 2:"1F"})
check("type", "std::function<R(A1, A2, A3, As...)> F", {1:"F", 2:"1F"})
{1: "module::blah", 2: "N6module4blahE"})
check("type", "std::function<void()> F", {1: "F", 2: "1F"})
check("type", "std::function<R(A1, A2)> F", {1: "F", 2: "1F"})
check("type", "std::function<R(A1, A2, A3)> F", {1: "F", 2: "1F"})
check("type", "std::function<R(A1, A2, A3, As...)> F", {1: "F", 2: "1F"})
check("type", "MyContainer::const_iterator",
{1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"})
{1: "MyContainer::const_iterator", 2: "N11MyContainer14const_iteratorE"})
check("type",
"public MyContainer::const_iterator",
{1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"},
{1: "MyContainer::const_iterator", 2: "N11MyContainer14const_iteratorE"},
output="MyContainer::const_iterator")
# test decl specs on right
check("type", "bool const b", {1:"b", 2:"1b"})
check("type", "bool const b", {1: "b", 2: "1b"})
# test name in global scope
check("type", "bool ::B::b", {1:"B::b", 2:"N1B1bE"})
check("type", "bool ::B::b", {1: "B::b", 2: "N1B1bE"})
check('type', 'A = B', {2:'1A'})
check('type', 'A = decltype(b)', {2:'1A'})
check('type', 'A = B', {2: '1A'})
check('type', 'A = decltype(b)', {2: '1A'})
# from breathe#267 (named function parameters for function pointers
check('type', 'void (*gpio_callback_t)(struct device *port, uint32_t pin)',
{1:'gpio_callback_t', 2:'15gpio_callback_t'})
check('type', 'void (*f)(std::function<void(int i)> g)', {1:'f', 2:'1f'})
{1: 'gpio_callback_t', 2: '15gpio_callback_t'})
check('type', 'void (*f)(std::function<void(int i)> g)', {1: 'f', 2: '1f'})
def test_concept_definitions():
check('concept', 'template<typename Param> A::B::Concept',
{2:'I0EN1A1B7ConceptE'})
{2: 'I0EN1A1B7ConceptE'})
check('concept', 'template<typename A, typename B, typename ...C> Foo',
{2:'I00DpE3Foo'})
{2: 'I00DpE3Foo'})
with pytest.raises(DefinitionError):
parse('concept', 'Foo')
with pytest.raises(DefinitionError):
@ -257,269 +257,270 @@ def test_concept_definitions():
def test_member_definitions():
check('member', ' const std::string & name = 42',
{1:"name__ssCR", 2:"4name"}, output='const std::string &name = 42')
check('member', ' const std::string & name', {1:"name__ssCR", 2:"4name"},
{1: "name__ssCR", 2: "4name"}, output='const std::string &name = 42')
check('member', ' const std::string & name', {1: "name__ssCR", 2: "4name"},
output='const std::string &name')
check('member', ' const std::string & name [ n ]',
{1:"name__ssCRA", 2:"4name"}, output='const std::string &name[n]')
{1: "name__ssCRA", 2: "4name"}, output='const std::string &name[n]')
check('member', 'const std::vector< unsigned int, long> &name',
{1:"name__std::vector:unsigned-i.l:CR", 2:"4name"},
{1: "name__std::vector:unsigned-i.l:CR", 2: "4name"},
output='const std::vector<unsigned int, long> &name')
check('member', 'module::myclass foo[n]', {1:"foo__module::myclassA", 2:"3foo"})
check('member', 'int *const p', {1:'p__iPC', 2:'1p'})
check('member', 'extern int myInt', {1:'myInt__i', 2:'5myInt'})
check('member', 'thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
check('member', 'extern thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
check('member', 'thread_local extern int myInt', {1:'myInt__i', 2:'5myInt'},
check('member', 'module::myclass foo[n]', {1: "foo__module::myclassA", 2: "3foo"})
check('member', 'int *const p', {1: 'p__iPC', 2: '1p'})
check('member', 'extern int myInt', {1: 'myInt__i', 2: '5myInt'})
check('member', 'thread_local int myInt', {1: 'myInt__i', 2: '5myInt'})
check('member', 'extern thread_local int myInt', {1: 'myInt__i', 2: '5myInt'})
check('member', 'thread_local extern int myInt', {1: 'myInt__i', 2: '5myInt'},
'extern thread_local int myInt')
def test_function_definitions():
check('function', 'operator bool() const', {1:"castto-b-operatorC", 2:"NKcvbEv"})
check('function', 'operator bool() const', {1: "castto-b-operatorC", 2: "NKcvbEv"})
check('function', 'A::operator bool() const',
{1:"A::castto-b-operatorC", 2:"NK1AcvbEv"})
{1: "A::castto-b-operatorC", 2: "NK1AcvbEv"})
check('function', 'A::operator bool() volatile const &',
{1:"A::castto-b-operatorVCR", 2:"NVKR1AcvbEv"})
{1: "A::castto-b-operatorVCR", 2: "NVKR1AcvbEv"})
check('function', 'A::operator bool() volatile const &&',
{1:"A::castto-b-operatorVCO", 2:"NVKO1AcvbEv"})
{1: "A::castto-b-operatorVCO", 2: "NVKO1AcvbEv"})
check('function', 'bool namespaced::theclass::method(arg1, arg2)',
{1:"namespaced::theclass::method__arg1.arg2",
2:"N10namespaced8theclass6methodE4arg14arg2"})
{1: "namespaced::theclass::method__arg1.arg2",
2: "N10namespaced8theclass6methodE4arg14arg2"})
x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
'foo, bar, std::string baz = "foobar, blah, bleh") const = 0'
check('function', x, {1:"module::test__i.bar.ssC",
2:"NK6module4testEi3barNSt6stringE"})
check('function', x, {1: "module::test__i.bar.ssC",
2: "NK6module4testEi3barNSt6stringE"})
check('function', 'void f(std::pair<A, B>)',
{1:"f__std::pair:A.B:", 2:"1fNSt4pairI1A1BEE"})
{1: "f__std::pair:A.B:", 2: "1fNSt4pairI1A1BEE"})
check('function', 'explicit module::myclass::foo::foo()',
{1:"module::myclass::foo::foo", 2:"N6module7myclass3foo3fooEv"})
{1: "module::myclass::foo::foo", 2: "N6module7myclass3foo3fooEv"})
check('function', 'module::myclass::foo::~foo()',
{1:"module::myclass::foo::~foo", 2:"N6module7myclass3fooD0Ev"})
{1: "module::myclass::foo::~foo", 2: "N6module7myclass3fooD0Ev"})
check('function', 'int printf(const char *fmt, ...)',
{1:"printf__cCP.z", 2:"6printfPKcz"})
{1: "printf__cCP.z", 2: "6printfPKcz"})
check('function', 'int foo(const unsigned int j)',
{1:"foo__unsigned-iC", 2:"3fooKj"})
{1: "foo__unsigned-iC", 2: "3fooKj"})
check('function', 'int foo(const int *const ptr)',
{1:"foo__iCPC", 2:"3fooPCKi"})
{1: "foo__iCPC", 2: "3fooPCKi"})
check('function', 'module::myclass::operator std::vector<std::string>()',
{1:"module::myclass::castto-std::vector:ss:-operator",
2:"N6module7myclasscvNSt6vectorINSt6stringEEEEv"})
{1: "module::myclass::castto-std::vector:ss:-operator",
2: "N6module7myclasscvNSt6vectorINSt6stringEEEEv"})
check('function',
'void operator()(const boost::array<VertexID, 2> &v) const',
{1:"call-operator__boost::array:VertexID.2:CRC",
2:"NKclERKN5boost5arrayI8VertexIDX2EEE",
3:"NKclERKN5boost5arrayI8VertexIDXL2EEEE"})
{1: "call-operator__boost::array:VertexID.2:CRC",
2: "NKclERKN5boost5arrayI8VertexIDX2EEE",
3: "NKclERKN5boost5arrayI8VertexIDXL2EEEE"})
check('function',
'void operator()(const boost::array<VertexID, 2, "foo, bar"> &v) const',
{1:'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
2:'NKclERKN5boost5arrayI8VertexIDX2EX"foo, bar"EEE',
3:'NKclERKN5boost5arrayI8VertexIDXL2EEXLA9_KcEEEE'})
{1: 'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
2: 'NKclERKN5boost5arrayI8VertexIDX2EX"foo, bar"EEE',
3: 'NKclERKN5boost5arrayI8VertexIDXL2EEXLA9_KcEEEE'})
check('function', 'MyClass::MyClass(MyClass::MyClass&&)',
{1:"MyClass::MyClass__MyClass::MyClassRR",
2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
check('function', 'constexpr int get_value()', {1:"get_valueCE", 2:"9get_valuev"})
{1: "MyClass::MyClass__MyClass::MyClassRR",
2: "N7MyClass7MyClassERRN7MyClass7MyClassE"})
check('function', 'constexpr int get_value()', {1: "get_valueCE", 2: "9get_valuev"})
check('function', 'static constexpr int get_value()',
{1:"get_valueCE", 2:"9get_valuev"})
{1: "get_valueCE", 2: "9get_valuev"})
check('function', 'int get_value() const noexcept',
{1:"get_valueC", 2:"NK9get_valueEv"})
{1: "get_valueC", 2: "NK9get_valueEv"})
check('function', 'int get_value() const noexcept = delete',
{1:"get_valueC", 2:"NK9get_valueEv"})
{1: "get_valueC", 2: "NK9get_valueEv"})
check('function', 'int get_value() volatile const',
{1:"get_valueVC", 2:"NVK9get_valueEv"})
{1: "get_valueVC", 2: "NVK9get_valueEv"})
check('function', 'MyClass::MyClass(MyClass::MyClass&&) = default',
{1:"MyClass::MyClass__MyClass::MyClassRR",
2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
{1: "MyClass::MyClass__MyClass::MyClassRR",
2: "N7MyClass7MyClassERRN7MyClass7MyClassE"})
check('function', 'virtual MyClass::a_virtual_function() const override',
{1:"MyClass::a_virtual_functionC", 2:"NK7MyClass18a_virtual_functionEv"})
check('function', 'A B() override', {1:"B", 2:"1Bv"})
check('function', 'A B() final', {1:"B", 2:"1Bv"})
check('function', 'A B() final override', {1:"B", 2:"1Bv"})
check('function', 'A B() override final', {1:"B", 2:"1Bv"},
{1: "MyClass::a_virtual_functionC", 2: "NK7MyClass18a_virtual_functionEv"})
check('function', 'A B() override', {1: "B", 2: "1Bv"})
check('function', 'A B() final', {1: "B", 2: "1Bv"})
check('function', 'A B() final override', {1: "B", 2: "1Bv"})
check('function', 'A B() override final', {1: "B", 2: "1Bv"},
output='A B() final override')
check('function', 'MyClass::a_member_function() volatile',
{1:"MyClass::a_member_functionV", 2:"NV7MyClass17a_member_functionEv"})
{1: "MyClass::a_member_functionV", 2: "NV7MyClass17a_member_functionEv"})
check('function', 'MyClass::a_member_function() volatile const',
{1:"MyClass::a_member_functionVC", 2:"NVK7MyClass17a_member_functionEv"})
{1: "MyClass::a_member_functionVC", 2: "NVK7MyClass17a_member_functionEv"})
check('function', 'MyClass::a_member_function() &&',
{1:"MyClass::a_member_functionO", 2:"NO7MyClass17a_member_functionEv"})
{1: "MyClass::a_member_functionO", 2: "NO7MyClass17a_member_functionEv"})
check('function', 'MyClass::a_member_function() &',
{1:"MyClass::a_member_functionR", 2:"NR7MyClass17a_member_functionEv"})
{1: "MyClass::a_member_functionR", 2: "NR7MyClass17a_member_functionEv"})
check('function', 'MyClass::a_member_function() const &',
{1:"MyClass::a_member_functionCR", 2:"NKR7MyClass17a_member_functionEv"})
{1: "MyClass::a_member_functionCR", 2: "NKR7MyClass17a_member_functionEv"})
check('function', 'int main(int argc, char *argv[])',
{1:"main__i.cPA", 2:"4mainiA_Pc"})
{1: "main__i.cPA", 2: "4mainiA_Pc"})
check('function', 'MyClass &MyClass::operator++()',
{1:"MyClass::inc-operator", 2:"N7MyClassppEv"})
{1: "MyClass::inc-operator", 2: "N7MyClassppEv"})
check('function', 'MyClass::pointer MyClass::operator->()',
{1:"MyClass::pointer-operator", 2:"N7MyClassptEv"})
{1: "MyClass::pointer-operator", 2: "N7MyClassptEv"})
x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
'foo, bar[n], std::string baz = "foobar, blah, bleh") const = 0'
check('function', x, {1:"module::test__i.barA.ssC",
2:"NK6module4testEiAn_3barNSt6stringE",
3:"NK6module4testEiA1n_3barNSt6stringE"})
check('function', x, {1: "module::test__i.barA.ssC",
2: "NK6module4testEiAn_3barNSt6stringE",
3: "NK6module4testEiA1n_3barNSt6stringE"})
check('function',
'int foo(Foo f = Foo(double(), std::make_pair(int(2), double(3.4))))',
{1:"foo__Foo", 2:"3foo3Foo"})
check('function', 'int foo(A a = x(a))', {1:"foo__A", 2:"3foo1A"})
{1: "foo__Foo", 2: "3foo3Foo"})
check('function', 'int foo(A a = x(a))', {1: "foo__A", 2: "3foo1A"})
with pytest.raises(DefinitionError):
parse('function', 'int foo(B b=x(a)')
with pytest.raises(DefinitionError):
parse('function', 'int foo)C c=x(a))')
with pytest.raises(DefinitionError):
parse('function', 'int foo(D d=x(a')
check('function', 'int foo(const A&... a)', {1:"foo__ACRDp", 2:"3fooDpRK1A"})
check('function', 'virtual void f()', {1:"f", 2:"1fv"})
check('function', 'int foo(const A&... a)', {1: "foo__ACRDp", 2: "3fooDpRK1A"})
check('function', 'virtual void f()', {1: "f", 2: "1fv"})
# test for ::nestedName, from issue 1738
check("function", "result(int val, ::std::error_category const &cat)",
{1:"result__i.std::error_categoryCR", 2:"6resultiRNSt14error_categoryE"})
check("function", "int *f()", {1:"f", 2:"1fv"})
{1: "result__i.std::error_categoryCR", 2: "6resultiRNSt14error_categoryE"})
check("function", "int *f()", {1: "f", 2: "1fv"})
# tests derived from issue #1753 (skip to keep sanity)
check("function", "f(int (&array)[10])", {2:"1fRA10_i", 3:"1fRAL10E_i"})
check("function", "void f(int (&array)[10])", {2:"1fRA10_i", 3:"1fRAL10E_i"})
check("function", "void f(float *q(double))", {2:"1fFPfdE"})
check("function", "void f(float *(*q)(double))", {2:"1fPFPfdE"})
check("function", "void f(float (*q)(double))", {2:"1fPFfdE"})
check("function", "int (*f(double d))(float)", {1:"f__double", 2:"1fd"})
check("function", "int (*f(bool b))[5]", {1:"f__b", 2:"1fb"})
check("function", "f(int (&array)[10])", {2: "1fRA10_i", 3: "1fRAL10E_i"})
check("function", "void f(int (&array)[10])", {2: "1fRA10_i", 3: "1fRAL10E_i"})
check("function", "void f(float *q(double))", {2: "1fFPfdE"})
check("function", "void f(float *(*q)(double))", {2: "1fPFPfdE"})
check("function", "void f(float (*q)(double))", {2: "1fPFfdE"})
check("function", "int (*f(double d))(float)", {1: "f__double", 2: "1fd"})
check("function", "int (*f(bool b))[5]", {1: "f__b", 2: "1fb"})
check("function", "int (*A::f(double d) const)(float)",
{1:"A::f__doubleC", 2:"NK1A1fEd"})
{1: "A::f__doubleC", 2: "NK1A1fEd"})
check("function", "void f(std::shared_ptr<int(double)> ptr)",
{2:"1fNSt10shared_ptrIFidEEE"})
check("function", "void f(int *const p)", {1:"f__iPC", 2:"1fPCi"})
check("function", "void f(int *volatile const p)", {1:"f__iPVC", 2:"1fPVCi"})
{2: "1fNSt10shared_ptrIFidEEE"})
check("function", "void f(int *const p)", {1: "f__iPC", 2: "1fPCi"})
check("function", "void f(int *volatile const p)", {1: "f__iPVC", 2: "1fPVCi"})
check('function', 'extern int f()', {1:'f', 2:'1fv'})
check('function', 'extern int f()', {1: 'f', 2: '1fv'})
check('function', 'decltype(auto) f()', {1: 'f', 2:"1fv"})
check('function', 'decltype(auto) f()', {1: 'f', 2: "1fv"})
# TODO: make tests for functions in a template, e.g., Test<int&&()>
# such that the id generation for function type types is correct.
check('function', 'friend std::ostream &f(std::ostream&, int)',
{1:'f__osR.i', 2:'1fRNSt7ostreamEi'})
{1: 'f__osR.i', 2: '1fRNSt7ostreamEi'})
# from breathe#223
check('function', 'void f(struct E e)', {1:'f__E', 2:'1f1E'})
check('function', 'void f(class E e)', {1:'f__E', 2:'1f1E'})
check('function', 'void f(typename E e)', {1:'f__E', 2:'1f1E'})
check('function', 'void f(enum E e)', {1:'f__E', 2:'1f1E'})
check('function', 'void f(union E e)', {1:'f__E', 2:'1f1E'})
check('function', 'void f(struct E e)', {1: 'f__E', 2: '1f1E'})
check('function', 'void f(class E e)', {1: 'f__E', 2: '1f1E'})
check('function', 'void f(typename E e)', {1: 'f__E', 2: '1f1E'})
check('function', 'void f(enum E e)', {1: 'f__E', 2: '1f1E'})
check('function', 'void f(union E e)', {1: 'f__E', 2: '1f1E'})
# pointer to member (function)
check('function', 'void f(int C::*)', {2:'1fM1Ci'})
check('function', 'void f(int C::* p)', {2:'1fM1Ci'})
check('function', 'void f(int ::C::* p)', {2:'1fM1Ci'})
check('function', 'void f(int C::* const)', {2:'1fKM1Ci'})
check('function', 'void f(int C::* const&)', {2:'1fRKM1Ci'})
check('function', 'void f(int C::* volatile)', {2:'1fVM1Ci'})
check('function', 'void f(int C::* const volatile)', {2:'1fVKM1Ci'},
check('function', 'void f(int C::*)', {2: '1fM1Ci'})
check('function', 'void f(int C::* p)', {2: '1fM1Ci'})
check('function', 'void f(int ::C::* p)', {2: '1fM1Ci'})
check('function', 'void f(int C::* const)', {2: '1fKM1Ci'})
check('function', 'void f(int C::* const&)', {2: '1fRKM1Ci'})
check('function', 'void f(int C::* volatile)', {2: '1fVM1Ci'})
check('function', 'void f(int C::* const volatile)', {2: '1fVKM1Ci'},
output='void f(int C::* volatile const)')
check('function', 'void f(int C::* volatile const)', {2:'1fVKM1Ci'})
check('function', 'void f(int (C::*)(float, double))', {2:'1fM1CFifdE'})
check('function', 'void f(int (C::* p)(float, double))', {2:'1fM1CFifdE'})
check('function', 'void f(int (::C::* p)(float, double))', {2:'1fM1CFifdE'})
check('function', 'void f(void (C::*)() const &)', {2:'1fM1CKRFvvE'})
check('function', 'int C::* f(int, double)', {2:'1fid'})
check('function', 'void f(int C::* *)', {2:'1fPM1Ci'})
check('function', 'void f(int C::* volatile const)', {2: '1fVKM1Ci'})
check('function', 'void f(int (C::*)(float, double))', {2: '1fM1CFifdE'})
check('function', 'void f(int (C::* p)(float, double))', {2: '1fM1CFifdE'})
check('function', 'void f(int (::C::* p)(float, double))', {2: '1fM1CFifdE'})
check('function', 'void f(void (C::*)() const &)', {2: '1fM1CKRFvvE'})
check('function', 'int C::* f(int, double)', {2: '1fid'})
check('function', 'void f(int C::* *)', {2: '1fPM1Ci'})
def test_operators():
check('function', 'void operator new [ ] ()',
{1:"new-array-operator", 2:"nav"}, output='void operator new[]()')
{1: "new-array-operator", 2: "nav"}, output='void operator new[]()')
check('function', 'void operator delete ()',
{1:"delete-operator", 2:"dlv"}, output='void operator delete()')
{1: "delete-operator", 2: "dlv"}, output='void operator delete()')
check('function', 'operator bool() const',
{1:"castto-b-operatorC", 2:"NKcvbEv"}, output='operator bool() const')
{1: "castto-b-operatorC", 2: "NKcvbEv"}, output='operator bool() const')
check('function', 'void operator * ()',
{1:"mul-operator", 2:"mlv"}, output='void operator*()')
{1: "mul-operator", 2: "mlv"}, output='void operator*()')
check('function', 'void operator - ()',
{1:"sub-operator", 2:"miv"}, output='void operator-()')
{1: "sub-operator", 2: "miv"}, output='void operator-()')
check('function', 'void operator + ()',
{1:"add-operator", 2:"plv"}, output='void operator+()')
{1: "add-operator", 2: "plv"}, output='void operator+()')
check('function', 'void operator = ()',
{1:"assign-operator", 2:"aSv"}, output='void operator=()')
{1: "assign-operator", 2: "aSv"}, output='void operator=()')
check('function', 'void operator / ()',
{1:"div-operator", 2:"dvv"}, output='void operator/()')
{1: "div-operator", 2: "dvv"}, output='void operator/()')
check('function', 'void operator % ()',
{1:"mod-operator", 2:"rmv"}, output='void operator%()')
{1: "mod-operator", 2: "rmv"}, output='void operator%()')
check('function', 'void operator ! ()',
{1:"not-operator", 2:"ntv"}, output='void operator!()')
{1: "not-operator", 2: "ntv"}, output='void operator!()')
check('function', 'void operator "" _udl()',
{2:'li4_udlv'}, output='void operator""_udl()')
{2: 'li4_udlv'}, output='void operator""_udl()')
def test_class_definitions():
check('class', 'public A', {1:"A", 2:"1A"}, output='A')
check('class', 'private A', {1:"A", 2:"1A"})
check('class', 'A final', {1:'A', 2:'1A'})
check('class', 'public A', {1: "A", 2: "1A"}, output='A')
check('class', 'private A', {1: "A", 2: "1A"})
check('class', 'A final', {1: 'A', 2: '1A'})
# test bases
check('class', 'A', {1:"A", 2:"1A"})
check('class', 'A::B::C', {1:"A::B::C", 2:"N1A1B1CE"})
check('class', 'A : B', {1:"A", 2:"1A"})
check('class', 'A : private B', {1:"A", 2:"1A"}, output='A : B')
check('class', 'A : public B', {1:"A", 2:"1A"})
check('class', 'A : B, C', {1:"A", 2:"1A"})
check('class', 'A : B, protected C, D', {1:"A", 2:"1A"})
check('class', 'A : virtual private B', {1:'A', 2:'1A'}, output='A : virtual B')
check('class', 'A : B, virtual C', {1:'A', 2:'1A'})
check('class', 'A : public virtual B', {1:'A', 2:'1A'})
check('class', 'A : B, C...', {1:'A', 2:'1A'})
check('class', 'A : B..., C', {1:'A', 2:'1A'})
check('class', 'A', {1: "A", 2: "1A"})
check('class', 'A::B::C', {1: "A::B::C", 2: "N1A1B1CE"})
check('class', 'A : B', {1: "A", 2: "1A"})
check('class', 'A : private B', {1: "A", 2: "1A"}, output='A : B')
check('class', 'A : public B', {1: "A", 2: "1A"})
check('class', 'A : B, C', {1: "A", 2: "1A"})
check('class', 'A : B, protected C, D', {1: "A", 2: "1A"})
check('class', 'A : virtual private B', {1: 'A', 2: '1A'}, output='A : virtual B')
check('class', 'A : B, virtual C', {1: 'A', 2: '1A'})
check('class', 'A : public virtual B', {1: 'A', 2: '1A'})
check('class', 'A : B, C...', {1: 'A', 2: '1A'})
check('class', 'A : B..., C', {1: 'A', 2: '1A'})
# from #4094
check('class', 'template<class, class = std::void_t<>> has_var', {2:'I00E7has_var'})
check('class', 'template<class T> has_var<T, std::void_t<decltype(&T::var)>>', {2:'I0E7has_varI1TNSt6void_tIDTadN1T3varEEEEE'})
check('class', 'template<class, class = std::void_t<>> has_var', {2: 'I00E7has_var'})
check('class', 'template<class T> has_var<T, std::void_t<decltype(&T::var)>>',
{2: 'I0E7has_varI1TNSt6void_tIDTadN1T3varEEEEE'})
def test_enum_definitions():
check('enum', 'A', {2:"1A"})
check('enum', 'A : std::underlying_type<B>::type', {2:"1A"})
check('enum', 'A : unsigned int', {2:"1A"})
check('enum', 'public A', {2:"1A"}, output='A')
check('enum', 'private A', {2:"1A"})
check('enum', 'A', {2: "1A"})
check('enum', 'A : std::underlying_type<B>::type', {2: "1A"})
check('enum', 'A : unsigned int', {2: "1A"})
check('enum', 'public A', {2: "1A"}, output='A')
check('enum', 'private A', {2: "1A"})
check('enumerator', 'A', {2:"1A"})
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2:"1A"})
check('enumerator', 'A', {2: "1A"})
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2: "1A"})
def test_templates():
check('class', "A<T>", {2:"IE1AI1TE"}, output="template<> A<T>")
check('class', "A<T>", {2: "IE1AI1TE"}, output="template<> A<T>")
# first just check which objects support templating
check('class', "template<> A", {2:"IE1A"})
check('function', "template<> void A()", {2:"IE1Av"})
check('member', "template<> A a", {2:"IE1a"})
check('type', "template<> a = A", {2:"IE1a"})
check('class', "template<> A", {2: "IE1A"})
check('function', "template<> void A()", {2: "IE1Av"})
check('member', "template<> A a", {2: "IE1a"})
check('type', "template<> a = A", {2: "IE1a"})
with pytest.raises(DefinitionError):
parse('enum', "template<> A")
with pytest.raises(DefinitionError):
parse('enumerator', "template<> A")
# then all the real tests
check('class', "template<typename T1, typename T2> A", {2:"I00E1A"})
check('type', "template<> a", {2:"IE1a"})
check('class', "template<typename T1, typename T2> A", {2: "I00E1A"})
check('type', "template<> a", {2: "IE1a"})
check('class', "template<typename T> A", {2:"I0E1A"})
check('class', "template<class T> A", {2:"I0E1A"})
check('class', "template<typename ...T> A", {2:"IDpE1A"})
check('class', "template<typename...> A", {2:"IDpE1A"})
check('class', "template<typename = Test> A", {2:"I0E1A"})
check('class', "template<typename T = Test> A", {2:"I0E1A"})
check('class', "template<typename T> A", {2: "I0E1A"})
check('class', "template<class T> A", {2: "I0E1A"})
check('class', "template<typename ...T> A", {2: "IDpE1A"})
check('class', "template<typename...> A", {2: "IDpE1A"})
check('class', "template<typename = Test> A", {2: "I0E1A"})
check('class', "template<typename T = Test> A", {2: "I0E1A"})
check('class', "template<template<typename> typename T> A", {2:"II0E0E1A"})
check('class', "template<template<typename> typename T> A", {2: "II0E0E1A"})
check('class', "template<template<typename> typename> A", {2: "II0E0E1A"})
check('class', "template<template<typename> typename ...T> A", {2:"II0EDpE1A"})
check('class', "template<template<typename> typename ...T> A", {2: "II0EDpE1A"})
check('class', "template<template<typename> typename...> A", {2: "II0EDpE1A"})
check('class', "template<int> A", {2:"I_iE1A"})
check('class', "template<int T> A", {2:"I_iE1A"})
check('class', "template<int... T> A", {2:"I_DpiE1A"})
check('class', "template<int T = 42> A", {2:"I_iE1A"})
check('class', "template<int = 42> A", {2:"I_iE1A"})
check('class', "template<int> A", {2: "I_iE1A"})
check('class', "template<int T> A", {2: "I_iE1A"})
check('class', "template<int... T> A", {2: "I_DpiE1A"})
check('class', "template<int T = 42> A", {2: "I_iE1A"})
check('class', "template<int = 42> A", {2: "I_iE1A"})
check('class', "template<> A<NS::B<>>", {2:"IE1AIN2NS1BIEEE"})
check('class', "template<> A<NS::B<>>", {2: "IE1AIN2NS1BIEEE"})
# from #2058
check('function',
@ -527,7 +528,7 @@ def test_templates():
"inline std::basic_ostream<Char, Traits> &operator<<("
"std::basic_ostream<Char, Traits> &os, "
"const c_string_view_base<const Char, Traits> &str)",
{2:"I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
{2: "I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
"RK18c_string_view_baseIK4Char6TraitsE"})
# template introductions
@ -536,42 +537,42 @@ def test_templates():
with pytest.raises(DefinitionError):
parse('enumerator', 'abc::ns::foo{id_0, id_1, id_2} A')
check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar',
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
{2: 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar',
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
{2: 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar<id_0, id_1, id_2>',
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE'})
{2: 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE'})
check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar<id_0, id_1, id_2...>',
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE'})
{2: 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE'})
check('class', 'template<> Concept{U} A<int>::B', {2:'IEI0EX7ConceptI1UEEN1AIiE1BE'})
check('class', 'template<> Concept{U} A<int>::B', {2: 'IEI0EX7ConceptI1UEEN1AIiE1BE'})
check('type', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar = ghi::qux',
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
{2: 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
check('type', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar = ghi::qux',
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
{2: 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
check('function', 'abc::ns::foo{id_0, id_1, id_2} void xyz::bar()',
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv'})
{2: 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv'})
check('function', 'abc::ns::foo{id_0, id_1, ...id_2} void xyz::bar()',
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv'})
{2: 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv'})
check('member', 'abc::ns::foo{id_0, id_1, id_2} ghi::qux xyz::bar',
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
{2: 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
check('member', 'abc::ns::foo{id_0, id_1, ...id_2} ghi::qux xyz::bar',
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
check('concept', 'Iterator{T, U} Another', {2:'I00EX8IteratorI1T1UEE7Another'})
{2: 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
check('concept', 'Iterator{T, U} Another', {2: 'I00EX8IteratorI1T1UEE7Another'})
check('concept', 'template<typename ...Pack> Numerics = (... && Numeric<Pack>)',
{2:'IDpE8Numerics'})
{2: 'IDpE8Numerics'})
# explicit specializations of members
check('member', 'template<> int A<int>::a', {2:'IEN1AIiE1aE'})
check('member', 'template<> int A<int>::a', {2: 'IEN1AIiE1aE'})
check('member', 'template int A<int>::a', {2: 'IEN1AIiE1aE'},
output='template<> int A<int>::a') # same as above
check('member', 'template<> template<> int A<int>::B<int>::b', {2:'IEIEN1AIiE1BIiE1bE'})
check('member', 'template<> template<> int A<int>::B<int>::b', {2: 'IEIEN1AIiE1BIiE1bE'})
check('member', 'template int A<int>::B<int>::b', {2: 'IEIEN1AIiE1BIiE1bE'},
output='template<> template<> int A<int>::B<int>::b') # same as above
# defaulted constrained type parameters
check('type', 'template<C T = int&> A', {2:'I_1CE1A'})
check('type', 'template<C T = int&> A', {2: 'I_1CE1A'})
def test_template_args():
@ -579,33 +580,32 @@ def test_template_args():
check('function',
"template<typename F> "
"void allow(F *f, typename func<F, B, G != 1>::type tt)",
{2:"I0E5allowP1FN4funcI1F1BXG != 1EE4typeE",
3:"I0E5allowP1FN4funcI1F1BXne1GL1EEE4typeE"})
{2: "I0E5allowP1FN4funcI1F1BXG != 1EE4typeE",
3: "I0E5allowP1FN4funcI1F1BXne1GL1EEE4typeE"})
# from #3542
check('type', "template<typename T> "
"enable_if_not_array_t = std::enable_if_t<!is_array<T>::value, int>",
{2:"I0E21enable_if_not_array_t"})
{2: "I0E21enable_if_not_array_t"})
def test_attributes():
# style: C++
check('member', '[[]] int f', {1:'f__i', 2:'1f'})
check('member', '[ [ ] ] int f', {1:'f__i', 2:'1f'},
check('member', '[[]] int f', {1: 'f__i', 2: '1f'})
check('member', '[ [ ] ] int f', {1: 'f__i', 2: '1f'},
# this will fail when the proper grammar is implemented
output='[[ ]] int f')
check('member', '[[a]] int f', {1:'f__i', 2:'1f'})
check('member', '[[a]] int f', {1: 'f__i', 2: '1f'})
# style: GNU
check('member', '__attribute__(()) int f', {1:'f__i', 2:'1f'})
check('member', '__attribute__((a)) int f', {1:'f__i', 2:'1f'})
check('member', '__attribute__((a, b)) int f', {1:'f__i', 2:'1f'})
check('member', '__attribute__(()) int f', {1: 'f__i', 2: '1f'})
check('member', '__attribute__((a)) int f', {1: 'f__i', 2: '1f'})
check('member', '__attribute__((a, b)) int f', {1: 'f__i', 2: '1f'})
# style: user-defined id
check('member', 'id_attr int f', {1:'f__i', 2:'1f'})
check('member', 'id_attr int f', {1: 'f__i', 2: '1f'})
# style: user-defined paren
check('member', 'paren_attr() int f', {1:'f__i', 2:'1f'})
check('member', 'paren_attr(a) int f', {1:'f__i', 2:'1f'})
check('member', 'paren_attr("") int f', {1:'f__i', 2:'1f'})
check('member', 'paren_attr(()[{}][]{}) int f', {1:'f__i', 2:'1f'})
check('member', 'paren_attr() int f', {1: 'f__i', 2: '1f'})
check('member', 'paren_attr(a) int f', {1: 'f__i', 2: '1f'})
check('member', 'paren_attr("") int f', {1: 'f__i', 2: '1f'})
check('member', 'paren_attr(()[{}][]{}) int f', {1: 'f__i', 2: '1f'})
with pytest.raises(DefinitionError):
parse('member', 'paren_attr(() int f')
with pytest.raises(DefinitionError):
@ -621,7 +621,7 @@ def test_attributes():
# position: decl specs
check('function', 'static inline __attribute__(()) void f()',
{1:'f', 2:'1fv'},
{1: 'f', 2: '1fv'},
output='__attribute__(()) static inline void f()')

2
tests/test_environment.py
View File

@ -22,7 +22,7 @@ def setup_module(rootdir, sphinx_test_tempdir):
global app, env
srcdir = sphinx_test_tempdir / 'root-envtest'
if not srcdir.exists():
(rootdir/'test-root').copytree(srcdir)
(rootdir / 'test-root').copytree(srcdir)
app = SphinxTestApp(srcdir=srcdir)
env = app.env
yield

3
tests/test_ext_autosummary.py
View File

@ -163,7 +163,8 @@ def test_import_by_name():
assert parent is sphinx.ext.autosummary
assert modname == 'sphinx.ext.autosummary'
prefixed_name, obj, parent, modname = import_by_name('sphinx.ext.autosummary.Autosummary.get_items')
prefixed_name, obj, parent, modname = \
import_by_name('sphinx.ext.autosummary.Autosummary.get_items')
assert prefixed_name == 'sphinx.ext.autosummary.Autosummary.get_items'
assert obj == sphinx.ext.autosummary.Autosummary.get_items
assert parent is sphinx.ext.autosummary.Autosummary

2
tests/test_ext_graphviz.py
View File

@ -40,6 +40,7 @@ def test_graphviz_png_html(app, status, warning):
r'}\" />\n</div>')
assert re.search(html, content, re.S)
@pytest.mark.sphinx('html', testroot='ext-graphviz',
confoverrides={'graphviz_output_format': 'svg'})
@pytest.mark.usefixtures('if_graphviz_found')
@ -80,6 +81,7 @@ def test_graphviz_svg_html(app, status, warning):
r'</div>')
assert re.search(html, content, re.S)
@pytest.mark.sphinx('latex', testroot='ext-graphviz')
@pytest.mark.usefixtures('if_graphviz_found')
def test_graphviz_latex(app, status, warning):

1
tests/test_ext_intersphinx.py
View File

@ -240,7 +240,6 @@ def test_missing_reference_cppdomain(tempdir, app, status, warning):
' title="(in foo v2.0)">bartype</a>' in html)
def test_missing_reference_jsdomain(tempdir, app, status, warning):
inv_file = tempdir / 'inventory'
inv_file.write_bytes(inventory_v2)

4
tests/test_ext_todo.py
View File

@ -85,6 +85,7 @@ def test_todo_not_included(app, status, warning):
assert len(todos) == 2
assert set(todo[1].astext() for todo in todos) == set(['todo in foo', 'todo in bar'])
@pytest.mark.sphinx('latex', testroot='ext-todo', freshenv=True,
confoverrides={'todo_include_todos': True, 'todo_emit_warnings': True})
def test_todo_valid_link(app, status, warning):
@ -107,8 +108,7 @@ def test_todo_valid_link(app, status, warning):
target = m[0]
# Look for the targets of this link.
labels = [m for m in re.findall(r'\\label\{([^}]*)}', content)
if m == target]
labels = [m for m in re.findall(r'\\label\{([^}]*)}', content) if m == target]
# If everything is correct we should have exactly one target.
assert len(labels) == 1

1
tests/test_intl.py
View File

@ -222,6 +222,7 @@ def test_text_inconsistency_warnings(app, warning):
u'.*/refs_inconsistency.txt:\\d+: WARNING: citation not found: ref3')
assert_re_search(expected_citation_warning_expr, warnings)
@sphinx_intl
@pytest.mark.sphinx('text')
@pytest.mark.test_params(shared_result='test_intl_basic')

1
tests/test_quickstart.py
View File

@ -96,7 +96,6 @@ def test_do_prompt_inputstrip():
def test_do_prompt_with_nonascii():
d = {}
answers = {
'Q1': u'\u30c9\u30a4\u30c4',
}

1
tests/test_util.py
View File

@ -95,7 +95,6 @@ def test_parselinenos():
parselinenos('3-1', 10)
def test_xmlname_check():
checker = xmlname_checker()
assert checker.match('id-pub')

16
tests/test_util_images.py
View File

@ -44,22 +44,22 @@ def test_guess_mimetype(testroot):
assert guess_mimetype('IMG.PNG') == 'image/png'
# guess by content
assert guess_mimetype(content=(testroot/GIF_FILENAME).bytes()) == 'image/gif'
assert guess_mimetype(content=(testroot/PNG_FILENAME).bytes()) == 'image/png'
assert guess_mimetype(content=(testroot/PDF_FILENAME).bytes()) is None
assert guess_mimetype(content=(testroot/TXT_FILENAME).bytes()) is None
assert guess_mimetype(content=(testroot/TXT_FILENAME).bytes(),
assert guess_mimetype(content=(testroot / GIF_FILENAME).bytes()) == 'image/gif'
assert guess_mimetype(content=(testroot / PNG_FILENAME).bytes()) == 'image/png'
assert guess_mimetype(content=(testroot / PDF_FILENAME).bytes()) is None
assert guess_mimetype(content=(testroot / TXT_FILENAME).bytes()) is None
assert guess_mimetype(content=(testroot / TXT_FILENAME).bytes(),
default='text/plain') == 'text/plain'
# the priority of params: filename > content > default
assert guess_mimetype('img.png',
content=(testroot/GIF_FILENAME).bytes(),
content=(testroot / GIF_FILENAME).bytes(),
default='text/plain') == 'image/png'
assert guess_mimetype('no_extension',
content=(testroot/GIF_FILENAME).bytes(),
content=(testroot / GIF_FILENAME).bytes(),
default='text/plain') == 'image/gif'
assert guess_mimetype('no_extension',
content=(testroot/TXT_FILENAME).bytes(),
content=(testroot / TXT_FILENAME).bytes(),
default='text/plain') == 'text/plain'

1
tests/test_util_inspect.py
View File

@ -113,7 +113,6 @@ def test_getargspec_bound_methods():
assert expected_bound == inspect.getargspec(wrapped_bound_method)
def test_Signature():
# literals
with pytest.raises(TypeError):

2
tests/test_versioning.py
View File

@ -28,7 +28,7 @@ def setup_module(rootdir, sphinx_test_tempdir):
global app, original, original_uids
srcdir = sphinx_test_tempdir / 'test-versioning'
if not srcdir.exists():
(rootdir/'test-versioning').copytree(srcdir)
(rootdir / 'test-versioning').copytree(srcdir)
app = SphinxTestApp(srcdir=srcdir)
app.builder.env.app = app
app.connect('doctree-resolved', on_doctree_resolved)