Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 661 insertions, 0 deletions

diff --git a/sw/qa/python/check_table.py b/sw/qa/python/check_table.py
new file mode 100644
index 000000000..f845be564
--- /dev/null
+++ b/sw/qa/python/check_table.py
@@ -0,0 +1,661 @@
+#! /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: