You may optionally pass in TextProperties to use for negative and

        positive amounts, respectively. If you don't, negative values will

        automatically be rendered in red (text color #f00).

        Results are cached. If you repeatedly call this method with the same

        arguments, you'll keep getting the same style returned, which will

        only be added to the document once.

        """

        if locale is None:

            locale = self.locale

        if negative_properties is None:

            negative_properties = odf.style.TextProperties(color='#ff0000')

        if root is None:

            root = self.document.styles

        cache_parts = [str(id(root)), code, str(locale)]

        for key, value in self.iter_attributes(negative_properties):

            cache_parts.append(f'{key}={value}')

        if positive_properties is not None:

            cache_parts.append('')

            for key, value in self.iter_attributes(positive_properties):

                cache_parts.append(f'{key}={value}')

        cache_key = '\0'.join(cache_parts)

        try:

            style = self._style_cache[cache_key]

        except KeyError:

            pos_style = self._build_currency_style(

                root, locale, code, 0, positive_properties, volatile=True,

            )

            curr_style = self._build_currency_style(

                root, locale, code, 1, negative_properties,

            )

            curr_style.addElement(odf.style.Map(

                condition='value()>=0', applystylename=pos_style,

            ))

            style = self.ensure_child(

                self.document.styles,

                odf.style.Style,

                name=f'{curr_style.getAttribute("name")}Cell',

                family='table-cell',

                datastylename=curr_style,

            )

            self._style_cache[cache_key] = style

        return style

    def _merge_style_iter_names(

            self,

            styles: Sequence[Union[str, odf.style.Style, None]],

    ) -> Iterator[str]:

        for source in styles:

            if source is None:

                continue

            elif not isinstance(source, str):

                source = source.getAttribute('name')

            if source.startswith('Merge_'):

                orig_names = iter(source.split('_'))

                next(orig_names)

                yield from orig_names

            else:

                yield source

    def _merge_styles(self,

                      new_style: odf.style.Style,

                      sources: Iterable[odf.style.Style],

    ) -> None:

        for elem in sources:

            for key, new_value in self.iter_attributes(elem):

                old_value = new_style.getAttribute(key)

                if (key == 'name'

                    or key == 'displayname'

                    or old_value == new_value):

                    pass

                elif old_value is None:

                    new_style.setAttribute(key, new_value)

                else:

                    raise ValueError(f"cannot merge styles with conflicting {key}")

            for child in elem.childNodes:

                new_style.addElement(self.copy_element(child))

    def merge_styles(self,

                     *styles: Union[str, odf.style.Style, None],

    ) -> Optional[odf.style.Style]:

        """Create a new style from multiple existing styles

        Given any number of existing styles, create a new style that combines

        all of those styles' attributes and properties, add it to the document

        styles, and return it.

        Styles can be specified by name, or by passing in their Style element.

        For convenience, you can also pass in None as an argument; None will

        simply be skipped.

        Results are cached. If you repeatedly call this method with the same

        arguments, you'll keep getting the same style returned, which will

        only be added to the document once.

        If you pass in zero real style arguments, returns None.

        If you pass in one style argument, returns that style unchanged.

        If you pass in a style that doesn't already exist in the document,

        or if you pass in styles that can't be merged (because they have

        conflicting attributes), raises ValueError.

        """

        name_map: Dict[str, odf.style.Style] = {}

        for name in self._merge_style_iter_names(styles):

            source = odf.style.Style(name=name)

            found = self.find_child(self.document.styles, source)

            if found is None:

                raise ValueError(f"no style named {name!r}")

            name_map[name] = found

        if not name_map:

            retval = None

        elif len(name_map) == 1:

            _, retval = name_map.popitem()

        else:

            new_name = f'Merge_{"_".join(sorted(name_map))}'

            retval = self.ensure_child(

                self.document.styles, odf.style.Style, name=new_name,

            )

            if retval.firstChild is None:

                self._merge_styles(retval, name_map.values())

        return retval

    ### Sheets

    def lock_first_row(self, sheet: Optional[odf.table.Table]=None) -> None:

        """Lock the first row of cells under the given sheet

        This method sets all the appropriate settings to "lock" the first row

        of cells in a sheet, so it stays in view even as the viewer scrolls

        through rows. If a sheet is not given, works on ``self.sheet``.

        """

        if sheet is None:

            sheet = self.sheet

        config_map = self.ensure_config_map_entry(

            self.view, 'Tables', sheet.getAttribute('name'),

        )

        self.set_config(config_map, 'PositionBottom', 1, 'int')

        self.set_config(config_map, 'VerticalSplitMode', 2, 'short')

        self.set_config(config_map, 'VerticalSplitPosition', 1, 'short')

    def use_sheet(self, name: str) -> odf.table.Table:

        """Switch the active sheet ``self.sheet`` to the one with the given name

        If there is no sheet with the given name, create it and append it to

        the spreadsheet first.

        If the current active sheet is empty when this method is called, it

        will be removed from the spreadsheet.

        """

        try:

            empty_sheet = not self.sheet.hasChildNodes()

        except AttributeError:

            empty_sheet = False

        if empty_sheet:

            self.document.spreadsheet.removeChild(self.sheet)

        self.sheet = self.ensure_child(

            self.document.spreadsheet, odf.table.Table, name=name,

        )

        return self.sheet

    ### Initialization hooks

    def init_settings(self) -> None:

        """Hook called to initialize settings

        This method is called by __init__ to populate

        ``self.document.settings``. This implementation creates the barest

        skeleton structure necessary to support other methods, in particular

        ``lock_first_row``.

        """

        view_settings = self.ensure_child(

            self.document.settings, odf.config.ConfigItemSet, name='ooo:view-settings',

        )

        views = self.ensure_child(

            view_settings, odf.config.ConfigItemMapIndexed, name='Views',

        )

        self.view = self.ensure_child(views, odf.config.ConfigItemMapEntry)

        self.set_config(self.view, 'ViewId', 'view1')

    def init_styles(self) -> None:

        """Hook called to initialize settings

        This method is called by __init__ to populate

        ``self.document.styles``. This implementation creates basic building

        block cell styles often used in financial reports.

        """

        styles = self.document.styles

        self.style_bold = self.ensure_child(

            styles, odf.style.Style, name='Bold', family='table-cell',

        )

        self.ensure_child(

            self.style_bold, odf.style.TextProperties, fontweight='bold',

        )

        date_style = self.replace_child(styles, odf.number.DateStyle, name='ISODate')

        date_style.addElement(odf.number.Year(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Month(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Day(style='long'))

        self.style_date = self.ensure_child(

            styles,

            odf.style.Style,

            name=f'{date_style.getAttribute("name")}Cell',

            family='table-cell',

            datastylename=date_style,

        )

        self.style_starttext: odf.style.Style

        self.style_centertext: odf.style.Style

        self.style_endtext: odf.style.Style

        for textalign in ['start', 'center', 'end']:

            aligned_style = self.replace_child(

                styles, odf.style.Style, name=f'{textalign.title()}Text',

            )

            aligned_style.setAttribute('family', 'table-cell')

            aligned_style.addElement(odf.style.ParagraphProperties(textalign=textalign))

            setattr(self, f'style_{textalign}text', aligned_style)

    ### Rows and cells

    def add_row(self, *cells: odf.table.TableCell, **attrs: Any) -> odf.table.TableRow:

        row = odf.table.TableRow(**attrs)

        for cell in cells:

            row.addElement(cell)

        self.sheet.addElement(row)

        return row

    def balance_cell(self, balance: Balance, **attrs: Any) -> odf.table.TableCell:

        balance = balance.clean_copy() or balance

        balance_currency_count = len(balance)

        if balance_currency_count == 0:

            return self.float_cell(0, **attrs)

        elif balance_currency_count == 1:

            amount = next(iter(balance.values()))

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.currency_style(amount.currency),

            )

            return self.currency_cell(amount, **attrs)

        else:

            lines = [babel.numbers.format_currency(

                number, currency, locale=self.locale, format_type=self.currency_fmt_key,

            ) for number, currency in balance.values()]

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.style_endtext,

            )

            return self.multiline_cell(lines, **attrs)

    def currency_cell(self, amount: data.Amount, **attrs: Any) -> odf.table.TableCell:

        if 'stylename' not in attrs:

            attrs['stylename'] = self.currency_style(amount.currency)

        number, currency = amount

        cell = odf.table.TableCell(valuetype='currency', value=number, **attrs)

        cell.addElement(odf.text.P(text=babel.numbers.format_currency(

            number, currency, locale=self.locale, format_type=self.currency_fmt_key,

        )))

        return cell

    def date_cell(self, date: datetime.date, **attrs: Any) -> odf.table.TableCell:

        attrs.setdefault('stylename', self.style_date)

        cell = odf.table.TableCell(valuetype='date', datevalue=date, **attrs)

        cell.addElement(odf.text.P(text=date.isoformat()))

        return cell

    def float_cell(self, value: Union[int, float, Decimal], **attrs: Any) -> odf.table.TableCell:

        cell = odf.table.TableCell(valuetype='float', value=value, **attrs)

        cell.addElement(odf.text.P(text=str(value)))

        return cell

    def _meta_link_pairs(self, links: Iterable[Optional[str]]) -> Iterator[Tuple[str, str]]:

        for href in links:

            if href is None:

                continue

            elif self.rt_wrapper is not None:

                rt_ids = self.rt_wrapper.parse(href)

                rt_href = rt_ids and self.rt_wrapper.url(*rt_ids)

            else:

                rt_ids = None

                rt_href = None

            if rt_ids is None or rt_href is None:

                # '..' pops the ODS filename off the link path. In other words,

                # make the link relative to the directory the ODS is in.

                href_path = Path('..', href)

                href = str(href_path)

                text = href_path.name

            else:

                rt_path = urlparse.urlparse(rt_href).path

                if rt_path.endswith('/Ticket/Display.html'):

                    text = rtutil.RT.unparse(*rt_ids)

                else:

                    text = urlparse.unquote(Path(rt_path).name)

                href = rt_href

            yield (href, text)

    def meta_links_cell(self, links: Iterable[Optional[str]], **attrs: Any) -> odf.table.TableCell:

        return self.multilink_cell(self._meta_link_pairs(links), **attrs)

    def multiline_cell(self, lines: Iterable[Any], **attrs: Any) -> odf.table.TableCell:

        cell = odf.table.TableCell(valuetype='string', **attrs)

        for line in lines:

            cell.addElement(odf.text.P(text=str(line)))

        return cell

    def multilink_cell(self, links: Iterable[LinkType], **attrs: Any) -> odf.table.TableCell:

        cell = odf.table.TableCell(valuetype='string', **attrs)

        for link in links:

            if isinstance(link, tuple):

                href, text = link

            else:

                href = link

                text = None

            cell.addElement(odf.text.P())

            cell.lastChild.addElement(odf.text.A(

                type='simple', href=href, text=text or href,

            ))

        return cell

    def string_cell(self, text: str, **attrs: Any) -> odf.table.TableCell:

        cell = odf.table.TableCell(valuetype='string', **attrs)

        cell.addElement(odf.text.P(text=text))

        return cell

    def write_row(self, row: RT) -> None:

        """Write a single row of input data to the spreadsheet

        This default implementation adds a single row to the spreadsheet,

        with one cell per element of the row. The type of each element

        determines what kind of cell is created.

        This implementation will help get you started, but you'll probably

        want to override it to specify styles.

        """

        out_row = odf.table.TableRow()

        for cell_source in row:

            if isinstance(cell_source, (int, float, Decimal)):

                cell = self.float_cell(cell_source)

            else:

                cell = self.string_cell(cell_source)

            out_row.addElement(cell)

        self.sheet.addElement(out_row)

    def save_file(self, out_file: BinaryIO) -> None:

        self.document.write(out_file)

    def save_path(self, path: Path, mode: str='w') -> None:

        with path.open(f'{mode}b') as out_file:

            out_file = cast(BinaryIO, out_file)

            self.save_file(out_file)

def account_balances(

        groups: Mapping[data.Account, PeriodPostings],

        order: Optional[Sequence[str]]=None,

) -> Iterator[Tuple[str, Balance]]:

    """Iterate account balances over a date range

    1. ``subclass = PeriodPostings.with_start_date(start_date)``

    2. ``groups = dict(subclass.group_by_account(postings))``

    3. ``for acct, bal in account_balances(groups, [optional ordering]): ...``

    This function returns an iterator of 2-tuples ``(account, balance)``

    that you can use to generate a report in the style of ``ledger balance``.

    The accounts are accounts in ``groups`` that appeared under one of the

    account name strings in ``order``. ``balance`` is the corresponding

    balance over the time period (``groups[key].period_bal``). Accounts are

    iterated in the order provided by ``sort_and_filter_accounts()``.

    The first 2-tuple is ``(OPENING_BALANCE_NAME, balance)`` with the balance of

    all these accounts as of ``start_date``.

    The final 2-tuple is ``(ENDING_BALANCE_NAME, balance)`` with the final

    balance of all these accounts as of ``start_date``.

    The iterator will always yield these special 2-tuples, even when there are

    no accounts in the input or to report.

    """

    if order is None:

        order = ['Equity', 'Income', 'Expenses']

    acct_seq = [account for _, account in sort_and_filter_accounts(groups, order)]

    yield (OPENING_BALANCE_NAME, sum(

        (groups[key].start_bal for key in acct_seq),

        MutableBalance(),

    ))

    for key in acct_seq:

        postings = groups[key]

        try:

            in_date_range = postings[-1].meta.date >= postings.START_DATE

    try:

        return get_children(parent, child_type, **kwargs)[index]

    except IndexError:

        raise ValueError("no matching child found") from None

def iter_text(parent):

    for child in parent.childNodes:

        if isinstance(child, odf.element.Text):

            yield child.data

        else:

            yield from iter_text(child)

def get_text(parent, joiner=''):

    return joiner.join(iter_text(parent))

def check_currency_style(curr_style):

    child_names = {child.tagName for child in curr_style.childNodes}

    assert odf.number.Number().tagName in child_names

    assert len(child_names) > 1

def test_spreadsheet(spreadsheet):

    rows = [(ch, ii) for ii, ch in enumerate('aabbcc', 1)]

    spreadsheet.write(iter(rows))

    assert spreadsheet.written_rows == rows

    assert spreadsheet.ended_sections == spreadsheet.started_sections

    assert spreadsheet.started_sections == list('abc')

    assert spreadsheet.start_call == []

    assert spreadsheet.end_call == spreadsheet.ended_sections

def test_empty_spreadsheet(spreadsheet):

    empty_list = []

    spreadsheet.write(iter(empty_list))

    assert spreadsheet.start_call == empty_list

    assert spreadsheet.end_call == empty_list

    assert spreadsheet.started_sections == empty_list

    assert spreadsheet.ended_sections == empty_list

    assert spreadsheet.written_rows == empty_list

def test_one_section_spreadsheet(spreadsheet):

    rows = [('A', n) for n in range(1, 4)]

    spreadsheet.write(iter(rows))

    assert spreadsheet.written_rows == rows

    assert spreadsheet.ended_sections == spreadsheet.started_sections

    assert spreadsheet.started_sections == list('A')

    assert spreadsheet.start_call == []

    assert spreadsheet.end_call == spreadsheet.ended_sections

def test_ods_writer(ods_writer):

    rows = [(ch, ii) for ii, ch in enumerate('aabbcc', 1)]

    ods_writer.write(iter(rows))

    sheets = ods_writer.document.getElementsByType(odf.table.Table)

    assert len(sheets) == 1

    for exp_row, act_row in zip(rows, testutil.ODSCell.from_sheet(sheets[0])):

        expected1, expected2 = exp_row

        actual1, actual2 = act_row

        assert actual1.value_type == 'string'

        assert actual1.text == expected1

        assert actual2.value_type == 'float'

        assert actual2.value == expected2

        assert actual2.text == str(expected2)

@pytest.mark.parametrize('save_type', ['file', 'path'])

def test_ods_writer_save(tmp_path, save_type):

    rows = list(zip('ABC', 'abc'))

    ods_writer = ODSTester()

    ods_writer.write(iter(rows))

    if save_type == 'file':

        ods_output = io.BytesIO()

        ods_writer.save_file(ods_output)

        ods_output.seek(0)

    else:

        ods_output = tmp_path / 'SavePathTest.ods'

        ods_writer.save_path(ods_output)

    for exp_row, act_row in zip(rows, testutil.ODSCell.from_ods_file(ods_output)):

        assert len(exp_row) == len(act_row)

        for expected, actual in zip(exp_row, act_row):

            assert actual.value_type == 'string'

            assert actual.value is None

            assert actual.text == expected

def test_ods_writer_use_sheet(ods_writer):

    names = ['One', 'Two']

    for name in names:

        ods_writer.use_sheet(name)

        ods_writer.write([(name,)])

    ods_writer.use_sheet('End')

    sheets = ods_writer.document.getElementsByType(odf.table.Table)

    assert len(sheets) == len(names) + 1

    for name, sheet in zip(names, sheets):

        texts = [cell.text for row in testutil.ODSCell.from_sheet(sheet)

                 for cell in row]

        assert texts == [name]

def test_ods_writer_use_sheet_returns_to_prior_sheets(ods_writer):

    names = ['One', 'Two']

    sheets = []

    for name in names:

        sheets.append(ods_writer.use_sheet(name))

        ods_writer.write([(name,)])

    for name, expected in zip(names, sheets):

        actual = ods_writer.use_sheet(name)

        assert actual is expected

        texts = [cell.text for row in testutil.ODSCell.from_sheet(actual)

                 for cell in row]

        assert texts == [name]

def test_ods_writer_use_sheet_discards_unused_sheets(ods_writer):

    ods_writer.use_sheet('Three')

    ods_writer.use_sheet('Two')

    ods_writer.use_sheet('One')

    sheets = ods_writer.document.getElementsByType(odf.table.Table)

    assert len(sheets) == 1

    assert sheets[0].getAttribute('name') == 'One'

@pytest.mark.parametrize('width,expect_name', [

    ('.750', 'col_0_75in'),

    (2, 'col_2in'),

    ('2.2in', 'col_2_2in'),

    (3.5, 'col_3_5in'),

    ('4cm', 'col_4cm'),

])

def test_ods_column_style(ods_writer, width, expect_name):

    style = ods_writer.column_style(width)

    assert style.getAttribute('name') == expect_name

    assert style.getAttribute('family') == 'table-column'

    curr_style = get_child(

        ods_writer.document.automaticstyles,

        odf.style.Style,

        name=expect_name,

    )

    assert get_child(

        curr_style,

        odf.style.TableColumnProperties,

        columnwidth=expect_name[4:].replace('_', '.'),

    )

def test_ods_column_style_caches(ods_writer):

    int_width = ods_writer.column_style('1in')

    float_width = ods_writer.column_style('1.00in')

    assert int_width is float_width

@pytest.mark.parametrize('width', [

    '1mi',

    '0in',

    '-1cm',

    'in',

    '.cm',

])

def test_ods_column_style_invalid_width(ods_writer, width):

    with pytest.raises(ValueError):

        ods_writer.column_style(width)

@pytest.mark.parametrize('currency_code', [

    'USD',

    'EUR',

    'BRL',

])

def test_ods_currency_style(ods_writer, currency_code):

    style = ods_writer.currency_style(currency_code)

    assert style.getAttribute('family') == 'table-cell'

    curr_style = get_child(

        ods_writer.document.styles,

        odf.number.CurrencyStyle,

        name=style.getAttribute('datastylename'),

    )

    check_currency_style(curr_style)

    mappings = get_children(curr_style, odf.style.Map)

    assert mappings

    for mapping in mappings:

        check_currency_style(get_child(

            ods_writer.document.styles,

            odf.number.CurrencyStyle,

            name=mapping.getAttribute('applystylename'),

        ))

def test_ods_currency_style_caches(ods_writer):

    expected = ods_writer.currency_style('USD')

    _ = ods_writer.currency_style('EUR')

    actual = ods_writer.currency_style('USD')

    assert actual is expected

def test_ods_currency_style_cache_considers_properties(ods_writer):

    bold_text = odf.style.TextProperties(fontweight='bold')

    plain = ods_writer.currency_style('USD')

    bold = ods_writer.currency_style('USD', positive_properties=bold_text)

    assert plain is not bold

    assert plain.getAttribute('name') != bold.getAttribute('name')

    assert plain.getAttribute('datastylename') != bold.getAttribute('datastylename')

@pytest.mark.parametrize('attr_name,child_type,checked_attr', [

    ('style_bold', odf.style.TextProperties, 'fontweight'),

    ('style_centertext', odf.style.ParagraphProperties, 'textalign'),

    ('style_endtext', odf.style.ParagraphProperties, 'textalign'),

    ('style_starttext', odf.style.ParagraphProperties, 'textalign'),

])

def test_ods_writer_style(ods_writer, attr_name, child_type, checked_attr):

    root = ods_writer.document.styles

    style = getattr(ods_writer, attr_name)

    actual = get_child(root, odf.style.Style, name=style.getAttribute('name'))

    assert actual is style

    child = get_child(actual, child_type)

    assert child.getAttribute(checked_attr)

@pytest.mark.parametrize('edges,width,style,color', [

    (core.Border.TOP,

     '5px', 'solid', '#ff0000'),

    (core.Border.RIGHT | core.Border.LEFT,

     '2pt', 'dashed', '#00ff00'),

    (core.Border.BOTTOM | core.Border.RIGHT | core.Border.LEFT,

     '1em', 'dotted', '#0000ff'),

    (core.Border.TOP | core.Border.BOTTOM | core.Border.RIGHT | core.Border.LEFT,

     '1cm', 'thick', '#aaaaaa'),

])

def test_ods_writer_border_style(ods_writer, edges, width, style, color):

    actual = ods_writer.border_style(edges, width, style, color)

    props, = actual.childNodes

    attr_s = f'{width} {style} {color}'

    for edge_exp, edge_name in enumerate(['top', 'right', 'bottom', 'left']):

        expected = attr_s if edges & (2 ** edge_exp) else None

        assert props.getAttribute(f'border{edge_name}') == expected

def test_ods_writer_border_style_caches(ods_writer):

    expected = ods_writer.border_style(core.Border.TOP)

    width, style, color = expected.childNodes[0].getAttribute('bordertop').split()

    actual = ods_writer.border_style(core.Border.TOP, width, style, color)

    assert actual is expected

@pytest.mark.parametrize('argname,val1,val2', [

    ('edges', core.Border.TOP, core.Border.LEFT),

    ('edges', core.Border.TOP, core.Border.TOP | core.Border.BOTTOM),

    ('style', 'solid', 'dashed'),

    ('width', '1px', '1em'),

    ('width', '1px', '2px'),

    ('color', '#0000fe', '#0000ff'),

])

def test_ods_writer_border_no_caching(ods_writer, argname, val1, val2):

    kwargs = {'edges': core.Border.TOP}

    kwargs[argname] = val1

    style1 = ods_writer.border_style(**kwargs)

    kwargs[argname] = val2

    style2 = ods_writer.border_style(**kwargs)

    assert style1 is not style2

def test_ods_writer_merge_styles(ods_writer):

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style.getAttribute('name'),

    )

    assert actual is style

    assert actual.getAttribute('family') == 'table-cell'

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

    cell_props = get_child(actual, odf.style.TableCellProperties)

    assert cell_props.getAttribute('borderbottom')

def test_ods_writer_merge_styles_with_children_and_attributes(ods_writer):

    jpy_style = ods_writer.currency_style('JPY')

    style = ods_writer.merge_styles(ods_writer.style_bold, jpy_style)

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style.getAttribute('name'),

    )

    assert actual is style

    assert actual.getAttribute('family') == 'table-cell'

    assert actual.getAttribute('datastylename') == jpy_style.getAttribute('datastylename')

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

def test_ods_writer_merge_styles_caches(ods_writer):

    style1 = ods_writer.merge_styles(*sources)

    style2 = ods_writer.merge_styles(*reversed(sources))

    assert style1 is style2

    assert get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style1.getAttribute('name'),

    )

def test_ods_writer_layer_merge_styles(ods_writer):

    usd_style = ods_writer.currency_style('USD')

    layer2 = ods_writer.merge_styles(layer1, usd_style)

    style_name = layer2.getAttribute('name')

    assert style_name.count('Merge_') == 1

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style_name,

    )

    assert actual is layer2

    assert actual.getAttribute('family') == 'table-cell'

    assert actual.getAttribute('datastylename') == usd_style.getAttribute('datastylename')

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

    cell_props = get_child(actual, odf.style.TableCellProperties)

    assert cell_props.getAttribute('borderbottom')

def test_ods_writer_merge_one_style(ods_writer):

    actual = ods_writer.merge_styles(None, ods_writer.style_bold)

    assert actual is ods_writer.style_bold

def test_ods_writer_merge_no_styles(ods_writer):

    assert ods_writer.merge_styles() is None

def test_ods_writer_merge_nonexistent_style(ods_writer):

    name = 'Non Existent Style'

    with pytest.raises(ValueError, match=repr(name)):

        ods_writer.merge_styles(ods_writer.style_bold, name)

def test_ods_writer_merge_conflicting_styles(ods_writer):

    sources = [ods_writer.currency_style(code) for code in ['USD', 'EUR']]

    with pytest.raises(ValueError, match='conflicting datastylename'):

        ods_writer.merge_styles(*sources)

def test_ods_writer_date_style(ods_writer):

    data_style_name = ods_writer.style_date.getAttribute('datastylename')

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        family='table-cell',

        datastylename=data_style_name,

    )

    assert actual is ods_writer.style_date

    data_style = get_child(

        ods_writer.document.styles,

        odf.number.DateStyle,

        name=data_style_name,

    )

    assert len(data_style.childNodes) == 5

    year, t1, month, t2, day = data_style.childNodes

    assert year.qname[1] == 'year'

    assert year.getAttribute('style') == 'long'

    assert get_text(t1) == '-'

    assert month.qname[1] == 'month'

    assert month.getAttribute('style') == 'long'

    assert get_text(t2) == '-'

    assert day.qname[1] == 'day'

    assert day.getAttribute('style') == 'long'

def test_ods_lock_first_row(ods_writer):

    ods_writer.lock_first_row()

    view_settings = get_child(

        ods_writer.document.settings,

        odf.config.ConfigItemSet,

        name='ooo:view-settings',

    )

    views = get_child(view_settings, odf.config.ConfigItemMapIndexed, name='Views')

    view1 = get_child(views, odf.config.ConfigItemMapEntry, index=0)

    config_map = get_child(view1, odf.config.ConfigItemMapNamed, name='Tables')

    sheet_name = ods_writer.sheet.getAttribute('name')

    config_entry = get_child(config_map, odf.config.ConfigItemMapEntry, name=sheet_name)

    for name, ctype, value in [

            ('PositionBottom', 'int', '1'),

            ('VerticalSplitMode', 'short', '2'),

            ('VerticalSplitPosition', 'short', '1'),

    ]:

        child = get_child(config_entry, odf.config.ConfigItem, name=name)

        assert child.getAttribute('type') == ctype

        assert child.firstChild.data == value

@pytest.mark.parametrize('style_name', XML_NAMES_LIST)

def test_ods_writer_add_row(ods_writer, style_name):

    cell1 = ods_writer.string_cell('one')

    cell2 = ods_writer.float_cell(42.0)

    row = ods_writer.add_row(cell1, cell2, defaultcellstylename=style_name)

    assert ods_writer.sheet.lastChild is row

    assert row.getAttribute('defaultcellstylename') == style_name

    assert row.firstChild is cell1

    assert row.lastChild is cell2

def test_ods_writer_add_row_single_cell(ods_writer):

    cell = ods_writer.multilink_cell(LINK_CELL_DATA[:1])

    row = ods_writer.add_row(cell)

    assert ods_writer.sheet.lastChild is row

    assert row.firstChild is cell

    assert row.lastChild is cell

def test_ods_writer_add_row_empty(ods_writer):

    row = ods_writer.add_row(stylename='blank')

    assert ods_writer.sheet.lastChild is row

    assert row.firstChild is None

    assert row.getAttribute('stylename') == 'blank'

def test_ods_writer_balance_cell_empty(ods_writer):

    balance = core.Balance()

    cell = ods_writer.balance_cell(balance)

    assert cell.value_type != 'string'

    assert float(cell.value) == 0

def test_ods_writer_balance_cell_single_currency(ods_writer):

    number = 250

    currency = 'EUR'

    balance = core.Balance([testutil.Amount(number, currency)])

    cell = ods_writer.balance_cell(balance)

    assert cell.value_type == 'currency'

    assert Decimal(cell.value) == number

    assert cell.text == babel.numbers.format_currency(

        number, currency, locale=EN_US, format_type='accounting',

    )

def test_ods_writer_balance_cell_multi_currency(ods_writer):

    amounts = [testutil.Amount(num, code) for num, code in [

        (2500, 'RUB'),

        (3500, 'BRL'),

    ]]

    balance = core.Balance(amounts)

    cell = ods_writer.balance_cell(balance)

    assert cell.text == '\0'.join(babel.numbers.format_currency(

        number, currency, locale=EN_US, format_type='accounting',

    ) for number, currency in amounts)

@pytest.mark.parametrize('cell_source,style_name', testutil.combine_values(

    CURRENCY_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_currency_cell(ods_writer, cell_source, style_name):

    cell = ods_writer.currency_cell(cell_source, stylename=style_name)

    number, currency = cell_source

    assert cell.getAttribute('valuetype') == 'currency'

    assert cell.getAttribute('value') == str(number)

    assert cell.getAttribute('stylename') == style_name

    expected = babel.numbers.format_currency(

        number, currency, locale=EN_US, format_type='accounting',

    )

    assert get_text(cell) == expected

@pytest.mark.parametrize('currency', [

    'EUR',

    'CHF',

    'GBP',

])

def test_ods_writer_currency_cell_default_style(ods_writer, currency):

    amount = testutil.Amount(1000, currency)

    expected_stylename = ods_writer.currency_style(currency).getAttribute('name')

    cell = ods_writer.currency_cell(amount)

    assert cell.getAttribute('valuetype') == 'currency'

    assert cell.getAttribute('value') == '1000'

    assert cell.getAttribute('stylename') == expected_stylename

@pytest.mark.parametrize('date,style_name', testutil.combine_values(

    [datetime.date(1980, 2, 5), datetime.date(2030, 10, 30)],

    XML_NAMES_LIST,

))

def test_ods_writer_date_cell(ods_writer, date, style_name):

    if style_name is None:

        expect_style = ods_writer.style_date.getAttribute('name')

        cell = ods_writer.date_cell(date)

    else:

        expect_style = style_name

        cell = ods_writer.date_cell(date, stylename=style_name)

    date_s = date.isoformat()

    assert cell.getAttribute('valuetype') == 'date'

    assert cell.getAttribute('datevalue') == date_s

    assert cell.getAttribute('stylename') == expect_style

    assert get_text(cell) == date_s

@pytest.mark.parametrize('cell_source,style_name', testutil.combine_values(

    NUMERIC_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_float_cell(ods_writer, cell_source, style_name):

    cell = ods_writer.float_cell(cell_source, stylename=style_name)

    assert cell.getAttribute('valuetype') == 'float'

    assert cell.getAttribute('stylename') == style_name

    expected = str(cell_source)

    assert cell.getAttribute('value') == expected

    assert get_text(cell) == expected

def test_ods_writer_meta_links_cell(ods_writer):

    rt_client = testutil.RTClient()