path: root/sw/qa/python/check_table.py

#! /usr/bin/env python
# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
#
# This file is part of the LibreOffice project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#

import math
import unittest

from org.libreoffice.unotest import UnoInProcess
from com.sun.star.beans import PropertyValue
from com.sun.star.uno import RuntimeException
from com.sun.star.table import BorderLine
from com.sun.star.table import BorderLine2
from com.sun.star.table.BorderLineStyle import (DOUBLE, SOLID, EMBOSSED,
                                                THICKTHIN_LARGEGAP, DASHED, DOTTED)
from com.sun.star.lang import Locale

class CheckTable(unittest.TestCase):
    def _fill_table(self, xTable):
        for x in range(3):
            for y in range(3):
                xTable[y, x].String = 'Cell %d %d' % (x, y)

    def _check_table(self, xTable):
        for x in range(3):
            for y in range(3):
                self.assertEqual('Cell %d %d' % (x, y), xTable[y, x].String)

    @classmethod
    def setUpClass(cls):
        cls._uno = UnoInProcess()
        cls._uno.setUp()
        cls.OOLineVeryThin = 18

    @classmethod
    def tearDownClass(cls):
        cls._uno.tearDown()

    def __test_borderAsserts(self, xBorderLine, line_valid):
        self.assertTrue(line_valid)
        self.assertEqual(0, xBorderLine.InnerLineWidth)
        self.assertEqual(self.OOLineVeryThin, xBorderLine.OuterLineWidth)
        self.assertEqual(0, xBorderLine.LineDistance)
        self.assertEqual(0, xBorderLine.Color)

    def __test_borderAssertsWithLineStyle(self, xBorderLine, line_valid):
        self.__test_borderAsserts(xBorderLine, line_valid)
        self.assertEqual(self.OOLineVeryThin, xBorderLine.LineWidth)
        self.assertEqual(SOLID, xBorderLine.LineStyle)

    def __test_borderDistance(self, border):
        self.assertTrue(border.IsDistanceValid)
        self.assertEqual(97, border.Distance)

    def test_tableborder(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        # insert table
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(3, 3)
        xText = xDoc.getText()
        xCursor = xText.createTextCursor()
        xText.insertTextContent(xCursor, xTable, False)

        border_distances = xTable.TableBorderDistances

        self.assertEqual(97, border_distances.TopDistance)
        self.assertEqual(97, border_distances.BottomDistance)
        self.assertEqual(97, border_distances.LeftDistance)
        self.assertEqual(97, border_distances.RightDistance)

        self.assertEqual(True, border_distances.IsTopDistanceValid)
        self.assertEqual(True, border_distances.IsBottomDistanceValid)
        self.assertEqual(True, border_distances.IsLeftDistanceValid)
        self.assertEqual(True, border_distances.IsRightDistanceValid)

        border = xTable.getPropertyValue("TableBorder")

        self.__test_borderAsserts(border.TopLine, border.IsTopLineValid)
        self.__test_borderAsserts(border.BottomLine, border.IsBottomLineValid)
        self.__test_borderAsserts(border.LeftLine, border.IsLeftLineValid)
        self.__test_borderAsserts(border.RightLine, border.IsRightLineValid)
        self.__test_borderAsserts(border.HorizontalLine, border.IsHorizontalLineValid)
        self.__test_borderAsserts(border.VerticalLine, border.IsVerticalLineValid)

        self.__test_borderDistance(border)

        # set border
        border.TopLine = BorderLine(0, 11, 19, 19)
        border.BottomLine = BorderLine(0xFF, 00, 11, 00)
        border.HorizontalLine = BorderLine(0xFF00, 00, 90, 00)
        xTable.setPropertyValue("TableBorder", border)

        # read set border
        border = xTable.getPropertyValue("TableBorder")

        self.assertTrue(border.IsTopLineValid)
        self.assertEqual(11, border.TopLine.InnerLineWidth)
        self.assertEqual(19, border.TopLine.OuterLineWidth)
        self.assertEqual(19, border.TopLine.LineDistance)
        self.assertEqual(0, border.TopLine.Color)

        self.assertTrue(border.IsBottomLineValid)
        self.assertEqual(0, border.BottomLine.InnerLineWidth)
        self.assertEqual(11, border.BottomLine.OuterLineWidth)
        self.assertEqual(0, border.BottomLine.LineDistance)
        self.assertEqual(0xFF, border.BottomLine.Color)

        self.__test_borderAsserts(border.LeftLine, border.IsLeftLineValid)

        self.__test_borderAsserts(border.RightLine, border.IsRightLineValid)

        self.assertTrue(border.IsHorizontalLineValid)
        self.assertEqual(0, border.HorizontalLine.InnerLineWidth)
        self.assertEqual(90, border.HorizontalLine.OuterLineWidth)
        self.assertEqual(0, border.HorizontalLine.LineDistance)
        self.assertEqual(0xFF00, border.HorizontalLine.Color)

        self.__test_borderAsserts(border.VerticalLine, border.IsVerticalLineValid)

        self.__test_borderDistance(border)

        border2 = xTable.getPropertyValue("TableBorder2")

        self.assertTrue(border2.IsTopLineValid)
        self.assertEqual(11, border2.TopLine.InnerLineWidth)
        self.assertEqual(19, border2.TopLine.OuterLineWidth)
        self.assertEqual(19, border2.TopLine.LineDistance)
        self.assertEqual(0, border2.TopLine.Color)
        self.assertEqual(DOUBLE, border2.TopLine.LineStyle)
        self.assertEqual(49, border2.TopLine.LineWidth)

        self.assertTrue(border2.IsBottomLineValid)
        self.assertEqual(0, border2.BottomLine.InnerLineWidth)
        self.assertEqual(11, border2.BottomLine.OuterLineWidth)
        self.assertEqual(0, border2.BottomLine.LineDistance)
        self.assertEqual(0xFF, border2.BottomLine.Color)
        self.assertEqual(SOLID, border2.BottomLine.LineStyle)
        self.assertEqual(11, border2.BottomLine.LineWidth)

        self.__test_borderAssertsWithLineStyle(border2.LeftLine, border2.IsLeftLineValid)

        self.__test_borderAssertsWithLineStyle(border2.RightLine, border2.IsRightLineValid)

        self.assertTrue(border2.IsHorizontalLineValid)
        self.assertEqual(0, border2.HorizontalLine.InnerLineWidth)
        self.assertEqual(90, border2.HorizontalLine.OuterLineWidth)
        self.assertEqual(0, border2.HorizontalLine.LineDistance)
        self.assertEqual(0xFF00, border2.HorizontalLine.Color)
        self.assertEqual(SOLID, border2.HorizontalLine.LineStyle)
        self.assertEqual(90, border2.HorizontalLine.LineWidth)

        self.__test_borderAssertsWithLineStyle(border2.VerticalLine, border2.IsVerticalLineValid)

        self.__test_borderDistance(border2)

        # set border2
        border2.RightLine = BorderLine2(0, 0, 0, 0, THICKTHIN_LARGEGAP, 120)
        border2.LeftLine = BorderLine2(0, 0, 0, 0, EMBOSSED, 90)
        border2.VerticalLine = BorderLine2(0xFF, 0, 90, 0, DOTTED, 0)
        border2.HorizontalLine = BorderLine2(0xFF00, 0, 0, 0, DASHED, 11)
        xTable.setPropertyValue("TableBorder2", border2)

        # read set border2
        border2 = xTable.getPropertyValue("TableBorder2")

        self.assertTrue(border2.IsTopLineValid)
        self.assertEqual(11, border2.TopLine.InnerLineWidth)
        self.assertEqual(19, border2.TopLine.OuterLineWidth)
        self.assertEqual(19, border2.TopLine.LineDistance)
        self.assertEqual(0, border2.TopLine.Color)
        self.assertEqual(DOUBLE, border2.TopLine.LineStyle)
        self.assertEqual(49, border2.TopLine.LineWidth)

        self.assertTrue(border2.IsBottomLineValid)
        self.assertEqual(0, border2.BottomLine.InnerLineWidth)
        self.assertEqual(11, border2.BottomLine.OuterLineWidth)
        self.assertEqual(0, border2.BottomLine.LineDistance)
        self.assertEqual(0xFF, border2.BottomLine.Color)
        self.assertEqual(SOLID, border2.BottomLine.LineStyle)
        self.assertEqual(11, border2.BottomLine.LineWidth)

        self.assertTrue(border2.IsLeftLineValid)
        self.assertEqual(23, border2.LeftLine.InnerLineWidth)
        self.assertEqual(23, border2.LeftLine.OuterLineWidth)
        self.assertEqual(46, border2.LeftLine.LineDistance)
        self.assertEqual(0, border2.LeftLine.Color)
        self.assertEqual(EMBOSSED, border2.LeftLine.LineStyle)
        self.assertEqual(90, border2.LeftLine.LineWidth)

        self.assertTrue(border2.IsRightLineValid)
        self.assertEqual(53, border2.RightLine.InnerLineWidth)
        self.assertEqual(26, border2.RightLine.OuterLineWidth)
        self.assertEqual(41, border2.RightLine.LineDistance)
        self.assertEqual(0, border2.RightLine.Color)
        self.assertEqual(THICKTHIN_LARGEGAP, border2.RightLine.LineStyle)
        self.assertEqual(120, border2.RightLine.LineWidth)

        self.assertTrue(border2.IsHorizontalLineValid)
        self.assertEqual(0, border2.HorizontalLine.InnerLineWidth)
        self.assertEqual(11, border2.HorizontalLine.OuterLineWidth)
        self.assertEqual(0, border2.HorizontalLine.LineDistance)
        self.assertEqual(0xFF00, border2.HorizontalLine.Color)
        self.assertEqual(DASHED, border2.HorizontalLine.LineStyle)
        self.assertEqual(11, border2.HorizontalLine.LineWidth)

        self.assertTrue(border2.IsVerticalLineValid)
        self.assertEqual(0, border2.VerticalLine.InnerLineWidth)
        self.assertEqual(90, border2.VerticalLine.OuterLineWidth)
        self.assertEqual(0, border2.VerticalLine.LineDistance)
        self.assertEqual(0xFF, border2.VerticalLine.Color)
        self.assertEqual(DOTTED, border2.VerticalLine.LineStyle)
        self.assertEqual(90, border2.VerticalLine.LineWidth)

        self.__test_borderDistance(border2)

        # close document
        xDoc.dispose()

    def test_fdo58242(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        # insert table
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(3, 3)
        xText = xDoc.getText()
        xCursor = xText.createTextCursor()
        xText.insertTextContent(xCursor, xTable, False)
        # get anchor
        xAnchor = xTable.getAnchor()

        # check all properties on the anchor - shouldn't crash despite
        # pointing to a non-SwTextNode
        xPropsInfo = xAnchor.getPropertySetInfo()
        for i in xPropsInfo.getProperties():
            try:
                xAnchor.getPropertyValue(i.Name)
            except RuntimeException:
                pass

        # close document
        xDoc.dispose()

    def test_descriptions(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        # insert table
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(3, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        self.assertEqual(3, xTable.Rows.Count)
        self.assertEqual(3, xTable.Columns.Count)
        xTable.TableName = "foo"
        self.assertEqual("foo", xTable.TableName)
        xTable.TableTemplateName = "bar"
        self.assertEqual("bar", xTable.TableTemplateName)

        # fill table
        self._fill_table(xTable)
        self._check_table(xTable)

        # check without labels first
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        self.assertEqual(0, len(xTable.RowDescriptions))
        self.assertEqual(0, len(xTable.ColumnDescriptions))
        self.RowDescriptions = ('foo', 'bar', 'baz')  # no labels, thus noop
        self.ColumnDescriptions = ('foo', 'bar', 'baz')  # no labels, thus noop
        self._check_table(xTable)

        # now check with labels
        xTable.ChartColumnAsLabel = True
        xTable.ChartRowAsLabel = True
        self.assertEqual(2, len(xTable.RowDescriptions))
        self.assertEqual('Cell 0 1', xTable.RowDescriptions[0])
        self.assertEqual('Cell 0 2', xTable.RowDescriptions[1])
        self.assertEqual(2, len(xTable.ColumnDescriptions))
        self.assertEqual('Cell 1 0', xTable.ColumnDescriptions[0])
        self.assertEqual('Cell 2 0', xTable.ColumnDescriptions[1])

        with self.assertRaises(Exception):
            xTable.RowDescriptions = ('foo',)  # too short

        with self.assertRaises(Exception):
            xTable.ColumnDescriptions = ('foo',)  # too short

        self._check_table(xTable)
        xTable.RowDescriptions = ('fooRow', 'bazRow')
        xTable.ColumnDescriptions = ('fooColumn', 'bazColumn')
        self.assertEqual('fooRow', xTable[1, 0].String)
        self.assertEqual('bazRow', xTable[2, 0].String)
        self.assertEqual('fooColumn', xTable[0, 1].String)
        self.assertEqual('bazColumn', xTable[0, 2].String)
        xTable[1, 0].String = 'Cell 0 1'  # reset changes values ...
        xTable[2, 0].String = 'Cell 0 2'
        xTable[0, 1].String = 'Cell 1 0'
        xTable[0, 2].String = 'Cell 2 0'
        self._check_table(xTable)  # ... to ensure the rest was untouched

        # check disconnected table excepts, but doesn't crash
        xTable2 = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable2.initialize(3, 3)

        with self.assertRaises(Exception):
            xTable2.RowDescriptions

        with self.assertRaises(Exception):
            xTable2.ColumnDescriptions

        xDoc.dispose()

    def test_getset_data(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()

        # insert table
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(4, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False

        # roundtrip
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))
        self.assertEqual(xTable.Data, ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12)))

        # missing row
        with self.assertRaises(Exception):
            xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

        # missing column
        with self.assertRaises(Exception):
            xTable.Data = ((1, 2), (4, 5), (7, 8), (10, 11))

        # with labels
        xTable.ChartColumnAsLabel = True
        xTable.ChartRowAsLabel = True
        self.assertEqual(xTable.Data, ((5, 6), (8, 9), (11, 12)))
        xTable.Data = ((55, 66), (88, 99), (1111, 1212))
        xTable.ChartColumnAsLabel = True
        xTable.ChartRowAsLabel = False
        self.assertEqual(xTable.Data, ((2, 3), (55, 66), (88, 99), (1111, 1212)))
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = True
        self.assertEqual(xTable.Data, ((4, 55, 66), (7, 88, 99), (10, 1111, 1212)))
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        self.assertEqual(xTable.Data, ((1, 2, 3), (4, 55, 66), (7, 88, 99), (10, 1111, 1212)))
        xDoc.dispose()

    def test_remove_colrow(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(4, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))
        xRows = xTable.Rows
        self.assertEqual(xRows.ImplementationName, 'SwXTableRows')
        self.assertTrue(xRows.supportsService('com.sun.star.text.TableRows'))
        self.assertFalse(xRows.supportsService('foo'))
        self.assertIn('com.sun.star.text.TableRows', xRows.SupportedServiceNames)
        self.assertNotIn('foo', xRows.SupportedServiceNames)
        xRows.removeByIndex(1, 2)
        self.assertEqual(xTable.Data, ((1, 2, 3), (10, 11, 12)))
        xCols = xTable.Columns
        self.assertEqual(xCols.ImplementationName, 'SwXTableColumns')
        self.assertTrue(xCols.supportsService('com.sun.star.text.TableColumns'))
        self.assertFalse(xCols.supportsService('foo'))
        self.assertIn('com.sun.star.text.TableColumns', xCols.SupportedServiceNames)
        self.assertNotIn('foo', xCols.SupportedServiceNames)
        xCols.removeByIndex(1, 1)
        self.assertEqual(xTable.Data, ((1, 3), (10, 12)))
        xDoc.dispose()

    def test_insert_colrow(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(4, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))
        xRows = xTable.Rows
        xRows.insertByIndex(1, 2)
        self.assertEqual(xTable.Data[0], (1, 2, 3))
        self.assertEqual(xTable.Data[3], (4, 5, 6))
        self.assertEqual(xTable.Data[4], (7, 8, 9))
        self.assertEqual(xTable.Data[5], (10, 11, 12))

        for x in range(3):
            self.assertTrue(math.isnan(xTable.Data[1][x]))
            self.assertTrue(math.isnan(xTable.Data[2][x]))

        xCols = xTable.Columns
        xCols.insertByIndex(1, 1)
        self.assertEqual(xTable.Data[0][0], 1)
        self.assertTrue(math.isnan(xTable.Data[0][1]))
        self.assertEqual(xTable.Data[0][2], 2)
        self.assertEqual(xTable.Data[0][3], 3)
        self.assertEqual(xTable.Data[3][0], 4)
        self.assertTrue(math.isnan(xTable.Data[3][1]))
        self.assertEqual(xTable.Data[3][2], 5)
        self.assertEqual(xTable.Data[3][3], 6)
        self.assertEqual(xTable.Data[4][0], 7)
        self.assertTrue(math.isnan(xTable.Data[4][1]))
        self.assertEqual(xTable.Data[4][2], 8)
        self.assertEqual(xTable.Data[4][3], 9)
        self.assertEqual(xTable.Data[5][0], 10)
        self.assertTrue(math.isnan(xTable.Data[5][1]))
        self.assertEqual(xTable.Data[5][2], 11)
        self.assertEqual(xTable.Data[5][3], 12)

        for x in range(4):
            self.assertTrue(math.isnan(xTable.Data[1][x]))
            self.assertTrue(math.isnan(xTable.Data[2][x]))
        xDoc.dispose()

    def test_chartdataprovider(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(4, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))
        self.assertTrue(xTable.Name == 'Table1')
        self.assertIn('com.sun.star.text.GenericTextDocument', xDoc.SupportedServiceNames)
        xChartdataprovider = xDoc.createInstance('com.sun.star.chart2.data.DataProvider')
        self.assertEqual(xChartdataprovider.ImplementationName, 'SwChartDataProvider')
        self.assertTrue(xChartdataprovider.supportsService('com.sun.star.chart2.data.DataProvider'))
        self.assertFalse(xChartdataprovider.supportsService('foo'))
        self.assertIn('com.sun.star.chart2.data.DataProvider', xChartdataprovider.SupportedServiceNames)
        pv = PropertyValue()
        pv.Name = 'CellRangeRepresentation'
        pv.Value = 'Table1.A1:C2'
        xDataSource = xChartdataprovider.createDataSource((pv,))
        self.assertEqual(len(xDataSource.DataSequences), 3)
        expected_values = ((1, 4), (2, 5), (3, 6))
        expected_cellrange = ('A1:A2', 'B1:B2', 'C1:C2')

        for col in range(3):
            xSeq = xDataSource.DataSequences[col].Values
            self.assertEqual(xSeq.ImplementationName, 'SwChartDataSequence')
            self.assertTrue(xSeq.supportsService('com.sun.star.chart2.data.DataSequence'))
            self.assertFalse(xSeq.supportsService('foo'))
            self.assertIn('com.sun.star.chart2.data.DataSequence', xSeq.SupportedServiceNames)
            self.assertEqual(xSeq.SourceRangeRepresentation, 'Table1.%s' % expected_cellrange[col])
            self.assertEqual(xSeq.Data, expected_values[col])
            self.assertEqual(xSeq.NumericalData, expected_values[col])
            self.assertEqual([int(txtval) for txtval in xSeq.TextualData],
                             [val for val in expected_values[col]])

            xSeq.Role = "One xSeq to rule them all"
            self.assertEqual("One xSeq to rule them all", xSeq.Role)

            xSeqClone = xSeq.createClone()
            self.assertEqual(xSeq.Role, xSeqClone.Role)

        xDoc.dispose()

    def test_tdf32082(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xDocFrame = xDoc.CurrentController.Frame
        xContext = CheckTable._uno.getContext()
        xServiceManager = xContext.ServiceManager
        xDispatcher = xServiceManager.createInstanceWithContext('com.sun.star.frame.DispatchHelper',
                                                                xContext)

        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(1, 1)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)

        # Setup numberformat for the cell
        xNumberFormats = xDoc.NumberFormats
        xLocale = Locale('en', 'US', '')
        format_string = '#,##0.00 [$€-407];[RED]-#,##0.00 [$€-407]'
        key = xNumberFormats.queryKey(format_string, xLocale, True)

        if key == -1:
            key = xNumberFormats.addNew(format_string, xLocale)

        # Apply the format on the first cell
        xTable[0, 0].NumberFormat = key
        xDispatcher.executeDispatch(xDocFrame, '.uno:GoToStartOfDoc', '', 0, ())
        xDispatcher.executeDispatch(xDocFrame, '.uno:InsertText', '', 0,
                                    (PropertyValue('Text', 0, '3', 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:JumpToNextCell', '', 0, ())

        # Check that the formatting we set up is not destroyed
        self.assertEqual(xTable[0, 0].getString(), '3.00 €')
        self.assertEqual(xTable[0, 0].getValue(), 3)

        # Verify that it works with number recognition turned on as well
        xDispatcher.executeDispatch(xDocFrame, '.uno:TableNumberRecognition', '', 0,
                                    (PropertyValue('TableNumberRecognition', 0, True, 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:InsertText', '', 0,
                                    (PropertyValue('Text', 0, '4', 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:JumpToNextCell', '', 0, ())
        self.assertEqual(xTable[1, 0].getString(), '4.00 €')
        self.assertEqual(xTable[1, 0].getValue(), 4)
        xDoc.dispose()

    def test_numberRecognition(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xDocFrame = xDoc.CurrentController.Frame
        xContext = CheckTable._uno.getContext()
        xServiceManager = xContext.ServiceManager
        xDispatcher = xServiceManager.createInstanceWithContext('com.sun.star.frame.DispatchHelper',
                                                                xContext)

        xTable = xDoc.createInstance('com.sun.star.text.TextTable')
        xTable.initialize(2, 1)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xDispatcher.executeDispatch(xDocFrame, '.uno:GoToStartOfDoc', '', 0, ())
        xDispatcher.executeDispatch(xDocFrame, '.uno:InsertText', '', 0,
                                    (PropertyValue('Text', 0, '2015-10-30', 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:JumpToNextCell', '', 0, ())

        # Without number recognition 2015-10-30 should not be interpreted as a date
        self.assertEqual(xTable[0, 0].getString(), '2015-10-30')
        self.assertEqual(xTable[0, 0].getValue(), 0)

        # Activate number recognition
        xDispatcher.executeDispatch(xDocFrame, '.uno:TableNumberRecognition', '', 0,
                                    (PropertyValue('TableNumberRecognition', 0, True, 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:InsertText', '', 0,
                                    (PropertyValue('Text', 0, '2015-10-30', 0),))
        xDispatcher.executeDispatch(xDocFrame, '.uno:JumpToNextCell', '', 0, ())

        # With number recognition it should now be a date, confirm by checking
        # the string and value of the cell.
        self.assertEqual(xTable[1, 0].getString(), '2015-10-30')
        self.assertEqual(xTable[1, 0].getValue(), 42307.0)
        xDoc.dispose()

    def test_tableTemplate(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(1, 1)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, True)
        # should return programmatic name, even though UI name was set.
        xTable.setPropertyValue("TableTemplateName", "Default Table Style")
        self.assertEqual(xTable.getPropertyValue("TableTemplateName"), "Default Style")
        xTable.setPropertyValue("TableTemplateName", "Default")
        self.assertEqual(xTable.getPropertyValue("TableTemplateName"), "Default")
        xTable.setPropertyValue("TableTemplateName", "other_style")
        self.assertEqual(xTable.getPropertyValue("TableTemplateName"), "other_style")
        xTable.setPropertyValue("TableTemplateName", "")
        self.assertEqual(xTable.getPropertyValue("TableTemplateName"), "")
        xDoc.dispose()

    def test_unoNames(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(3, 3)
        xText = xDoc.getText()
        xCursor = xText.createTextCursor()
        xText.insertTextContent(xCursor, xTable, False)

        self.assertEqual("SwXTextTable", xTable.ImplementationName)
        self.assertEqual(("com.sun.star.document.LinkTarget",
                          "com.sun.star.text.TextTable",
                          "com.sun.star.text.TextContent",
                          "com.sun.star.text.TextSortable"), xTable.SupportedServiceNames)
        self.assertEqual(b'', xTable.ImplementationId.value)

        xCell = xTable[1, 1]
        self.assertEqual("SwXCell", xCell.ImplementationName)
        self.assertEqual(("com.sun.star.text.CellProperties",), xCell.SupportedServiceNames)
        self.assertEqual(b'', xCell.ImplementationId.value)

        xRow = xTable.Rows[0]
        self.assertEqual("SwXTextTableRow", xRow.ImplementationName)
        self.assertEqual(("com.sun.star.text.TextTableRow",), xRow.SupportedServiceNames)
        self.assertEqual(b'', xRow.ImplementationId.value)

        xTableCursor = xTable.createCursorByCellName("A1")
        self.assertEqual("SwXTextTableCursor", xTableCursor.ImplementationName)
        self.assertEqual(("com.sun.star.text.TextTableCursor",), xTableCursor.SupportedServiceNames)
        self.assertEqual(b'', xTableCursor.ImplementationId.value)

        xDoc.dispose()

    def test_xmlRangeConversions(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(4, 3)
        xCursor = xDoc.Text.createTextCursor()
        xDoc.Text.insertTextContent(xCursor, xTable, False)
        xTable.ChartColumnAsLabel = False
        xTable.ChartRowAsLabel = False
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))

        xChartDataProvider = xDoc.createInstance('com.sun.star.chart2.data.DataProvider')

        self.assertEqual('', xChartDataProvider.convertRangeToXML(''))
        self.assertEqual('', xChartDataProvider.convertRangeFromXML(''))
        self.assertEqual('.A1;.A1', xChartDataProvider.convertRangeFromXML('<some xml>'))

        xml = xChartDataProvider.convertRangeToXML('Table1.A1:C3')

        self.assertEqual("Table1.$A$1:.$C$3", xml)

        xCellRangeString = xChartDataProvider.convertRangeFromXML("Table1.$A$1:.$C$3")
        self.assertEqual("Table1.A1:C3", xCellRangeString)

        xDoc.dispose()

    def test_splitRangeHorizontal(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(2, 2)
        xText = xDoc.getText()
        xCursor = xText.createTextCursor()
        xText.insertTextContent(xCursor, xTable, False)
        xTable.Data = ((1, 2), (3, 4))
        xCursor = xTable.createCursorByCellName("A1")
        xCursor.splitRange(2, True)
        self.assertEqual(len(xTable.Data), 4)
        self.assertEqual(xTable.Data[0], (float(1), float(2)))
        self.assertEqual(xTable.Data[3], (float(3), float(4)))
        self.assertTrue(math.isnan(xTable.Data[1][0]))
        self.assertTrue(math.isnan(xTable.Data[1][1]))
        self.assertTrue(math.isnan(xTable.Data[2][0]))
        self.assertTrue(math.isnan(xTable.Data[2][1]))
        xDoc.dispose()

    def test_mergeRangeHorizontal(self):
        xDoc = CheckTable._uno.openEmptyWriterDoc()
        xTable = xDoc.createInstance("com.sun.star.text.TextTable")
        xTable.initialize(3, 3)
        xText = xDoc.getText()
        xCursor = xText.createTextCursor()
        xText.insertTextContent(xCursor, xTable, False)
        xTable.Data = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
        xCursor = xTable.createCursorByCellName("A1")
        xCursor.goDown(1, True)
        xCursor.mergeRange()
        self.assertEqual(len(xTable.Data), 3)
        self.assertEqual(xTable.Data[0], (float(1), float(2), float(3)))
        self.assertTrue(math.isnan(xTable.Data[1][0]))
        self.assertEqual(xTable.Data[1][1], float(5))
        self.assertEqual(xTable.Data[1][2], float(6))
        self.assertEqual(xTable.Data[2], (float(7), float(8), float(9)))
        xDoc.dispose()

if __name__ == '__main__':
    unittest.main()

# vim: set shiftwidth=4 softtabstop=4 expandtab: