Пример #1
0
def test_boolean_columns():
    "Regression: recognize boolean columns (issue #64)"
    xortable = [[False, True], [True, False]]
    expected = "\n".join(["False  True",
                          "True   False"])
    result = tabulate(xortable, tablefmt="plain")
    assert_equal(result, expected)
Пример #2
0
def test_moinmoin():
    "Output: moinmoin with headers"
    expected = "\n".join(['|| \'\'\' strings   \'\'\' ||<style="text-align: right;"> \'\'\'   numbers \'\'\' ||',
                          '||  spam       ||<style="text-align: right;">    41.9999  ||',
                          '||  eggs       ||<style="text-align: right;">   451       ||',])
    result = tabulate(_test_table, _test_table_headers, tablefmt="moinmoin")
    assert_equal(expected, result)
Пример #3
0
def test_align_long_integers():
    "Regression: long integers should be aligned as integers (issue #61)"
    table = [[_long_type(1)], [_long_type(234)]]
    result = tabulate(table, tablefmt="plain")
    expected = "\n".join(["  1",
                          "234"])
    assert_equal(result, expected)
Пример #4
0
def test_pipe_headerless():
    "Output: pipe without headers"
    expected = '\n'.join(['|:-----|---------:|',
                          '| spam |  41.9999 |',
                          '| eggs | 451      |',])
    result = tabulate(_test_table, tablefmt="pipe")
    assert_equal(expected, result)
Пример #5
0
def test_plain():
    "Output: plain with headers"
    expected = "\n".join(['strings      numbers',
                          'spam         41.9999',
                          'eggs        451',])
    result = tabulate(_test_table, _test_table_headers, tablefmt="plain")
    assert_equal(expected, result)
Пример #6
0
def test_jira_headerless():
    "Output: jira without headers"
    expected = '\n'.join(['| spam |  41.9999 |',
                          '| eggs | 451      |',])

    result = tabulate(_test_table, tablefmt="jira")
    assert_equal(expected, result)
Пример #7
0
def test_column_alignment():
    "Output: custom alignment for text and numbers"
    expected = '\n'.join(['-----  ---',
                          'Alice   1',
                          '  Bob  333',
                          '-----  ---',])
    result = tabulate([['Alice', 1],['Bob', 333]], stralign="right", numalign="center")
    assert_equal(expected, result)
Пример #8
0
def test_simple_headerless():
    "Output: simple without headers"
    expected = "\n".join(['----  --------',
                          'spam   41.9999',
                          'eggs  451',
                          '----  --------',])
    result = tabulate(_test_table, tablefmt="simple")
    assert_equal(expected, result)
Пример #9
0
def test_simple_separated_format():
    "Regression: simple_separated_format() accepts any separator (issue #12)"
    from tabulate import simple_separated_format
    fmt = simple_separated_format("!")
    expected = 'spam!eggs'
    formatted = tabulate([["spam", "eggs"]], tablefmt=fmt)
    print("expected: %r\n\ngot:      %r\n" % (expected, formatted))
    assert_equal(expected, formatted)
Пример #10
0
def test_textile_with_center_align():
    "Output: textile with center align"
    result = tabulate(_test_table, tablefmt="textile", stralign='center')
    expected = """\
|=. spam  |>.  41.9999 |
|=. eggs  |>. 451      |"""

    assert_equal(expected, result)
Пример #11
0
def test_rst_headerless():
    "Output: rst without headers"
    expected = '\n'.join(['====  ========',
                          'spam   41.9999',
                          'eggs  451',
                          '====  ========',])
    result = tabulate(_test_table, tablefmt="rst")
    assert_equal(expected, result)
Пример #12
0
def test_textile():
    "Output: textile without header"
    result = tabulate(_test_table, tablefmt="textile")
    expected = """\
|<. spam  |>.  41.9999 |
|<. eggs  |>. 451      |"""

    assert_equal(expected, result)
Пример #13
0
def test_script_from_stdin_to_stdout():
    """Command line utility: read from stdin, print to stdout"""
    cmd = ["python", "tabulate.py"]
    out = run_and_capture_stdout(cmd, input=sample_input())
    expected = SAMPLE_SIMPLE_FORMAT
    print("got:     ",repr(out))
    print("expected:",repr(expected))
    assert_equal(out.splitlines(), expected.splitlines())
Пример #14
0
def test_jira():
    "Output: jira with headers"
    expected = '\n'.join(['|| strings   ||   numbers ||',
                          '| spam      |   41.9999 |',
                          '| eggs      |  451      |',])

    result = tabulate(_test_table, _test_table_headers, tablefmt="jira")
    assert_equal(expected, result)
Пример #15
0
def test_orgtbl():
    "Output: orgtbl with headers"
    expected = '\n'.join(['| strings   |   numbers |',
                          '|-----------+-----------|',
                          '| spam      |   41.9999 |',
                          '| eggs      |  451      |',])
    result = tabulate(_test_table, _test_table_headers, tablefmt="orgtbl")
    assert_equal(expected, result)
Пример #16
0
def test_psql_headerless():
    "Output: psql without headers"
    expected = '\n'.join(['+------+----------+',
                          '| spam |  41.9999 |',
                          '| eggs | 451      |',
                          '+------+----------+',])
    result = tabulate(_test_table, tablefmt="psql")
    assert_equal(expected, result)
Пример #17
0
def test_textile_with_header():
    "Output: textile with header"
    result = tabulate(_test_table, ['strings', 'numbers'], tablefmt="textile")
    expected = """\
|_.  strings   |_.   numbers |
|<. spam       |>.   41.9999 |
|<. eggs       |>.  451      |"""

    assert_equal(expected, result)
Пример #18
0
def test_html_headerless():
    "Output: html without headers"
    expected = '\n'.join([
        '<table>',
        '<tr><td>spam</td><td style="text-align: right;"> 41.9999</td></tr>',
        '<tr><td>eggs</td><td style="text-align: right;">451     </td></tr>',
        '</table>',])
    result = tabulate(_test_table, tablefmt="html")
    assert_equal(expected, result)
Пример #19
0
def test_ansi_color_for_decimal_numbers():
    "Regression: ANSI colors for decimal numbers (issue #36)"
    table = [["Magenta", "\033[95m" + "1.1" + "\033[0m"]]
    expected = "\n".join([
        '-------  ---',
        'Magenta  \x1b[95m1.1\x1b[0m',
        '-------  ---'])
    result = tabulate(table)
    assert_equal(result, expected)
Пример #20
0
def test_fancy_grid_headerless():
    "Output: fancy_grid without headers"
    expected = '\n'.join([
        '╒══════╤══════════╕',
        '│ spam │  41.9999 │',
        '├──────┼──────────┤',
        '│ eggs │ 451      │',
        '╘══════╧══════════╛',])
    result = tabulate(_test_table, tablefmt="fancy_grid")
    assert_equal(expected, result)
Пример #21
0
def test_rst():
    "Output: rst with headers"
    expected = '\n'.join(['=========  =========',
                          'strings      numbers',
                          '=========  =========',
                          'spam         41.9999',
                          'eggs        451',
                          '=========  =========',])
    result = tabulate(_test_table, _test_table_headers, tablefmt="rst")
    assert_equal(expected, result)
Пример #22
0
def test_script_sep_option():
    """Command line utility: -s, --sep option"""
    for option in ["-s", "--sep"]:
        cmd = ["python", "tabulate.py", option, ","]
        raw_table = sample_input(sep=",")
        out = run_and_capture_stdout(cmd, input=raw_table)
        expected = SAMPLE_SIMPLE_FORMAT
        print("got:     ",repr(out))
        print("expected:",repr(expected))
        assert_equal(out.splitlines(), expected.splitlines())
Пример #23
0
def test_latex_headerless():
    "Output: latex without headers"
    result   = tabulate(_test_table, tablefmt="latex")
    expected = "\n".join([r"\begin{tabular}{lr}",
                          r"\hline",
                          r" spam &  41.9999 \\",
                          r" eggs & 451      \\",
                          r"\hline",
                          r"\end{tabular}"])
    assert_equal(expected, result)
Пример #24
0
def test_list_of_lists_firstrow():
    "Input: a list of lists with the first row as headers."
    ll = [["string","number"],["a","one",1],["b","two",None]]
    expected = "\n".join([
        '    string      number',
        '--  --------  --------',
        'a   one              1',
        'b   two'])
    result   = tabulate(ll, headers="firstrow")
    assert_equal(expected, result)
