From 95780ec73990f96dc16fc677c895d00fa1360008 Mon Sep 17 00:00:00 2001 From: Markus Mohrhard Date: Sat, 21 Jan 2012 12:02:46 +0100 Subject: refactor concept for c++ based subsequenttests --- test/Library_subsequenttest.mk | 11 + test/Package_inc.mk | 11 + test/inc/test/container/xnamecontainer.hxx | 55 ++++ test/inc/test/sheet/cellproperties.hxx | 48 ++++ test/inc/test/sheet/datapilotfield.hxx | 50 ++++ test/inc/test/sheet/tableautoformatfield.hxx | 49 ++++ test/inc/test/sheet/xcellrangesquery.hxx | 57 ++++ test/inc/test/sheet/xdatabaserange.hxx | 50 ++++ test/inc/test/sheet/xdatapilotdescriptor.hxx | 67 +++++ test/inc/test/sheet/xdatapilotfieldgrouping.hxx | 48 ++++ test/inc/test/sheet/xdatapilottable.hxx | 54 ++++ test/inc/test/sheet/xnamedrange.hxx | 56 ++++ test/inc/test/sheet/xnamedranges.hxx | 63 +++++ test/inc/test/sheet/xspreadsheets2.hxx | 83 ++++++ test/inc/test/unoapi_test.hxx | 12 +- test/source/container/xnamecontainer.cxx | 72 +++++ test/source/sheet/cellproperties.cxx | 79 ++++++ test/source/sheet/datapilotfield.cxx | 211 ++++++++++++++ test/source/sheet/tableautoformatfield.cxx | 87 ++++++ test/source/sheet/xcellrangesquery.cxx | 116 ++++++++ test/source/sheet/xdatabaserange.cxx | 145 ++++++++++ test/source/sheet/xdatapilotdescriptor.cxx | 222 +++++++++++++++ test/source/sheet/xdatapilotfieldgrouping.cxx | 62 +++++ test/source/sheet/xdatapilottable.cxx | 75 +++++ test/source/sheet/xnamedrange.cxx | 152 ++++++++++ test/source/sheet/xnamedranges.cxx | 215 +++++++++++++++ test/source/sheet/xspreadsheets2.cxx | 352 ++++++++++++++++++++++++ test/source/unoapi_test.cxx | 8 + 28 files changed, 2502 insertions(+), 8 deletions(-) create mode 100644 test/inc/test/container/xnamecontainer.hxx create mode 100644 test/inc/test/sheet/cellproperties.hxx create mode 100644 test/inc/test/sheet/datapilotfield.hxx create mode 100644 test/inc/test/sheet/tableautoformatfield.hxx create mode 100644 test/inc/test/sheet/xcellrangesquery.hxx create mode 100644 test/inc/test/sheet/xdatabaserange.hxx create mode 100644 test/inc/test/sheet/xdatapilotdescriptor.hxx create mode 100644 test/inc/test/sheet/xdatapilotfieldgrouping.hxx create mode 100644 test/inc/test/sheet/xdatapilottable.hxx create mode 100644 test/inc/test/sheet/xnamedrange.hxx create mode 100644 test/inc/test/sheet/xnamedranges.hxx create mode 100644 test/inc/test/sheet/xspreadsheets2.hxx create mode 100644 test/source/container/xnamecontainer.cxx create mode 100644 test/source/sheet/cellproperties.cxx create mode 100644 test/source/sheet/datapilotfield.cxx create mode 100644 test/source/sheet/tableautoformatfield.cxx create mode 100644 test/source/sheet/xcellrangesquery.cxx create mode 100644 test/source/sheet/xdatabaserange.cxx create mode 100644 test/source/sheet/xdatapilotdescriptor.cxx create mode 100644 test/source/sheet/xdatapilotfieldgrouping.cxx create mode 100644 test/source/sheet/xdatapilottable.cxx create mode 100644 test/source/sheet/xnamedrange.cxx create mode 100644 test/source/sheet/xnamedranges.cxx create mode 100644 test/source/sheet/xspreadsheets2.cxx (limited to 'test') diff --git a/test/Library_subsequenttest.mk b/test/Library_subsequenttest.mk index 802b0f71dc98..649fa1e75036 100644 --- a/test/Library_subsequenttest.mk +++ b/test/Library_subsequenttest.mk @@ -67,6 +67,17 @@ $(eval $(call gb_Library_use_external,subsequenttest,cppunit)) $(eval $(call gb_Library_add_exception_objects,subsequenttest,\ test/source/unoapi_test \ + test/source/container/xnamecontainer \ + test/source/sheet/cellproperties \ + test/source/sheet/datapilotfield \ + test/source/sheet/xcellrangesquery \ + test/source/sheet/xdatabaserange \ + test/source/sheet/xdatapilotdescriptor \ + test/source/sheet/xdatapilotfieldgrouping \ + test/source/sheet/xdatapilottable \ + test/source/sheet/xnamedrange \ + test/source/sheet/xnamedranges \ + test/source/sheet/xspreadsheets2 \ )) # vim: set noet sw=4 ts=4: diff --git a/test/Package_inc.mk b/test/Package_inc.mk index 13b70cf99592..aeb82f1ae73b 100644 --- a/test/Package_inc.mk +++ b/test/Package_inc.mk @@ -29,5 +29,16 @@ $(eval $(call gb_Package_Package,test_inc,$(SRCDIR)/test/inc)) $(eval $(call gb_Package_add_file,test_inc,inc/test/bootstrapfixture.hxx,test/bootstrapfixture.hxx)) $(eval $(call gb_Package_add_file,test_inc,inc/test/testdllapi.hxx,test/testdllapi.hxx)) $(eval $(call gb_Package_add_file,test_inc,inc/test/unoapi_test.hxx,test/unoapi_test.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xdatapilotdescriptor.hxx,test/sheet/xdatapilotdescriptor.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xcellrangesquery.hxx,test/sheet/xcellrangesquery.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xnamedranges.hxx,test/sheet/xnamedranges.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xnamedrange.hxx,test/sheet/xnamedrange.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xdatabaserange.hxx,test/sheet/xdatabaserange.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/container/xnamecontainer.hxx,test/container/xnamecontainer.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/cellproperties.hxx,test/sheet/cellproperties.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xdatapilottable.hxx,test/sheet/xdatapilottable.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xdatapilotfieldgrouping.hxx,test/sheet/xdatapilotfieldgrouping.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/datapilotfield.hxx,test/sheet/datapilotfield.hxx)) +$(eval $(call gb_Package_add_file,test_inc,inc/test/sheet/xspreadsheets2.hxx,test/sheet/xspreadsheets2.hxx)) # vim: set noet sw=4 ts=4: diff --git a/test/inc/test/container/xnamecontainer.hxx b/test/inc/test/container/xnamecontainer.hxx new file mode 100644 index 000000000000..6f296d7c5905 --- /dev/null +++ b/test/inc/test/container/xnamecontainer.hxx @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XNameContainer +{ +public: + // removes default entry + XNameContainer(); + // removes given entry + XNameContainer(const rtl::OUString& rName); + + virtual uno::Reference< uno::XInterface > init() = 0; + + void testRemoveByName(); + +private: + rtl::OUString maNameToRemove; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/cellproperties.hxx b/test/inc/test/sheet/cellproperties.hxx new file mode 100644 index 000000000000..f2a3b7150060 --- /dev/null +++ b/test/inc/test/sheet/cellproperties.hxx @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST CellProperties +{ +public: + virtual uno::Reference < uno::XInterface > init() = 0; + + void testVertJustify(); + void testRotateReference(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/datapilotfield.hxx b/test/inc/test/sheet/datapilotfield.hxx new file mode 100644 index 000000000000..c87dfc07537b --- /dev/null +++ b/test/inc/test/sheet/datapilotfield.hxx @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST DataPilotField +{ +public: + virtual uno::Reference< uno::XInterface > init() = 0; + + void testSortInfo(); + void testLayoutInfo(); + void testAutoShowInfo(); + void testReference(); + void testIsGroupField(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/tableautoformatfield.hxx b/test/inc/test/sheet/tableautoformatfield.hxx new file mode 100644 index 000000000000..ae262f59d34a --- /dev/null +++ b/test/inc/test/sheet/tableautoformatfield.hxx @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +using namespace com::sun::star; + +namespace apitest { + +class TableAutoFormatField +{ +public: + //don't use virtual init() here + uno::Reference< beans::XPropertySet > initTest(); + + virtual uno::Reference< > getServiceFactory() = 0; + + void testRotateReference(); + void testVertJustify(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xcellrangesquery.hxx b/test/inc/test/sheet/xcellrangesquery.hxx new file mode 100644 index 000000000000..c315163f5b90 --- /dev/null +++ b/test/inc/test/sheet/xcellrangesquery.hxx @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * [ Copyright (C) 2011 Markus Mohrhard (initial developer) ] + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include + +using namespace com::sun::star; + + +namespace apitest { + + +class OOO_DLLPUBLIC_TEST XCellRangesQuery +{ +public: + + virtual uno::Reference< uno::XInterface > init() = 0; + + //Testcases + void testQueryColumnDifference(); + void testQueryContentDifference(); + void testQueryEmptyCells(); + void testQueryFormulaCells(); + void testQueryIntersection(); + void testQueryRowDifference(); + void testQueryVisibleCells(); + +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xdatabaserange.hxx b/test/inc/test/sheet/xdatabaserange.hxx new file mode 100644 index 000000000000..6c5eac04d977 --- /dev/null +++ b/test/inc/test/sheet/xdatabaserange.hxx @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XDatabaseRange +{ +public: + virtual uno::Reference< uno::XInterface > init(const rtl::OUString& rDBName) = 0; + + void testDataArea(); + void testGetSortDescriptor(); + void testGetSubtotalDescriptor(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xdatapilotdescriptor.hxx b/test/inc/test/sheet/xdatapilotdescriptor.hxx new file mode 100644 index 000000000000..9eca14ca4c51 --- /dev/null +++ b/test/inc/test/sheet/xdatapilotdescriptor.hxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +#include + +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XDataPilotDescriptor +{ +public: + void testSourceRange(); + void testTag(); + void testGetFilterDescriptor(); + void testGetDataPilotFields(); + void testGetColumnFields(); + void testGetRowFields(); + void testGetPageFields(); + void testGetDataFields(); + void testGetHiddenFields(); + + virtual uno::Reference< uno::XInterface > init() = 0; +private: + + void testGetDataPilotFields_Impl( uno::Reference< sheet::XDataPilotDescriptor > xDescr ); + + void checkName( uno::Reference< container::XIndexAccess > xIndex, sal_Int32 nIndex ); + static std::vector maFieldNames; +}; + +std::vector< rtl::OUString > XDataPilotDescriptor::maFieldNames; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xdatapilotfieldgrouping.hxx b/test/inc/test/sheet/xdatapilotfieldgrouping.hxx new file mode 100644 index 000000000000..b1e086461693 --- /dev/null +++ b/test/inc/test/sheet/xdatapilotfieldgrouping.hxx @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XDataPilotFieldGrouping +{ +public: + void testCreateNameGroup(); + void testCreateDateGroup(); + + virtual uno::Reference< uno::XInterface > init() = 0; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xdatapilottable.hxx b/test/inc/test/sheet/xdatapilottable.hxx new file mode 100644 index 000000000000..7d67f97e7f7c --- /dev/null +++ b/test/inc/test/sheet/xdatapilottable.hxx @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +#include "cppunit/extensions/HelperMacros.h" + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XDataPilotTable +{ +public: + virtual uno::Reference< uno::XInterface > init() = 0; + + void testGetOutputRange(); + void testRefresh(); + +protected: + uno::Reference< table::XCell > xCellForChange; + uno::Reference< table::XCell > xCellForCheck; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xnamedrange.hxx b/test/inc/test/sheet/xnamedrange.hxx new file mode 100644 index 000000000000..1859237a5c96 --- /dev/null +++ b/test/inc/test/sheet/xnamedrange.hxx @@ -0,0 +1,56 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XNamedRange +{ +public: + virtual uno::Reference< uno::XInterface > init() = 0; + + // XNamedRange + void testGetContent(); + void testSetContent(); + void testGetType(); + void testSetType(); + void testGetReferencePosition(); + void testSetReferencePosition(); +protected: + virtual uno::Reference< sheet::XNamedRange> getNamedRange(const rtl::OUString&) = 0; + +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xnamedranges.hxx b/test/inc/test/sheet/xnamedranges.hxx new file mode 100644 index 000000000000..508fec5f2180 --- /dev/null +++ b/test/inc/test/sheet/xnamedranges.hxx @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XNamedRanges +{ +public: + // remove default entry + XNamedRanges(); + // removes given entry + XNamedRanges(const rtl::OUString& rNameToRemove); + + virtual uno::Reference< uno::XInterface > init(sal_Int32 nSheets = 0) = 0; + + // XNamedRanges + void testAddNewByName(); + void testAddNewFromTitles(); + void testRemoveByName(); + void testOutputList(); + +protected: + uno::Reference< sheet::XSpreadsheet > xSheet; + +private: + rtl::OUString maNameToRemove; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/sheet/xspreadsheets2.hxx b/test/inc/test/sheet/xspreadsheets2.hxx new file mode 100644 index 000000000000..cb8f5c2181c2 --- /dev/null +++ b/test/inc/test/sheet/xspreadsheets2.hxx @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include "test/testdllapi.hxx" + +#include +#include +#include +#include + +#include + +using namespace com::sun::star; + +namespace apitest { + +class OOO_DLLPUBLIC_TEST XSpreadsheets2 +{ +public: + XSpreadsheets2(); + + // XSpreadsheets2 + void testImportedSheetNameAndIndex(); + void testImportString(); + void testImportValue(); + void testImportFormulaBasicMath(); + void testImportFormulaWithNamedRange(); + void testImportOverExistingNamedRange(); + void testImportNamedRangeDefinedInSource(); + void testImportNamedRangeRedefinedInSource(); + void testImportNewNamedRange(); + void testImportCellStyle(); + + virtual uno::Reference< lang::XComponent > getComponent() = 0; + virtual uno::Reference< uno::XInterface > init() = 0; + virtual uno::Reference< lang::XComponent > loadFromDesktop(const rtl::OUString&) = 0; + virtual void createFileURL(const rtl::OUString&, rtl::OUString&) = 0; + +protected: + uno::Reference< sheet::XSpreadsheetDocument> xDocument; + +private: + uno::Reference< sheet::XSpreadsheetDocument> getDoc(const rtl::OUString&, uno::Reference< lang::XComponent >&); + uno::Reference< sheet::XNamedRanges> getNamedRanges(uno::Reference< sheet::XSpreadsheetDocument >); + void importSheetToCopy(); + bool isExternalReference(const rtl::OUString& aDestContent, const rtl::OUString& aSrcContent ); + + uno::Reference< sheet::XSpreadsheetDocument> xDestDoc; + uno::Reference< sheet::XSpreadsheet > xDestSheet; + uno::Reference< sheet::XSpreadsheet > xSrcSheet; + rtl::OUString aSrcSheetName; + rtl::OUString aSrcFileName; + rtl::OUString aDestFileBase; +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/inc/test/unoapi_test.hxx b/test/inc/test/unoapi_test.hxx index 54dcff854b41..b3e341a188d2 100644 --- a/test/inc/test/unoapi_test.hxx +++ b/test/inc/test/unoapi_test.hxx @@ -29,17 +29,10 @@ #include #include #include +#include #include #include -#define ODS_FORMAT_TYPE 50331943 -#define XLS_FORMAT_TYPE 318767171 -#define XLSX_FORMAT_TYPE 268959811 - -#define ODS 0 -#define XLS 1 -#define XLSX 2 - using namespace ::com::sun::star; using namespace ::com::sun::star::uno; @@ -55,6 +48,9 @@ public: virtual void setUp(); virtual void tearDown(); +protected: + void closeDocument( uno::Reference< lang::XComponent > xDocument ); + private: uno::Reference m_xCalcComponent; diff --git a/test/source/container/xnamecontainer.cxx b/test/source/container/xnamecontainer.cxx new file mode 100644 index 000000000000..17f8f0eee2c8 --- /dev/null +++ b/test/source/container/xnamecontainer.cxx @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include + +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +XNameContainer::XNameContainer(): maNameToRemove(RTL_CONSTASCII_USTRINGPARAM("XNameContainer")) +{ +} + +XNameContainer::XNameContainer(const rtl::OUString& rNameToRemove): + maNameToRemove(rNameToRemove) +{ +} + +void XNameContainer::testRemoveByName() +{ + uno::Reference< container::XNameContainer > xNameContainer(init(),UNO_QUERY_THROW); + CPPUNIT_ASSERT(xNameContainer->hasByName(maNameToRemove)); + xNameContainer->removeByName(maNameToRemove); + CPPUNIT_ASSERT(!xNameContainer->hasByName(maNameToRemove)); + + bool bExceptionThrown = false; + try + { + xNameContainer->removeByName(maNameToRemove); + } + catch( const container::NoSuchElementException& ) + { + std::cout << "Exception Caught" << std::endl; + bExceptionThrown = true; + } + + CPPUNIT_ASSERT_MESSAGE("no exception thrown", bExceptionThrown); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/cellproperties.cxx b/test/source/sheet/cellproperties.cxx new file mode 100644 index 000000000000..d9d5fc00891b --- /dev/null +++ b/test/source/sheet/cellproperties.cxx @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include + +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +void CellProperties::testVertJustify() +{ + uno::Reference< beans::XPropertySet > xCellRangeBase(init(),UNO_QUERY_THROW); + rtl::OUString aVertJustify(RTL_CONSTASCII_USTRINGPARAM("VertJustify")); + uno::Any aOldVertJustify = xCellRangeBase->getPropertyValue(aVertJustify); + sal_Int32 aValue = 0; + CPPUNIT_ASSERT(aOldVertJustify >>= aValue); + std::cout << "Old VertJustify value: " << aValue << std::endl; + + uno::Any aNewVertJustify; + aNewVertJustify <<= static_cast(3); + xCellRangeBase->setPropertyValue(aVertJustify, aNewVertJustify); + uno::Any aVertJustifyControllValue = xCellRangeBase->getPropertyValue(aVertJustify); + CPPUNIT_ASSERT(aVertJustifyControllValue >>= aValue); + std::cout << "New VertJustify value: " << aValue << std::endl; + CPPUNIT_ASSERT_MESSAGE("value has not been changed", aValue == 3); +} + +void CellProperties::testRotateReference() +{ + uno::Reference< beans::XPropertySet > xCellRangeBase(init(),UNO_QUERY_THROW); + rtl::OUString aRotateReference(RTL_CONSTASCII_USTRINGPARAM("RotateReference")); + uno::Any aOldRotateReference = xCellRangeBase->getPropertyValue(aRotateReference); + sal_Int32 aValue = 0; + CPPUNIT_ASSERT(aOldRotateReference >>= aValue); + std::cout << "Old RotateReference Value: " << aValue << std::endl; + + uno::Any aNewRotateReference; + aNewRotateReference <<= static_cast(3); + xCellRangeBase->setPropertyValue(aRotateReference, aNewRotateReference); + uno::Any aRotateReferenceControllValue = xCellRangeBase->getPropertyValue(aRotateReference); + CPPUNIT_ASSERT(aRotateReferenceControllValue >>= aValue); + std::cout << "New RotateReference value: " << aValue << std::endl; + CPPUNIT_ASSERT_MESSAGE("value has not been changed", aValue == 3); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/datapilotfield.cxx b/test/source/sheet/datapilotfield.cxx new file mode 100644 index 000000000000..3a323bee9d2a --- /dev/null +++ b/test/source/sheet/datapilotfield.cxx @@ -0,0 +1,211 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +void DataPilotField::testSortInfo() +{ + uno::Reference< beans::XPropertySet> xPropSet(init(),UNO_QUERY_THROW); + sheet::DataPilotFieldSortInfo aSortInfoValue; + rtl::OUString aSortInfo(RTL_CONSTASCII_USTRINGPARAM("SortInfo")); + aSortInfoValue.Field = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Col1")); + aSortInfoValue.IsAscending = false; + aSortInfoValue.Mode = sheet::DataPilotFieldSortMode::MANUAL; + uno::Any xValue; + xValue <<= aSortInfoValue; + xPropSet->setPropertyValue(aSortInfo, xValue); + + sheet::DataPilotFieldSortInfo aNewSortInfoValue; + xValue = xPropSet->getPropertyValue(aSortInfo); + CPPUNIT_ASSERT( xValue >>= aNewSortInfoValue ); + CPPUNIT_ASSERT_MESSAGE("set value should be the same as got value", aNewSortInfoValue.Field == aSortInfoValue.Field + && aNewSortInfoValue.Mode == aSortInfoValue.Mode && aNewSortInfoValue.IsAscending == aSortInfoValue.IsAscending); + + //setting HasSortInfo only makes sense for false, for true the uno implementation does nothing + sal_Bool bHasSortInfo; + rtl::OUString aHasSortInfo(RTL_CONSTASCII_USTRINGPARAM("HasSortInfo")); + xValue = xPropSet->getPropertyValue(aHasSortInfo); + CPPUNIT_ASSERT( xValue >>= bHasSortInfo ); + CPPUNIT_ASSERT_MESSAGE("should have sort info", bHasSortInfo); + + bHasSortInfo = false; + xValue <<= bHasSortInfo; + xPropSet->setPropertyValue(aHasSortInfo, xValue); + + xValue = xPropSet->getPropertyValue(aHasSortInfo); + CPPUNIT_ASSERT( xValue >>= bHasSortInfo ); + CPPUNIT_ASSERT_MESSAGE("should have no sort info", !bHasSortInfo); +} + +void DataPilotField::testLayoutInfo() +{ + uno::Reference< beans::XPropertySet > xPropSet(init(),UNO_QUERY_THROW); + sheet::DataPilotFieldLayoutInfo aLayoutInfoValue; + rtl::OUString aLayoutInfo(RTL_CONSTASCII_USTRINGPARAM("LayoutInfo")); + aLayoutInfoValue.AddEmptyLines = false; + aLayoutInfoValue.LayoutMode = sheet::DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_BOTTOM; + uno::Any xValue; + xValue <<= aLayoutInfoValue; + xPropSet->setPropertyValue(aLayoutInfo, xValue); + + sheet::DataPilotFieldLayoutInfo aNewLayoutInfoValue; + xValue = xPropSet->getPropertyValue(aLayoutInfo); + CPPUNIT_ASSERT( xValue >>= aNewLayoutInfoValue ); + CPPUNIT_ASSERT_MESSAGE("set value should be the same as the got value", aNewLayoutInfoValue.LayoutMode == aLayoutInfoValue.LayoutMode && + aNewLayoutInfoValue.AddEmptyLines == aLayoutInfoValue.AddEmptyLines); + + //setting HasLayoutInfo only makes sense for false, tor true the uno implementation does nothing + sal_Bool bHasLayoutInfo; + rtl::OUString aHasLayoutInfo(RTL_CONSTASCII_USTRINGPARAM("HasLayoutInfo")); + xValue = xPropSet->getPropertyValue(aHasLayoutInfo); + CPPUNIT_ASSERT( xValue >>= bHasLayoutInfo ); + CPPUNIT_ASSERT_MESSAGE("should have layout information", bHasLayoutInfo); + + bHasLayoutInfo = false; + xValue <<= bHasLayoutInfo; + xPropSet->setPropertyValue(aHasLayoutInfo, xValue); + + xValue = xPropSet->getPropertyValue(aHasLayoutInfo); + CPPUNIT_ASSERT( xValue >>= bHasLayoutInfo ); + CPPUNIT_ASSERT_MESSAGE("should have no longer sort information", !bHasLayoutInfo); +} + +void DataPilotField::testAutoShowInfo() +{ + uno::Reference< beans::XPropertySet > xPropSet(init(),UNO_QUERY_THROW); + sheet::DataPilotFieldAutoShowInfo aAutoShowInfoValue; + aAutoShowInfoValue.DataField = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Col1")); + aAutoShowInfoValue.IsEnabled = true; + rtl::OUString aAutoShowInfo(RTL_CONSTASCII_USTRINGPARAM("AutoShowInfo")); + uno::Any xValue; + xValue <<= aAutoShowInfoValue; + xPropSet->setPropertyValue(aAutoShowInfo, xValue); + + sheet::DataPilotFieldAutoShowInfo aNewAutoShowInfoValue; + xValue = xPropSet->getPropertyValue(aAutoShowInfo); + CPPUNIT_ASSERT( xValue >>= aNewAutoShowInfoValue ); + CPPUNIT_ASSERT_MESSAGE("set value should be the same as the got value", aNewAutoShowInfoValue.DataField == aAutoShowInfoValue.DataField && + aNewAutoShowInfoValue.IsEnabled == aAutoShowInfoValue.IsEnabled); + + //setting HasLayoutInfo only makes sense for false, tor true the uno implementation does nothing + sal_Bool bHasAutoShowInfo; + rtl::OUString aHasAutoShowInfo(RTL_CONSTASCII_USTRINGPARAM("HasAutoShowInfo")); + xValue = xPropSet->getPropertyValue(aHasAutoShowInfo); + CPPUNIT_ASSERT( xValue >>= bHasAutoShowInfo ); + CPPUNIT_ASSERT_MESSAGE("should have AutoShow information", bHasAutoShowInfo); + + bHasAutoShowInfo = false; + xValue <<= bHasAutoShowInfo; + xPropSet->setPropertyValue(aHasAutoShowInfo, xValue); + + xValue = xPropSet->getPropertyValue(aHasAutoShowInfo); + CPPUNIT_ASSERT( xValue >>= bHasAutoShowInfo ); + CPPUNIT_ASSERT_MESSAGE("should have no longer AutoShow information", !bHasAutoShowInfo); +} + +void DataPilotField::testReference() +{ + uno::Reference< beans::XPropertySet > xPropSet(init(),UNO_QUERY_THROW); + sheet::DataPilotFieldReference aReferenceValue; + aReferenceValue.ReferenceField = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Col1")); + aReferenceValue.ReferenceItemType = sheet::DataPilotFieldReferenceItemType::NAMED; + rtl::OUString aReference(RTL_CONSTASCII_USTRINGPARAM("Reference")); + uno::Any xValue; + xValue <<= aReferenceValue; + xPropSet->setPropertyValue(aReference, xValue); + + sheet::DataPilotFieldReference aNewReferenceValue; + xValue = xPropSet->getPropertyValue(aReference); + CPPUNIT_ASSERT( xValue >>= aNewReferenceValue ); + CPPUNIT_ASSERT_MESSAGE("set value should be the same as the got value", aReferenceValue.ReferenceField == aNewReferenceValue.ReferenceField + && aReferenceValue.ReferenceItemType == aNewReferenceValue.ReferenceItemType); + + //setting HasReference only makes sense for false, tor true the uno implementation does nothing + sal_Bool bHasReference; + rtl::OUString aHasReference(RTL_CONSTASCII_USTRINGPARAM("HasReference")); + xValue = xPropSet->getPropertyValue(aHasReference); + CPPUNIT_ASSERT( xValue >>= bHasReference ); + CPPUNIT_ASSERT_MESSAGE("should have Reference information", bHasReference); + + bHasReference = false; + xValue <<= bHasReference; + xPropSet->setPropertyValue(aHasReference, xValue); + + xValue = xPropSet->getPropertyValue(aHasReference); + CPPUNIT_ASSERT( xValue >>= bHasReference ); + CPPUNIT_ASSERT_MESSAGE("should have no longer reference information", !bHasReference); +} + +void DataPilotField::testIsGroupField() +{ + uno::Reference< beans::XPropertySet > xPropSet(init(),UNO_QUERY_THROW); + uno::Any xValue; + rtl::OUString aIsGroupField(RTL_CONSTASCII_USTRINGPARAM("IsGroupField")); + sal_Bool bIsGroupField; + + xValue = xPropSet->getPropertyValue(aIsGroupField); + CPPUNIT_ASSERT( xValue >>= bIsGroupField); + //only setting to false is supported + if (bIsGroupField) + { + bIsGroupField = false; + xValue <<= bIsGroupField; + + xPropSet->setPropertyValue(aIsGroupField, xValue); + xValue = xPropSet->getPropertyValue(aIsGroupField); + CPPUNIT_ASSERT(xValue >>= bIsGroupField); + CPPUNIT_ASSERT_MESSAGE("setting IsGroupField is supported and should have happened", !bIsGroupField); + } + else + std::cout << "Could not test IsGroupField" << std::endl; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/tableautoformatfield.cxx b/test/source/sheet/tableautoformatfield.cxx new file mode 100644 index 000000000000..c846b6a22503 --- /dev/null +++ b/test/source/sheet/tableautoformatfield.cxx @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initTestial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include "cppunit/extensions/HelperMacros.h" + +using namespace com::sun::star::uno; + +namespace apitest { + +uno::Reference< beans::XPropertySet > TableAutoFormatField::initTest() +{ + uno::Reference< container::XIndexAccess > xAutoFormatFields( getServiceFactory()->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.TableAutoFormats"))), UNO_QUERY_THROW ); + CPPUNIT_ASSERT(xAutoFormatFields.is()); + uno::Reference< container::XIndexAccess > xIndex( xAutoFormatFields->getByIndex(0), UNO_QUERY_THROW ); + CPPUNIT_ASSERT(xIndex.is()); + uno::Reference< beans::XPropertySet > xReturn( xIndex->getByIndex(0), UNO_QUERY_THROW ); + CPPUNIT_ASSERT_MESSAGE("could not create table auto formats", xReturn.is()); + return xReturn; +} + +void TableAutoFormatField::testRotateReference() +{ + uno::Reference< beans::XPropertySet > xTableAutoFormatField = initTest(); + rtl::OUString aRotateReference(RTL_CONSTASCII_USTRINGPARAM("RotateReference")); + uno::Any aOldRotateReference = xTableAutoFormatField->getPropertyValue(aRotateReference); + sal_Int32 aValue = 0; + CPPUNIT_ASSERT(aOldRotateReference >>= aValue); + std::cout << "Old RotateReferene Value: " << aValue << std::endl; + + uno::Any aNewRotateReference; + aNewRotateReference <<= static_cast(3); + xTableAutoFormatField->setPropertyValue(aRotateReference, aNewRotateReference); + uno::Any aRotateReferenceControllValue = xTableAutoFormatField->getPropertyValue(aRotateReference); + CPPUNIT_ASSERT(aRotateReferenceControllValue >>= aValue); + std::cout << "New VertJustify value: " << aValue << std::endl; + CPPUNIT_ASSERT_MESSAGE("value has not been changed", aValue == 3); +} + +void TableAutoFormatField::testVertJustify() +{ + uno::Reference< beans::XPropertySet > xTableAutoFormatField = initTest(); + rtl::OUString aVertJustify(RTL_CONSTASCII_USTRINGPARAM("VertJustify")); + uno::Any aOldVertJustify = xTableAutoFormatField->getPropertyValue(aVertJustify); + sal_Int32 aValue = 0; + CPPUNIT_ASSERT(aOldVertJustify >>= aValue); + std::cout << "Old VertJustify value: " << aValue << std::endl; + + uno::Any aNewVertJustify; + aNewVertJustify <<= static_cast(3); + xTableAutoFormatField->setPropertyValue(aVertJustify, aNewVertJustify); + uno::Any aVertJustifyControllValue = xTableAutoFormatField->getPropertyValue(aVertJustify); + CPPUNIT_ASSERT(aVertJustifyControllValue >>= aValue); + std::cout << "New VertJustify value: " << aValue << std::endl; + CPPUNIT_ASSERT_MESSAGE("value has not been changed", aValue == 3); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xcellrangesquery.cxx b/test/source/sheet/xcellrangesquery.cxx new file mode 100644 index 000000000000..b1f55e05d3f4 --- /dev/null +++ b/test/source/sheet/xcellrangesquery.cxx @@ -0,0 +1,116 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * [ Copyright (C) 2011 Markus Mohrhard (initial developer) ] + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include +#include +#include + +#include "cppunit/extensions/HelperMacros.h" + +using namespace com::sun::star; +using namespace com::sun::star::uno; + + +namespace apitest { + +void XCellRangesQuery::testQueryColumnDifference() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.B1:C1,Sheet1.B3:C5")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryColumnDifferences(table::CellAddress(0, 1, 1)); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryColumnDifference: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryColumnDifference", aResult == aExpected); +} + +void XCellRangesQuery::testQueryContentDifference() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.B2:B3")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryContentCells(sheet::CellFlags::VALUE); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryContentDifference: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryContentDifference", aResult == aExpected); +} + +void XCellRangesQuery::testQueryEmptyCells() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.A1:A5,Sheet1.B1:C1,Sheet1.B5,Sheet1.C3:C5,Sheet1.D1:D5")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryEmptyCells(); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryEmptyCells: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryEmptyCells", aResult == aExpected); +} + +void XCellRangesQuery::testQueryFormulaCells() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.C2")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryFormulaCells(sheet::CellFlags::FORMULA); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryFormulaCells: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryFormulaCells", aResult == aExpected); +} + +void XCellRangesQuery::testQueryIntersection() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.D4:D5")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryIntersection(table::CellRangeAddress(0,3,3,7,7)); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryIntersection: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryFormulaCells", aResult == aExpected); +} + +void XCellRangesQuery::testQueryRowDifference() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.A2:A4,Sheet1.C2:D4")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryRowDifferences(table::CellAddress(0,1,1)); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryRowDifference: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryFormulaCells", aResult == aExpected); +} + +void XCellRangesQuery::testQueryVisibleCells() +{ + rtl::OUString aExpected(RTL_CONSTASCII_USTRINGPARAM("Sheet1.A1:D5")); + uno::Reference xCellRangesQuery(init(),UNO_QUERY_THROW); + uno::Reference xRanges = xCellRangesQuery->queryVisibleCells(); + rtl::OUString aResult = xRanges->getRangeAddressesAsString(); + std::cout << "testQueryVisibleCells: Result: " << rtl::OUStringToOString(aResult, RTL_TEXTENCODING_UTF8).getStr() << std::endl; + CPPUNIT_ASSERT_MESSAGE("testQueryFormulaCells", aResult == aExpected); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xdatabaserange.cxx b/test/source/sheet/xdatabaserange.cxx new file mode 100644 index 000000000000..d8cf5e4a1929 --- /dev/null +++ b/test/source/sheet/xdatabaserange.cxx @@ -0,0 +1,145 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +/** + * tests setDataArea and getDataArea + */ +void XDatabaseRange::testDataArea() +{ + uno::Reference< sheet::XDatabaseRange > xDBRange(init(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataArea"))), UNO_QUERY_THROW); + + table::CellRangeAddress aCellAddress; + aCellAddress.Sheet = 0; + aCellAddress.StartColumn = 1; + aCellAddress.EndColumn = 4; + aCellAddress.StartRow = 2; + aCellAddress.EndRow = 5; + xDBRange->setDataArea(aCellAddress); + table::CellRangeAddress aValue; + aValue = xDBRange->getDataArea(); + CPPUNIT_ASSERT( aCellAddress.Sheet == aValue.Sheet ); + CPPUNIT_ASSERT( aCellAddress.StartRow == aValue.StartRow ); + CPPUNIT_ASSERT( aCellAddress.EndRow == aValue.EndRow ); + CPPUNIT_ASSERT( aCellAddress.StartColumn == aValue.StartColumn ); + CPPUNIT_ASSERT( aCellAddress.EndColumn == aValue.EndColumn ); +} + +void XDatabaseRange::testGetSubtotalDescriptor() +{ + uno::Reference< sheet::XDatabaseRange > xDBRange(init(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SubtotalDescriptor"))), UNO_QUERY_THROW); + uno::Reference< sheet::XSubTotalDescriptor> xSubtotalDescr = xDBRange->getSubTotalDescriptor(); + CPPUNIT_ASSERT(xSubtotalDescr.is()); +} + +void XDatabaseRange::testGetSortDescriptor() +{ + uno::Reference< sheet::XDatabaseRange > xDBRange(init(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SortDescriptor"))), UNO_QUERY_THROW); + uno::Sequence< beans::PropertyValue > xSortDescr = xDBRange->getSortDescriptor(); + for (sal_Int32 i = 0; i < xSortDescr.getLength(); ++i) + { + beans::PropertyValue xProp = xSortDescr[i]; + //std::cout << "Prop " << i << " Name: " << rtl::OUString(xProp.Name) << std::endl; + + if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IsSortColumns"))) + { + sal_Bool bIsSortColumns; + xProp.Value >>= bIsSortColumns; + CPPUNIT_ASSERT(bIsSortColumns == false); + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ContainsHeader"))) + { + sal_Bool bContainsHeader; + xProp.Value >>= bContainsHeader; + CPPUNIT_ASSERT(bContainsHeader == true); + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MaxFieldCount"))) + { + sal_Int32 nMaxFieldCount; + xProp.Value >>= nMaxFieldCount; + std::cout << "Value: " << nMaxFieldCount << std::endl; + + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SortFields"))) + { + + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BindFormatsToContent"))) + { + sal_Bool bBindFormatsToContent; + xProp.Value >>= bBindFormatsToContent; + CPPUNIT_ASSERT(bBindFormatsToContent == true); + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CopyOutputData"))) + { + sal_Bool bCopyOutputData; + xProp.Value >>= bCopyOutputData; + CPPUNIT_ASSERT(bCopyOutputData == false); + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OutputPosition"))) + { + + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IsUserListEnabled"))) + { + sal_Bool bIsUserListEnabled; + xProp.Value >>= bIsUserListEnabled; + CPPUNIT_ASSERT(bIsUserListEnabled == false); + + } + else if (xProp.Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("UserListIndex"))) + { + sal_Int32 nUserListIndex; + xProp.Value >>= nUserListIndex; + CPPUNIT_ASSERT(nUserListIndex == 0); + } + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xdatapilotdescriptor.cxx b/test/source/sheet/xdatapilotdescriptor.cxx new file mode 100644 index 000000000000..aa39416d0be6 --- /dev/null +++ b/test/source/sheet/xdatapilotdescriptor.cxx @@ -0,0 +1,222 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include "test/sheet/xdatapilotdescriptor.hxx" + +#include +#include +#include +#include + +#include "cppunit/extensions/HelperMacros.h" + +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +void XDataPilotDescriptor::testTag() +{ + rtl::OUString aTag(RTL_CONSTASCII_USTRINGPARAM("DataPilotDescriptor_Tag")); + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(), UNO_QUERY_THROW); + xDescr->setTag(aTag); + rtl::OUString aNewTag = xDescr->getTag(); + CPPUNIT_ASSERT( aTag == aNewTag ); +} + +void XDataPilotDescriptor::testSourceRange() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(), UNO_QUERY_THROW); + table::CellRangeAddress aOldAddress = xDescr->getSourceRange(); + + table::CellRangeAddress aAddress; + aAddress.Sheet = 1; + aAddress.StartColumn = 1; + aAddress.StartRow = 1; + aAddress.EndColumn = 5; + aAddress.EndRow = 5; + xDescr->setSourceRange(aAddress); + + table::CellRangeAddress aReturn; + aReturn = xDescr->getSourceRange(); + + CPPUNIT_ASSERT(aAddress.Sheet == aReturn.Sheet); + CPPUNIT_ASSERT(aAddress.StartColumn == aReturn.StartColumn); + CPPUNIT_ASSERT(aAddress.StartRow == aReturn.StartRow); + CPPUNIT_ASSERT(aAddress.EndColumn == aReturn.EndColumn); + CPPUNIT_ASSERT(aAddress.EndRow == aReturn.EndRow); + + //restore old settings + xDescr->setSourceRange(aOldAddress); +} + +void XDataPilotDescriptor::testGetFilterDescriptor() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(), UNO_QUERY_THROW); + uno::Reference< sheet::XSheetFilterDescriptor > xSheetFilterDescr = xDescr->getFilterDescriptor(); + CPPUNIT_ASSERT(xSheetFilterDescr.is()); +} + +void XDataPilotDescriptor::testGetDataPilotFields_Impl( uno::Reference< sheet::XDataPilotDescriptor > xDescr) +{ + //this method should only be called once but needs to be called before any of the other tests + static bool bCalled = false; + if (bCalled) + return; + else + bCalled = true; + + uno::Reference< container::XIndexAccess > xIndex(xDescr->getDataPilotFields(), UNO_QUERY_THROW); + CPPUNIT_ASSERT( xIndex.is()); + + sal_Int32 nCount = xIndex->getCount(); + + rtl::OUString aOrientation(RTL_CONSTASCII_USTRINGPARAM("Orientation")); + for (sal_Int32 i = 0; i < nCount && i < 5; ++i) + { + uno::Reference< container::XNamed > xNamed( xIndex->getByIndex( i ), UNO_QUERY_THROW); + CPPUNIT_ASSERT(xNamed.is()); + rtl::OUString aName = xNamed->getName(); + maFieldNames.push_back(aName); + CPPUNIT_ASSERT( !aName.equalsAscii("Data") ); + + uno::Reference< beans::XPropertySet > xPropSet( xNamed, UNO_QUERY_THROW); + CPPUNIT_ASSERT( xPropSet.is() ); + + switch ( i % 5 ) + { + case 0: + { + uno::Any aAny; + aAny<<= sheet::DataPilotFieldOrientation_COLUMN; + xPropSet->setPropertyValue(aOrientation, aAny); + } + break; + case 1: + { + uno::Any aAny; + aAny<<= sheet::DataPilotFieldOrientation_ROW; + xPropSet->setPropertyValue(aOrientation, aAny); + } + break; + case 2: + { + uno::Any aAny; + aAny<<= sheet::DataPilotFieldOrientation_DATA; + xPropSet->setPropertyValue(aOrientation, aAny); + } + break; + case 3: + { + uno::Any aAny; + aAny<<= sheet::DataPilotFieldOrientation_HIDDEN; + xPropSet->setPropertyValue(aOrientation, aAny); + } + break; + case 4: + { + uno::Any aAny; + aAny<<= sheet::DataPilotFieldOrientation_PAGE; + xPropSet->setPropertyValue(aOrientation, aAny); + } + break; + default: + break; + } + } +} + +void XDataPilotDescriptor::testGetDataPilotFields() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(), UNO_QUERY_THROW); + testGetDataPilotFields_Impl( xDescr ); +} + +void XDataPilotDescriptor::testGetColumnFields() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(),UNO_QUERY_THROW); + testGetDataPilotFields_Impl( xDescr ); + uno::Reference< container::XIndexAccess > xIndex(xDescr->getColumnFields(), UNO_QUERY_THROW); + + checkName( xIndex, 0 ); +} + +void XDataPilotDescriptor::testGetRowFields() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(),UNO_QUERY_THROW); + testGetDataPilotFields_Impl( xDescr ); + uno::Reference< container::XIndexAccess > xIndex(xDescr->getRowFields(), UNO_QUERY_THROW); + + //checkName( xIndex, 1 ); +} + +void XDataPilotDescriptor::testGetPageFields() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(), UNO_QUERY_THROW); + testGetDataPilotFields_Impl( xDescr ); + uno::Reference< container::XIndexAccess > xIndex(xDescr->getPageFields(), UNO_QUERY_THROW); + + checkName( xIndex, 4 ); +} + +void XDataPilotDescriptor::testGetDataFields() +{ + uno::Reference< sheet::XDataPilotDescriptor > xDescr(init(),UNO_QUERY_THROW); + testGetDataPilotFields_Impl( xDescr ); + uno::Reference< container::XIndexAccess > xIndex(xDescr->getDataFields(), UNO_QUERY_THROW); + + checkName( xIndex, 2 ); +} + +void XDataPilotDescriptor::testGetHiddenFields() +{ + std::cout << "testGetHiddenFields" < xDescr(init(),UNO_QUERY_THROW);; + testGetDataPilotFields_Impl( xDescr ); + uno::Reference< container::XIndexAccess > xIndex(xDescr->getHiddenFields(), UNO_QUERY_THROW); + + checkName( xIndex, 3 ); +} + +void XDataPilotDescriptor::checkName( uno::Reference< container::XIndexAccess > xIndex, sal_Int32 nIndex ) +{ + CPPUNIT_ASSERT(xIndex.is()); + CPPUNIT_ASSERT(maFieldNames.size() >= static_cast(nIndex)); + + for (sal_Int32 i = 0; i < xIndex->getCount(); ++i) + { + uno::Reference< container::XNamed > xNamed( xIndex->getByIndex(i), UNO_QUERY_THROW); + std::cout << "Expected: " << maFieldNames[nIndex] << " Got: " << xNamed->getName() << std::endl; + CPPUNIT_ASSERT( xNamed->getName() == maFieldNames[nIndex] ); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xdatapilotfieldgrouping.cxx b/test/source/sheet/xdatapilotfieldgrouping.cxx new file mode 100644 index 000000000000..942addc2a25c --- /dev/null +++ b/test/source/sheet/xdatapilotfieldgrouping.cxx @@ -0,0 +1,62 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include + +#include "cppunit/extensions/HelperMacros.h" + +using namespace com::sun::star::uno; + +namespace apitest { + +void XDataPilotFieldGrouping::testCreateNameGroup() +{ + uno::Reference< sheet::XDataPilotFieldGrouping > xDataPilotFieldGrouping(init(),UNO_QUERY_THROW); + uno::Reference< sheet::XDataPilotField > xDataPilotField( xDataPilotFieldGrouping, UNO_QUERY_THROW ); + uno::Reference< container::XNameAccess > xNameAccess( xDataPilotField->getItems(), UNO_QUERY_THROW ); + CPPUNIT_ASSERT(xNameAccess->hasElements()); + + uno::Sequence< rtl::OUString > aElements = xNameAccess->getElementNames(); + xDataPilotFieldGrouping->createNameGroup( aElements ); +} + +void XDataPilotFieldGrouping::testCreateDateGroup() +{ + uno::Reference< sheet::XDataPilotFieldGrouping > xDataPilotFieldGrouping(init(),UNO_QUERY_THROW); + sheet::DataPilotFieldGroupInfo aGroupInfo; + aGroupInfo.GroupBy = sheet::DataPilotFieldGroupBy::MONTHS; + aGroupInfo.HasDateValues = true; + xDataPilotFieldGrouping->createDateGroup(aGroupInfo); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xdatapilottable.cxx b/test/source/sheet/xdatapilottable.cxx new file mode 100644 index 000000000000..64bc81364dd2 --- /dev/null +++ b/test/source/sheet/xdatapilottable.cxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2012 Markus Mohrhard (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace com::sun::star::uno; + +namespace apitest +{ + +void XDataPilotTable::testGetOutputRange() +{ + uno::Reference< sheet::XDataPilotTable > xDPTable(init(),UNO_QUERY_THROW); + + table::CellRangeAddress aRange = xDPTable->getOutputRange(); + CPPUNIT_ASSERT( aRange.Sheet == 0 ); + CPPUNIT_ASSERT( aRange.StartColumn == 7 ); + CPPUNIT_ASSERT( aRange.StartRow == 8 ); +} + +void XDataPilotTable::testRefresh() +{ + uno::Reference< sheet::XDataPilotTable > xDPTable(init(),UNO_QUERY_THROW); + std::cout << "xCellForChange: Old Value: " << xCellForChange->getValue() << std::endl; + std::cout << "xCellForCheck: Old Value: " << xCellForCheck->getValue() << std::endl; + double aOldData = xCellForCheck->getValue(); + xCellForChange->setValue( 5 ); + + xDPTable->refresh(); + xDPTable->refresh(); + std::cout << "xCellForChange: Old Value: " << xCellForChange->getValue() << std::endl; + std::cout << "xCellForCheck: Old Value: " << xCellForCheck->getValue() << std::endl; + double aNewData = xCellForCheck->getValue(); + CPPUNIT_ASSERT_MESSAGE("value needs to change", aOldData != aNewData); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xnamedrange.cxx b/test/source/sheet/xnamedrange.cxx new file mode 100644 index 000000000000..1c910852e4be --- /dev/null +++ b/test/source/sheet/xnamedrange.cxx @@ -0,0 +1,152 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +void XNamedRange::testGetContent() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + + rtl::OUString aExpectedContent(RTL_CONSTASCII_USTRINGPARAM("$Sheet1.$B$1")); + CPPUNIT_ASSERT_MESSAGE("Wrong expected content for initial1 on GetContent", xNamedRange->getContent().equals(aExpectedContent)); +} + +void XNamedRange::testSetContent() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + + rtl::OUString aExpectedContent; + + // test a cell + aExpectedContent = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("D1")); + xNamedRange->setContent(aExpectedContent); + CPPUNIT_ASSERT_MESSAGE("Wrong expected content for initial1 after SetContent a cell", xNamedRange->getContent().equals(aExpectedContent)); + + // test a cellrange + aExpectedContent = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("D1:D10")); + xNamedRange->setContent(aExpectedContent); + CPPUNIT_ASSERT_MESSAGE("Wrong expected content for initial1 after SetContent a cellrange", xNamedRange->getContent().equals(aExpectedContent)); + + // test a formula + aExpectedContent = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=D10")); + xNamedRange->setContent(aExpectedContent); + aExpectedContent = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("D10")); + CPPUNIT_ASSERT_MESSAGE("Wrong expected content for initial1 after SetContent a formula", xNamedRange->getContent().equals(aExpectedContent)); + +} + +void XNamedRange::testGetType() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type", xNamedRange->getType() == 0); +} + +void XNamedRange::testSetType() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + + sal_Int32 nType = ::sheet::NamedRangeFlag::ROW_HEADER;; + xNamedRange->setType(nType); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type ROW_HEADER after setting it", xNamedRange->getType() == nType); + + nType = ::sheet::NamedRangeFlag::COLUMN_HEADER; + xNamedRange->setType(nType); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type COLUMN_HEADER after setting it", xNamedRange->getType() == nType); + + nType = ::sheet::NamedRangeFlag::FILTER_CRITERIA; + xNamedRange->setType(nType); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type FILTER_CRITERIA after setting it", xNamedRange->getType() == nType); + + nType = ::sheet::NamedRangeFlag::PRINT_AREA; + xNamedRange->setType(nType); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type PRINT_AREA after setting it", xNamedRange->getType() == nType); + + nType = 0; + xNamedRange->setType(nType); + CPPUNIT_ASSERT_MESSAGE("Wrong expected Type 0 after setting it", xNamedRange->getType() == nType); +} + +void XNamedRange::testGetReferencePosition() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial2")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + + table::CellAddress xCellAddress = xNamedRange->getReferencePosition(); + // the expeted address is on B1, as it was the active cell when intial2 created + CPPUNIT_ASSERT_MESSAGE("Wrong SHEET reference position", xCellAddress.Sheet == 0); + CPPUNIT_ASSERT_MESSAGE("Wrong COLUMN reference position", xCellAddress.Column == 1); + CPPUNIT_ASSERT_MESSAGE("Wrong ROW reference position", xCellAddress.Row == 0); +} + +void XNamedRange::testSetReferencePosition() +{ + rtl::OUString aTestedNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + uno::Reference< sheet::XNamedRange > xNamedRange = getNamedRange(aTestedNamedRangeString); + + table::CellAddress aBaseAddress = table::CellAddress(1,2,3); + + xNamedRange->setReferencePosition(aBaseAddress); + + table::CellAddress xCellAddress = xNamedRange->getReferencePosition(); + CPPUNIT_ASSERT_MESSAGE("Wrong SHEET reference position after setting it", xCellAddress.Sheet == 1); + CPPUNIT_ASSERT_MESSAGE("Wrong COLUMN reference position after setting it", xCellAddress.Column == 2); + CPPUNIT_ASSERT_MESSAGE("Wrong ROW reference position after setting it", xCellAddress.Row == 3); +} + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xnamedranges.cxx b/test/source/sheet/xnamedranges.cxx new file mode 100644 index 000000000000..9f5b3aa07a42 --- /dev/null +++ b/test/source/sheet/xnamedranges.cxx @@ -0,0 +1,215 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include "cppunit/extensions/HelperMacros.h" +#include + +using namespace com::sun::star::uno; + +namespace apitest { + +XNamedRanges::XNamedRanges(): + maNameToRemove(RTL_CONSTASCII_USTRINGPARAM("initial1")) +{ + +} + +XNamedRanges::XNamedRanges(const rtl::OUString& rNameToRemove): + maNameToRemove(rNameToRemove) +{ + +} + +void XNamedRanges::testAddNewByName() +{ + uno::Reference< sheet::XNamedRanges > xNamedRanges(init(), UNO_QUERY_THROW); + uno::Reference< container::XNameAccess > xNamedRangesNameAccess(init(1), UNO_QUERY_THROW); + + table::CellAddress aBaseAddress = table::CellAddress(0,0,0); + + sal_Int32 nType = 0; + rtl::OUString aContent1(RTL_CONSTASCII_USTRINGPARAM("D1")); + rtl::OUString aName1(RTL_CONSTASCII_USTRINGPARAM("type_0")); + xNamedRanges->addNewByName(aName1, aContent1, aBaseAddress, nType); + CPPUNIT_ASSERT_MESSAGE("Failed to create Namedrange Type 0 - Normal case", xNamedRanges->hasByName(aName1)); + + nType = ::sheet::NamedRangeFlag::COLUMN_HEADER; + rtl::OUString aContent2(RTL_CONSTASCII_USTRINGPARAM("D2")); + rtl::OUString aName2(RTL_CONSTASCII_USTRINGPARAM("type_COLUMN_HEADER")); + xNamedRanges->addNewByName(aName2, aContent2, aBaseAddress, nType); + CPPUNIT_ASSERT_MESSAGE("Failed to create Namedrange Type COLUMN_HEADER", xNamedRanges->hasByName(aName2)); + + nType = ::sheet::NamedRangeFlag::FILTER_CRITERIA; + rtl::OUString aContent3(RTL_CONSTASCII_USTRINGPARAM("D3")); + rtl::OUString aName3(RTL_CONSTASCII_USTRINGPARAM("type_FILTER_CRITERIA")); + xNamedRanges->addNewByName(aName3, aContent3, aBaseAddress, nType); + CPPUNIT_ASSERT_MESSAGE("Failed to create Namedrange Type FILTER_CRITERIA", xNamedRanges->hasByName(aName3)); + + nType = ::sheet::NamedRangeFlag::PRINT_AREA; + rtl::OUString aContent4(RTL_CONSTASCII_USTRINGPARAM("D4")); + rtl::OUString aName4(RTL_CONSTASCII_USTRINGPARAM("type_PRINT_AREA")); + xNamedRanges->addNewByName(aName4, aContent4, aBaseAddress, nType); + CPPUNIT_ASSERT_MESSAGE("Failed to create Namedrange Type PRINT_AREA", xNamedRanges->hasByName(aName4)); + + nType = ::sheet::NamedRangeFlag::ROW_HEADER; + rtl::OUString aContent5(RTL_CONSTASCII_USTRINGPARAM("D5")); + rtl::OUString aName5(RTL_CONSTASCII_USTRINGPARAM("type_ROW_HEADER")); + xNamedRanges->addNewByName(aName5, aContent5, aBaseAddress, nType); + CPPUNIT_ASSERT_MESSAGE("Failed to create Namedrange Type ROW_HEADER", xNamedRanges->hasByName(aName5)); + +} + +void XNamedRanges::testAddNewFromTitles() +{ + uno::Reference< sheet::XNamedRanges > xNamedRanges(init(1), UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xNamedRangesIndex(xNamedRanges, UNO_QUERY_THROW); + uno::Reference< container::XNameAccess > xNamedRangesNameAccess(xNamedRanges, UNO_QUERY_THROW); + + table::CellRangeAddress aCellRangeAddress = table::CellRangeAddress(1,0,0,3,3); + + rtl::OUString aString; + uno::Reference< table::XCell > xCell; + + xNamedRanges->addNewFromTitles(aCellRangeAddress, sheet::Border_TOP); + + for (sal_Int32 i = 1; i < 4; i++) + { + // verify namedrange exists + xCell = xSheet->getCellByPosition(i,0); + uno::Reference< text::XTextRange > xTextRange(xCell, UNO_QUERY_THROW); + aString = xTextRange->getString(); + std::cout << "addNewFromTitles: verify " << aString << std::endl; + CPPUNIT_ASSERT_MESSAGE("Non existing NamedRange", xNamedRanges->hasByName(aString)); + + // verify it points on the right cell + uno::Any aNr = xNamedRangesNameAccess->getByName(aString); + uno::Reference< sheet::XNamedRange > xNamedRange(aNr, UNO_QUERY_THROW); + + uno::Reference< sheet::XCellRangeReferrer > xCellRangeRef(xNamedRange, UNO_QUERY_THROW); + uno::Reference< sheet::XCellRangeAddressable > xCellRangeAdr(xCellRangeRef->getReferredCells(), UNO_QUERY_THROW); + table::CellRangeAddress cellRangeAddress = xCellRangeAdr->getRangeAddress(); + + CPPUNIT_ASSERT(cellRangeAddress.EndColumn == i && cellRangeAddress.StartColumn == i); + CPPUNIT_ASSERT(cellRangeAddress.StartRow == 1); + CPPUNIT_ASSERT(cellRangeAddress.EndRow == 3); + CPPUNIT_ASSERT(cellRangeAddress.Sheet == 1); + } + + xNamedRanges->addNewFromTitles(aCellRangeAddress, sheet::Border_LEFT); + + for (sal_Int32 i = 1; i < 4; i++) + { + // verify namedrange exists + xCell = xSheet->getCellByPosition(0,i); + uno::Reference< text::XTextRange > xTextRange(xCell, UNO_QUERY_THROW); + aString = xTextRange->getString(); + std::cout << "verify " << aString << std::endl; + CPPUNIT_ASSERT_MESSAGE("Non existing NamedRange", xNamedRanges->hasByName(aString)); + + // verify it points on the right cell + uno::Any aNr= xNamedRangesNameAccess->getByName(aString); + uno::Reference< sheet::XNamedRange > xNamedRange(aNr, UNO_QUERY_THROW); + + uno::Reference< sheet::XCellRangeReferrer > xCellRangeRef(xNamedRange, UNO_QUERY_THROW); + uno::Reference< sheet::XCellRangeAddressable > xCellRangeAdr(xCellRangeRef->getReferredCells(), UNO_QUERY_THROW); + table::CellRangeAddress cellRangeAddress = xCellRangeAdr->getRangeAddress(); + + CPPUNIT_ASSERT(cellRangeAddress.EndRow == i && cellRangeAddress.StartRow == i); + CPPUNIT_ASSERT(cellRangeAddress.StartColumn == 1); + CPPUNIT_ASSERT(cellRangeAddress.EndColumn == 3); + CPPUNIT_ASSERT(cellRangeAddress.Sheet == 1); + } +} + +void XNamedRanges::testRemoveByName() +{ + uno::Reference< sheet::XNamedRanges > xNamedRanges(init(), UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xIndex(xNamedRanges, UNO_QUERY_THROW); + + bool bHasIt = xNamedRanges->hasByName(maNameToRemove); + CPPUNIT_ASSERT_MESSAGE("NamedRange initial1 des not exits, can't remove it", bHasIt); + + if (bHasIt) + { + // remove existing + sal_Int32 nInitialCount = xIndex->getCount(); + xNamedRanges->removeByName(maNameToRemove); + sal_Int32 nNewCount = xIndex->getCount(); + CPPUNIT_ASSERT_MESSAGE("NamedRange initial1 not removed", nNewCount == nInitialCount - 1); + CPPUNIT_ASSERT_MESSAGE("Wrong NamedRange removed, initial1 still present", !xNamedRanges->hasByName(maNameToRemove)); + // try to remove non existing + rtl::OUString aNr2(RTL_CONSTASCII_USTRINGPARAM("dummyNonExistingNamedRange")); + xNamedRanges->removeByName(aNr2);// an exception should be raised here + } +} + +void XNamedRanges::testOutputList() +{ + table::CellAddress xCellAddress = table::CellAddress (0,2,0); + uno::Reference< sheet::XNamedRanges > xNamedRanges(init(), UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xNamedRangesIndex(init(), UNO_QUERY_THROW); + sal_Int32 nElementsCount = xNamedRangesIndex->getCount(); + + xNamedRanges->outputList(xCellAddress); + + rtl::OUString aString; + uno::Reference< table::XCell > xCell; + + for (sal_Int32 i = 0; i < nElementsCount; i++) + { + xCell = xSheet->getCellByPosition(2,i); + uno::Reference< text::XTextRange > xTextRange(xCell, UNO_QUERY_THROW); + aString = xTextRange->getString(); + std::cout << "verify " << aString << std::endl; + CPPUNIT_ASSERT_MESSAGE("Non existing NamedRange", xNamedRanges->hasByName(aString)); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/sheet/xspreadsheets2.cxx b/test/source/sheet/xspreadsheets2.cxx new file mode 100644 index 000000000000..263425995a81 --- /dev/null +++ b/test/source/sheet/xspreadsheets2.cxx @@ -0,0 +1,352 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Version: MPL 1.1 / GPLv3+ / LGPLv3+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Major Contributor(s): + * Copyright (C) 2011 Laurent Godard lgodard.libre@laposte.net (initial developer) + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 3 or later (the "GPLv3+"), or + * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"), + * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable + * instead of those above. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include +#include "cppunit/extensions/HelperMacros.h" + +using namespace com::sun::star::uno; + +namespace apitest { + +XSpreadsheets2::XSpreadsheets2(): + aSrcSheetName(RTL_CONSTASCII_USTRINGPARAM("SheetToCopy")), + aSrcFileName(RTL_CONSTASCII_USTRINGPARAM("rangenamessrc.ods")), + aDestFileBase(RTL_CONSTASCII_USTRINGPARAM("rangenames.ods")) +{ +} + +void XSpreadsheets2::testImportedSheetNameAndIndex() +{ +/** + Verfiy that the imported sheet has the correct name and is placed at the right requested index +*/ + + importSheetToCopy(); + + uno::Reference< container::XNameAccess > xDestSheetNameAccess(xDestDoc->getSheets(), UNO_QUERY_THROW); + CPPUNIT_ASSERT_MESSAGE("Wrong sheet name", xDestSheetNameAccess->hasByName(aSrcSheetName)); + +} + +void XSpreadsheets2::testImportString() +{ +/** + tests the cell A1 containing a string correctly imported +*/ + importSheetToCopy(); + + uno::Reference< table::XCell > xSrcCell = xSrcSheet->getCellByPosition(0,0); + uno::Reference< text::XTextRange > xSrcTextRange(xSrcCell, UNO_QUERY_THROW); + rtl::OUString aSrcString = xSrcTextRange->getString(); + + uno::Reference< table::XCell > xDestCell = xDestSheet->getCellByPosition(0,0); + uno::Reference< text::XTextRange > xDestTextRange(xDestCell, UNO_QUERY_THROW); + rtl::OUString aDestString = xDestTextRange->getString(); + + CPPUNIT_ASSERT_MESSAGE("Wrong string imported", aDestString.equals(aSrcString)); +} + +void XSpreadsheets2::testImportValue() +{ +/** + tests the cell B1 containing a value correctly imported +*/ + importSheetToCopy(); + + uno::Reference< table::XCell > xSrcCell = xSrcSheet->getCellByPosition(1,0); + sal_Int32 aSrcValue = xSrcCell->getValue(); + + uno::Reference< table::XCell > xDestCell = xDestSheet->getCellByPosition(1,0); + sal_Int32 aDestValue = xDestCell->getValue(); + + CPPUNIT_ASSERT_MESSAGE("Wrong value imported", aSrcValue == aDestValue); +} + +void XSpreadsheets2::testImportFormulaBasicMath() +{ +/** + tests the cell C1 containing an arithmetic formula correctly imported +*/ + importSheetToCopy(); + + uno::Reference< table::XCell > xSrcCell = xSrcSheet->getCellByPosition(2,0); + rtl::OUString aSrcFormula = xSrcCell->getFormula(); + + uno::Reference< table::XCell > xDestCell = xDestSheet->getCellByPosition(2,0); + rtl::OUString aDestFormula = xDestCell->getFormula(); + + // potential problem later: formulas might be adjusted + // add some tests that the formulas are correctly adjusted + CPPUNIT_ASSERT_MESSAGE("Wrong formula imported", aDestFormula.equals(aSrcFormula)); +} + +void XSpreadsheets2::testImportFormulaWithNamedRange() +{ +/** + tests the cell D1 containing a formula that uses a NamedRange expression +*/ + importSheetToCopy(); + + uno::Reference< table::XCell > xSrcCell = xSrcSheet->getCellByPosition(3,0); + rtl::OUString aSrcFormula = xSrcCell->getFormula(); + + uno::Reference< table::XCell > xDestCell = xDestSheet->getCellByPosition(3,0); + rtl::OUString aDestFormula = xDestCell->getFormula(); + + CPPUNIT_ASSERT_MESSAGE("Wrong Namedrange formula imported", aDestFormula.equals(aSrcFormula)); +} + +void XSpreadsheets2::testImportOverExistingNamedRange() +{ +/** + Both Source and Target file define the named range initial1 + in Source, initial1 is defined outside the copied sheet + In Target, after import sheet, initial1 should point on its initial definition $Sheet1.$B$1 + + NEED MORE WORK +*/ + importSheetToCopy(); + + rtl::OUString aNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial1")); + + uno::Reference< container::XNameAccess > xDestNamedRangesNameAccess(getNamedRanges(xDestDoc), UNO_QUERY_THROW); + uno::Any aNr = xDestNamedRangesNameAccess->getByName(aNamedRangeString); + uno::Reference< sheet::XNamedRange > xDestNamedRange(aNr, UNO_QUERY_THROW); + rtl::OUString aNrDestContent = xDestNamedRange->getContent(); + + rtl::OUString aExpectedContent(RTL_CONSTASCII_USTRINGPARAM("$Sheet1.$B$1")); + + std::cout << "testImportSheet : initial1 aNrDestContent " << aNrDestContent << std::endl; + CPPUNIT_ASSERT_MESSAGE("Wrong address for initial1", aNrDestContent.equals(aExpectedContent)); + +} + +void XSpreadsheets2::testImportNamedRangeDefinedInSource() +{ +/** + in Source file, InSheetRangeName named range is defined in the copied sheet + it does not exists in target file + test that the range named is created in target and that it points in the target copied sheet +*/ + importSheetToCopy(); + + // New range name defined in imported sheet $SheetToCopy.$A$7 + rtl::OUString aNewInSheetNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("InSheetRangeName")); + uno::Reference< container::XNameAccess > xDestNamedRangesNameAccess(getNamedRanges(xDestDoc), UNO_QUERY_THROW); + CPPUNIT_ASSERT_MESSAGE("InSheetRangeName", xDestNamedRangesNameAccess->hasByName(aNewInSheetNamedRangeString)); + + uno::Any aNewInSheetNr = xDestNamedRangesNameAccess->getByName(aNewInSheetNamedRangeString); + uno::Reference< sheet::XNamedRange > xDestNewInSheetNamedRange(aNewInSheetNr, UNO_QUERY_THROW); + rtl::OUString aNewInSheetNrDestContent = xDestNewInSheetNamedRange->getContent(); + rtl::OUString aNewInSheetExpectedContent(RTL_CONSTASCII_USTRINGPARAM("$SheetToCopy.$A$7")); + + std::cout << "testImportSheet : InSheetRangeName content " << aNewInSheetNrDestContent << std::endl; + std::cout << "testImportSheet : InSheetRangeName expected " << aNewInSheetExpectedContent << std::endl; + CPPUNIT_ASSERT_MESSAGE("Wrong address for InSheetRangeName", aNewInSheetNrDestContent.equals(aNewInSheetExpectedContent)); +} + +void XSpreadsheets2::testImportNamedRangeRedefinedInSource() +{ +/** + in Source file, initial2 named range is defined in the copied sheet + it is defined in another sheet of target file + test that the range named points in the target copied sheet +*/ + importSheetToCopy(); + + // the source file redefines an existing named range in the imported sheet --> the target should not be changed + rtl::OUString aRedefinedInSheetNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("initial2")); + uno::Reference< container::XNameAccess > xDestNamedRangesNameAccess(getNamedRanges(xDestDoc), UNO_QUERY_THROW); + CPPUNIT_ASSERT_MESSAGE("aRedefinedInSheetNamedRangeString", xDestNamedRangesNameAccess->hasByName(aRedefinedInSheetNamedRangeString)); + + uno::Any aRedefinedInSheetNr = xDestNamedRangesNameAccess->getByName(aRedefinedInSheetNamedRangeString); + uno::Reference< sheet::XNamedRange > xDestRedefinedInSheetNamedRange(aRedefinedInSheetNr, UNO_QUERY_THROW); + rtl::OUString aRedefinedInSheetNrDestContent = xDestRedefinedInSheetNamedRange->getContent(); + rtl::OUString aRedefinedInSheetExpectedContent(RTL_CONSTASCII_USTRINGPARAM("$Sheet1.$B$2")); + std::cout << "testImportSheet : initial2 content " << aRedefinedInSheetNrDestContent << std::endl; + CPPUNIT_ASSERT_MESSAGE("Wrong address for Redefined InSheet named range", aRedefinedInSheetNrDestContent.equals(aRedefinedInSheetExpectedContent)); +} + +void XSpreadsheets2::testImportNewNamedRange() +{ +/** + in Soucre file, new_rangename range named is defined outside the copied sheet + it does not exists in target file + test that new_rangename is created and its content points to source file as an external reference +*/ + importSheetToCopy(); + + //formula with a non-existant named range in dest - new_rangename + rtl::OUString aNewNamedRangeString(RTL_CONSTASCII_USTRINGPARAM("new_rangename")); + uno::Reference< container::XNameAccess > xDestNamedRangesNameAccess(getNamedRanges(xDestDoc), UNO_QUERY_THROW); + CPPUNIT_ASSERT_MESSAGE("New NamedRange not created", xDestNamedRangesNameAccess->hasByName(aNewNamedRangeString)); + + // verify the content of this new namedrange, pointing on $Sheet1.$B$1 in source. This address is already defined in target as NR content + + uno::Any aNewNr = xDestNamedRangesNameAccess->getByName(aNewNamedRangeString); + uno::Reference< sheet::XNamedRange > xDestNewNamedRange(aNewNr, UNO_QUERY_THROW); + rtl::OUString aNewNrDestContent = xDestNewNamedRange->getContent(); + + rtl::OUString aNewExpectedContent(RTL_CONSTASCII_USTRINGPARAM("$Sheet1.$B$1")); + + std::cout << "testImportSheet : new_rangename aNewExpectedContent " << aNewExpectedContent << std::endl; + std::cout << "testImportSheet : new_rangename aNewNrDestContent " << aNewNrDestContent << std::endl; + CPPUNIT_ASSERT_MESSAGE("Wrong New NamedRange formula string value", isExternalReference(aNewNrDestContent, aNewExpectedContent)); +} + +void XSpreadsheets2::testImportCellStyle() +{ +/** + in source file, imported sheet uses a cellstyle that does not exists in target + test that + - an imported cell D1 uses the right cellStyle + - the cellStyle is created in CellStyles family + - a property of the cellStyle (VertJustify) is correctly set +*/ + importSheetToCopy(); + + uno::Reference< table::XCell > xSrcCell = xSrcSheet->getCellByPosition(3,0); + uno::Reference< table::XCell > xDestCell = xDestSheet->getCellByPosition(3,0); + + //new style created in dest + uno::Reference< beans::XPropertySet > xSrcCellPropSet (xSrcCell, UNO_QUERY_THROW); + const rtl::OUString aCellProperty(RTL_CONSTASCII_USTRINGPARAM("CellStyle")); + rtl::OUString aSrcStyleName; + CPPUNIT_ASSERT(xSrcCellPropSet->getPropertyValue(aCellProperty) >>= aSrcStyleName); + + uno::Reference< beans::XPropertySet > xDestCellPropSet (xSrcCell, UNO_QUERY_THROW); + rtl::OUString aDestStyleName; + CPPUNIT_ASSERT(xDestCellPropSet->getPropertyValue(aCellProperty) >>= aDestStyleName); + + CPPUNIT_ASSERT_MESSAGE("Wrong imported Cell Style", aDestStyleName.equals(aSrcStyleName)); + + uno::Reference< style::XStyleFamiliesSupplier > xFamiliesSupplier (xDestDoc, UNO_QUERY_THROW); + uno::Reference< container::XNameAccess > xFamiliesNameAccess (xFamiliesSupplier->getStyleFamilies(), UNO_QUERY_THROW); + rtl::OUString aCellFamilyName(RTL_CONSTASCII_USTRINGPARAM("CellStyles")); + uno::Any xCellStylesFamily = xFamiliesNameAccess->getByName(aCellFamilyName); + uno::Reference< container::XNameContainer > xCellStylesFamilyNameAccess (xCellStylesFamily, UNO_QUERY_THROW); + + CPPUNIT_ASSERT_MESSAGE("New cell style not present", xCellStylesFamilyNameAccess->hasByName(aDestStyleName)); + + uno::Any aCellStyle = xCellStylesFamilyNameAccess->getByName(aDestStyleName); + uno::Reference< beans::XPropertySet > xCellStyleProp (aCellStyle, UNO_QUERY_THROW); + rtl::OUString aProperty(RTL_CONSTASCII_USTRINGPARAM("VertJustify")); + sal_Int32 aVertJustify = 0; + CPPUNIT_ASSERT(xCellStyleProp->getPropertyValue(aProperty) >>= aVertJustify); + + CPPUNIT_ASSERT_MESSAGE("New style: VertJustify not set", aVertJustify == table::CellVertJustify_CENTER); +} + +uno::Reference< sheet::XSpreadsheetDocument> XSpreadsheets2::getDoc(const rtl::OUString& aFileBase, uno::Reference< lang::XComponent >& xComp) +{ + rtl::OUString aFileURL; + createFileURL(aFileBase, aFileURL); + + if (!xComp.is()) + xComp = loadFromDesktop(aFileURL); + + CPPUNIT_ASSERT(xComp.is()); + + uno::Reference< sheet::XSpreadsheetDocument > xDoc(xComp, UNO_QUERY_THROW); + CPPUNIT_ASSERT(xDoc.is()); + return xDoc; +} + +uno::Reference< sheet::XNamedRanges> XSpreadsheets2::getNamedRanges(uno::Reference< sheet::XSpreadsheetDocument> xDoc) +{ + uno::Reference< beans::XPropertySet > xPropSet (xDoc, UNO_QUERY_THROW); + rtl::OUString NamedRangesPropertyString(RTL_CONSTASCII_USTRINGPARAM("NamedRanges")); + uno::Reference< sheet::XNamedRanges > xNamedRanges(xPropSet->getPropertyValue(NamedRangesPropertyString), UNO_QUERY_THROW); + CPPUNIT_ASSERT(xNamedRanges.is()); + + return xNamedRanges; +} + +void XSpreadsheets2::importSheetToCopy() +{ + uno::Reference< container::XNameAccess> xSrcNameAccess(init(),UNO_QUERY_THROW); + xSrcSheet = uno::Reference< sheet::XSpreadsheet >( xSrcNameAccess->getByName(aSrcSheetName), UNO_QUERY_THROW); + + static uno::Reference< lang::XComponent > xDestComponent; + if (!xDestComponent.is()) + { + xDestDoc = getDoc(aDestFileBase, xDestComponent); + CPPUNIT_ASSERT(xDestDoc.is()); + + // import sheet + uno::Reference< sheet::XSpreadsheets2 > xDestSheets (xDestDoc->getSheets(), UNO_QUERY_THROW); + sal_Int32 nDestPos = 0; + sal_Int32 nDestPosEffective = xDestSheets->importSheet(xDocument, aSrcSheetName, nDestPos); + CPPUNIT_ASSERT_MESSAGE("Wrong sheet index", nDestPosEffective == nDestPos); + } + else + { + xDestDoc = uno::Reference< sheet::XSpreadsheetDocument >(xDestComponent,UNO_QUERY_THROW); + } + + uno::Reference< container::XNameAccess > xDestSheetNameAccess (xDestDoc->getSheets(), UNO_QUERY_THROW); + xDestSheet = uno::Reference< sheet::XSpreadsheet > ( xDestSheetNameAccess->getByName(aSrcSheetName), UNO_QUERY_THROW); +} + +bool XSpreadsheets2::isExternalReference(const rtl::OUString& aDestContent, const rtl::OUString& aSrcContent ) +{ + rtl::OUString aStart(RTL_CONSTASCII_USTRINGPARAM("'file://")); + const sal_Char* sSrcContent = rtl::OUStringToOString( aSrcContent, RTL_TEXTENCODING_UTF8 ).getStr(); + + return (aDestContent.endsWithIgnoreAsciiCaseAsciiL(sSrcContent, aSrcContent.getLength()) // same cell address + && aDestContent.indexOf(aStart)==0 // starts with 'file:// + && aDestContent.indexOf(aSrcFileName)>0); // contains source file name +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/test/source/unoapi_test.cxx b/test/source/unoapi_test.cxx index 0a6f4aa4adf0..2d9292a87041 100644 --- a/test/source/unoapi_test.cxx +++ b/test/source/unoapi_test.cxx @@ -28,6 +28,8 @@ #include "test/unoapi_test.hxx" +#include + UnoApiTest::UnoApiTest() : m_aBaseString(RTL_CONSTASCII_USTRINGPARAM("/sc/qa/extras/testdocuments")) { @@ -64,4 +66,10 @@ void UnoApiTest::createFileURL(const rtl::OUString& aFileBase, rtl::OUString& rF rFilePath = aBuffer.makeStringAndClear(); } +void UnoApiTest::closeDocument( uno::Reference< lang::XComponent > xDocument ) +{ + uno::Reference< util::XCloseable > xCloseable(xDocument, UNO_QUERY_THROW); + xCloseable->close(false); +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit