WeasyPrint/weasyprint/tests/test_boxes.py

# coding: utf-8
"""
    weasyprint.tests.test_boxes
    ---------------------------

    Test that the "before layout" box tree is correctly constructed.

    :copyright: Copyright 2011-2014 Simon Sapin and contributors, see AUTHORS.
    :license: BSD, see LICENSE for details.

"""

from __future__ import division, unicode_literals

import functools
import pprint
import difflib

from .testing_utils import (
    resource_filename, FakeHTML, assert_no_logs, capture_logs)
from ..css import get_all_computed_styles
from .. import images
from ..formatting_structure import boxes, build, counters


PROPER_CHILDREN = dict((key, tuple(map(tuple, value))) for key, value in {
    # Children can be of *any* type in *one* of the lists.
    boxes.BlockContainerBox: [[boxes.BlockLevelBox], [boxes.LineBox]],
    boxes.LineBox: [[boxes.InlineLevelBox]],
    boxes.InlineBox: [[boxes.InlineLevelBox]],
    boxes.TableBox: [[boxes.TableCaptionBox,
                      boxes.TableColumnGroupBox, boxes.TableColumnBox,
                      boxes.TableRowGroupBox, boxes.TableRowBox]],
    boxes.InlineTableBox: [[boxes.TableCaptionBox,
                            boxes.TableColumnGroupBox, boxes.TableColumnBox,
                            boxes.TableRowGroupBox, boxes.TableRowBox]],
    boxes.TableColumnGroupBox: [[boxes.TableColumnBox]],
    boxes.TableRowGroupBox: [[boxes.TableRowBox]],
    boxes.TableRowBox: [[boxes.TableCellBox]],
}.items())


def serialize(box_list):
    """Transform a box list into a structure easier to compare for testing."""
    return [
        (box.element_tag,
         ('Anon' if (box.style.anonymous and
                     type(box) not in (boxes.TextBox, boxes.LineBox))
          else '') + type(box).__name__[:-3],
         # All concrete boxes are either text, replaced, column or parent.
         (box.text if isinstance(box, boxes.TextBox)
          else '<replaced>' if isinstance(box, boxes.ReplacedBox)
          else serialize(
            getattr(box, 'column_groups', ()) + tuple(box.children))))
        for box in box_list]


def unwrap_html_body(box):
    """Test that the box tree starts with a ``<html>`` and a ``<body>`` blocks.

    Remove them to simplify further tests. These are always at the root
    of HTML documents.

    """
    assert box.element_tag == 'html'
    assert isinstance(box, boxes.BlockBox)
    assert len(box.children) == 1

    box = box.children[0]
    assert isinstance(box, boxes.BlockBox)
    assert box.element_tag == 'body'

    return box.children


def to_lists(box_tree):
    """Serialize and unwrap ``<html>`` and ``<body>``."""
    return serialize(unwrap_html_body(box_tree))


def _parse_base(
        html_content,
        # Dummy filename, but in the right directory.
        base_url=resource_filename('<test>')):
    document = FakeHTML(string=html_content, base_url=base_url)
    style_for = get_all_computed_styles(document)
    get_image_from_uri = functools.partial(
        images.get_image_from_uri, {}, document.url_fetcher)
    return document.root_element, style_for, get_image_from_uri


def parse(html_content):
    """Parse some HTML, apply stylesheets and transform to boxes."""
    box, = build.element_to_box(*_parse_base(html_content))
    return box


def parse_all(html_content, base_url=resource_filename('<test>')):
    """Like parse() but also run all corrections on boxes."""
    box = build.build_formatting_structure(*_parse_base(
        html_content, base_url))
    sanity_checks(box)
    return box


def render_pages(html_content):
    """Lay out a document and return a list of PageBox objects."""
    return [p._page_box for p in FakeHTML(
            string=html_content, base_url=resource_filename('<test>')
            ).render(enable_hinting=True).pages]


def assert_tree(box, expected):
    """Check the box tree equality.

    The obtained result is prettified in the message in case of failure.

    box: a Box object, starting with <html> and <body> blocks.
    expected: a list of serialized <body> children as returned by to_lists().

    """
    lists = to_lists(box)
    if lists != expected:
        print(''.join(difflib.unified_diff(
            *[pprint.pformat(v).splitlines(True) for v in [lists, expected]],
            n=9999)))
        assert lists == expected


def sanity_checks(box):
    """Check that the rules regarding boxes are met.

    This is not required and only helps debugging.

    - A block container can contain either only block-level boxes or
      only line boxes;
    - Line boxes and inline boxes can only contain inline-level boxes.

    """
    if not isinstance(box, boxes.ParentBox):
        return

    acceptable_types_lists = None  # raises when iterated
    for class_ in type(box).mro():
        if class_ in PROPER_CHILDREN:
            acceptable_types_lists = PROPER_CHILDREN[class_]
            break

    assert any(
        all(isinstance(child, acceptable_types) or
            not child.is_in_normal_flow()
            for child in box.children)
        for acceptable_types in acceptable_types_lists
    ), (box, box.children)

    for child in box.children:
        sanity_checks(child)


@assert_no_logs
def test_box_tree():
    """Test the creation of trees from HTML strings."""
    assert_tree(parse('<p>'), [('p', 'Block', [])])
    assert_tree(parse(
        '''
        <style>
            span { display: inline-block }
        </style>
        <p>Hello <em>World <img src="pattern.png"><span>L</span></em>!</p>'''),
        [('p', 'Block', [
            ('p', 'Text', 'Hello '),
            ('em', 'Inline', [
                ('em', 'Text', 'World '),
                ('img', 'InlineReplaced', '<replaced>'),
                ('span', 'InlineBlock', [
                    ('span', 'Text', 'L')])]),
            ('p', 'Text', '!')])])


@assert_no_logs
def test_html_entities():
    """Test the management of HTML entities."""
    for quote in ['"', '&quot;', '&#x22;', '&#34;']:
        assert_tree(parse('<p>{0}abc{1}'.format(quote, quote)), [
            ('p', 'Block', [
                ('p', 'Text', '"abc"')])])


@assert_no_logs
def test_inline_in_block():
    """Test the management of inline boxes in block boxes."""
    source = '<div>Hello, <em>World</em>!\n<p>Lipsum.</p></div>'
    expected = [
        ('div', 'Block', [
            ('div', 'AnonBlock', [
                ('div', 'Line', [
                    ('div', 'Text', 'Hello, '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'World')]),
                    ('div', 'Text', '!\n')])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lipsum.')])])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)

    source = '<div><p>Lipsum.</p>Hello, <em>World</em>!\n</div>'
    expected = [
        ('div', 'Block', [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lipsum.')])]),
            ('div', 'AnonBlock', [
                ('div', 'Line', [
                    ('div', 'Text', 'Hello, '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'World')]),
                    ('div', 'Text', '!\n')])])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)

    # Absolutes are left in the lines to get their static position later.
    source = '''<p>Hello <em style="position:absolute;
                                    display: block">World</em>!</p>'''
    expected = [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Hello '),
                ('em', 'Block', [
                    ('em', 'Line', [
                        ('em', 'Text', 'World')])]),
                ('p', 'Text', '!')])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)
    box = build.block_in_inline(box)
    assert_tree(box, expected)

    # Floats are pull to the top of their containing blocks
    source = '<p>Hello <em style="float: left">World</em>!</p>'
    box = parse(source)
    box = build.inline_in_block(box)
    box = build.block_in_inline(box)
    assert_tree(box, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Hello '),
                ('em', 'Block', [
                    ('em', 'Line', [
                        ('em', 'Text', 'World')])]),
                ('p', 'Text', '!')])])])


@assert_no_logs
def test_block_in_inline():
    """Test the management of block boxes in inline boxes."""
    box = parse('''
<style>
    p { display: inline-block; }
    span, i { display: block; }
</style>
<p>Lorem <em>ipsum <strong>dolor <span>sit</span>
    <span>amet,</span></strong><span><em>conse<i></i></em></span></em></p>''')
    box = build.inline_in_block(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lorem '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'ipsum '),
                        ('strong', 'Inline', [
                            ('strong', 'Text', 'dolor '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'sit')])]),
                            # No whitespace processing here.
                            ('strong', 'Text', '\n    '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'amet,')])])]),
                        ('span', 'Block', [  # This block is "pulled up"
                            ('span', 'Line', [
                                ('em', 'Inline', [
                                    ('em', 'Text', 'conse'),
                                    ('i', 'Block', [])])])])])])])])])

    box = build.block_in_inline(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('p', 'Text', 'Lorem '),
                        ('em', 'Inline', [
                            ('em', 'Text', 'ipsum '),
                            ('strong', 'Inline', [
                                ('strong', 'Text', 'dolor ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'sit')])]),
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [
                                # Whitespace processing not done yet.
                                ('strong', 'Text', '\n    ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'amet,')])]),

                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [])])])]),
                ('span', 'Block', [
                    ('span', 'AnonBlock', [
                        ('span', 'Line', [
                            ('em', 'Inline', [
                                ('em', 'Text', 'conse')])])]),
                    ('i', 'Block', []),
                    ('span', 'AnonBlock', [
                        ('span', 'Line', [
                            ('em', 'Inline', [])])])]),
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [])])])])])])


@assert_no_logs
def test_styles():
    """Test the application of CSS to HTML."""
    box = parse('''
        <style>
            span { display: block; }
            * { margin: 42px }
            html { color: blue }
        </style>
        <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
            <span>amet,</span></strong><span>consectetur</span></em></p>''')
    box = build.inline_in_block(box)
    box = build.block_in_inline(box)

    descendants = list(box.descendants())
    assert len(descendants) == 31
    assert descendants[0] == box

    for child in descendants:
        # All boxes inherit the color
        assert child.style.color == (0, 0, 1, 1)  # blue
        # Only non-anonymous boxes have margins
        if child.style.anonymous:
            assert child.style.margin_top == (0, 'px')
        else:
            assert child.style.margin_top == (42, 'px')


@assert_no_logs
def test_whitespace():
    """Test the management of white spaces."""
    # TODO: test more cases
    # http://www.w3.org/TR/CSS21/text.html#white-space-model
    assert_tree(parse_all('''
        <p>Lorem \t\r\n  ipsum\t<strong>  dolor
            <img src=pattern.png> sit
            <span style="position: absolute"></span> <em> amet </em>
            consectetur</strong>.</p>
        <pre>\t  foo\n</pre>
        <pre style="white-space: pre-wrap">\t  foo\n</pre>
        <pre style="white-space: pre-line">\t  foo\n</pre>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Lorem ipsum '),
                ('strong', 'Inline', [
                    ('strong', 'Text', 'dolor '),
                    ('img', 'InlineReplaced', '<replaced>'),
                    ('strong', 'Text', ' sit '),
                    ('span', 'Block', []),
                    ('em', 'Inline', [
                        ('em', 'Text', 'amet ')]),
                    ('strong', 'Text', 'consectetur')]),
                ('p', 'Text', '.')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre
                ('pre', 'Text', '\t  foo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-wrap
                ('pre', 'Text', '\t  foo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-line
                ('pre', 'Text', ' foo\n')])])])


@assert_no_logs
def test_page_style():
    """Test the management of page styles."""
    style_for = get_all_computed_styles(FakeHTML(string='''
        <style>
            @page { margin: 3px }
            @page :first { margin-top: 20px }
            @page :right { margin-right: 10px; margin-top: 10px }
            @page :left { margin-left: 10px; margin-top: 10px }
        </style>
    '''))

    def assert_page_margins(page_type, top, right, bottom, left):
        """Check the page margin values."""
        style = style_for(page_type)
        assert style.margin_top == (top, 'px')
        assert style.margin_right == (right, 'px')
        assert style.margin_bottom == (bottom, 'px')
        assert style.margin_left == (left, 'px')

    assert_page_margins('first_left_page', top=20, right=3, bottom=3, left=10)
    assert_page_margins('first_right_page', top=20, right=10, bottom=3, left=3)
    assert_page_margins('left_page', top=10, right=3, bottom=3, left=10)
    assert_page_margins('right_page', top=10, right=10, bottom=3, left=3)


@assert_no_logs
def test_images():
    """Test images that may or may not be available."""
    with capture_logs() as logs:
        result = parse_all('''
            <p><img src=pattern.png
                /><img alt="No src"
                /><img src=inexistent.jpg alt="Inexistent src" /></p>
        ''')
    assert len(logs) == 1
    assert 'WARNING: Failed to load image' in logs[0]
    assert 'inexistent.jpg' in logs[0]
    assert_tree(result, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('img', 'InlineReplaced', '<replaced>'),
                ('img', 'Inline', [
                    ('img', 'Text', 'No src')]),
                ('img', 'Inline', [
                    ('img', 'Text', 'Inexistent src')])])])])

    with capture_logs() as logs:
        result = parse_all('<p><img src=pattern.png alt="No base_url">',
                           base_url=None)
    assert len(logs) == 1
    assert 'WARNING: Relative URI reference without a base URI' in logs[0]
    assert_tree(result, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('img', 'Inline', [
                    ('img', 'Text', 'No base_url')])])])])


@assert_no_logs
def test_tables():
    # Rules in http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    # Rule 1.3
    # Also table model: http://www.w3.org/TR/CSS21/tables.html#model
    assert_tree(parse_all('''
        <x-table>
            <x-tr>
                <x-th>foo</x-th>
                <x-th>bar</x-th>
            </x-tr>
            <x-tfoot></x-tfoot>
            <x-thead><x-th></x-th></x-thead>
            <x-caption style="caption-side: bottom"></x-caption>
            <x-thead></x-thead>
            <x-col></x-col>
            <x-caption>top caption</x-caption>
            <x-tr>
                <x-td>baz</x-td>
            </x-tr>
        </x-table>
    '''), [
        ('x-table', 'AnonBlock', [
            ('x-caption', 'TableCaption', [
                ('x-caption', 'Line', [
                    ('x-caption', 'Text', 'top caption')])]),
            ('x-table', 'Table', [
                ('x-table', 'AnonTableColumnGroup', [
                    ('x-col', 'TableColumn', [])]),
                ('x-thead', 'TableRowGroup', [
                    ('x-thead', 'AnonTableRow', [
                        ('x-th', 'TableCell', [])])]),
                ('x-table', 'AnonTableRowGroup', [
                    ('x-tr', 'TableRow', [
                        ('x-th', 'TableCell', [
                            ('x-th', 'Line', [
                                ('x-th', 'Text', 'foo')])]),
                        ('x-th', 'TableCell', [
                            ('x-th', 'Line', [
                                ('x-th', 'Text', 'bar')])])])]),
                ('x-thead', 'TableRowGroup', []),
                ('x-table', 'AnonTableRowGroup', [
                    ('x-tr', 'TableRow', [
                        ('x-td', 'TableCell', [
                            ('x-td', 'Line', [
                                ('x-td', 'Text', 'baz')])])])]),
                ('x-tfoot', 'TableRowGroup', [])]),
            ('x-caption', 'TableCaption', [])])])

    # Rules 1.4 and 3.1
    assert_tree(parse_all('''
        <span style="display: table-cell">foo</span>
        <span style="display: table-cell">bar</span>
    '''), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableRowGroup', [
                    ('body', 'AnonTableRow', [
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'foo')])]),
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'bar')])])])])])])])

    # http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    # Rules 1.1 and 1.2
    # Rule XXX (not in the spec): column groups have at least one column child
    assert_tree(parse_all('''
        <span style="display: table-column-group">
            1
            <em style="display: table-column">
                2
                <strong>3</strong>
            </em>
            <strong>4</strong>
        </span>
        <ins style="display: table-column-group"></ins>
    '''), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('span', 'TableColumnGroup', [
                    ('em', 'TableColumn', [])]),
                ('ins', 'TableColumnGroup', [
                    ('ins', 'AnonTableColumn', [])])])])])

    # Rules 2.1 then 2.3
    assert_tree(parse_all('<x-table>foo <div></div></x-table>'), [
        ('x-table', 'AnonBlock', [
            ('x-table', 'Table', [
                ('x-table', 'AnonTableRowGroup', [
                    ('x-table', 'AnonTableRow', [
                        ('x-table', 'AnonTableCell', [
                            ('x-table', 'AnonBlock', [
                                ('x-table', 'Line', [
                                    ('x-table', 'Text', 'foo ')])]),
                            ('div', 'Block', [])])])])])])])

    # Rule 2.2
    assert_tree(parse_all('<x-thead style="display: table-header-group">'
                          '<div></div><x-td></x-td></x-thead>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('x-thead', 'TableRowGroup', [
                    ('x-thead', 'AnonTableRow', [
                        ('x-thead', 'AnonTableCell', [
                            ('div', 'Block', [])]),
                        ('x-td', 'TableCell', [])])])])])])

    # TODO: re-enable this once we support inline-table
    # Rule 3.2
    assert_tree(parse_all('<span><x-tr></x-tr></span>'), [
        ('body', 'Line', [
            ('span', 'Inline', [
                ('span', 'AnonInlineBlock', [
                    ('span', 'AnonInlineTable', [
                        ('span', 'AnonTableRowGroup', [
                            ('x-tr', 'TableRow', [])])])])])])])

    # Rule 3.1
    # Also, rule 1.3 does not apply: whitespace before and after is preserved
    assert_tree(parse_all('''
        <span>
            <em style="display: table-cell"></em>
            <em style="display: table-cell"></em>
        </span>
    '''), [
        ('body', 'Line', [
            ('span', 'Inline', [
                # Whitespace is preserved in table handling, then collapsed
                # into a single space.
                ('span', 'Text', ' '),
                ('span', 'AnonInlineBlock', [
                    ('span', 'AnonInlineTable', [
                        ('span', 'AnonTableRowGroup', [
                            ('span', 'AnonTableRow', [
                                ('em', 'TableCell', []),
                                ('em', 'TableCell', [])])])])]),
                ('span', 'Text', ' ')])])])

    # Rule 3.2
    assert_tree(parse_all('<x-tr></x-tr>\t<x-tr></x-tr>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableRowGroup', [
                    ('x-tr', 'TableRow', []),
                    ('x-tr', 'TableRow', [])])])])])

    assert_tree(parse_all('<x-col></x-col>\n<x-colgroup></x-colgroup>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableColumnGroup', [
                    ('x-col', 'TableColumn', [])]),
                ('x-colgroup', 'TableColumnGroup', [
                    ('x-colgroup', 'AnonTableColumn', [])])])])])


@assert_no_logs
def test_table_style():
    html = parse_all('<table style="margin: 1px; padding: 2px"></table>')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    assert isinstance(wrapper, boxes.BlockBox)
    assert isinstance(table, boxes.TableBox)
    assert wrapper.style.margin_top == (1, 'px')
    assert wrapper.style.padding_top == (0, 'px')
    assert table.style.margin_top == (0, 'px')
    assert table.style.padding_top == (2, 'px')


@assert_no_logs
def test_column_style():
    html = parse_all('''
        <table>
            <col span=3 style="width: 10px"></col>
            <col span=2></col>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    colgroup, = table.column_groups
    widths = [col.style.width for col in colgroup.children]
    assert widths == [(10, 'px'), (10, 'px'), (10, 'px'), 'auto', 'auto']
    assert [col.grid_x for col in colgroup.children] == [0, 1, 2, 3, 4]
    # copies, not the same box object
    assert colgroup.children[0] is not colgroup.children[1]


@assert_no_logs
def test_nested_grid_x():
    html = parse_all('''
        <table>
            <col span=2></col>
            <colgroup span=2></colgroup>
            <colgroup>
                <col></col>
                <col span=2></col>
            </colgroup>
            <col></col>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    grid = [(colgroup.grid_x, [col.grid_x for col in colgroup.children])
            for colgroup in table.column_groups]
    assert grid == [(0, [0, 1]), (2, [2, 3]), (4, [4, 5, 6]), (7, [7])]


@assert_no_logs
def test_colspan_rowspan():
    """
    +---+---+---+
    | A | B | C | #
    +---+---+---+
    | D |     E | #
    +---+---+   +---+
    |  F ...|   |   |   <-- overlap
    +---+---+---+   +
    | H | #   # | G |
    +---+---+   +   +
    | I | J | # |   |
    +---+---+   +---+

    # empty cells

    """
    html = parse_all('''
        <table>
            <tr>
                <td>A <td>B <td>C
            </tr>
            <tr>
                <td>D <td colspan=2 rowspan=2>E
            </tr>
            <tr>
                <td colspan=2>F <td rowspan=0>G
            </tr>
            <tr>
                <td>H
            </tr>
            <tr>
                <td>I <td>J
            </tr>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    group, = table.children
    assert [[c.grid_x for c in row.children] for row in group.children] == [
        [0, 1, 2],
        [0, 1],
        [0,      3],
        [0],
        [0, 1],
    ]
    assert [[c.colspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [2,      1],
        [1],
        [1, 1],
    ]
    assert [[c.rowspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [1,      3],
        [1],
        [1, 1],
    ]

    # A cell box cannot extend beyond the last row box of a table.
    html = parse_all('''
        <table>
            <tr>
                <td rowspan=5></td>
                <td></td>
            </tr>
            <tr>
                <td></td>
            </tr>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    group, = table.children
    assert [[c.grid_x for c in row.children] for row in group.children] == [
        [0, 1],
        [1],
    ]
    assert [[c.colspan for c in row.children] for row in group.children] == [
        [1, 1],
        [1],
    ]
    assert [[c.rowspan for c in row.children] for row in group.children] == [
        [2, 1],  # Not 5
        [1],
    ]


@assert_no_logs
def test_before_after():
    """Test the ::before and ::after pseudo-elements."""
    assert_tree(parse_all('''
        <style>
            p:before { content: normal }
            div:before { content: none }
            section::before { color: black }
        </style>
        <p></p>
        <div></div>
        <section></section>
    '''), [
        # No content in pseudo-element, no box generated
        ('p', 'Block', []),
        ('div', 'Block', []),
        ('section', 'Block', [])])

    assert_tree(parse_all('''
        <style>
            p:before { content: 'a' 'b' }
            p::after { content: 'd' 'e' }
        </style>
        <p>
            c
        </p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', 'ab')]),
                ('p', 'Text', ' c '),
                ('p::after', 'Inline', [
                    ('p::after', 'Text', 'de')])])])])

    assert_tree(parse_all('''
        <style>
            a[href]:before { content: '[' attr(href) '] ' }
        </style>
        <p><a href="some url">some text</a></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('a', 'Inline', [
                    ('a::before', 'Inline', [
                        ('a::before', 'Text', '[some url] ')]),
                    ('a', 'Text', 'some text')])])])])

    assert_tree(parse_all('''
        <style>
            body { quotes: '«' '»' '“' '”' }
            q:before { content: open-quote ' '}
            q:after { content: ' ' close-quote }
        </style>
        <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '“ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ”')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' »')])])])])])
    with capture_logs() as logs:
        assert_tree(parse_all('''
            <style>
                p:before {
                    content: 'a' url(pattern.png) 'b';

                    /* Invalid, ignored in favor of the one above.
                       Regression test: this used to crash: */
                    content: some-function(nested-function(something));
                }
            </style>
            <p>c</p>
        '''), [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::before', 'Inline', [
                        ('p::before', 'Text', 'a'),
                        ('p::before', 'AnonInlineReplaced', '<replaced>'),
                        ('p::before', 'Text', 'b')]),
                    ('p', 'Text', 'c')])])])
    assert len(logs) == 1
    assert 'nested-function(' in logs[0]
    assert 'invalid value' in logs[0]


@assert_no_logs
def test_counters():
    """Test counter-reset, counter-increment, content: counter() counters()"""
    assert_tree(parse_all('''
        <style>
            p { counter-increment: p 2 }
            p:before { content: counter(p); }
            p:nth-child(1) { counter-increment: none; }
            p:nth-child(2) { counter-increment: p; }
        </style>
        <p></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p 117 p"></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p -13"></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p 42"></p>
        <p></p>
        <p></p>'''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '0 1 3  2 4 6  -11 -9 -7  44 46 48'.split()])

    assert_tree(parse_all('''
        <ol style="list-style-position: inside">
            <li></li>
            <li></li>
            <li></li>
            <li><ol>
                <li></li>
                <li style="counter-increment: none"></li>
                <li></li>
            </ol></li>
            <li></li>
        </ol>'''), [
        ('ol', 'Block', [
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Text', '1.')])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Text', '2.')])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Text', '3.')])]),
            ('li', 'Block', [
                ('li', 'AnonBlock', [
                    ('li', 'Line', [
                        ('li::marker', 'Text', '4.')])]),
                ('ol', 'Block', [
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Text', '1.')])]),
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Text', '1.')])]),
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Text', '2.')])])])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Text', '5.')])])])])

    assert_tree(parse_all('''
        <style>
            p { display: list-item; list-style: inside decimal }
        </style>
        <div>
            <p></p>
            <p></p>
            <p style="counter-reset: list-item 7 list-item -56"></p>
        </div>
        <p></p>'''), [
        ('div', 'Block', [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Text', '1.')])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Text', '2.')])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Text', '-55.')])])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::marker', 'Text', '1.')])])])

    assert_tree(parse_all('''
        <style>
            section:before { counter-reset: h; content: '' }
            h1:before { counter-increment: h; content: counters(h, '.') }
        </style>
        <body>
            <section><h1></h1>
                <h1></h1>
                <section><h1></h1>
                    <h1></h1>
                </section>
                <h1></h1>
            </section>
        </body>'''), [
        ('section', 'Block', [
            ('section', 'AnonBlock', [
                ('section', 'Line', [
                    ('section::before', 'Inline', [])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '1')])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '2')])])]),
            ('section', 'Block', [
                ('section', 'AnonBlock', [
                    ('section', 'Line', [
                        ('section::before', 'Inline', [])])]),
                ('h1', 'Block', [
                    ('h1', 'Line', [
                        ('h1::before', 'Inline', [
                            ('h1::before', 'Text', '2.1')])])]),
                ('h1', 'Block', [
                    ('h1', 'Line', [
                        ('h1::before', 'Inline', [
                            ('h1::before', 'Text', '2.2')])])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '3')])])])])])

    assert_tree(parse_all('''
        <style>
            p:before { content: counter(c) }
        </style>
        <div>
            <span style="counter-reset: c">
                Scope created now, deleted after the div
            </span>
        </div>
        <p></p>'''), [
        ('div', 'Block', [
            ('div', 'Line', [
                ('span', 'Inline', [
                    ('span', 'Text',
                     'Scope created now, deleted after the div ')])])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', '0')])])])])

    # counter-increment may interfere with display: list-item
    assert_tree(parse_all('''
        <p style="counter-increment: c;
                  display: list-item; list-style: inside decimal">'''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::marker', 'Text', '0.')])])])


@assert_no_logs
def test_counter_styles():
    """Test the various counter styles."""
    assert_tree(parse_all('''
        <style>
            body { counter-reset: p -12 }
            p { counter-increment: p }
            p:nth-child(1):before { content: '-' counter(p, none) '-'; }
            p:nth-child(2):before { content: counter(p, disc); }
            p:nth-child(3):before { content: counter(p, circle); }
            p:nth-child(4):before { content: counter(p, square); }
            p:nth-child(5):before { content: counter(p); }
        </style>
        <p></p>
        <p></p>
        <p></p>
        <p></p>
        <p></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '--  •  ◦  ▪  -7'.split()])

    assert_tree(parse_all('''
        <style>
            p { counter-increment: p }
            p::before { content: counter(p, decimal-leading-zero); }
        </style>
        <p style="counter-reset: p -1987"></p>
        <p></p>
        <p style="counter-reset: p -12"></p>
        <p></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p -2"></p>
        <p></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p 8"></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p 98"></p>
        <p></p>
        <p></p>
        <p style="counter-reset: p 4134"></p>
        <p></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '''-1986 -1985  -11 -10 -09 -08  -01 00 01 02  09 10 11
                            99 100 101  4135 4136'''.split()])

    # Same test as above, but short-circuit HTML and boxes

    assert [counters.format(value, 'decimal-leading-zero') for value in [
        -1986, -1985,  -11, -10, -9, -8,  -1, 0, 1, 2,  9, 10, 11,
        99, 100, 101,  4135, 4136
    ]] == '''
        -1986 -1985  -11 -10 -09 -08  -01 00 01 02  09 10 11
        99 100 101  4135 4136
    '''.split()

    # Now that we’re confident that they do the same, use the shorter form.

# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-007.htm
    assert [counters.format(value, 'lower-roman') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        49, 50,  389, 390,  3489, 3490, 3491, 4999, 5000, 5001
    ]] == '''
        -1986 -1985  -1 0 i ii iii iv v vi vii viii ix x xi xii
        xlix l  ccclxxxix cccxc  mmmcdlxxxix mmmcdxc mmmcdxci
        mmmmcmxcix  5000 5001
    '''.split()

# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-008.htm
    assert [counters.format(value, 'upper-roman') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        49, 50,  389, 390,  3489, 3490, 3491, 4999, 5000, 5001
    ]] == '''
        -1986 -1985  -1 0 I II III IV V VI VII VIII IX X XI XII
        XLIX L  CCCLXXXIX CCCXC  MMMCDLXXXIX MMMCDXC MMMCDXCI
        MMMMCMXCIX 5000 5001
    '''.split()

    assert [counters.format(value, 'lower-alpha') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
    ]] == '''
        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
    '''.split()

    assert [counters.format(value, 'upper-alpha') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
    ]] == '''
        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
    '''.split()

    assert [counters.format(value, 'lower-latin') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
    ]] == '''
        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
    '''.split()

    assert [counters.format(value, 'upper-latin') for value in [
        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
    ]] == '''
        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
    '''.split()

# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-009.htm
    assert [counters.format(value, 'georgian') for value in [
        -1986, -1985,  -1, 0, 1,
        2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        20, 30, 40, 50, 60, 70, 80, 90, 100,
        200, 300, 400, 500, 600, 700, 800, 900, 1000,
        2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000,
        19999, 20000, 20001
    ]] == '''
        -1986 -1985  -1 0 ა
        ბ გ დ ე ვ ზ ჱ თ ი ია იბ
        კ ლ მ ნ ჲ ო პ ჟ რ
        ს ტ ჳ ფ ქ ღ ყ შ ჩ
        ც ძ წ ჭ ხ ჴ ჯ ჰ ჵ
        ჵჰშჟთ 20000 20001
    '''.split()

# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-010.htm
    assert [counters.format(value, 'armenian') for value in [
        -1986, -1985,  -1, 0, 1,
        2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        20, 30, 40, 50, 60, 70, 80, 90, 100,
        200, 300, 400, 500, 600, 700, 800, 900, 1000,
        2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000,
        9999, 10000, 10001
    ]] == '''
        -1986 -1985  -1 0 Ա
        Բ Գ Դ Ե Զ Է Ը Թ Ժ ԺԱ ԺԲ
        Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ
        Մ Յ Ն Շ Ո Չ Պ Ջ Ռ
        Ս Վ Տ Ր Ց Ւ Փ Ք
        ՔՋՂԹ 10000 10001
    '''.split()


@assert_no_logs
def test_margin_boxes():
    """
    Test that the correct margin boxes are created.
    """
    page_1, page_2 = render_pages('''
        <style>
            @page {
                /* Make the page content area only 10px high and wide,
                   so every word in <p> end up on a page of its own. */
                size: 30px;
                margin: 10px;
                @top-center { content: "Title" }
            }
            @page :first {
                @bottom-left { content: "foo" }
                @bottom-left-corner { content: "baz" }
            }
        </style>
        <p>lorem ipsum
    ''')
    assert page_1.children[0].element_tag == 'html'
    assert page_2.children[0].element_tag == 'html'

    margin_boxes_1 = [box.at_keyword for box in page_1.children[1:]]
    margin_boxes_2 = [box.at_keyword for box in page_2.children[1:]]
    assert margin_boxes_1 == ['@top-center', '@bottom-left',
                              '@bottom-left-corner']
    assert margin_boxes_2 == ['@top-center']

    html, top_center = page_2.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'Title'


@assert_no_logs
def test_margin_box_string_set():
    """Test string-set / string() in margin boxes."""
    # Test that both pages get string in the `bottom-center` margin box
    page_1, page_2 = render_pages('''
        <style>
            @page {
                @bottom-center { content: string(text_header); }
            }
            p{
                -weasy-string-set: text_header content();
            }
            .page{
                page-break-before: always;
            }
        </style>
        <p>first assignment</p>
        <div class="page"></div>
    ''')

    html, bottom_center = page_2.children
    line_box, = bottom_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'

    html, bottom_center = page_1.children
    line_box, = bottom_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'

    def simple_string_set_test(content_val, extra_style=""):
        page_1, = render_pages('''
            <style>
                @page {
                    @top-center { content: string(text_header); }
                }
                p{
                    -weasy-string-set: text_header content(%(content_val)s);
                }
                %(extra_style)s
            </style>
            <p>first assignment</p>
        ''' % dict(content_val=content_val, extra_style=extra_style))

        html, top_center = page_1.children
        line_box, = top_center.children
        text_box, = line_box.children
        if content_val in ('before', 'after'):
            assert text_box.text == 'pseudo'
        else:
            assert text_box.text == 'first assignment'

    # Test each accepted value of `content()` as an arguemnt to `string-set`
    for value in ('', 'text', 'before', 'after'):
        if value in ('before', 'after'):
            extra_style = "p:%s{content: 'pseudo'}" % value
            simple_string_set_test(value, extra_style)
        else:
            simple_string_set_test(value)

    # Test `first` (default value) ie. use the first assignment on the page
    page_1, = render_pages('''
        <style>
            @page {
                @top-center { content: string(text_header, first); }
            }
            p{
                -weasy-string-set: text_header content();
            }
        </style>
        <p>first assignment</p>
        <p>Second assignment</p>
    ''')

    html, top_center = page_1.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'

    # test `first-except` ie. exclude from page on which value is assigned
    page_1, page_2 = render_pages('''
        <style>
            @page {
                @top-center { content: string(header_nofirst, first-except); }
            }
            p{
                -weasy-string-set: header_nofirst content();
            }
            .page{
                page-break-before: always;
            }
        </style>
        <p>first_excepted</p>
        <div class="page"></div>
    ''')
    html, top_center = page_1.children
    assert len(top_center.children) == 0

    html, top_center = page_2.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'first_excepted'

    # Test `last` ie. use the most-recent assignment
    page_1, = render_pages('''
        <style>
            @page {
                @top-center { content: string(header_last, last); }
            }
            p{
                -weasy-string-set: header_last content();
            }
        </style>
        <p>String set</p>
        <p>Second assignment</p>
    ''')

    html, top_center = page_1.children[:2]
    line_box, = top_center.children

    text_box, = line_box.children
    assert text_box.text == 'Second assignment'

    # Test multiple complex string-set values
    page_1, = render_pages('''
        <style>
            @page {
              @top-center { content: string(text_header, first); }
              @bottom-center { content: string(text_footer, last); }
            }
            html { counter-reset: a }
            body { counter-increment: a }
            ul { counter-reset: b }
            li {
              counter-increment: b;
              -weasy-string-set:
                text_header content(before) "-" content() "-" content(after)
                            counter(a, upper-roman) '.' counters(b, '|'),
                text_footer content(before) '-' attr(class)
                            counters(b, '|') "/" counter(a, upper-roman);
            }
            li:before { content: 'before!' }
            li:after { content: 'after!' }
            li:last-child:before { content: 'before!last' }
            li:last-child:after { content: 'after!last' }
        </style>
        <ul>
          <li class="firstclass">first
          <li>
            <ul>
              <li class="secondclass">second
    ''')

    html, top_center, bottom_center = page_1.children
    top_line_box, = top_center.children
    top_text_box, = top_line_box.children
    assert top_text_box.text == 'before!-first-after!I.1'
    bottom_line_box, = bottom_center.children
    bottom_text_box, = bottom_line_box.children
    assert bottom_text_box.text == 'before!last-secondclass2|1/I'


@assert_no_logs
def test_page_counters():
    """Test page-based counters."""
    pages = render_pages('''
        <style>
            @page {
                /* Make the page content area only 10px high and wide,
                   so every word in <p> end up on a page of its own. */
                size: 30px;
                margin: 10px;
                @bottom-center {
                    content: "Page " counter(page) " of " counter(pages) ".";
                }
            }
        </style>
        <p>lorem ipsum dolor
    ''')
    for page_number, page in enumerate(pages, 1):
        html, bottom_center = page.children
        line_box, = bottom_center.children
        text_box, = line_box.children
        assert text_box.text == 'Page {0} of 3.'.format(page_number)


@assert_no_logs
def test_border_collapse():
    html = parse_all('<table></table>')
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    assert isinstance(table, boxes.TableBox)
    assert not hasattr(table, 'collapsed_border_grid')

    def get_grid(html):
        html = parse_all(html)
        body, = html.children
        table_wrapper, = body.children
        table, = table_wrapper.children
        return tuple(
            [[(style, width, color) if width else None
              for _score, (style, width, color) in column]
             for column in grid]
            for grid in table.collapsed_border_grid)

    grid = get_grid('<table style="border-collapse: collapse"></table>')
    assert grid == ([], [])

    black = (0, 0, 0, 1)
    red = (1, 0, 0, 1)
    green = (0, 1, 0, 1)  # lime in CSS
    blue = (0, 0, 1, 1)
    yellow = (1, 1, 0, 1)

    vertical_borders, horizontal_borders = get_grid('''
        <style>td { border: 1px solid red }</style>
        <table style="border-collapse: collapse; border: 3px solid black">
            <tr> <td>A</td> <td>B</td> </tr>
            <tr> <td>C</td> <td>D</td> </tr>
        </table>
    ''')
    black_3 = ('solid', 3, black)
    red_1 = ('solid', 1, red)
    assert vertical_borders == [
        [black_3, red_1, black_3],
        [black_3, red_1, black_3],
    ]
    assert horizontal_borders == [
        [black_3, black_3],
        [red_1, red_1],
        [black_3, black_3],
    ]

    # hidden vs. none
    vertical_borders, horizontal_borders = get_grid('''
        <style>table, td { border: 3px solid }</style>
        <table style="border-collapse: collapse">
            <tr> <td>A</td> <td style="border-style: hidden">B</td> </tr>
            <tr> <td>C</td> <td style="border-style: none">D</td> </tr>
        </table>
    ''')
    assert vertical_borders == [
        [black_3, None, None],
        [black_3, black_3, black_3],
    ]
    assert horizontal_borders == [
        [black_3, None],
        [black_3, None],
        [black_3, black_3],
    ]

    yellow_5 = ('solid', 5, yellow)
    green_5 = ('solid', 5, green)
    dashed_blue_5 = ('dashed', 5, blue)
    vertical_borders, horizontal_borders = get_grid('''
        <style>td { border: 1px solid red }</style>
        <table style="border-collapse: collapse; border: 5px solid yellow">
            <col style="border: 3px solid black" />
            <tr> <td></td> <td></td> <td></td> </tr>
            <tr> <td></td> <td style="border: 5px dashed blue"></td>
                 <td style="border: 5px solid lime"></td> </tr>
            <tr> <td></td> <td></td> <td></td> </tr>
            <tr> <td></td> <td></td> <td></td> </tr>
        </table>
    ''')
    assert vertical_borders == [
        [yellow_5, black_3, red_1, yellow_5],
        [yellow_5, dashed_blue_5, green_5, green_5],
        [yellow_5, black_3, red_1, yellow_5],
        [yellow_5, black_3, red_1, yellow_5],
    ]
    assert horizontal_borders == [
        [yellow_5, yellow_5, yellow_5],
        [red_1, dashed_blue_5, green_5],
        [red_1, dashed_blue_5, green_5],
        [red_1, red_1, red_1],
        [yellow_5, yellow_5, yellow_5],
    ]

    # rowspan and colspan
    vertical_borders, horizontal_borders = get_grid('''
        <style>col, tr { border: 3px solid }</style>
        <table style="border-collapse: collapse">
            <col /><col /><col />
            <tr> <td rowspan=2></td> <td></td> <td></td> </tr>
            <tr>                     <td colspan=2></td> </tr>
        </table>
    ''')
    assert vertical_borders == [
        [black_3, black_3, black_3, black_3],
        [black_3, black_3, None, black_3],
    ]
    assert horizontal_borders == [
        [black_3, black_3, black_3],
        [None, black_3, black_3],
        [black_3, black_3, black_3],
    ]
-												Replace utf8 with utf-8 for gettext compatibility

											
										
										
											2015-11-25 10:38:01 +03:00
+								# coding: utf-8
-												Switch the licence to BSD and rewrite module docstrings/headers

											
										
										
											2012-03-22 02:19:27 +04:00
+								"""
 								    weasyprint.tests.test_boxes
 								    ---------------------------
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Switch the licence to BSD and rewrite module docstrings/headers

											
										
										
											2012-03-22 02:19:27 +04:00
+								    Test that the "before layout" box tree is correctly constructed.
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-.

											
										
										
											2014-01-10 18:27:02 +04:00
+								    :copyright: Copyright 2011-2014 Simon Sapin and contributors, see AUTHORS.
-												Switch the licence to BSD and rewrite module docstrings/headers

											
										
										
											2012-03-22 02:19:27 +04:00
+								    :license: BSD, see LICENSE for details.
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
 								"""
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								from __future__ import division, unicode_literals
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								import functools
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								import pprint
 								import difflib
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
+								from .testing_utils import (
-												Replace TestHTML by FakeHTML to please pytest3

											
										
										
											2016-09-12 01:30:39 +03:00
+								    resource_filename, FakeHTML, assert_no_logs, capture_logs)
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								from ..css import get_all_computed_styles
 								from .. import images
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								from ..formatting_structure import boxes, build, counters
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								PROPER_CHILDREN = dict((key, tuple(map(tuple, value))) for key, value in {
 								    # Children can be of *any* type in *one* of the lists.
 								    boxes.BlockContainerBox: [[boxes.BlockLevelBox], [boxes.LineBox]],
 								    boxes.LineBox: [[boxes.InlineLevelBox]],
 								    boxes.InlineBox: [[boxes.InlineLevelBox]],
 								    boxes.TableBox: [[boxes.TableCaptionBox,
 								                      boxes.TableColumnGroupBox, boxes.TableColumnBox,
 								                      boxes.TableRowGroupBox, boxes.TableRowBox]],
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    boxes.InlineTableBox: [[boxes.TableCaptionBox,
 								                            boxes.TableColumnGroupBox, boxes.TableColumnBox,
 								                            boxes.TableRowGroupBox, boxes.TableRowBox]],
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								    boxes.TableColumnGroupBox: [[boxes.TableColumnBox]],
 								    boxes.TableRowGroupBox: [[boxes.TableRowBox]],
 								    boxes.TableRowBox: [[boxes.TableCellBox]],
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								}.items())
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								def serialize(box_list):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Transform a box list into a structure easier to compare for testing."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return [
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								        (box.element_tag,
 								         ('Anon' if (box.style.anonymous and
 								                     type(box) not in (boxes.TextBox, boxes.LineBox))
 								          else '') + type(box).__name__[:-3],
 								         # All concrete boxes are either text, replaced, column or parent.
 								         (box.text if isinstance(box, boxes.TextBox)
 								          else '<replaced>' if isinstance(box, boxes.ReplacedBox)
-												Don't always copy boxes

											
										
										
											2016-11-01 06:31:15 +03:00
+								          else serialize(
 								            getattr(box, 'column_groups', ()) + tuple(box.children))))
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								        for box in box_list]
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
 								def unwrap_html_body(box):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test that the box tree starts with a ``<html>`` and a ``<body>`` blocks.
 								    Remove them to simplify further tests. These are always at the root
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								    of HTML documents.
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								    """
-												Remove references to elements in boxes.

											
										
										
											2011-12-02 15:36:20 +04:00
+								    assert box.element_tag == 'html'
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    assert isinstance(box, boxes.BlockBox)
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    assert len(box.children) == 1
 								    box = box.children[0]
-												Add box classes to propely represent eg. an inline-level block container
generated by an element with 'display: inline-block'

											
										
										
											2011-05-25 16:59:42 +04:00
+								    assert isinstance(box, boxes.BlockBox)
-												Remove references to elements in boxes.

											
										
										
											2011-12-02 15:36:20 +04:00
+								    assert box.element_tag == 'body'
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return box.children
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
+								def to_lists(box_tree):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Serialize and unwrap ``<html>`` and ``<body>``."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return serialize(unwrap_html_body(box_tree))
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
+								def _parse_base(
 								        html_content,
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								        # Dummy filename, but in the right directory.
 								        base_url=resource_filename('<test>')):
-												Replace TestHTML by FakeHTML to please pytest3

											
										
										
											2016-09-12 01:30:39 +03:00
+								    document = FakeHTML(string=html_content, base_url=base_url)
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    style_for = get_all_computed_styles(document)
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
+								    get_image_from_uri = functools.partial(
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								        images.get_image_from_uri, {}, document.url_fetcher)
 								    return document.root_element, style_for, get_image_from_uri
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
-												Split box classes and box-building functions into a module each.

											
										
										
											2011-06-29 23:59:29 +04:00
+								def parse(html_content):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Parse some HTML, apply stylesheets and transform to boxes."""
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    box, = build.element_to_box(*_parse_base(html_content))
-												Remove monkey patches about float

											
										
										
											2012-05-30 05:36:37 +04:00
+								    return box
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
+								def parse_all(html_content, base_url=resource_filename('<test>')):
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    """Like parse() but also run all corrections on boxes."""
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    box = build.build_formatting_structure(*_parse_base(
 								        html_content, base_url))
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    sanity_checks(box)
 								    return box
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								def render_pages(html_content):
 								    """Lay out a document and return a list of PageBox objects."""
-												Replace TestHTML by FakeHTML to please pytest3

											
										
										
											2016-09-12 01:30:39 +03:00
+								    return [p._page_box for p in FakeHTML(
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								            string=html_content, base_url=resource_filename('<test>')
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
+								            ).render(enable_hinting=True).pages]
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								def assert_tree(box, expected):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Check the box tree equality.
 								    The obtained result is prettified in the message in case of failure.
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    box: a Box object, starting with <html> and <body> blocks.
 								    expected: a list of serialized <body> children as returned by to_lists().
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    """
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    lists = to_lists(box)
 								    if lists != expected:
 								        print(''.join(difflib.unified_diff(
-												Fix again failing tests with Python 2

											
										
										
											2013-10-17 16:55:16 +04:00
+								            *[pprint.pformat(v).splitlines(True) for v in [lists, expected]],
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								            n=9999)))
 								        assert lists == expected
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
+								def sanity_checks(box):
 								    """Check that the rules regarding boxes are met.
 								    This is not required and only helps debugging.
 								    - A block container can contain either only block-level boxes or
 								      only line boxes;
 								    - Line boxes and inline boxes can only contain inline-level boxes.
 								    """
 								    if not isinstance(box, boxes.ParentBox):
 								        return
-												Tests n’ fixes. Lots of them.

											
										
										
											2012-04-02 16:45:44 +04:00
+								    acceptable_types_lists = None  # raises when iterated
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								    for class_ in type(box).mro():
 								        if class_ in PROPER_CHILDREN:
 								            acceptable_types_lists = PROPER_CHILDREN[class_]
 								            break
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
 								    assert any(
-												Fix many PEP8 errors and warnings

- Put line breaks after operators (that's OK)
- Don't assign lambdas, use functions (well, that's really explicit in
  PEP8, it's really verbose but why not)
- Put imports at the beginning of the file (only special cases for us)

											
										
										
											2016-01-15 14:47:03 +03:00
+								        all(isinstance(child, acceptable_types) or
 								            not child.is_in_normal_flow()
-												Fix whitespace collapsing across not-in-normal-flow boxes.

											
										
										
											2012-06-28 15:05:22 +04:00
+								            for child in box.children)
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								        for acceptable_types in acceptable_types_lists
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    ), (box, box.children)
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
 								    for child in box.children:
 								        sanity_checks(child)
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								def test_box_tree():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the creation of trees from HTML strings."""
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								    assert_tree(parse('<p>'), [('p', 'Block', [])])
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								    assert_tree(parse(
 								        '''
-												Use the new box classes as appropriate (ie. for inline-block.)

											
										
										
											2011-05-25 17:27:30 +04:00
+								        <style>
 								            span { display: inline-block }
 								        </style>
-												Fix a test broken by 1d1bf9cd

											
										
										
											2013-04-11 20:43:05 +04:00
+								        <p>Hello <em>World <img src="pattern.png"><span>L</span></em>!</p>'''),
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								        [('p', 'Block', [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								            ('p', 'Text', 'Hello '),
 								            ('em', 'Inline', [
 								                ('em', 'Text', 'World '),
-												Shorter names.

											
										
										
											2011-12-05 17:24:43 +04:00
+								                ('img', 'InlineReplaced', '<replaced>'),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('span', 'InlineBlock', [
-												Fix a test broken by 1d1bf9cd

											
										
										
											2013-04-11 20:43:05 +04:00
+								                    ('span', 'Text', 'L')])]),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								            ('p', 'Text', '!')])])
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
+								def test_html_entities():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of HTML entities."""
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
+								    for quote in ['"', '&quot;', '&#x22;', '&#34;']:
-												Actual python 2.6 compatibility

											
										
										
											2012-02-21 17:13:34 +04:00
+								        assert_tree(parse('<p>{0}abc{1}'.format(quote, quote)), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								            ('p', 'Block', [
 								                ('p', 'Text', '"abc"')])])
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								def test_inline_in_block():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of inline boxes in block boxes."""
-												Make process_whitespace a separate step and also collapse spaces across tags.

											
										
										
											2011-05-23 18:56:12 +04:00
+								    source = '<div>Hello, <em>World</em>!\n<p>Lipsum.</p></div>'
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								    expected = [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('div', 'Block', [
 								            ('div', 'AnonBlock', [
 								                ('div', 'Line', [
 								                    ('div', 'Text', 'Hello, '),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'World')]),
 								                    ('div', 'Text', '!\n')])]),
 								            ('p', 'Block', [
 								                ('p', 'Line', [
 								                    ('p', 'Text', 'Lipsum.')])])])]
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								    box = parse(source)
-												Tests n’ fixes. Lots of them.

											
										
										
											2012-04-02 16:45:44 +04:00
+								    box = build.inline_in_block(box)
 								    assert_tree(box, expected)
 								    source = '<div><p>Lipsum.</p>Hello, <em>World</em>!\n</div>'
 								    expected = [
 								        ('div', 'Block', [
 								            ('p', 'Block', [
 								                ('p', 'Line', [
 								                    ('p', 'Text', 'Lipsum.')])]),
 								            ('div', 'AnonBlock', [
 								                ('div', 'Line', [
 								                    ('div', 'Text', 'Hello, '),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'World')]),
 								                    ('div', 'Text', '!\n')])])])]
 								    box = parse(source)
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    assert_tree(box, expected)
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
-												Fix lines vs. anonymous blocks in precence of floats.

											
										
										
											2012-06-01 19:08:54 +04:00
+								    # Absolutes are left in the lines to get their static position later.
 								    source = '''<p>Hello <em style="position:absolute;
 								                                    display: block">World</em>!</p>'''
-												Handle not-in-flow elements in inline boxes

											
										
										
											2012-05-09 16:14:42 +04:00
+								    expected = [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'Hello '),
 								                ('em', 'Block', [
 								                    ('em', 'Line', [
 								                        ('em', 'Text', 'World')])]),
 								                ('p', 'Text', '!')])])]
-												Fix lines vs. anonymous blocks in precence of floats.

											
										
										
											2012-06-01 19:08:54 +04:00
+								    box = parse(source)
 								    box = build.inline_in_block(box)
 								    assert_tree(box, expected)
 								    box = build.block_in_inline(box)
 								    assert_tree(box, expected)
-												Handle not-in-flow elements in inline boxes

											
										
										
											2012-05-09 16:14:42 +04:00
-												Bug fixes and tests on floats…

											
										
										
											2012-06-15 19:59:15 +04:00
+								    # Floats are pull to the top of their containing blocks
-												Fix lines vs. anonymous blocks in precence of floats.

											
										
										
											2012-06-01 19:08:54 +04:00
+								    source = '<p>Hello <em style="float: left">World</em>!</p>'
-												Bug fixes and tests on floats…

											
										
										
											2012-06-15 19:59:15 +04:00
+								    box = parse(source)
 								    box = build.inline_in_block(box)
 								    box = build.block_in_inline(box)
 								    assert_tree(box, [
-												Fix lines vs. anonymous blocks in precence of floats.

											
										
										
											2012-06-01 19:08:54 +04:00
+								        ('p', 'Block', [
-												Fix some tests

											
										
										
											2012-06-22 13:40:15 +04:00
+								            ('p', 'Line', [
 								                ('p', 'Text', 'Hello '),
 								                ('em', 'Block', [
 								                    ('em', 'Line', [
 								                        ('em', 'Text', 'World')])]),
 								                ('p', 'Text', '!')])])])
-												Handle not-in-flow elements in inline boxes

											
										
										
											2012-05-09 16:14:42 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												WIP: if an inline has a block child, pull the block up (see docstring)

											
										
										
											2011-05-19 20:58:39 +04:00
+								def test_block_in_inline():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of block boxes in inline boxes."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    box = parse('''
-												Bug fix: properly build anonymous blocks when a block element is in an inline

											
										
										
											2011-08-17 19:33:19 +04:00
+								<style>
 								    p { display: inline-block; }
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    span, i { display: block; }
-												Bug fix: properly build anonymous blocks when a block element is in an inline

											
										
										
											2011-08-17 19:33:19 +04:00
+								</style>
 								<p>Lorem <em>ipsum <strong>dolor <span>sit</span>
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    <span>amet,</span></strong><span><em>conse<i></i></em></span></em></p>''')
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    assert_tree(box, [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('body', 'Line', [
 								            ('p', 'InlineBlock', [
 								                ('p', 'Line', [
 								                    ('p', 'Text', 'Lorem '),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'ipsum '),
 								                        ('strong', 'Inline', [
 								                            ('strong', 'Text', 'dolor '),
 								                            ('span', 'Block', [  # This block is "pulled up"
 								                                ('span', 'Line', [
 								                                    ('span', 'Text', 'sit')])]),
-												Make process_whitespace a separate step and also collapse spaces across tags.

											
										
										
											2011-05-23 18:56:12 +04:00
+								                            # No whitespace processing here.
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                            ('strong', 'Text', '\n    '),
 								                            ('span', 'Block', [  # This block is "pulled up"
 								                                ('span', 'Line', [
 								                                    ('span', 'Text', 'amet,')])])]),
 								                        ('span', 'Block', [  # This block is "pulled up"
 								                            ('span', 'Line', [
 								                                ('em', 'Inline', [
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								                                    ('em', 'Text', 'conse'),
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                                    ('i', 'Block', [])])])])])])])])])
-												Change a test to cover more cases with inline-block.

											
										
										
											2011-05-25 17:55:08 +04:00
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.block_in_inline(box)
-												Change a test to cover more cases with inline-block.

											
										
										
											2011-05-25 17:55:08 +04:00
+								    assert_tree(box, [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('body', 'Line', [
 								            ('p', 'InlineBlock', [
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('p', 'Text', 'Lorem '),
 								                        ('em', 'Inline', [
 								                            ('em', 'Text', 'ipsum '),
 								                            ('strong', 'Inline', [
 								                                ('strong', 'Text', 'dolor ')])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'Line', [
 								                        ('span', 'Text', 'sit')])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [
 								                            ('strong', 'Inline', [
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								                                # Whitespace processing not done yet.
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                                ('strong', 'Text', '\n    ')])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'Line', [
 								                        ('span', 'Text', 'amet,')])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [
 								                            ('strong', 'Inline', [])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'AnonBlock', [
 								                        ('span', 'Line', [
 								                            ('em', 'Inline', [
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								                                ('em', 'Text', 'conse')])])]),
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                    ('i', 'Block', []),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                    ('span', 'AnonBlock', [
 								                        ('span', 'Line', [
 								                            ('em', 'Inline', [])])])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [])])])])])])
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								def test_styles():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the application of CSS to HTML."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    box = parse('''
 								        <style>
 								            span { display: block; }
 								            * { margin: 42px }
 								            html { color: blue }
 								        </style>
 								        <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
 								            <span>amet,</span></strong><span>consectetur</span></em></p>''')
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
 								    box = build.block_in_inline(box)
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								    descendants = list(box.descendants())
 								    assert len(descendants) == 31
 								    assert descendants[0] == box
 								    for child in descendants:
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        # All boxes inherit the color
-												Switch from cssutils to tinycss as the CSS parser

											
										
										
											2012-03-24 16:39:31 +04:00
+								        assert child.style.color == (0, 0, 1, 1)  # blue
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        # Only non-anonymous boxes have margins
-												Being anonymous is now an attribute of styles, not boxes.

											
										
										
											2011-12-05 18:25:42 +04:00
+								        if child.style.anonymous:
-												Do not keep tokens for percentages after validation.

Make (value, unit) namedtuples instead.
Pixel values that could be percentages are not plain numbers anymore.

											
										
										
											2012-04-03 16:59:06 +04:00
+								            assert child.style.margin_top == (0, 'px')
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        else:
-												Do not keep tokens for percentages after validation.

Make (value, unit) namedtuples instead.
Pixel values that could be percentages are not plain numbers anymore.

											
										
										
											2012-04-03 16:59:06 +04:00
+								            assert child.style.margin_top == (42, 'px')
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								def test_whitespace():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of white spaces."""
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								    # TODO: test more cases
 								    # http://www.w3.org/TR/CSS21/text.html#white-space-model
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								        <p>Lorem \t\r\n  ipsum\t<strong>  dolor
-												Fix whitespace collapsing across not-in-normal-flow boxes.

											
										
										
											2012-06-28 15:05:22 +04:00
+								            <img src=pattern.png> sit
 								            <span style="position: absolute"></span> <em> amet </em>
 								            consectetur</strong>.</p>
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								        <pre>\t  foo\n</pre>
 								        <pre style="white-space: pre-wrap">\t  foo\n</pre>
 								        <pre style="white-space: pre-line">\t  foo\n</pre>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'Lorem ipsum '),
 								                ('strong', 'Inline', [
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								                    ('strong', 'Text', 'dolor '),
-												Shorter names.

											
										
										
											2011-12-05 17:24:43 +04:00
+								                    ('img', 'InlineReplaced', '<replaced>'),
-												Fix whitespace collapsing across not-in-normal-flow boxes.

											
										
										
											2012-06-28 15:05:22 +04:00
+								                    ('strong', 'Text', ' sit '),
 								                    ('span', 'Block', []),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'amet ')]),
 								                    ('strong', 'Text', 'consectetur')]),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('p', 'Text', '.')])]),
 								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre
-												Don't use no-break spaces to avoid text wrapping

Fix #189

											
										
										
											2016-05-08 17:44:57 +03:00
+								                ('pre', 'Text', '\t  foo\n')])]),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre-wrap
-												Don't use no-break spaces to avoid text wrapping

Fix #189

											
										
										
											2016-05-08 17:44:57 +03:00
+								                ('pre', 'Text', '\t  foo\n')])]),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre-line
-												Fix whitespace collapsing across not-in-normal-flow boxes.

											
										
										
											2012-06-28 15:05:22 +04:00
+								                ('pre', 'Text', ' foo\n')])])])
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								def test_page_style():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of page styles."""
-												Replace TestHTML by FakeHTML to please pytest3

											
										
										
											2016-09-12 01:30:39 +03:00
+								    style_for = get_all_computed_styles(FakeHTML(string='''
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								        <style>
 								            @page { margin: 3px }
 								            @page :first { margin-top: 20px }
 								            @page :right { margin-right: 10px; margin-top: 10px }
 								            @page :left { margin-left: 10px; margin-top: 10px }
 								        </style>
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    '''))
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								    def assert_page_margins(page_type, top, right, bottom, left):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								        """Check the page margin values."""
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								        style = style_for(page_type)
-												Do not keep tokens for percentages after validation.

Make (value, unit) namedtuples instead.
Pixel values that could be percentages are not plain numbers anymore.

											
										
										
											2012-04-03 16:59:06 +04:00
+								        assert style.margin_top == (top, 'px')
 								        assert style.margin_right == (right, 'px')
 								        assert style.margin_bottom == (bottom, 'px')
 								        assert style.margin_left == (left, 'px')
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								    assert_page_margins('first_left_page', top=20, right=3, bottom=3, left=10)
 								    assert_page_margins('first_right_page', top=20, right=10, bottom=3, left=3)
 								    assert_page_margins('left_page', top=10, right=3, bottom=3, left=10)
 								    assert_page_margins('right_page', top=10, right=10, bottom=3, left=3)
-												Implement the `text-transform` property.

											
										
										
											2011-10-21 13:36:01 +04:00
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
+								@assert_no_logs
 								def test_images():
 								    """Test images that may or may not be available."""
 								    with capture_logs() as logs:
 								        result = parse_all('''
 								            <p><img src=pattern.png
 								                /><img alt="No src"
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								                /><img src=inexistent.jpg alt="Inexistent src" /></p>
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
+								        ''')
 								    assert len(logs) == 1
-												Fix #84: Mak loading an author stylesheet not fatal.

											
										
										
											2013-06-21 01:07:52 +04:00
+								    assert 'WARNING: Failed to load image' in logs[0]
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
+								    assert 'inexistent.jpg' in logs[0]
 								    assert_tree(result, [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('img', 'InlineReplaced', '<replaced>'),
 								                ('img', 'Inline', [
 								                    ('img', 'Text', 'No src')]),
 								                ('img', 'Inline', [
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								                    ('img', 'Text', 'Inexistent src')])])])])
-												Warn for relative URI references without a base URI.

											
										
										
											2012-05-24 18:06:58 +04:00
 								    with capture_logs() as logs:
 								        result = parse_all('<p><img src=pattern.png alt="No base_url">',
 								                           base_url=None)
 								    assert len(logs) == 1
 								    assert 'WARNING: Relative URI reference without a base URI' in logs[0]
 								    assert_tree(result, [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('img', 'Inline', [
 								                    ('img', 'Text', 'No base_url')])])])])
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								def test_tables():
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    # Rules in http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
 								    # Rule 1.3
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								    # Also table model: http://www.w3.org/TR/CSS21/tables.html#model
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								        <x-table>
 								            <x-tr>
 								                <x-th>foo</x-th>
 								                <x-th>bar</x-th>
 								            </x-tr>
 								            <x-tfoot></x-tfoot>
 								            <x-thead><x-th></x-th></x-thead>
 								            <x-caption style="caption-side: bottom"></x-caption>
 								            <x-thead></x-thead>
 								            <x-col></x-col>
 								            <x-caption>top caption</x-caption>
 								            <x-tr>
 								                <x-td>baz</x-td>
 								            </x-tr>
 								        </x-table>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								        ('x-table', 'AnonBlock', [
 								            ('x-caption', 'TableCaption', [
 								                ('x-caption', 'Line', [
 								                    ('x-caption', 'Text', 'top caption')])]),
 								            ('x-table', 'Table', [
 								                ('x-table', 'AnonTableColumnGroup', [
 								                    ('x-col', 'TableColumn', [])]),
 								                ('x-thead', 'TableRowGroup', [
 								                    ('x-thead', 'AnonTableRow', [
 								                        ('x-th', 'TableCell', [])])]),
 								                ('x-table', 'AnonTableRowGroup', [
 								                    ('x-tr', 'TableRow', [
 								                        ('x-th', 'TableCell', [
 								                            ('x-th', 'Line', [
 								                                ('x-th', 'Text', 'foo')])]),
 								                        ('x-th', 'TableCell', [
 								                            ('x-th', 'Line', [
 								                                ('x-th', 'Text', 'bar')])])])]),
 								                ('x-thead', 'TableRowGroup', []),
 								                ('x-table', 'AnonTableRowGroup', [
 								                    ('x-tr', 'TableRow', [
 								                        ('x-td', 'TableCell', [
 								                            ('x-td', 'Line', [
 								                                ('x-td', 'Text', 'baz')])])])]),
 								                ('x-tfoot', 'TableRowGroup', [])]),
 								            ('x-caption', 'TableCaption', [])])])
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    # Rules 1.4 and 3.1
 								    assert_tree(parse_all('''
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								        <span style="display: table-cell">foo</span>
 								        <span style="display: table-cell">bar</span>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableRowGroup', [
 								                    ('body', 'AnonTableRow', [
 								                        ('span', 'TableCell', [
 								                            ('span', 'Line', [
 								                                ('span', 'Text', 'foo')])]),
 								                        ('span', 'TableCell', [
 								                            ('span', 'Line', [
 								                                ('span', 'Text', 'bar')])])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
 								    # Rules 1.1 and 1.2
-												Fix column group without column children.

											
										
										
											2011-12-14 21:33:55 +04:00
+								    # Rule XXX (not in the spec): column groups have at least one column child
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
 								        <span style="display: table-column-group">
 
 								            <em style="display: table-column">
 
 								                <strong>3</strong>
 								            </em>
 								            <strong>4</strong>
 								        </span>
-												Fix column group without column children.

											
										
										
											2011-12-14 21:33:55 +04:00
+								        <ins style="display: table-column-group"></ins>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
 								                ('span', 'TableColumnGroup', [
-												Fix column group without column children.

											
										
										
											2011-12-14 21:33:55 +04:00
+								                    ('em', 'TableColumn', [])]),
 								                ('ins', 'TableColumnGroup', [
 								                    ('ins', 'AnonTableColumn', [])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rules 2.1 then 2.3
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    assert_tree(parse_all('<x-table>foo <div></div></x-table>'), [
 								        ('x-table', 'AnonBlock', [
 								            ('x-table', 'Table', [
 								                ('x-table', 'AnonTableRowGroup', [
 								                    ('x-table', 'AnonTableRow', [
 								                        ('x-table', 'AnonTableCell', [
 								                            ('x-table', 'AnonBlock', [
 								                                ('x-table', 'Line', [
 								                                    ('x-table', 'Text', 'foo ')])]),
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                            ('div', 'Block', [])])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rule 2.2
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    assert_tree(parse_all('<x-thead style="display: table-header-group">'
 								                          '<div></div><x-td></x-td></x-thead>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                ('x-thead', 'TableRowGroup', [
 								                    ('x-thead', 'AnonTableRow', [
 								                        ('x-thead', 'AnonTableCell', [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								                            ('div', 'Block', [])]),
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                        ('x-td', 'TableCell', [])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
-												Disable support for inline-table since inline-block is not supported either.

											
										
										
											2011-11-21 20:38:08 +04:00
+								    # TODO: re-enable this once we support inline-table
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    # Rule 3.2
 								    assert_tree(parse_all('<span><x-tr></x-tr></span>'), [
 								        ('body', 'Line', [
 								            ('span', 'Inline', [
 								                ('span', 'AnonInlineBlock', [
 								                    ('span', 'AnonInlineTable', [
 								                        ('span', 'AnonTableRowGroup', [
 								                            ('x-tr', 'TableRow', [])])])])])])])
 								    # Rule 3.1
 								    # Also, rule 1.3 does not apply: whitespace before and after is preserved
 								    assert_tree(parse_all('''
 								        <span>
 								            <em style="display: table-cell"></em>
 								            <em style="display: table-cell"></em>
 								        </span>
 								    '''), [
 								        ('body', 'Line', [
 								            ('span', 'Inline', [
 								                # Whitespace is preserved in table handling, then collapsed
 								                # into a single space.
 								                ('span', 'Text', ' '),
 								                ('span', 'AnonInlineBlock', [
 								                    ('span', 'AnonInlineTable', [
 								                        ('span', 'AnonTableRowGroup', [
 								                            ('span', 'AnonTableRow', [
 								                                ('em', 'TableCell', []),
 								                                ('em', 'TableCell', [])])])])]),
 								                ('span', 'Text', ' ')])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rule 3.2
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								    assert_tree(parse_all('<x-tr></x-tr>\t<x-tr></x-tr>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableRowGroup', [
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                    ('x-tr', 'TableRow', []),
 								                    ('x-tr', 'TableRow', [])])])])])
 								    assert_tree(parse_all('<x-col></x-col>\n<x-colgroup></x-colgroup>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableColumnGroup', [
-												Switch to html5lib to parse HTML. Fix #12.

											
										
										
											2013-07-22 03:10:25 +04:00
+								                    ('x-col', 'TableColumn', [])]),
 								                ('x-colgroup', 'TableColumnGroup', [
 								                    ('x-colgroup', 'AnonTableColumn', [])])])])])
-												Distribute table style among table wrapper box and table box.

											
										
										
											2011-11-15 21:58:43 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Distribute table style among table wrapper box and table box.

											
										
										
											2011-11-15 21:58:43 +04:00
+								def test_table_style():
 								    html = parse_all('<table style="margin: 1px; padding: 2px"></table>')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
 								    assert isinstance(wrapper, boxes.BlockBox)
 								    assert isinstance(table, boxes.TableBox)
-												Do not keep tokens for percentages after validation.

Make (value, unit) namedtuples instead.
Pixel values that could be percentages are not plain numbers anymore.

											
										
										
											2012-04-03 16:59:06 +04:00
+								    assert wrapper.style.margin_top == (1, 'px')
 								    assert wrapper.style.padding_top == (0, 'px')
 								    assert table.style.margin_top == (0, 'px')
 								    assert table.style.padding_top == (2, 'px')
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								def test_column_style():
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								    html = parse_all('''
 								        <table>
 								            <col span=3 style="width: 10px"></col>
 								            <col span=2></col>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    colgroup, = table.column_groups
 								    widths = [col.style.width for col in colgroup.children]
-												Do not keep tokens for percentages after validation.

Make (value, unit) namedtuples instead.
Pixel values that could be percentages are not plain numbers anymore.

											
										
										
											2012-04-03 16:59:06 +04:00
+								    assert widths == [(10, 'px'), (10, 'px'), (10, 'px'), 'auto', 'auto']
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    assert [col.grid_x for col in colgroup.children] == [0, 1, 2, 3, 4]
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								    # copies, not the same box object
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    assert colgroup.children[0] is not colgroup.children[1]
-												Handle span on columns and assign grid_x positions.

											
										
										
											2011-11-17 19:13:00 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Handle span on columns and assign grid_x positions.

											
										
										
											2011-11-17 19:13:00 +04:00
+								def test_nested_grid_x():
 								    html = parse_all('''
 								        <table>
 								            <col span=2></col>
 								            <colgroup span=2></colgroup>
 								            <colgroup>
 								                <col></col>
 								                <col span=2></col>
 								            </colgroup>
 								            <col></col>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    grid = [(colgroup.grid_x, [col.grid_x for col in colgroup.children])
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								            for colgroup in table.column_groups]
-												Fix column group without column children.

											
										
										
											2011-12-14 21:33:55 +04:00
+								    assert grid == [(0, [0, 1]), (2, [2, 3]), (4, [4, 5, 6]), (7, [7])]
-												Assign grid positions to cells, accounting for colspan and rowspan.

											
										
										
											2011-11-21 16:51:22 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Assign grid positions to cells, accounting for colspan and rowspan.

											
										
										
											2011-11-21 16:51:22 +04:00
+								def test_colspan_rowspan():
 								    """
 								    +---+---+---+
 								    | A | B | C | #
 								    +---+---+---+
 								    | D |     E | #
 								    +---+---+   +---+
 								    |  F ...|   |   |   <-- overlap
 								    +---+---+---+   +
 								    | H | #   # | G |
 								    +---+---+   +   +
 								    | I | J | # |   |
 								    +---+---+   +---+
 								    # empty cells
 								    """
 								    html = parse_all('''
 								        <table>
 								            <tr>
 								                <td>A <td>B <td>C
 								            </tr>
 								            <tr>
 								                <td>D <td colspan=2 rowspan=2>E
 								            </tr>
 								            <tr>
 								                <td colspan=2>F <td rowspan=0>G
 								            </tr>
 								            <tr>
 								                <td>H
 								            </tr>
 								            <tr>
 								                <td>I <td>J
 								            </tr>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
 								    group, = table.children
 								    assert [[c.grid_x for c in row.children] for row in group.children] == [
 								        [0, 1, 2],
 								        [0, 1],
 								        [0,      3],
 								        [0],
 								        [0, 1],
 								    ]
 								    assert [[c.colspan for c in row.children] for row in group.children] == [
 								        [1, 1, 1],
 								        [1, 2],
 								        [2,      1],
 								        [1],
 								        [1, 1],
 								    ]
 								    assert [[c.rowspan for c in row.children] for row in group.children] == [
 								        [1, 1, 1],
 								        [1, 2],
 								        [1,      3],
 								        [1],
 								        [1, 1],
 								    ]
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
-												Handle degerate rowspan values.

Previously, such values crashed the layout.

											
										
										
											2012-06-02 11:02:01 +04:00
+								    # A cell box cannot extend beyond the last row box of a table.
 								    html = parse_all('''
 								        <table>
 								            <tr>
 								                <td rowspan=5></td>
 								                <td></td>
 								            </tr>
 								            <tr>
 								                <td></td>
 								            </tr>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
 								    group, = table.children
 								    assert [[c.grid_x for c in row.children] for row in group.children] == [
 								        [0, 1],
 								        [1],
 								    ]
 								    assert [[c.colspan for c in row.children] for row in group.children] == [
 								        [1, 1],
 								        [1],
 								    ]
 								    assert [[c.rowspan for c in row.children] for row in group.children] == [
 								        [2, 1],  # Not 5
 								        [1],
 								    ]
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								def test_before_after():
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								    """Test the ::before and ::after pseudo-elements."""
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								    assert_tree(parse_all('''
 								        <style>
 								            p:before { content: normal }
 								            div:before { content: none }
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								            section::before { color: black }
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								        </style>
 								        <p></p>
 								        <div></div>
 								        <section></section>
 								    '''), [
 								        # No content in pseudo-element, no box generated
 								        ('p', 'Block', []),
 								        ('div', 'Block', []),
 								        ('section', 'Block', [])])
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								    assert_tree(parse_all('''
 								        <style>
 								            p:before { content: 'a' 'b' }
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								            p::after { content: 'd' 'e' }
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								        </style>
 								        <p>
 								            c
 								        </p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::before', 'Inline', [
 								                    ('p::before', 'Text', 'ab')]),
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								                ('p', 'Text', ' c '),
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::after', 'Inline', [
 								                    ('p::after', 'Text', 'de')])])])])
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
 								    assert_tree(parse_all('''
 								        <style>
 								            a[href]:before { content: '[' attr(href) '] ' }
 								        </style>
 								        <p><a href="some url">some text</a></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('a', 'Inline', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('a::before', 'Inline', [
 								                        ('a::before', 'Text', '[some url] ')]),
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								                    ('a', 'Text', 'some text')])])])])
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								    assert_tree(parse_all('''
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								        <style>
 								            body { quotes: '«' '»' '“' '”' }
 								            q:before { content: open-quote ' '}
 								            q:after { content: ' ' close-quote }
 								        </style>
 								        <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('q', 'Inline', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('q::before', 'Inline', [
 								                        ('q::before', 'Text', '« ')]),
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                    ('q', 'Text', 'Lorem ipsum '),
 								                    ('q', 'Inline', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                        ('q::before', 'Inline', [
 								                            ('q::before', 'Text', '“ ')]),
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                        ('q', 'Text', 'dolor'),
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                        ('q::after', 'Inline', [
 								                            ('q::after', 'Text', ' ”')])]),
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                    ('q', 'Text', ' sit amet'),
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('q::after', 'Inline', [
 								                        ('q::after', 'Text', ' »')])])])])])
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
+								    with capture_logs() as logs:
 								        assert_tree(parse_all('''
 								            <style>
 								                p:before {
 								                    content: 'a' url(pattern.png) 'b';
 								                    /* Invalid, ignored in favor of the one above.
 								                       Regression test: this used to crash: */
 								                    content: some-function(nested-function(something));
 								                }
 								            </style>
 								            <p>c</p>
 								        '''), [
 								            ('p', 'Block', [
 								                ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('p::before', 'Inline', [
 								                        ('p::before', 'Text', 'a'),
 								                        ('p::before', 'AnonInlineReplaced', '<replaced>'),
 								                        ('p::before', 'Text', 'b')]),
-												Fix #71: crash when parsing nested functional notation.

											
										
										
											2013-04-08 12:02:37 +04:00
+								                    ('p', 'Text', 'c')])])])
 								    assert len(logs) == 1
 								    assert 'nested-function(' in logs[0]
 								    assert 'invalid value' in logs[0]
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								def test_counters():
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+								    """Test counter-reset, counter-increment, content: counter() counters()"""
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								    assert_tree(parse_all('''
 								        <style>
 								            p { counter-increment: p 2 }
 								            p:before { content: counter(p); }
 								            p:nth-child(1) { counter-increment: none; }
 								            p:nth-child(2) { counter-increment: p; }
 								        </style>
 								        <p></p>
 								        <p></p>
 								        <p></p>
-												Correct counter scoping rules.

											
										
										
											2011-12-07 21:29:04 +04:00
+								        <p style="counter-reset: p 117 p"></p>
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p -13"></p>
 								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p 42"></p>
 								        <p></p>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								        <p></p>'''), [
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::before', 'Inline', [
 								                    ('p::before', 'Text', counter)])])])
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        for counter in '0 1 3  2 4 6  -11 -9 -7  44 46 48'.split()])
 								    assert_tree(parse_all('''
 								        <ol style="list-style-position: inside">
 								            <li></li>
 								            <li></li>
 								            <li></li>
 								            <li><ol>
 								                <li></li>
-												Make counter-increment inhibit the auto increment of list-item.

											
										
										
											2011-12-08 12:56:55 +04:00
+								                <li style="counter-increment: none"></li>
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								                <li></li>
 								            </ol></li>
 								            <li></li>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								        </ol>'''), [
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        ('ol', 'Block', [
 								            ('li', 'Block', [
 								                ('li', 'Line', [
 								                    ('li::marker', 'Text', '1.')])]),
 								            ('li', 'Block', [
 								                ('li', 'Line', [
 								                    ('li::marker', 'Text', '2.')])]),
 								            ('li', 'Block', [
 								                ('li', 'Line', [
 								                    ('li::marker', 'Text', '3.')])]),
 								            ('li', 'Block', [
 								                ('li', 'AnonBlock', [
 								                    ('li', 'Line', [
 								                        ('li::marker', 'Text', '4.')])]),
 								                ('ol', 'Block', [
 								                    ('li', 'Block', [
 								                        ('li', 'Line', [
 								                            ('li::marker', 'Text', '1.')])]),
 								                    ('li', 'Block', [
-												Make counter-increment inhibit the auto increment of list-item.

											
										
										
											2011-12-08 12:56:55 +04:00
+								                        ('li', 'Line', [
 								                            ('li::marker', 'Text', '1.')])]),
 								                    ('li', 'Block', [
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								                        ('li', 'Line', [
 								                            ('li::marker', 'Text', '2.')])])])]),
 								            ('li', 'Block', [
 								                ('li', 'Line', [
 								                    ('li::marker', 'Text', '5.')])])])])
 								    assert_tree(parse_all('''
 								        <style>
 								            p { display: list-item; list-style: inside decimal }
 								        </style>
 								        <div>
 								            <p></p>
 								            <p></p>
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								            <p style="counter-reset: list-item 7 list-item -56"></p>
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        </div>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								        <p></p>'''), [
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        ('div', 'Block', [
 								            ('p', 'Block', [
 								                ('p', 'Line', [
 								                    ('p::marker', 'Text', '1.')])]),
 								            ('p', 'Block', [
 								                ('p', 'Line', [
-												Correct counter scoping rules.

											
										
										
											2011-12-07 21:29:04 +04:00
+								                    ('p::marker', 'Text', '2.')])]),
 								            ('p', 'Block', [
 								                ('p', 'Line', [
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								                    ('p::marker', 'Text', '-55.')])])]),
-												Implement ordered lists, content:counter(), counter-reset, counter-increment

											
										
										
											2011-12-07 20:09:59 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p::marker', 'Text', '1.')])])])
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
 								    assert_tree(parse_all('''
 								        <style>
 								            section:before { counter-reset: h; content: '' }
 								            h1:before { counter-increment: h; content: counters(h, '.') }
 								        </style>
 								        <body>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								            <section><h1></h1>
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								                <h1></h1>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								                <section><h1></h1>
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								                    <h1></h1>
 								                </section>
 								                <h1></h1>
 								            </section>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								        </body>'''), [
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								        ('section', 'Block', [
 								            ('section', 'AnonBlock', [
 								                ('section', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('section::before', 'Inline', [])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								            ('h1', 'Block', [
 								                ('h1', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('h1::before', 'Inline', [
 								                        ('h1::before', 'Text', '1')])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								            ('h1', 'Block', [
 								                ('h1', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('h1::before', 'Inline', [
 								                        ('h1::before', 'Text', '2')])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								            ('section', 'Block', [
 								                ('section', 'AnonBlock', [
 								                    ('section', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                        ('section::before', 'Inline', [])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								                ('h1', 'Block', [
 								                    ('h1', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                        ('h1::before', 'Inline', [
 								                            ('h1::before', 'Text', '2.1')])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								                ('h1', 'Block', [
 								                    ('h1', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                        ('h1::before', 'Inline', [
 								                            ('h1::before', 'Text', '2.2')])])])]),
-												Implement content: counters()

											
										
										
											2011-12-08 14:32:35 +04:00
+								            ('h1', 'Block', [
 								                ('h1', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                    ('h1::before', 'Inline', [
 								                        ('h1::before', 'Text', '3')])])])])])
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
-												Add a test about counter scopes

											
										
										
											2012-05-29 19:56:46 +04:00
+								    assert_tree(parse_all('''
 								        <style>
 								            p:before { content: counter(c) }
 								        </style>
 								        <div>
 								            <span style="counter-reset: c">
 								                Scope created now, deleted after the div
 								            </span>
 								        </div>
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								        <p></p>'''), [
-												Add a test about counter scopes

											
										
										
											2012-05-29 19:56:46 +04:00
+								        ('div', 'Block', [
 								            ('div', 'Line', [
 								                ('span', 'Inline', [
 								                    ('span', 'Text',
 								                     'Scope created now, deleted after the div ')])])]),
 								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::before', 'Inline', [
 								                    ('p::before', 'Text', '0')])])])])
-												Add a test about counter scopes

											
										
										
											2012-05-29 19:56:46 +04:00
-												Fix counter-increment interference with display: list-item

											
										
										
											2012-06-01 11:56:19 +04:00
+								    # counter-increment may interfere with display: list-item
 								    assert_tree(parse_all('''
 								        <p style="counter-increment: c;
-												Work around parser changes in libxml2 2.9

											
										
										
											2012-12-26 19:43:10 +04:00
+								                  display: list-item; list-style: inside decimal">'''), [
-												Fix counter-increment interference with display: list-item

											
										
										
											2012-06-01 11:56:19 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								                ('p::marker', 'Text', '0.')])])])
-												Fix counter-increment interference with display: list-item

											
										
										
											2012-06-01 11:56:19 +04:00
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+								def test_counter_styles():
 								    """Test the various counter styles."""
 								    assert_tree(parse_all('''
 								        <style>
 								            body { counter-reset: p -12 }
 								            p { counter-increment: p }
 								            p:nth-child(1):before { content: '-' counter(p, none) '-'; }
 								            p:nth-child(2):before { content: counter(p, disc); }
 								            p:nth-child(3):before { content: counter(p, circle); }
 								            p:nth-child(4):before { content: counter(p, square); }
 								            p:nth-child(5):before { content: counter(p); }
 								        </style>
 								        <p></p>
 								        <p></p>
 								        <p></p>
 								        <p></p>
 								        <p></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::before', 'Inline', [
 								                    ('p::before', 'Text', counter)])])])
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								        for counter in '--  •  ◦  ▪  -7'.split()])
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
 								    assert_tree(parse_all('''
 								        <style>
 								            p { counter-increment: p }
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								            p::before { content: counter(p, decimal-leading-zero); }
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+								        </style>
 								        <p style="counter-reset: p -1987"></p>
 								        <p></p>
 								        <p style="counter-reset: p -12"></p>
 								        <p></p>
 								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p -2"></p>
 								        <p></p>
 								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p 8"></p>
 								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p 98"></p>
 								        <p></p>
 								        <p></p>
 								        <p style="counter-reset: p 4134"></p>
 								        <p></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
-												Always use two colons for pseudo-elements

Tests now mix one and two colons in CSS, but the user agent stylesheet
and internal representation of the pseudo-elements now awlays use two
colons.

											
										
										
											2016-12-04 18:43:49 +03:00
+								                ('p::before', 'Inline', [
 								                    ('p::before', 'Text', counter)])])])
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								        for counter in '''-1986 -1985  -11 -10 -09 -08  -01 00 01 02  09 10 11
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+100 101  4135 4136'''.split()])
 								    # Same test as above, but short-circuit HTML and boxes
 								    assert [counters.format(value, 'decimal-leading-zero') for value in [
 								        -1986, -1985,  -11, -10, -9, -8,  -1, 0, 1, 2,  9, 10, 11,
 , 100, 101,  4135, 4136
 								    ]] == '''
 								        -1986 -1985  -11 -10 -09 -08  -01 00 01 02  09 10 11
 100 101  4135 4136
 								    '''.split()
 								    # Now that we’re confident that they do the same, use the shorter form.
 								# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-007.htm
 								    assert [counters.format(value, 'lower-roman') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
 , 50,  389, 390,  3489, 3490, 3491, 4999, 5000, 5001
 								    ]] == '''
 								        -1986 -1985  -1 0 i ii iii iv v vi vii viii ix x xi xii
 								        xlix l  ccclxxxix cccxc  mmmcdlxxxix mmmcdxc mmmcdxci
 								        mmmmcmxcix  5000 5001
 								    '''.split()
 								# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-008.htm
 								    assert [counters.format(value, 'upper-roman') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
 , 50,  389, 390,  3489, 3490, 3491, 4999, 5000, 5001
 								    ]] == '''
 								        -1986 -1985  -1 0 I II III IV V VI VII VIII IX X XI XII
 								        XLIX L  CCCLXXXIX CCCXC  MMMCDLXXXIX MMMCDXC MMMCDXCI
 								        MMMMCMXCIX 5000 5001
 								    '''.split()
 								    assert [counters.format(value, 'lower-alpha') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
 								    ]] == '''
 								        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
 								    '''.split()
 								    assert [counters.format(value, 'upper-alpha') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
 								    ]] == '''
 								        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
 								    '''.split()
 								    assert [counters.format(value, 'lower-latin') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
 								    ]] == '''
 								        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
 								    '''.split()
 								    assert [counters.format(value, 'upper-latin') for value in [
 								        -1986, -1985,  -1, 0, 1, 2, 3, 4,  25, 26, 27, 28, 29,  2002, 2003
 								    ]] == '''
 								        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
 								    '''.split()
 								# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-009.htm
 								    assert [counters.format(value, 'georgian') for value in [
 								        -1986, -1985,  -1, 0, 1,
 , 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
 , 30, 40, 50, 60, 70, 80, 90, 100,
 , 300, 400, 500, 600, 700, 800, 900, 1000,
 , 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000,
 , 20000, 20001
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								    ]] == '''
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+								        -1986 -1985  -1 0 ა
 								        ბ გ დ ე ვ ზ ჱ თ ი ია იბ
 								        კ ლ მ ნ ჲ ო პ ჟ რ
 								        ს ტ ჳ ფ ქ ღ ყ შ ჩ
 								        ც ძ წ ჭ ხ ჴ ჯ ჰ ჵ
 								        ჵჰშჟთ 20000 20001
 								    '''.split()
 								# http://test.csswg.org/suites/css2.1/20110323/html4/content-counter-010.htm
 								    assert [counters.format(value, 'armenian') for value in [
 								        -1986, -1985,  -1, 0, 1,
 , 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
 , 30, 40, 50, 60, 70, 80, 90, 100,
 , 300, 400, 500, 600, 700, 800, 900, 1000,
 , 3000, 4000, 5000, 6000, 7000, 8000, 9000,
 , 10000, 10001
-												Python 3 compat. All tests pass with the same code base!

											
										
										
											2012-02-17 21:49:58 +04:00
+								    ]] == '''
-												Test various counter styles

											
										
										
											2011-12-08 17:10:02 +04:00
+								        -1986 -1985  -1 0 Ա
 								        Բ Գ Դ Ե Զ Է Ը Թ Ժ ԺԱ ԺԲ
 								        Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ
 								        Մ Յ Ն Շ Ո Չ Պ Ջ Ռ
 								        Ս Վ Տ Ր Ց Ւ Փ Ք
 								        ՔՋՂԹ 10000 10001
 								    '''.split()
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								def test_margin_boxes():
 								    """
 								    Test that the correct margin boxes are created.
 								    """
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    page_1, page_2 = render_pages('''
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								        <style>
 								            @page {
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								                /* Make the page content area only 10px high and wide,
 								                   so every word in <p> end up on a page of its own. */
-												Unprefix paged media, transforms, and SVG properties

The image-rendering, transform, transform-origin and size
properties are now unprefixed.

The prefixed form (eg. -weasy-size) is ignored but gives
a specific warning.

											
										
										
											2012-07-04 13:27:20 +04:00
+								                size: 30px;
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								                margin: 10px;
 								                @top-center { content: "Title" }
 								            }
 								            @page :first {
 								                @bottom-left { content: "foo" }
 								                @bottom-left-corner { content: "baz" }
 								            }
 								        </style>
 								        <p>lorem ipsum
 								    ''')
 								    assert page_1.children[0].element_tag == 'html'
 								    assert page_2.children[0].element_tag == 'html'
 								    margin_boxes_1 = [box.at_keyword for box in page_1.children[1:]]
 								    margin_boxes_2 = [box.at_keyword for box in page_2.children[1:]]
-												Fix the Variable Dimension rules, add tests.

This implements the updated algorithm described in
https://github.com/SimonSapin/css/blob/81b5d93d0d/margin-boxes-variable-dimension

											
										
										
											2012-07-02 20:15:57 +04:00
+								    assert margin_boxes_1 == ['@top-center', '@bottom-left',
 								                              '@bottom-left-corner']
-												Create margin boxes (not laid-out correctly yet.)

											
										
										
											2011-12-28 18:34:30 +04:00
+								    assert margin_boxes_2 == ['@top-center']
 								    html, top_center = page_2.children
 								    line_box, = top_center.children
 								    text_box, = line_box.children
 								    assert text_box.text == 'Title'
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
-												PEP8/flake8 compliance

											
										
										
											2015-03-21 07:50:22 +03:00
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								@assert_no_logs
 								def test_margin_box_string_set():
-												Allow attr() in bookmark-label and string-set

											
										
										
											2015-05-01 12:06:54 +03:00
+								    """Test string-set / string() in margin boxes."""
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								    # Test that both pages get string in the `bottom-center` margin box
-												Bug fix for string-set validation not accepting no argument (default should be 'text')
Alter TEXT_CONTENT_EXTRACTORS so that string-set can use ::before/::after
 - Don't allow empty string to be assigned to string set (happends with psuedo elements)