Пример #25
0
def test_iterable_of_iterables():
    "Input: an interable of iterables."
    ii = iter(map(lambda x: iter(x), [range(5), range(5,0,-1)]))
    expected = "\n".join(
        ['-  -  -  -  -',
         '0  1  2  3  4',
         '5  4  3  2  1',
         '-  -  -  -  -'])
    result   = tabulate(ii)
    assert_equal(expected, result)
Пример #26
0
def test_iterable_of_iterables_firstrow():
    "Input: an interable of iterables with the first row as headers"
    ii = iter(map(lambda x: iter(x), ["abcde", range(5), range(5,0,-1)]))
    expected = "\n".join(
        ['  a    b    c    d    e',
         '---  ---  ---  ---  ---',
         '  0    1    2    3    4',
         '  5    4    3    2    1'])
    result   = tabulate(ii, "firstrow")
    assert_equal(expected, result)
Пример #27
0
def test_unaligned_separated():
    "Output: non-aligned data columns"
    expected = '\n'.join(['name|score',
                          'Alice|1',
                          'Bob|333'])
    fmt = simple_separated_format("|")
    result = tabulate([['Alice', 1],['Bob', 333]],
                      ["name", "score"],
                      tablefmt=fmt, stralign=None, numalign=None)
    assert_equal(expected, result)
Пример #28
0
def test_script_floatfmt_option():
    """Command line utility: -F, --float option"""
    for option in ["-F", "--float"]:
        cmd = ["python", "tabulate.py", option, ".1e", "--format", "grid"]
        raw_table = sample_input()
        out = run_and_capture_stdout(cmd, input=raw_table)
        expected = SAMPLE_GRID_FORMAT_WITH_DOT1E_FLOATS
        print("got:     ",repr(out))
        print("expected:",repr(expected))
        assert_equal(out.splitlines(), expected.splitlines())
Пример #29
0
def test_latex_booktabs_headerless():
    "Output: latex without headers, using the booktabs format"
    result   = tabulate(_test_table, tablefmt="latex_booktabs")
    expected = "\n".join([r"\begin{tabular}{lr}",
                          r"\toprule",
                          r" spam &  41.9999 \\",
                          r" eggs & 451      \\",
                          r"\bottomrule",
                          r"\end{tabular}"])
    assert_equal(expected, result)
Пример #30
0
def test_list_of_lists_keys():
    "Input: a list of lists with column indices as headers."
    ll = [["a","one",1],["b","two",None]]
    expected = "\n".join([
        '0    1      2',
        '---  ---  ---',
        'a    one    1',
        'b    two'])
    result   = tabulate(ll, headers="keys")
    assert_equal(expected, result)
Пример #31
0
def test_plain_multiline_with_empty_cells():
    "Output: plain with multiline cells and empty cells with headers"
    table = [
        ["hdr", "data", "fold"],
        ["1", "", ""],
        ["2", "very long data", "fold\nthis"],
    ]
    expected = "\n".join([
        "  hdr  data            fold",
        "    1",
        "    2  very long data  fold",
        "                       this",
    ])
    result = tabulate(table, headers="firstrow", tablefmt="plain")
    assert_equal(expected, result)
Пример #32
0
def test_wrap_full_line_color():
    """TextWrapper: Wrap a line when the full thing is enclosed in color tags"""
    # This has both a text color and a background color
    data = (
        "\033[31m\033[104mThis is a test string for testing TextWrap with colors\033[0m"
    )

    expected = [
        "\033[31m\033[104mThis is a test\033[0m",
        "\033[31m\033[104mstring for testing\033[0m",
        "\033[31m\033[104mTextWrap with colors\033[0m",
    ]
    wrapper = CTW(width=20)
    result = wrapper.wrap(data)
    assert_equal(expected, result)
