fop/test/fotree/unittests/table/collapsed-conditional-borders_test-generator.py

#!/usr/bin/python
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
# 
#      http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# $Id$

"""A testcase generator for conditional borders and the collapsing border model, in the FO
tree.
Computes all the possible combinations of borders (retained/discarded, with/without header
and footer, etc.) and generates the corresponding tables together with the expected
resolved borders.

The two functions to call are generateTestCases and generateTestCasesHeaderFooter; each of
them returns a complete FO file on stdout and a table of resolved borders on stderr, to be
included in the Java test case. This is all a bit rough be enough to get the testcases
generated.

Type definitions:
    border specification:
    {'length': <string, e.g. '4pt'>,
     'cond': <'retain' or 'discard'>
     'color': <string, e.g. 'black'>
    }
"""

import sys;
import copy;

fo_table  = 0
fo_column = 1
fo_body   = 2
fo_row    = 3
fo_cell   = 4

def printFOStart():
    print '<?xml version="1.0" standalone="no"?>'
    print '<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">'
    print '  <fo:layout-master-set>'
    print '    <fo:simple-page-master master-name="page" page-height="20cm" page-width="15cm" margin="1cm">'
    print '      <fo:region-body/>'
    print '    </fo:simple-page-master>'
    print '  </fo:layout-master-set>'
    print '  <fo:page-sequence master-reference="page" font-size="14pt">'
    print '    <fo:flow flow-name="xsl-region-body">'
    print

def printFOEnd():
    print '    </fo:flow>'
    print '  </fo:page-sequence>'
    print '</fo:root>'

def printBorder(side, border, indent):
    """Prints out the border specifications.
    Params:
        side: one of 'before', 'after', 'start', 'end'
        border: a border specification
        indent: for pretty-printing, string of whitespaces to put before the border
    """
    print indent + '  border-' + side + '-width.length="' + border['length'] + '"'
    print indent + '  border-' + side + '-width.conditionality="' + border['cond'] + '"'
    print indent + '  border-' + side + '-style="solid"'
    print indent + '  border-' + side + '-color="' + border['color'] + '"'

class TableGenerator:
    """Generates on stdout tables with no header and footer, with the border
    specifications passed to this object; and on stderr the corresponding resolved borders
    in a Java array, for inclusion into the test case. As soon as a pair of border sets is
    recorded, a table is generated.
    """

    fobjs = [
            ('<fo:table width="10cm" space-before="12pt" table-layout="fixed"', '>'),
            ('<fo:table-column column-width="proportional-column-width(1)"', '/>'),
            ('<fo:table-body', '>'),
            ('<fo:table-row', '>'),
            ('<fo:table-cell', '>')
            ]

    bordersBefore = None
    resBefore = {}
    """The comma between each table; nothing before the first one."""
    separator = ''

    def addBorderSet(self, borderSet, resolution):
        """Records a new border set, and prints out a table if its number is even.
        The first set will be used for borders-before, the second one for borders-after.

        Params:
        borderSet: a list of 5 border specifications for resp. table, table-column,
        table-body, table-row and table-cell
        resolution: the resolved border for the rest case (for the normal and leading
        cases the resolution is always the same)
        """
        if not self.bordersBefore:
            self.bordersBefore = borderSet
            self.resBefore = resolution
        else:
            # First the table
            for i in range(5):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', self.bordersBefore[i], indent)
                printBorder('after', borderSet[i], indent)
                print indent + fobj[1]
            print '                <fo:block>Cell</fo:block>'
            print '              </fo:table-cell>'
            print '            </fo:table-row>'
            print '          </fo:table-body>'
            print '      </fo:table>'
            print
            # Then the resolution
            sys.stderr.write(self.separator + '{')
            comma = ''
            for beforeAfter in [self.resBefore, resolution]:
                sys.stderr.write(comma + '{border' + beforeAfter['length']
                        + ', Color.' + beforeAfter['color'] + '}')
                comma = ', '
            sys.stderr.write('}')
            self.separator = ',\n'
            # Reset
            self.bordersBefore = None
            self.resBefore = {}