Added some documentation to explain string function resolution

											
										
										
											2015-03-19 05:46:51 +03:00
+								    page_1, page_2 = render_pages('''
 								        <style>
 								            @page {
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								                @bottom-center { content: string(text_header); }
-												Bug fix for string-set validation not accepting no argument (default should be 'text')
Alter TEXT_CONTENT_EXTRACTORS so that string-set can use ::before/::after
 - Don't allow empty string to be assigned to string set (happends with psuedo elements)
Added some documentation to explain string function resolution

											
										
										
											2015-03-19 05:46:51 +03:00
+								            }
 								            p{
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								                -weasy-string-set: text_header content();
-												Bug fix for string-set validation not accepting no argument (default should be 'text')
Alter TEXT_CONTENT_EXTRACTORS so that string-set can use ::before/::after
 - Don't allow empty string to be assigned to string set (happends with psuedo elements)
Added some documentation to explain string function resolution

											
										
										
											2015-03-19 05:46:51 +03:00
+								            }
 								            .page{
 								                page-break-before: always;
 								            }
 								        </style>
 								        <p>first assignment</p>
 								        <div class="page"></div>
 								    ''')
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								    html, bottom_center = page_2.children
 								    line_box, = bottom_center.children
-												Bug fix for string-set validation not accepting no argument (default should be 'text')
Alter TEXT_CONTENT_EXTRACTORS so that string-set can use ::before/::after
 - Don't allow empty string to be assigned to string set (happends with psuedo elements)
Added some documentation to explain string function resolution

											
										
										
											2015-03-19 05:46:51 +03:00
+								    text_box, = line_box.children
 								    assert text_box.text == 'first assignment'
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								    html, bottom_center = page_1.children
 								    line_box, = bottom_center.children
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								    text_box, = line_box.children
 								    assert text_box.text == 'first assignment'
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								    def simple_string_set_test(content_val, extra_style=""):
 								        page_1, = render_pages('''
 								            <style>
 								                @page {
 								                    @top-center { content: string(text_header); }
 								                }
 								                p{
 								                    -weasy-string-set: text_header content(%(content_val)s);
 								                }
 								                %(extra_style)s
 								            </style>
 								            <p>first assignment</p>
-												More changes for named strings [3]
PEP8/flake8 compliance again (sorry)

											
										
										
											2015-03-22 07:30:38 +03:00
+								        ''' % dict(content_val=content_val, extra_style=extra_style))
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
 								        html, top_center = page_1.children
 								        line_box, = top_center.children
 								        text_box, = line_box.children
-												More changes for named string support
Pep8/flake8 conformance

											
										
										
											2015-03-22 02:24:13 +03:00
+								        if content_val in ('before', 'after'):
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								            assert text_box.text == 'pseudo'
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								        else:
 								            assert text_box.text == 'first assignment'
 								    # Test each accepted value of `content()` as an arguemnt to `string-set`
 								    for value in ('', 'text', 'before', 'after'):
-												More changes for named string support
Pep8/flake8 conformance

											
										
										
											2015-03-22 02:24:13 +03:00
+								        if value in ('before', 'after'):
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								            extra_style = "p:%s{content: 'pseudo'}" % value
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								            simple_string_set_test(value, extra_style)
 								        else:
 								            simple_string_set_test(value)
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								    # Test `first` (default value) ie. use the first assignment on the page
-												Remove support of string set using psuedo elements. Was unsure of the change to the function in build.TEXT_CONTENT_EXTRACTORS. That would be part of the text anyways.
Combined test functions to conform to coding style of other tests.

											
										
										
											2015-03-20 06:03:57 +03:00
+								    page_1, = render_pages('''
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								        <style>
 								            @page {
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								                @top-center { content: string(text_header, first); }
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								            }
 								            p{
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								                -weasy-string-set: text_header content();
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								            }
 								        </style>
 								        <p>first assignment</p>
-												Set `string-set` default to 'none', altered validation & resolution [do nothing in that case]
Added validation to the second argument to `string()`
More info./discussion here: https://github.com/Kozea/WeasyPrint/pull/246#issuecomment-83994925

											
										
										
											2015-03-21 07:08:12 +03:00
+								        <p>Second assignment</p>
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								    ''')
-												Remove support of string set using psuedo elements. Was unsure of the change to the function in build.TEXT_CONTENT_EXTRACTORS. That would be part of the text anyways.
Combined test functions to conform to coding style of other tests.

											
										
										
											2015-03-20 06:03:57 +03:00
+								    html, top_center = page_1.children
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								    line_box, = top_center.children
 								    text_box, = line_box.children
-												Remove support of string set using psuedo elements. Was unsure of the change to the function in build.TEXT_CONTENT_EXTRACTORS. That would be part of the text anyways.
Combined test functions to conform to coding style of other tests.

											
										
										
											2015-03-20 06:03:57 +03:00
+								    assert text_box.text == 'first assignment'
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
-												Remove support of string set using psuedo elements. Was unsure of the change to the function in build.TEXT_CONTENT_EXTRACTORS. That would be part of the text anyways.
Combined test functions to conform to coding style of other tests.

											
										
										
											2015-03-20 06:03:57 +03:00
+								    # test `first-except` ie. exclude from page on which value is assigned
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								    page_1, page_2 = render_pages('''
 								        <style>
 								            @page {
 								                @top-center { content: string(header_nofirst, first-except); }
 								            }
 								            p{
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								                -weasy-string-set: header_nofirst content();
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								            }
 								            .page{
 								                page-break-before: always;
 								            }
 								        </style>
 								        <p>first_excepted</p>
 								        <div class="page"></div>
 								    ''')
 								    html, top_center = page_1.children
 								    assert len(top_center.children) == 0
 								    html, top_center = page_2.children
 								    line_box, = top_center.children
 								    text_box, = line_box.children
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								    assert text_box.text == 'first_excepted'
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
-												PEP8/flake8 compliance

											
										
										
											2015-03-21 07:50:22 +03:00
+								    # Test `last` ie. use the most-recent assignment
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								    page_1, = render_pages('''
 								        <style>
 								            @page {
 								                @top-center { content: string(header_last, last); }
 								            }
 								            p{
-												More changes for named string support
Reinstate support for psuedo elements as an arugument to `content()`
Have to check if a box is a `ParentBox` when using `decendants()` in `TEXT_CONTENT_EXTRACTORS` for psuedo elements because it was returning the value twice in a row (ex. "stringstring")

											
										
										
											2015-03-22 01:54:14 +03:00
+								                -weasy-string-set: header_last content();
-												Basic support for named strings. String-set limited to one value.

											
										
										
											2015-03-09 06:02:51 +03:00
+								            }
 								        </style>
 								        <p>String set</p>
 								        <p>Second assignment</p>
 								    ''')
 								    html, top_center = page_1.children[:2]
 								    line_box, = top_center.children
 								    text_box, = line_box.children
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								    assert text_box.text == 'Second assignment'
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								    # Test multiple complex string-set values
 								    page_1, = render_pages('''
 								        <style>
 								            @page {
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								              @top-center { content: string(text_header, first); }
 								              @bottom-center { content: string(text_footer, last); }
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								            }
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								            html { counter-reset: a }
 								            body { counter-increment: a }
 								            ul { counter-reset: b }
 								            li {
 								              counter-increment: b;
 								              -weasy-string-set:
 								                text_header content(before) "-" content() "-" content(after)
 								                            counter(a, upper-roman) '.' counters(b, '|'),
 								                text_footer content(before) '-' attr(class)
 								                            counters(b, '|') "/" counter(a, upper-roman);
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								            }
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								            li:before { content: 'before!' }
 								            li:after { content: 'after!' }
 								            li:last-child:before { content: 'before!last' }
 								            li:last-child:after { content: 'after!last' }
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								        </style>
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								        <ul>
 								          <li class="firstclass">first
 								          <li>
 								            <ul>
 								              <li class="secondclass">second
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								    ''')
 								    html, top_center, bottom_center = page_1.children
 								    top_line_box, = top_center.children
 								    top_text_box, = top_line_box.children
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								    assert top_text_box.text == 'before!-first-after!I.1'
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
+								    bottom_line_box, = bottom_center.children
 								    bottom_text_box, = bottom_line_box.children
-												Fix attr() and allow counters in string-set and bookmark-label

											
										
										
											2015-05-01 21:28:42 +03:00
+								    assert bottom_text_box.text == 'before!last-secondclass2|1/I'
-												Use the <content-list> defined in GCPM for string-set and bookmark-label

In this content-list, here are the possibilities:
- string: implemented
- counter/counters: not implemented, but easily possible
- content: implemented (but what's exactly the "string value of an element"?)
- attr: not implemented (I don't know how to do this)

											
										
										
											2015-04-30 22:54:19 +03:00
-												PEP8/flake8 compliance

											
										
										
											2015-03-21 07:50:22 +03:00
-												Switch to pytest

											
										
										
											2012-02-20 16:04:35 +04:00
+								@assert_no_logs
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								def test_page_counters():
 								    """Test page-based counters."""
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    pages = render_pages('''
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								        <style>
 								            @page {
 								                /* Make the page content area only 10px high and wide,
 								                   so every word in <p> end up on a page of its own. */
-												Unprefix paged media, transforms, and SVG properties

The image-rendering, transform, transform-origin and size
properties are now unprefixed.

The prefixed form (eg. -weasy-size) is ignored but gives
a specific warning.

											
										
										
											2012-07-04 13:27:20 +04:00
+								                size: 30px;
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								                margin: 10px;
 								                @bottom-center {
 								                    content: "Page " counter(page) " of " counter(pages) ".";
 								                }
 								            }
 								        </style>
 								        <p>lorem ipsum dolor
 								    ''')
-												Get rid of the Document class (finally!)

											
										
										
											2012-09-25 18:01:47 +04:00
+								    for page_number, page in enumerate(pages, 1):
-												Implement page-based counters.

Currently in the page context only the 'page' and 'pages' counters are
available, and counter-reset and counter-increment have no effect at all.

											
										
										
											2012-01-17 18:40:26 +04:00
+								        html, bottom_center = page.children
 								        line_box, = bottom_center.children
 								        text_box, = line_box.children
-												Actual python 2.6 compatibility

											
										
										
											2012-02-21 17:13:34 +04:00
+								        assert text_box.text == 'Page {0} of 3.'.format(page_number)
-												Add border conflict resolution for border-collapse

(No layout or painting yet.)

											
										
										
											2012-07-11 16:11:26 +04:00
-												PEP8/flake8 compliance

											
										
										
											2015-03-21 07:50:22 +03:00
-												Add border conflict resolution for border-collapse

(No layout or painting yet.)

											
										
										
											2012-07-11 16:11:26 +04:00
+								@assert_no_logs
 								def test_border_collapse():
 								    html = parse_all('<table></table>')
 								    body, = html.children
 								    table_wrapper, = body.children
 								    table, = table_wrapper.children
 								    assert isinstance(table, boxes.TableBox)
 								    assert not hasattr(table, 'collapsed_border_grid')
 								    def get_grid(html):
 								        html = parse_all(html)
 								        body, = html.children
 								        table_wrapper, = body.children
 								        table, = table_wrapper.children
 								        return tuple(
 								            [[(style, width, color) if width else None
-												Flake8.

											
										
										
											2013-04-11 14:08:53 +04:00
+								              for _score, (style, width, color) in column]
 								             for column in grid]
-												Add border conflict resolution for border-collapse

(No layout or painting yet.)

											
										
										
											2012-07-11 16:11:26 +04:00
+								            for grid in table.collapsed_border_grid)
 								    grid = get_grid('<table style="border-collapse: collapse"></table>')
 								    assert grid == ([], [])
 								    black = (0, 0, 0, 1)
 								    red = (1, 0, 0, 1)
 								    green = (0, 1, 0, 1)  # lime in CSS
 								    blue = (0, 0, 1, 1)
 								    yellow = (1, 1, 0, 1)
 								    vertical_borders, horizontal_borders = get_grid('''
 								        <style>td { border: 1px solid red }</style>
 								        <table style="border-collapse: collapse; border: 3px solid black">
 								            <tr> <td>A</td> <td>B</td> </tr>
 								            <tr> <td>C</td> <td>D</td> </tr>
 								        </table>
 								    ''')
 								    black_3 = ('solid', 3, black)
 								    red_1 = ('solid', 1, red)
 								    assert vertical_borders == [
 								        [black_3, red_1, black_3],
 								        [black_3, red_1, black_3],
 								    ]
 								    assert horizontal_borders == [
 								        [black_3, black_3],
 								        [red_1, red_1],
 								        [black_3, black_3],
 								    ]
 								    # hidden vs. none
 								    vertical_borders, horizontal_borders = get_grid('''
 								        <style>table, td { border: 3px solid }</style>
 								        <table style="border-collapse: collapse">
 								            <tr> <td>A</td> <td style="border-style: hidden">B</td> </tr>
 								            <tr> <td>C</td> <td style="border-style: none">D</td> </tr>
 								        </table>
 								    ''')
 								    assert vertical_borders == [
 								        [black_3, None, None],
 								        [black_3, black_3, black_3],
 								    ]
 								    assert horizontal_borders == [
 								        [black_3, None],
 								        [black_3, None],
 								        [black_3, black_3],
 								    ]
 								    yellow_5 = ('solid', 5, yellow)
 								    green_5 = ('solid', 5, green)
 								    dashed_blue_5 = ('dashed', 5, blue)
 								    vertical_borders, horizontal_borders = get_grid('''
 								        <style>td { border: 1px solid red }</style>
 								        <table style="border-collapse: collapse; border: 5px solid yellow">
 								            <col style="border: 3px solid black" />
 								            <tr> <td></td> <td></td> <td></td> </tr>
 								            <tr> <td></td> <td style="border: 5px dashed blue"></td>
 								                 <td style="border: 5px solid lime"></td> </tr>
 								            <tr> <td></td> <td></td> <td></td> </tr>
 								            <tr> <td></td> <td></td> <td></td> </tr>
 								        </table>
 								    ''')
 								    assert vertical_borders == [
 								        [yellow_5, black_3, red_1, yellow_5],
 								        [yellow_5, dashed_blue_5, green_5, green_5],
 								        [yellow_5, black_3, red_1, yellow_5],
 								        [yellow_5, black_3, red_1, yellow_5],
 								    ]
 								    assert horizontal_borders == [
 								        [yellow_5, yellow_5, yellow_5],
 								        [red_1, dashed_blue_5, green_5],
 								        [red_1, dashed_blue_5, green_5],
 								        [red_1, red_1, red_1],
 								        [yellow_5, yellow_5, yellow_5],
 								    ]
 								    # rowspan and colspan
 								    vertical_borders, horizontal_borders = get_grid('''
 								        <style>col, tr { border: 3px solid }</style>
 								        <table style="border-collapse: collapse">
 								            <col /><col /><col />
 								            <tr> <td rowspan=2></td> <td></td> <td></td> </tr>
 								            <tr>                     <td colspan=2></td> </tr>
 								        </table>
 								    ''')
 								    assert vertical_borders == [
 								        [black_3, black_3, black_3, black_3],
 								        [black_3, black_3, None, black_3],
 								    ]
 								    assert horizontal_borders == [
 								        [black_3, black_3, black_3],
 								        [None, black_3, black_3],
 								        [black_3, black_3, black_3],
 								    ]