Пример #33
0
def test_numpy_2d_keys():
    "Input: a two-dimensional NumPy array with column indices as headers."
    try:
        import numpy
        na = (numpy.arange(1, 10, dtype=numpy.float32).reshape(
            (3, 3))**3) * 0.5
        expected = "\n".join([
            '    0      1      2', '-----  -----  -----',
            '  0.5    4     13.5', ' 32     62.5  108', '171.5  256    364.5'
        ])
        result = tabulate(na, headers="keys")
        assert_equal(expected, result)
    except ImportError:
        print("test_numpy_2d_keys is skipped")
        pass  # this test is optional
Пример #34
0
def test_pandas():
    "Input: a Pandas DataFrame."
    try:
        import pandas
        df = pandas.DataFrame([["one",1],["two",None]], index=["a","b"])
        expected = "\n".join([
            '    string      number',
            '--  --------  --------',
            'a   one              1',
            'b   two            nan'])
        result   = tabulate(df, headers=["string", "number"])
        assert_equal(expected, result)
    except ImportError:
        print("test_pandas is skipped")
        pass   # this test is optional
Пример #35
0
def test_mediawiki():
    "Output: mediawiki with headers"
    expected = '\n'.join([
        '{| class="wikitable" style="text-align: left;"',
        '|+ <!-- caption -->',
        '|-',
        '! strings   !! align="right"|   numbers',
        '|-',
        '| spam      || align="right"|   41.9999',
        '|-',
        '| eggs      || align="right"|  451',
        '|}',
    ])
    result = tabulate(_test_table, _test_table_headers, tablefmt="mediawiki")
    assert_equal(expected, result)
Пример #36
0
def test_psql_multiline_with_empty_cells():
    "Output: psql with multiline cells and empty cells with headers"
    table = [['hdr', 'data', 'fold'], ['1', '', ''],
             ['2', 'very long data', 'fold\nthis']]
    expected = "\n".join([
        "+-------+----------------+--------+",
        "|   hdr | data           | fold   |",
        "|-------+----------------+--------|",
        "|     1 |                |        |",
        "|     2 | very long data | fold   |",
        "|       |                | this   |",
        "+-------+----------------+--------+"
    ])
    result = tabulate(table, headers="firstrow", tablefmt="psql")
    assert_equal(expected, result)
Пример #37
0
def test_numpy_2d_firstrow():
    "Input: a two-dimensional NumPy array with the first row as headers."
    try:
        import numpy
        na = (numpy.arange(1,10, dtype=numpy.int32).reshape((3,3))**3)
        expected = "\n".join([
            '  1    8    27',
            '---  ---  ----',
            ' 64  125   216',
            '343  512   729'])
        result   = tabulate(na, headers="firstrow")
        assert_equal(expected, result)
    except ImportError:
        print("test_numpy_2d_firstrow is skipped")
        pass   # this test is optional
Пример #38
0
def test_ansi_color_bold_and_fgcolor():
    "Regression: set ANSI color and bold face together (issue #65)"
    table = [["1", "2", "3"], ["4", "\x1b[1;31m5\x1b[1;m", "6"],
             ["7", "8", "9"]]
    result = tabulate(table, tablefmt="grid")
    expected = "\n".join([
        "+---+---+---+",
        "| 1 | 2 | 3 |",
        "+---+---+---+",
        "| 4 | \x1b[1;31m5\x1b[1;m | 6 |",
        "+---+---+---+",
        "| 7 | 8 | 9 |",
        "+---+---+---+",
    ])
    assert_equal(result, expected)
Пример #39
0
def test_colorclass_colors():
    "Regression: ANSI colors in a unicode/str subclass (issue #49)"
    try:
        import colorclass
        s = colorclass.Color("{magenta}3.14{/magenta}")
        result = tabulate([[s]], tablefmt="plain")
        expected = "\x1b[35m3.14\x1b[39m"
        assert_equal(result, expected)
    except ImportError:
        class textclass(_text_type):
            pass
        s = textclass("\x1b[35m3.14\x1b[39m")
        result = tabulate([[s]], tablefmt="plain")
        expected = "\x1b[35m3.14\x1b[39m"
        assert_equal(result, expected)