class TableHFGenerator:
    """Generates on stdout tables with headers and footers, and the border specifications
    passed to this object; and on stderr the corresponding resolved borders in a Java
    array."""

    fobjs = [
            ['<fo:table width="10cm" space-before="12pt" table-layout="fixed"', '>'],
            ['<fo:table-column column-width="proportional-column-width(1)"', '/>'],
            ['<fo:table-header', '>'],
            ['<fo:table-row', '>'],
            ['<fo:table-cell', '>']
            ]

    borderHeader = [] # border-before for the header.
    borderFooter = [] # border-after for the footer.
    bordersBody = []  # borders for the cells in the body.

    def addBorderHeader(self, borders, resolution):
        self.borderHeader.append((borders, resolution))

    def addBorderFooter(self, borders, resolution):
        self.borderFooter.append((borders, resolution))

    def addBordersBody(self, borders, resolution):
        self.bordersBody.append((borders, resolution))

    def finish(self):
        """Prints out the tables and the resolved borders."""
        separator = ''  # The comma between each table, none before the first one
        for tableNum in range(len(self.borderHeader)):
            # First the table
            print '      <!-- Table ' + str(tableNum) + ' -->'
            for i in range(2):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', self.borderHeader[tableNum][0][i], indent)
                printBorder('after', self.borderFooter[tableNum][0][i], indent)
                print indent + fobj[1]
            self.fobjs[fo_body][0] = '<fo:table-header'
            for i in range(2, 5):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', self.borderHeader[tableNum][0][i], indent)
                printBorder('after', self.bordersBody[tableNum][0][i-2], indent)
                print indent + fobj[1]
            print '                <fo:block>Header</fo:block>'
            print '              </fo:table-cell>'
            print '            </fo:table-row>'
            print '          </fo:table-header>'
            self.fobjs[fo_body][0] = '<fo:table-footer'
            for i in range(2, 5):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', self.bordersBody[tableNum][0][i+7], indent)
                printBorder('after', self.borderFooter[tableNum][0][i], indent)
                print indent + fobj[1]
            print '                <fo:block>Footer</fo:block>'
            print '              </fo:table-cell>'
            print '            </fo:table-row>'
            print '          </fo:table-footer>'
            self.fobjs[fo_body][0] = '<fo:table-body'
            for i in range(2, 5):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', {'length': '4pt', 'cond': 'discard', 'color': 'black'}, indent)
                printBorder('after', self.bordersBody[tableNum][0][i+1], indent)
                print indent + fobj[1]
            print '                <fo:block>Cell1</fo:block>'
            print '              </fo:table-cell>'
            print '            </fo:table-row>'
            print '          </fo:table-body>'
            for i in range(2, 5):
                fobj = self.fobjs[i]
                indent = ' ' * (6 + 2*i)
                print indent + fobj[0]
                printBorder('before', self.bordersBody[tableNum][0][i+4], indent)
                printBorder('after', {'length': '4pt', 'cond': 'discard', 'color': 'blue'}, indent)
                print indent + fobj[1]
            print '                <fo:block>Cell1</fo:block>'
            print '              </fo:table-cell>'
            print '            </fo:table-row>'
            print '          </fo:table-body>'
            print '      </fo:table>'
            print
            # Then the resolutions
            sys.stderr.write(separator + '{')
            comma = ''
            for resHeadFoot in [self.borderHeader[tableNum][1], self.borderFooter[tableNum][1]]:
                for firstRest in ['first', 'rest']:
                    sys.stderr.write(comma + '{border'
                            + resHeadFoot[firstRest]['length']
                            + ', Color.' + resHeadFoot[firstRest]['color']
                            + '}')
                    comma = ', '
            resBody = self.bordersBody[tableNum][1]
            for i in range(4):
                for normLeadRest in ['normal', 'lead', 'rest']:
                    sys.stderr.write(', {border'
                            + resBody[i][normLeadRest][0]
                            + ', Color.' + resBody[i][normLeadRest][1]
                            + '}')
            sys.stderr.write('}')
            separator = ',\n'

def generateTestCases():
    """Generates testcases for table without header and footer."""
    def createAllCombinations():
        def createCombinations(n):
            if n == 0:
                allCombinations[0].append([])
            else:
                createCombinations(n-1)
                i = n
                while i > 0:
                    for combinations in allCombinations[i-1]:
                        allCombinations[i].append(copy.copy(combinations) + [n-1])
                    i = i - 1
        allCombinations = [[] for i in range(6)]
        createCombinations(5)
        return allCombinations

    printFOStart()
    tableGenerator = TableGenerator()

    defaultBorders = []
    for color in ['black', 'red', 'magenta', 'blue', 'yellow']:
        defaultBorders.append({'length': '4pt', 'cond': 'discard', 'color': color})
    defaultBorders[fo_table]['length'] = '8pt'

    resolution = {'length': '0pt', 'color': 'black'}
    tableGenerator.addBorderSet(defaultBorders, resolution)
    for combinations in createAllCombinations()[1:]:
        for combination in combinations:
            retainedBorders = copy.deepcopy(defaultBorders)
            for index in combination:
                retainedBorders[index]['cond'] = 'retain'
            for index in combination:
                finalBorders = copy.deepcopy(retainedBorders)
                if index != fo_table:
                    finalBorders[index]['length'] = '6pt'
                if fo_table in combination:
                    resolution = {'length': '8pt', 'color': 'black'}
                else:
                    resolution = {'length': '6pt', 'color': finalBorders[index]['color']}
                tableGenerator.addBorderSet(finalBorders, resolution)
    printFOEnd()

def generateTestCasesHeaderFooter():
    """Generates testcases for table with headers and footers."""
    def generateBordersHeaderFooter(tableGenerator):
        defaultBorders = [
                {'length': '4pt', 'cond': 'discard', 'color': 'black'}, # table
                {'length': '4pt', 'cond': 'discard', 'color': 'black'}, # table-column
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'},  # table-body
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'},  # table-row
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'}   # table-cell
                ]
        defaultResolution = {
                'first': {'length': '4pt', 'color': 'blue'},
                'rest':  {'length': '4pt', 'color': 'blue'}
                }
        for (winner, other) in [(fo_table, fo_column), (fo_column, fo_table)]:
            borders = copy.deepcopy(defaultBorders)
            borders[winner]['length'] = '8pt'
            resolution = copy.deepcopy(defaultResolution)
            resolution['first'] = {'length': '8pt', 'color': 'black'}
            for border in [
                    ((other, '6pt', 'retain'),    'black'),
                    ((fo_body, '6pt', 'discard'), 'blue'),
                    ((fo_row, '6pt', 'discard'),  'blue'),
                    ((fo_cell, '6pt', 'discard'), 'blue')
                    ]:
                finalBorders = copy.deepcopy(borders)
                finalBorders[border[0][0]]['length'] = border[0][1]
                finalBorders[border[0][0]]['cond'] = border[0][2]
                finalResolution = copy.deepcopy(resolution)
                finalResolution['rest']['length'] = '6pt'
                finalResolution['rest']['color'] = border[1]
                tableGenerator.addBorderHeader(finalBorders, finalResolution)
                tableGenerator.addBorderFooter(finalBorders, finalResolution)

    def generateBordersBody(tableGenerator):
        # Named indices for readability
        header =  0
        rowh   =  1
        cellh  =  2
        body1  =  3
        row1   =  4
        cell1  =  5
        body2  =  6
        row2   =  7
        cell2  =  8
        footer =  9
        rowf   = 10
        cellf  = 11

        defaultBorders = [
                {'length': '4pt', 'cond': 'discard', 'color': 'red'},     # header
                {'length': '4pt', 'cond': 'discard', 'color': 'red'},     # header > row
                {'length': '4pt', 'cond': 'discard', 'color': 'red'},     # header > row > cell
                {'length': '4pt', 'cond': 'discard', 'color': 'black'},   # body1
                {'length': '4pt', 'cond': 'discard', 'color': 'black'},   # body1 > row
                {'length': '4pt', 'cond': 'discard', 'color': 'black'},   # body1 > row > cell
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'},    # body2
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'},    # body2 > row
                {'length': '4pt', 'cond': 'discard', 'color': 'blue'},    # body2 > row > cell
                {'length': '4pt', 'cond': 'discard', 'color': 'magenta'}, # footer
                {'length': '4pt', 'cond': 'discard', 'color': 'magenta'}, # footer > row
                {'length': '4pt', 'cond': 'discard', 'color': 'magenta'}  # footer > row > cell
                ]
        defaultResolution = [
                {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'red')},     # border-before cell 1
                {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'magenta')}, # border-after cell 1
                {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'red')},     # border-before cell 2
                {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}  # border-after cell 2
                ]
        # The following contains changes to the default borders. Depending on the object
        # targeted (in header, footer, body1 or body2), the affected border is either before
        # or after (the other one keeping its default value):
        # - for header: border-after
        # - for body1: border-after
        # - for body2: border-before
        # - for footer: border-before
        for setting in [
                {'borders': [(body2, '8pt', 'discard'), (body1, '6pt', 'discard')], 'res': [
                    {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'blue'),  'lead': ('6pt', 'black'), 'rest': ('4pt', 'magenta')},
                    {'normal': ('8pt', 'blue'),  'lead': ('8pt', 'blue'),  'rest': ('4pt', 'red')},
                    {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                {'borders': [(row2,  '8pt', 'discard'), (row1,  '6pt', 'retain')], 'res': [
                    {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'blue'),  'lead': ('6pt', 'black'), 'rest': ('6pt', 'black')},
                    {'normal': ('8pt', 'blue'),  'lead': ('8pt', 'blue'),  'rest': ('4pt', 'red')},
                    {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                {'borders': [(cell2, '6pt', 'retain'), (cellh, '8pt', 'discard'), (cell1, '4pt', 'retain')], 'res': [
                    {'normal': ('8pt', 'red'),  'lead': ('8pt', 'red'),   'rest': ('8pt', 'red')},
                    {'normal': ('6pt', 'blue'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'black')},
                    {'normal': ('6pt', 'blue'), 'lead': ('8pt', 'red'),   'rest': ('8pt', 'red')},
                    {'normal': ('4pt', 'blue'), 'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                {'borders': [(body2, '6pt',  'retain'), (rowh,  '8pt', 'discard'), (row1,  '4pt', 'retain')], 'res': [
                    {'normal': ('8pt', 'red'),  'lead': ('8pt', 'red'),   'rest': ('8pt', 'red')},
                    {'normal': ('6pt', 'blue'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'magenta')},
                    {'normal': ('6pt', 'blue'), 'lead': ('8pt', 'red'),   'rest': ('8pt', 'red')},
                    {'normal': ('4pt', 'blue'), 'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                # Almost a copy-paste of the above, swapping 1 and 2, header and footer
                {'borders': [(body1, '8pt', 'discard'), (body2, '6pt', 'discard')], 'res': [
                    {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'black'), 'lead': ('8pt', 'black'), 'rest': ('4pt', 'magenta')},
                    {'normal': ('8pt', 'black'), 'lead': ('6pt', 'blue'),  'rest': ('4pt', 'red')},
                    {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                {'borders': [(cell1,  '8pt', 'discard'), (cell2,  '6pt', 'retain')], 'res': [
                    {'normal': ('4pt', 'black'), 'lead': ('4pt', 'black'), 'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'black'), 'lead': ('8pt', 'black'), 'rest': ('4pt', 'magenta')},
                    {'normal': ('8pt', 'black'), 'lead': ('6pt', 'blue'),  'rest': ('6pt', 'blue')},
                    {'normal': ('4pt', 'blue'),  'lead': ('4pt', 'blue'),  'rest': ('4pt', 'magenta')}]},
                {'borders': [(row1, '6pt', 'retain'), (footer, '8pt', 'discard'), (body2, '4pt', 'retain')], 'res': [
                    {'normal': ('4pt', 'black'),   'lead': ('4pt', 'black'),   'rest': ('4pt', 'red')},
                    {'normal': ('6pt', 'black'),   'lead': ('8pt', 'magenta'), 'rest': ('8pt', 'magenta')},
                    {'normal': ('6pt', 'black'),   'lead': ('4pt', 'blue'),    'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'magenta'), 'lead': ('8pt', 'magenta'), 'rest': ('8pt', 'magenta')}]},
                {'borders': [(body1, '8pt',  'retain'), (cellf,  '6pt', 'discard'), (row2,  '4pt', 'retain')], 'res': [
                    {'normal': ('4pt', 'black'),   'lead': ('4pt', 'black'),   'rest': ('4pt', 'red')},
                    {'normal': ('8pt', 'black'),   'lead': ('8pt', 'black'),   'rest': ('8pt', 'black')},
                    {'normal': ('8pt', 'black'),   'lead': ('4pt', 'blue'),    'rest': ('4pt', 'red')},
                    {'normal': ('6pt', 'magenta'), 'lead': ('6pt', 'magenta'), 'rest': ('6pt', 'magenta')}]}]:
            finalBorders = copy.deepcopy(defaultBorders)
            for border in setting['borders']:
                finalBorders[border[0]]['length'] = border[1]
                finalBorders[border[0]]['cond'] = border[2]
            tableGenerator.addBordersBody(finalBorders, setting['res'])

    tableGenerator = TableHFGenerator()
    printFOStart()
    generateBordersHeaderFooter(tableGenerator)
    generateBordersBody(tableGenerator)
    tableGenerator.finish()
    printFOEnd()

# Uncomment the appropriate line
#generateTestCases()
#generateTestCasesHeaderFooter()