Пример #40
0
def test_grid_multiline_headerless():
    "Output: grid with multiline cells without headers"
    table = [["foo bar\nbaz\nbau", "hello"], ["", "multiline\nworld"]]
    expected = "\n".join([
        "+---------+-----------+",
        "| foo bar |   hello   |",
        "|   baz   |           |",
        "|   bau   |           |",
        "+---------+-----------+",
        "|         | multiline |",
        "|         |   world   |",
        "+---------+-----------+",
    ])
    result = tabulate(table, stralign="center", tablefmt="grid")
    assert_equal(expected, result)
Пример #41
0
def test_rst_multiline():
    "Output: rst with multiline cells with headers"
    table = [[2, "foo\nbar"]]
    headers = ("more\nspam \x1b[31meggs\x1b[0m", "more spam\n& eggs")
    expected = "\n".join([
        "===========  ===========",
        "       more  more spam",
        "  spam \x1b[31meggs\x1b[0m  & eggs",
        "===========  ===========",
        "          2  foo",
        "             bar",
        "===========  ===========",
    ])
    result = tabulate(table, headers, tablefmt="rst")
    assert_equal(expected, result)
Пример #42
0
def test_html():
    "Output: html with headers"
    expected = '\n'.join([
        '<table>',
        '<thead>',
        '<tr><th>strings  </th><th style="text-align: right;">  numbers</th></tr>',
        '</thead>',
        '<tbody>',
        '<tr><td>spam     </td><td style="text-align: right;">  41.9999</td></tr>',
        '<tr><td>eggs     </td><td style="text-align: right;"> 451     </td></tr>',
        '</tbody>',
        '</table>',
    ])
    result = tabulate(_test_table, _test_table_headers, tablefmt="html")
    assert_equal(expected, result)
Пример #43
0
def test_grid_multiline():
    "Output: grid with multiline cells with headers"
    table = [[2, "foo\nbar"]]
    headers = ("more\nspam \x1b[31meggs\x1b[0m", "more spam\n& eggs")
    expected = "\n".join([
        "+-------------+-------------+",
        "|        more | more spam   |",
        "|   spam \x1b[31meggs\x1b[0m | & eggs      |",
        "+=============+=============+",
        "|           2 | foo         |",
        "|             | bar         |",
        "+-------------+-------------+",
    ])
    result = tabulate(table, headers, tablefmt="grid")
    assert_equal(expected, result)
Пример #44
0
def test_numpy_2d():
    "Input: a 2D NumPy array with headers."
    try:
        import numpy
        na = (numpy.arange(1, 10, dtype=numpy.float32).reshape(
            (3, 3))**3) * 0.5
        expected = "\n".join([
            '    a      b      c', '-----  -----  -----',
            '  0.5    4     13.5', ' 32     62.5  108', '171.5  256    364.5'
        ])
        result = tabulate(na, ["a", "b", "c"])
        assert_equal(expected, result)
    except ImportError:
        print("test_numpy_2d is skipped")
        raise SkipTest()  # this test is optional
Пример #45
0
def test_fancy_grid_multiline_headerless():
    "Output: fancy_grid with multiline cells without headers"
    table = [["foo bar\nbaz\nbau", "hello"], ["", "multiline\nworld"]]
    expected = "\n".join([
        "╒═════════╤═══════════╕",
        "│ foo bar │   hello   │",
        "│   baz   │           │",
        "│   bau   │           │",
        "├─────────┼───────────┤",
        "│         │ multiline │",
        "│         │   world   │",
        "╘═════════╧═══════════╛",
    ])
    result = tabulate(table, stralign="center", tablefmt="fancy_grid")
    assert_equal(expected, result)
Пример #46
0
def test_fancy_grid_multiline():
    "Output: fancy_grid with multiline cells with headers"
    table = [[2, "foo\nbar"]]
    headers = ("more\nspam \x1b[31meggs\x1b[0m", "more spam\n& eggs")
    expected = "\n".join([
        "╒═════════════╤═════════════╕",
        "│        more │ more spam   │",
        "│   spam \x1b[31meggs\x1b[0m │ & eggs      │",
        "╞═════════════╪═════════════╡",
        "│           2 │ foo         │",
        "│             │ bar         │",
        "╘═════════════╧═════════════╛",
    ])
    result = tabulate(table, headers, tablefmt="fancy_grid")
    assert_equal(expected, result)
Пример #47
0
def test_wrap_wide_char_longword():
    """TextWrapper: wrapping wide char word that needs to be broken up"""
    try:
        import wcwidth  # noqa
    except ImportError:
        skip("test_wrap_wide_char_longword is skipped")

    data = "약간감싸면더잘보일수있"

    expected = ["약간", "감싸", "면더", "잘보", "일수", "있"]

    # Explicit odd number to ensure the 2 width is taken into account
    wrapper = CTW(width=5)
    result = wrapper.wrap(data)
    assert_equal(expected, result)
Пример #48
0
def test_disable_numparse_list():
    "Output: Default table output, but with number parsing selectively disabled"
    table_headers = ['h1', 'h2', 'h3']
    test_table = [['foo', 'bar', '42992e1']]
    expected = "\n".join(['h1    h2    h3',
                          '----  ----  -------',
                          'foo   bar   42992e1',])
    result = tabulate(test_table, table_headers, disable_numparse=[2])
    assert_equal(expected, result)

    expected = "\n".join(['h1    h2        h3',
                          '----  ----  ------',
                          'foo   bar   429920',])
    result = tabulate(test_table, table_headers, disable_numparse=[0, 1])
    assert_equal(expected, result)
Пример #49
0
def test_wrap_text_to_colwidths_single_ansi_colors_full_cell():
    """Internal: autowrapped text can retain a single ANSI colors
    when it is at the beginning and end of full cell"""
    data = [[("\033[31mThis is a rather long description that might"
              " look better if it is wrapped a bit\033[0m")]]
    result = T._wrap_text_to_colwidths(data, [30])

    expected = [[
        "\n".join([
            "\033[31mThis is a rather long\033[0m",
            "\033[31mdescription that might look\033[0m",
            "\033[31mbetter if it is wrapped a bit\033[0m",
        ])
    ]]
    assert_equal(expected, result)
Пример #50
0
def test_wrap_text_to_colwidths_multi_ansi_colors_in_subset():
    """Internal: autowrapped text can retain multiple ANSI colors
    when they are around subsets of the cell"""
    data = [[("This is a rather \033[31mlong description\033[0m that"
              " might look better \033[93mif it is wrapped\033[0m a bit")]]
    result = T._wrap_text_to_colwidths(data, [30])

    expected = [[
        "\n".join([
            "This is a rather \033[31mlong\033[0m",
            "\033[31mdescription\033[0m that might look",
            "better \033[93mif it is wrapped\033[0m a bit",
        ])
    ]]
    assert_equal(expected, result)
Пример #51
0
def test_pandas_firstrow():
    "Input: a Pandas DataFrame with the first row as headers."
    try:
        import pandas

        df = pandas.DataFrame([["one", 1], ["two", None]],
                              columns=["string", "number"],
                              index=["a", "b"])
        expected = "\n".join(
            ["a    one      1.0", "---  -----  -----", "b    two      nan"])
        result = tabulate(df, headers="firstrow")
        assert_equal(expected, result)
    except ImportError:
        print("test_pandas_firstrow is skipped")
        raise SkipTest()  # this test is optional
Пример #52
0
def test_escape_empty_cell_in_first_column_in_rst():
    "Regression: escape empty cells of the first column in RST format (issue #82)"
    table = [["foo", 1], ["", 2], ["bar", 3]]
    headers = ["", "val"]
    expected = "\n".join([
        "====  =====",
        "..      val",
        "====  =====",
        "foo       1",
        "..        2",
        "bar       3",
        "====  =====",
    ])
    result = tabulate(table, headers, tablefmt="rst")
    assert_equal(result, expected)
Пример #53
0
def test_simple_multiline():
    "Output: simple with multiline cells"
    expected = "\n".join([
        " key     value",
        "-----  ---------",
        " foo      bar",
        "spam   multiline",
        "         world",
    ])
    table = [["key", "value"], ["foo", "bar"], ["spam", "multiline\nworld"]]
    result = tabulate(table,
                      headers='firstrow',
                      stralign="center",
                      tablefmt="simple")
    assert_equal(expected, result)
Пример #54
0
def test_datetime_values():
    "Regression: datetime, date, and time values in cells (issue #10)."
    import datetime

    dt = datetime.datetime(1991, 2, 19, 17, 35, 26)
    d = datetime.date(1991, 2, 19)
    t = datetime.time(17, 35, 26)
    formatted = tabulate([[dt, d, t]])
    expected = "\n".join([
        "-------------------  ----------  --------",
        "1991-02-19 17:35:26  1991-02-19  17:35:26",
        "-------------------  ----------  --------",
    ])
    print("expected: %r\n\ngot:      %r\n" % (expected, formatted))
    assert_equal(expected, formatted)
Пример #55
0
def test_latex_escape_special_chars():
    "Regression: escape special characters in LaTeX output (issue #32)"
    expected = "\n".join(
        [
            r"\begin{tabular}{l}",
            r"\hline",
            r" foo\^{}bar     \\",
            r"\hline",
            r" \&\%\^{}\_\$\#\{\}\ensuremath{<}\ensuremath{>}\textasciitilde{} \\",
            r"\hline",
            r"\end{tabular}",
        ]
    )
    result = tabulate([["&%^_$#{}<>~"]], ["foo^bar"], tablefmt="latex")
    assert_equal(result, expected)
Пример #56
0
def test_numpy_2d_firstrow():
    "Input: a 2D NumPy array with the first row as headers."
    try:
        import numpy

        na = numpy.arange(1, 10, dtype=numpy.int32).reshape((3, 3))**3
        expected = "\n".join([
            "  1    8    27", "---  ---  ----", " 64  125   216",
            "343  512   729"
        ])
        result = tabulate(na, headers="firstrow")
        assert_equal(expected, result)
    except ImportError:
        print("test_numpy_2d_firstrow is skipped")
        raise SkipTest()  # this test is optional
Пример #57
0
def test_custom_tablefmt():
    "Regression: allow custom TableFormat that specifies with_header_hide (github issue #20)"
    tablefmt = TableFormat(
        lineabove=Line("", "-", "  ", ""),
        linebelowheader=Line("", "-", "  ", ""),
        linebetweenrows=None,
        linebelow=Line("", "-", "  ", ""),
        headerrow=DataRow("", "  ", ""),
        datarow=DataRow("", "  ", ""),
        padding=0,
        with_header_hide=["lineabove", "linebelow"],
    )
    rows = [["foo", "bar"], ["baz", "qux"]]
    expected = "\n".join(["A    B", "---  ---", "foo  bar", "baz  qux"])
    result = tabulate(rows, headers=["A", "B"], tablefmt=tablefmt)
    assert_equal(result, expected)
Пример #58
0
def test_latex():
    "Output: latex with headers and replaced characters"
    raw_test_table_headers = list(_test_table_headers)
    raw_test_table_headers[-1] += " ($N_0$)"
    result = tabulate(_test_table, raw_test_table_headers, tablefmt="latex")
    expected = "\n".join([
        r"\begin{tabular}{lr}",
        r"\hline",
        r" strings   &   numbers (\$N\_0\$) \\",
        r"\hline",
        r" spam      &           41.9999 \\",
        r" eggs      &          451      \\",
        r"\hline",
        r"\end{tabular}",
    ])
    assert_equal(expected, result)
Пример #59
0
def test_latex_booktabs():
    "Output: latex with headers, using the booktabs format"
    result = tabulate(_test_table,
                      _test_table_headers,
                      tablefmt="latex_booktabs")
    expected = "\n".join([
        r"\begin{tabular}{lr}",
        r"\toprule",
        r" strings   &   numbers \\",
        r"\midrule",
        r" spam      &   41.9999 \\",
        r" eggs      &  451      \\",
        r"\bottomrule",
        r"\end{tabular}",
    ])
    assert_equal(expected, result)
Пример #60
0
def test_presto_multiline_with_empty_cells():
    "Output: presto with multiline cells and empty cells with headers"
    table = [
        ["hdr", "data", "fold"],
        ["1", "", ""],
        ["2", "very long data", "fold\nthis"],
    ]
    expected = "\n".join([
        "   hdr | data           | fold",
        "-------+----------------+--------",
        "     1 |                |",
        "     2 | very long data | fold",
        "       |                | this",
    ])
    result = tabulate(table, headers="firstrow", tablefmt="presto")
    assert_equal(expected, result)