summaryrefslogtreecommitdiffstats
path: root/comphelper/qa/unit
diff options
context:
space:
mode:
Diffstat (limited to 'comphelper/qa/unit')
-rw-r--r--comphelper/qa/unit/base64_test.cxx112
-rw-r--r--comphelper/qa/unit/parallelsorttest.cxx101
-rw-r--r--comphelper/qa/unit/propertyvalue.cxx131
-rw-r--r--comphelper/qa/unit/syntaxhighlighttest.cxx117
-rw-r--r--comphelper/qa/unit/test_guards.cxx88
-rw-r--r--comphelper/qa/unit/test_hash.cxx130
-rw-r--r--comphelper/qa/unit/test_traceevent.cxx125
-rw-r--r--comphelper/qa/unit/threadpooltest.cxx169
-rw-r--r--comphelper/qa/unit/types_test.cxx96
-rw-r--r--comphelper/qa/unit/variadictemplates.cxx179
10 files changed, 1248 insertions, 0 deletions
diff --git a/comphelper/qa/unit/base64_test.cxx b/comphelper/qa/unit/base64_test.cxx
new file mode 100644
index 0000000000..dc637f63f7
--- /dev/null
+++ b/comphelper/qa/unit/base64_test.cxx
@@ -0,0 +1,112 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/types.h>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/uno/Sequence.hxx>
+
+#include <comphelper/base64.hxx>
+
+using namespace css;
+
+namespace
+{
+class Base64Test : public CppUnit::TestFixture
+{
+public:
+ void testBase64Encode();
+ void testBase64Decode();
+ void testBase64EncodeForOStringBuffer();
+
+ CPPUNIT_TEST_SUITE(Base64Test);
+ CPPUNIT_TEST(testBase64Encode);
+ CPPUNIT_TEST(testBase64Decode);
+ CPPUNIT_TEST(testBase64EncodeForOStringBuffer);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+void Base64Test::testBase64Encode()
+{
+ OUStringBuffer aBuffer(32);
+ uno::Sequence<sal_Int8> inputSequence;
+
+ inputSequence = { 0, 0, 0, 0, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL(OUString("AAAAAAABAgM="), aBuffer.toString());
+ aBuffer.setLength(0);
+
+ inputSequence = { 5, 2, 3, 0, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL(OUString("BQIDAAABAgM="), aBuffer.toString());
+ aBuffer.setLength(0);
+
+ inputSequence = { sal_Int8(sal_uInt8(200)), 31, 77, 111, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL(OUString("yB9NbwABAgM="), aBuffer.makeStringAndClear());
+}
+
+void Base64Test::testBase64Decode()
+{
+ uno::Sequence<sal_Int8> decodedSequence;
+
+ uno::Sequence<sal_Int8> expectedSequence = { 0, 0, 0, 0, 0, 1, 2, 3 };
+ comphelper::Base64::decode(decodedSequence, u"AAAAAAABAgM=");
+ CPPUNIT_ASSERT(std::equal(std::cbegin(expectedSequence), std::cend(expectedSequence),
+ std::cbegin(decodedSequence)));
+
+ expectedSequence = { 5, 2, 3, 0, 0, 1, 2, 3 };
+ comphelper::Base64::decode(decodedSequence, u"BQIDAAABAgM=");
+ CPPUNIT_ASSERT(std::equal(std::cbegin(expectedSequence), std::cend(expectedSequence),
+ std::cbegin(decodedSequence)));
+
+ expectedSequence = { sal_Int8(sal_uInt8(200)), 31, 77, 111, 0, 1, 2, 3 };
+ comphelper::Base64::decode(decodedSequence, u"yB9NbwABAgM=");
+ CPPUNIT_ASSERT(std::equal(std::cbegin(expectedSequence), std::cend(expectedSequence),
+ std::cbegin(decodedSequence)));
+}
+
+void Base64Test::testBase64EncodeForOStringBuffer()
+{
+ OStringBuffer aBuffer(32);
+ uno::Sequence<sal_Int8> inputSequence;
+
+ inputSequence = { 0, 0, 0, 0, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL("AAAAAAABAgM="_ostr, aBuffer.toString());
+ aBuffer.setLength(0);
+
+ inputSequence = { 5, 2, 3, 0, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL("BQIDAAABAgM="_ostr, aBuffer.toString());
+ aBuffer.setLength(0);
+
+ inputSequence = { sal_Int8(sal_uInt8(200)), 31, 77, 111, 0, 1, 2, 3 };
+ comphelper::Base64::encode(aBuffer, inputSequence);
+ CPPUNIT_ASSERT_EQUAL("yB9NbwABAgM="_ostr, aBuffer.makeStringAndClear());
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(Base64Test);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/parallelsorttest.cxx b/comphelper/qa/unit/parallelsorttest.cxx
new file mode 100644
index 0000000000..a3618244ab
--- /dev/null
+++ b/comphelper/qa/unit/parallelsorttest.cxx
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <comphelper/parallelsort.hxx>
+#include <comphelper/threadpool.hxx>
+#include <rtl/string.hxx>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/plugin/TestPlugIn.h>
+
+#include <cstdlib>
+#include <vector>
+#include <algorithm>
+#include <random>
+
+class ParallelSortTest : public CppUnit::TestFixture
+{
+public:
+ void testSortTiny();
+ void testSortMedium();
+ void testSortBig();
+
+ virtual void setUp() override;
+ virtual void tearDown() override;
+
+ CPPUNIT_TEST_SUITE(ParallelSortTest);
+ CPPUNIT_TEST(testSortTiny);
+ CPPUNIT_TEST(testSortMedium);
+ CPPUNIT_TEST(testSortBig);
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+ void sortTest(size_t nLen);
+ void fillRandomUptoN(std::vector<size_t>& rVector, size_t N);
+
+ comphelper::ThreadPool* pThreadPool;
+ size_t mnThreads;
+};
+
+void ParallelSortTest::setUp()
+{
+ pThreadPool = &comphelper::ThreadPool::getSharedOptimalPool();
+ mnThreads = pThreadPool->getWorkerCount();
+}
+
+void ParallelSortTest::tearDown()
+{
+ if (pThreadPool)
+ pThreadPool->joinThreadsIfIdle();
+}
+
+void ParallelSortTest::fillRandomUptoN(std::vector<size_t>& rVector, size_t N)
+{
+ rVector.resize(N);
+ for (size_t nIdx = 0; nIdx < N; ++nIdx)
+ rVector[nIdx] = nIdx;
+ std::shuffle(rVector.begin(), rVector.end(), std::default_random_engine(42));
+}
+
+void ParallelSortTest::sortTest(size_t nLen)
+{
+ std::vector<size_t> aVector(nLen);
+ fillRandomUptoN(aVector, nLen);
+ comphelper::parallelSort(aVector.begin(), aVector.end());
+ for (size_t nIdx = 0; nIdx < nLen; ++nIdx)
+ {
+ OString aMsg = "Wrong aVector[" + OString::number(nIdx) + "]";
+ CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nIdx, aVector[nIdx]);
+ }
+}
+
+void ParallelSortTest::testSortTiny()
+{
+ sortTest(5);
+ sortTest(15);
+ sortTest(16);
+ sortTest(17);
+}
+
+void ParallelSortTest::testSortMedium()
+{
+ sortTest(1025);
+ sortTest(1029);
+ sortTest(1024 * 2 + 1);
+ sortTest(1024 * 2 + 9);
+}
+
+void ParallelSortTest::testSortBig() { sortTest(1024 * 16 + 3); }
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ParallelSortTest);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/propertyvalue.cxx b/comphelper/qa/unit/propertyvalue.cxx
new file mode 100644
index 0000000000..4470b28f50
--- /dev/null
+++ b/comphelper/qa/unit/propertyvalue.cxx
@@ -0,0 +1,131 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sal/config.h>
+
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <cppu/unotype.hxx>
+#include <o3tl/any.hxx>
+
+using namespace com::sun::star;
+
+namespace
+{
+class MakePropertyValueTest : public CppUnit::TestFixture
+{
+ CPPUNIT_TEST_SUITE(MakePropertyValueTest);
+ CPPUNIT_TEST(testLvalue);
+ CPPUNIT_TEST(testRvalue);
+ CPPUNIT_TEST(testBitField);
+ CPPUNIT_TEST(testJson);
+ CPPUNIT_TEST_SUITE_END();
+
+ void testLvalue()
+ {
+ sal_Int32 const i = 123;
+ auto const v = comphelper::makePropertyValue("test", i);
+ CPPUNIT_ASSERT_EQUAL(cppu::UnoType<sal_Int32>::get(), v.Value.getValueType());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(123), *o3tl::doAccess<sal_Int32>(v.Value));
+ }
+
+ void testRvalue()
+ {
+ auto const v = comphelper::makePropertyValue("test", sal_Int32(456));
+ CPPUNIT_ASSERT_EQUAL(cppu::UnoType<sal_Int32>::get(), v.Value.getValueType());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(456), *o3tl::doAccess<sal_Int32>(v.Value));
+ }
+
+ void testBitField()
+ {
+ struct
+ {
+ bool b : 1;
+ } s = { false };
+ auto const v = comphelper::makePropertyValue("test", s.b);
+ CPPUNIT_ASSERT_EQUAL(cppu::UnoType<bool>::get(), v.Value.getValueType());
+ CPPUNIT_ASSERT_EQUAL(false, *o3tl::doAccess<bool>(v.Value));
+ }
+
+ void testJson()
+ {
+ std::vector<beans::PropertyValue> aRet = comphelper::JsonToPropertyValues(R"json(
+{
+ "FieldType": {
+ "type": "string",
+ "value": "vnd.oasis.opendocument.field.UNHANDLED"
+ },
+ "FieldCommandPrefix": {
+ "type": "string",
+ "value": "ADDIN ZOTERO_ITEM"
+ },
+ "Fields": {
+ "type": "[][]com.sun.star.beans.PropertyValue",
+ "value": [
+ {
+ "FieldType": {
+ "type": "string",
+ "value": "vnd.oasis.opendocument.field.UNHANDLED"
+ },
+ "FieldCommand": {
+ "type": "string",
+ "value": "ADDIN ZOTERO_ITEM new command 1"
+ },
+ "Fields": {
+ "type": "string",
+ "value": "new result 1"
+ }
+ },
+ {
+ "FieldType": {
+ "type": "string",
+ "value": "vnd.oasis.opendocument.field.UNHANDLED"
+ },
+ "FieldCommandPrefix": {
+ "type": "string",
+ "value": "ADDIN ZOTERO_ITEM new command 2"
+ },
+ "Fields": {
+ "type": "string",
+ "value": "new result 2"
+ }
+ }
+ ]
+ }
+}
+)json"_ostr);
+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), aRet.size());
+ beans::PropertyValue aFirst = aRet[0];
+ CPPUNIT_ASSERT_EQUAL(OUString("FieldType"), aFirst.Name);
+ CPPUNIT_ASSERT_EQUAL(OUString("vnd.oasis.opendocument.field.UNHANDLED"),
+ aFirst.Value.get<OUString>());
+ beans::PropertyValue aSecond = aRet[1];
+ CPPUNIT_ASSERT_EQUAL(OUString("FieldCommandPrefix"), aSecond.Name);
+ CPPUNIT_ASSERT_EQUAL(OUString("ADDIN ZOTERO_ITEM"), aSecond.Value.get<OUString>());
+ beans::PropertyValue aThird = aRet[2];
+ CPPUNIT_ASSERT_EQUAL(OUString("Fields"), aThird.Name);
+ uno::Sequence<uno::Sequence<beans::PropertyValue>> aSeqs;
+ aThird.Value >>= aSeqs;
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(2), aSeqs.getLength());
+ uno::Sequence<beans::PropertyValue> aFirstSeq = aSeqs[0];
+ CPPUNIT_ASSERT_EQUAL(OUString("FieldType"), aFirstSeq[0].Name);
+ CPPUNIT_ASSERT_EQUAL(OUString("FieldCommand"), aFirstSeq[1].Name);
+ CPPUNIT_ASSERT_EQUAL(OUString("ADDIN ZOTERO_ITEM new command 1"),
+ aFirstSeq[1].Value.get<OUString>());
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MakePropertyValueTest);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/comphelper/qa/unit/syntaxhighlighttest.cxx b/comphelper/qa/unit/syntaxhighlighttest.cxx
new file mode 100644
index 0000000000..eab382b85a
--- /dev/null
+++ b/comphelper/qa/unit/syntaxhighlighttest.cxx
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <comphelper/syntaxhighlight.hxx>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/plugin/TestPlugIn.h>
+#include <rtl/ustring.hxx>
+
+#include <vector>
+
+class SyntaxHighlightTest : public CppUnit::TestFixture
+{
+public:
+ void testBasicString();
+ void testBasicComment();
+ void testBasicCommentNewline();
+ void testBasicEmptyComment();
+ void testBasicEmptyCommentNewline();
+ void testBasic();
+
+ CPPUNIT_TEST_SUITE(SyntaxHighlightTest);
+ CPPUNIT_TEST(testBasicString);
+ CPPUNIT_TEST(testBasicComment);
+ CPPUNIT_TEST(testBasicCommentNewline);
+ CPPUNIT_TEST(testBasicEmptyComment);
+ CPPUNIT_TEST(testBasicEmptyCommentNewline);
+ CPPUNIT_TEST(testBasic);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+void SyntaxHighlightTest::testBasicString() {
+ std::vector<HighlightPortion> ps;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(u"\"foo\"", ps);
+ CPPUNIT_ASSERT_EQUAL(
+ static_cast<std::vector<HighlightPortion>::size_type>(1), ps.size());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ps[0].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(5), ps[0].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::String, ps[0].tokenType);
+}
+
+void SyntaxHighlightTest::testBasicComment() {
+ std::vector<HighlightPortion> ps;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(u"' foo", ps);
+ CPPUNIT_ASSERT_EQUAL(
+ static_cast<std::vector<HighlightPortion>::size_type>(1), ps.size());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ps[0].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(5), ps[0].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::Comment, ps[0].tokenType);
+}
+
+void SyntaxHighlightTest::testBasicCommentNewline() {
+ std::vector<HighlightPortion> ps;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(u"' foo\n", ps);
+ CPPUNIT_ASSERT_EQUAL(
+ static_cast<std::vector<HighlightPortion>::size_type>(2), ps.size());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ps[0].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(5), ps[0].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::Comment, ps[0].tokenType);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(5), ps[1].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(6), ps[1].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::EOL, ps[1].tokenType);
+}
+
+void SyntaxHighlightTest::testBasicEmptyComment() {
+ std::vector<HighlightPortion> ps;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(u"'", ps);
+ CPPUNIT_ASSERT_EQUAL(
+ static_cast<std::vector<HighlightPortion>::size_type>(1), ps.size());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ps[0].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), ps[0].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::Comment, ps[0].tokenType);
+}
+
+void SyntaxHighlightTest::testBasicEmptyCommentNewline() {
+ std::vector<HighlightPortion> ps;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(u"'\n", ps);
+ CPPUNIT_ASSERT_EQUAL(
+ static_cast<std::vector<HighlightPortion>::size_type>(2), ps.size());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ps[0].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), ps[0].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::Comment, ps[0].tokenType);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), ps[1].nBegin);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), ps[1].nEnd);
+ CPPUNIT_ASSERT_EQUAL(TokenType::EOL, ps[1].tokenType);
+}
+
+void SyntaxHighlightTest::testBasic()
+{
+ OUString aBasicString(" if Mid(sText,iRun,1 )<> \" \" then Mid( sText ,iRun, 1, Chr( 1 + Asc( Mid(sText,iRun,1 )) ) '");
+
+ std::vector<HighlightPortion> aPortions;
+ SyntaxHighlighter(HighlighterLanguage::Basic).getHighlightPortions(
+ aBasicString, aPortions );
+
+ sal_Int32 prevEnd = 0;
+ for (auto const& portion : aPortions)
+ {
+ CPPUNIT_ASSERT_EQUAL(prevEnd, portion.nBegin);
+ CPPUNIT_ASSERT(portion.nBegin < portion.nEnd);
+ prevEnd = portion.nEnd;
+ }
+ CPPUNIT_ASSERT_EQUAL(aBasicString.getLength(), prevEnd);
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SyntaxHighlightTest);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/test_guards.cxx b/comphelper/qa/unit/test_guards.cxx
new file mode 100644
index 0000000000..83034a2dcc
--- /dev/null
+++ b/comphelper/qa/unit/test_guards.cxx
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <comphelper/flagguard.hxx>
+#include <unotest/bootstrapfixturebase.hxx>
+
+CPPUNIT_TEST_FIXTURE(CppUnit::TestFixture, testScopeGuard)
+{
+ // Test that comphelper::ScopeGuard executes its parameter on destruction
+
+ // initial value "true", out-of-scope ScopeGuard function executes and changes the value to "false"
+ bool bFlag = true;
+ {
+ comphelper::ScopeGuard aGuard([&bFlag] { bFlag = false; });
+ CPPUNIT_ASSERT(bFlag);
+ }
+ CPPUNIT_ASSERT(!bFlag);
+}
+
+CPPUNIT_TEST_FIXTURE(CppUnit::TestFixture, testFlagGuard)
+{
+ // Test that comphelper::FlagGuard properly sets and resets the flag
+
+ // initial value "false", change to "true", out-of-scope change to "false"
+ bool bFlag = false;
+ {
+ comphelper::FlagGuard aGuard(bFlag);
+ CPPUNIT_ASSERT(bFlag);
+ }
+ // comphelper::FlagGuard must reset flag to false on destruction unconditionally
+ CPPUNIT_ASSERT(!bFlag);
+
+ // initial value "true", retain the value at "true", out-of-scope change to "false"
+ bFlag = true;
+ {
+ comphelper::FlagGuard aGuard(bFlag);
+ CPPUNIT_ASSERT(bFlag);
+ }
+ // comphelper::FlagGuard must reset flag to false on destruction unconditionally
+ CPPUNIT_ASSERT(!bFlag);
+}
+
+CPPUNIT_TEST_FIXTURE(CppUnit::TestFixture, testFlagRestorationGuard)
+{
+ // Test that comphelper::FlagRestorationGuard properly sets and resets the flag
+
+ // initial value "true", change to "false", out-of-scope change to "true"
+
+ bool bFlag = true;
+ {
+ comphelper::FlagRestorationGuard aGuard(bFlag, false);
+ CPPUNIT_ASSERT(!bFlag);
+ }
+ // comphelper::FlagRestorationGuard must reset flag to initial state on destruction
+ CPPUNIT_ASSERT(bFlag);
+}
+
+CPPUNIT_TEST_FIXTURE(CppUnit::TestFixture, testValueRestorationGuard)
+{
+ // Test that comphelper::ValueRestorationGuard properly sets and resets the (int) value
+
+ int value = 199;
+
+ // set value and restore after scope ends
+ {
+ CPPUNIT_ASSERT_EQUAL(199, value);
+ comphelper::ValueRestorationGuard aGuard(value, 100);
+ CPPUNIT_ASSERT_EQUAL(100, value);
+ }
+ CPPUNIT_ASSERT_EQUAL(199, value);
+
+ // set value, manually setto another value and restore after scope ends
+ {
+ CPPUNIT_ASSERT_EQUAL(199, value);
+ comphelper::ValueRestorationGuard aGuard(value, 100);
+ CPPUNIT_ASSERT_EQUAL(100, value);
+ value = 200;
+ }
+ CPPUNIT_ASSERT_EQUAL(199, value);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/test_hash.cxx b/comphelper/qa/unit/test_hash.cxx
new file mode 100644
index 0000000000..64815ee56d
--- /dev/null
+++ b/comphelper/qa/unit/test_hash.cxx
@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sal/config.h>
+#include <config_oox.h>
+#include <comphelper/hash.hxx>
+#include <comphelper/docpasswordhelper.hxx>
+
+#include <rtl/ustring.hxx>
+#include <iomanip>
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#if USE_TLS_NSS
+#include <nss.h>
+#endif
+
+class TestHash : public CppUnit::TestFixture
+{
+public:
+ void testMD5();
+ void testSHA1();
+ void testSHA256();
+ void testSHA512();
+ void testSHA512_NoSaltNoSpin();
+ void testSHA512_saltspin();
+
+ virtual void tearDown()
+ {
+#if USE_TLS_NSS
+ NSS_Shutdown();
+#endif
+ }
+ CPPUNIT_TEST_SUITE(TestHash);
+ CPPUNIT_TEST(testMD5);
+ CPPUNIT_TEST(testSHA1);
+ CPPUNIT_TEST(testSHA256);
+ CPPUNIT_TEST(testSHA512);
+ CPPUNIT_TEST(testSHA512_NoSaltNoSpin);
+ CPPUNIT_TEST(testSHA512_saltspin);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+namespace {
+
+std::string tostring(const std::vector<unsigned char>& a)
+{
+ std::stringstream aStrm;
+ for (auto& i:a)
+ {
+ aStrm << std::setw(2) << std::setfill('0') << std::hex << static_cast<int>(i);
+ }
+
+ return aStrm.str();
+}
+
+}
+
+void TestHash::testMD5()
+{
+ comphelper::Hash aHash(comphelper::HashType::MD5);
+ const char* const pInput = "";
+ aHash.update(reinterpret_cast<const unsigned char*>(pInput), 0);
+ std::vector<unsigned char> calculate_hash = aHash.finalize();
+ CPPUNIT_ASSERT_EQUAL(size_t(16), calculate_hash.size());
+ CPPUNIT_ASSERT_EQUAL(std::string("d41d8cd98f00b204e9800998ecf8427e"), tostring(calculate_hash));
+}
+
+void TestHash::testSHA1()
+{
+ comphelper::Hash aHash(comphelper::HashType::SHA1);
+ const char* const pInput = "";
+ aHash.update(reinterpret_cast<const unsigned char*>(pInput), 0);
+ std::vector<unsigned char> calculate_hash = aHash.finalize();
+ CPPUNIT_ASSERT_EQUAL(size_t(20), calculate_hash.size());
+ CPPUNIT_ASSERT_EQUAL(std::string("da39a3ee5e6b4b0d3255bfef95601890afd80709"), tostring(calculate_hash));
+}
+
+void TestHash::testSHA256()
+{
+ comphelper::Hash aHash(comphelper::HashType::SHA256);
+ const char* const pInput = "";
+ aHash.update(reinterpret_cast<const unsigned char*>(pInput), 0);
+ std::vector<unsigned char> calculate_hash = aHash.finalize();
+ CPPUNIT_ASSERT_EQUAL(size_t(32), calculate_hash.size());
+ CPPUNIT_ASSERT_EQUAL(std::string("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), tostring(calculate_hash));
+}
+
+void TestHash::testSHA512()
+{
+ comphelper::Hash aHash(comphelper::HashType::SHA512);
+ const char* const pInput = "";
+ aHash.update(reinterpret_cast<const unsigned char*>(pInput), 0);
+ std::vector<unsigned char> calculate_hash = aHash.finalize();
+ CPPUNIT_ASSERT_EQUAL(size_t(64), calculate_hash.size());
+ std::string aStr("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
+ CPPUNIT_ASSERT_EQUAL(aStr, tostring(calculate_hash));
+}
+
+// Must be identical to testSHA512()
+void TestHash::testSHA512_NoSaltNoSpin()
+{
+ const char* const pInput = "";
+ std::vector<unsigned char> calculate_hash =
+ comphelper::Hash::calculateHash( reinterpret_cast<const unsigned char*>(pInput), 0,
+ nullptr, 0, 0, comphelper::Hash::IterCount::NONE, comphelper::HashType::SHA512);
+ CPPUNIT_ASSERT_EQUAL(size_t(64), calculate_hash.size());
+ std::string aStr("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
+ CPPUNIT_ASSERT_EQUAL(aStr, tostring(calculate_hash));
+}
+
+// Password, salt, hash and spin count taken from OOXML sheetProtection of
+// tdf#104250 https://bugs.documentfoundation.org/attachment.cgi?id=129104
+void TestHash::testSHA512_saltspin()
+{
+ const OUString aHash = comphelper::DocPasswordHelper::GetOoxHashAsBase64( "pwd", u"876MLoKTq42+/DLp415iZQ==", 100000,
+ comphelper::Hash::IterCount::APPEND, u"SHA-512");
+ CPPUNIT_ASSERT_EQUAL(OUString("5l3mgNHXpWiFaBPv5Yso1Xd/UifWvQWmlDnl/hsCYbFT2sJCzorjRmBCQ/3qeDu6Q/4+GIE8a1DsdaTwYh1q2g=="), aHash);
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestHash);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/test_traceevent.cxx b/comphelper/qa/unit/test_traceevent.cxx
new file mode 100644
index 0000000000..34d10f519d
--- /dev/null
+++ b/comphelper/qa/unit/test_traceevent.cxx
@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sal/config.h>
+
+#include <comphelper/profilezone.hxx>
+#include <comphelper/traceevent.hxx>
+
+#include <rtl/ustring.hxx>
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+class TestTraceEvent : public CppUnit::TestFixture
+{
+public:
+ void test();
+
+ CPPUNIT_TEST_SUITE(TestTraceEvent);
+ CPPUNIT_TEST(test);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+namespace
+{
+void trace_event_test()
+{
+ {
+ // When we start recording is off and this will not generate any 'X' event when we leave the scope
+ comphelper::ProfileZone aZone0("test0");
+
+ // This will not generate any 'b' and 'e' events either
+ auto pAsync1(std::make_shared<comphelper::AsyncEvent>("async1"));
+
+ {
+ // No 'X' by this either
+ comphelper::ProfileZone aZone1("block1");
+
+ // Now we turn on recording
+ comphelper::TraceEvent::startRecording();
+ }
+
+ // This will generate an 'i' event for instant1
+ comphelper::TraceEvent::addInstantEvent("instant1");
+
+ std::shared_ptr<comphelper::AsyncEvent> pAsync25;
+ {
+ comphelper::ProfileZone aZone2("block2");
+
+ // This does not generate any 'e' event as it was created when recording was off
+ // And the nested async2 object will thus not generate anything either
+ pAsync1.reset();
+
+ // This will generate 'b' event and an 'e' event when the pointer is reset or goes out of scope
+ pAsync25 = std::make_shared<comphelper::AsyncEvent>("async2.5");
+
+ // Leaving this scope will generate an 'X' event for block2
+ }
+
+ // This will generate a 'b' event for async3
+ std::map<OUString, OUString> aArgsAsync3({ { "foo", "bar" }, { "tem", "42" } });
+ auto pAsync3(std::make_shared<comphelper::AsyncEvent>("async3", aArgsAsync3));
+
+ {
+ comphelper::ProfileZone aZone3("block3");
+
+ // Leaving this scope will generate an 'X' event for block3
+ }
+
+ // This will generate an 'e' event for async2.5
+ pAsync25.reset();
+
+ comphelper::ProfileZone aZone4("test2");
+
+ // This will generate an 'i' event for instant2"
+ std::map<OUString, OUString> aArgsInstant2({ { "foo2", "bar2" }, { "tem2", "42" } });
+ comphelper::TraceEvent::addInstantEvent("instant2", aArgsInstant2);
+
+ // Leaving this scope will generate 'X' events for test2 and a
+ // 'e' event for async4in3, async7in3, and async3.
+ }
+
+ // This incorrect use of overlapping (not nested) ProfileZones
+ // will generate a SAL_WARN but should not crash
+ auto p1 = new comphelper::ProfileZone("error1");
+ auto p2 = new comphelper::ProfileZone("error2");
+ delete p1;
+ delete p2;
+}
+}
+
+void TestTraceEvent::test()
+{
+ trace_event_test();
+ auto aEvents = comphelper::TraceEvent::getEventVectorAndClear();
+ for (const auto& s : aEvents)
+ {
+ std::cerr << s << "\n";
+ }
+
+ CPPUNIT_ASSERT_EQUAL(9, static_cast<int>(aEvents.size()));
+
+ CPPUNIT_ASSERT(aEvents[0].startsWith("{\"name:\"instant1\",\"ph\":\"i\","));
+ CPPUNIT_ASSERT(aEvents[1].startsWith("{\"name\":\"async2.5\",\"ph\":\"S\",\"id\":1,"));
+ CPPUNIT_ASSERT(aEvents[2].startsWith("{\"name\":\"block2\",\"ph\":\"X\","));
+ CPPUNIT_ASSERT(aEvents[3].startsWith(
+ "{\"name\":\"async3\",\"ph\":\"S\",\"id\":2,\"args\":{\"foo\":\"bar\",\"tem\":\"42\"},"));
+ CPPUNIT_ASSERT(aEvents[4].startsWith("{\"name\":\"block3\",\"ph\":\"X\","));
+ CPPUNIT_ASSERT(aEvents[5].startsWith("{\"name\":\"async2.5\",\"ph\":\"F\",\"id\":1,"));
+ CPPUNIT_ASSERT(aEvents[6].startsWith(
+ "{\"name:\"instant2\",\"ph\":\"i\",\"args\":{\"foo2\":\"bar2\",\"tem2\":\"42\"},"));
+ CPPUNIT_ASSERT(aEvents[7].startsWith("{\"name\":\"test2\",\"ph\":\"X\""));
+ CPPUNIT_ASSERT(aEvents[8].startsWith(
+ "{\"name\":\"async3\",\"ph\":\"F\",\"id\":2,\"args\":{\"foo\":\"bar\",\"tem\":\"42\"},"));
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestTraceEvent);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/threadpooltest.cxx b/comphelper/qa/unit/threadpooltest.cxx
new file mode 100644
index 0000000000..13eaf210a1
--- /dev/null
+++ b/comphelper/qa/unit/threadpooltest.cxx
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <comphelper/threadpool.hxx>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/plugin/TestPlugIn.h>
+#include <tools/time.hxx>
+#include <osl/thread.hxx>
+
+#include <stdlib.h>
+#include <atomic>
+#include <cstddef>
+#include <thread>
+#include <mutex>
+
+class ThreadPoolTest : public CppUnit::TestFixture
+{
+public:
+ void testPreferredConcurrency();
+ void testWorkerUsage();
+ void testTasksInThreads();
+ void testNoThreads();
+ void testDedicatedPool();
+
+ CPPUNIT_TEST_SUITE(ThreadPoolTest);
+ CPPUNIT_TEST(testPreferredConcurrency);
+ CPPUNIT_TEST(testWorkerUsage);
+ CPPUNIT_TEST(testTasksInThreads);
+ CPPUNIT_TEST(testNoThreads);
+ CPPUNIT_TEST(testDedicatedPool);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+void ThreadPoolTest::testPreferredConcurrency()
+{
+ // Check default.
+ auto nThreads = comphelper::ThreadPool::getPreferredConcurrency();
+ std::size_t nExpected = 4; // UTs are capped to 4.
+ CPPUNIT_ASSERT_MESSAGE("Expected no more than 4 threads", nExpected >= nThreads);
+
+#ifndef _WIN32
+ // The result should be cached, so this should change anything.
+ nThreads = std::thread::hardware_concurrency() * 2;
+ setenv("MAX_CONCURRENCY", std::to_string(nThreads).c_str(), true);
+ nThreads = comphelper::ThreadPool::getPreferredConcurrency();
+ CPPUNIT_ASSERT_MESSAGE("Expected no more than hardware threads",
+ nThreads <= std::thread::hardware_concurrency());
+
+ // Revert and check. Again, nothing should change.
+ unsetenv("MAX_CONCURRENCY");
+ nThreads = comphelper::ThreadPool::getPreferredConcurrency();
+ CPPUNIT_ASSERT_MESSAGE("Expected no more than 4 threads", nExpected >= nThreads);
+#endif
+}
+
+namespace
+{
+class UsageTask : public comphelper::ThreadTask
+{
+public:
+ UsageTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag)
+ : ThreadTask(pTag)
+ {
+ }
+ virtual void doWork()
+ {
+ ++count;
+ mutex.lock();
+ mutex.unlock();
+ }
+ static inline std::atomic<int> count = 0;
+ static inline std::mutex mutex;
+};
+} // namespace
+
+void ThreadPoolTest::testWorkerUsage()
+{
+ // Create tasks for each available worker. Lock a shared mutex before that to make all
+ // tasks block on it. And check that all workers have started, i.e. that the full
+ // thread pool capacity is used.
+ comphelper::ThreadPool& rSharedPool = comphelper::ThreadPool::getSharedOptimalPool();
+ std::shared_ptr<comphelper::ThreadTaskTag> pTag = comphelper::ThreadPool::createThreadTaskTag();
+ UsageTask::mutex.lock();
+ for (int i = 0; i < rSharedPool.getWorkerCount(); ++i)
+ {
+ rSharedPool.pushTask(std::make_unique<UsageTask>(pTag));
+ osl::Thread::wait(std::chrono::milliseconds(10)); // give it a time to start
+ }
+ sal_uInt64 startTicks = tools::Time::GetSystemTicks();
+ while (UsageTask::count != rSharedPool.getWorkerCount())
+ {
+ // Wait at most 5 seconds, that should do even on slow systems.
+ CPPUNIT_ASSERT_MESSAGE("Thread pool does not use all worker threads.",
+ startTicks + 5000 > tools::Time::GetSystemTicks());
+ osl::Thread::wait(std::chrono::milliseconds(10));
+ }
+ UsageTask::mutex.unlock();
+ rSharedPool.waitUntilDone(pTag);
+}
+
+namespace
+{
+class CheckThreadTask : public comphelper::ThreadTask
+{
+ oslThreadIdentifier mThreadId;
+ bool mCheckEqual;
+
+public:
+ CheckThreadTask(oslThreadIdentifier threadId, bool checkEqual,
+ const std::shared_ptr<comphelper::ThreadTaskTag>& pTag)
+ : ThreadTask(pTag)
+ , mThreadId(threadId)
+ , mCheckEqual(checkEqual)
+ {
+ }
+ virtual void doWork()
+ {
+ CPPUNIT_ASSERT(mCheckEqual ? osl::Thread::getCurrentIdentifier() == mThreadId
+ : osl::Thread::getCurrentIdentifier() != mThreadId);
+ }
+};
+} // namespace
+
+void ThreadPoolTest::testTasksInThreads()
+{
+ // Check that all tasks are run in worker threads, not this thread.
+ comphelper::ThreadPool& pool = comphelper::ThreadPool::getSharedOptimalPool();
+ std::shared_ptr<comphelper::ThreadTaskTag> pTag = comphelper::ThreadPool::createThreadTaskTag();
+ for (int i = 0; i < 8; ++i)
+ pool.pushTask(
+ std::make_unique<CheckThreadTask>(osl::Thread::getCurrentIdentifier(), false, pTag));
+ pool.waitUntilDone(pTag);
+}
+
+void ThreadPoolTest::testNoThreads()
+{
+ // No worker threads, tasks will be run in this thread.
+ comphelper::ThreadPool pool(0);
+ std::shared_ptr<comphelper::ThreadTaskTag> pTag = comphelper::ThreadPool::createThreadTaskTag();
+ for (int i = 0; i < 8; ++i)
+ pool.pushTask(
+ std::make_unique<CheckThreadTask>(osl::Thread::getCurrentIdentifier(), true, pTag));
+ pool.waitUntilDone(pTag);
+}
+
+void ThreadPoolTest::testDedicatedPool()
+{
+ // Test that a separate thread pool works. The tasks themselves do not matter.
+ comphelper::ThreadPool pool(4);
+ std::shared_ptr<comphelper::ThreadTaskTag> pTag = comphelper::ThreadPool::createThreadTaskTag();
+ for (int i = 0; i < 8; ++i)
+ pool.pushTask(
+ std::make_unique<CheckThreadTask>(osl::Thread::getCurrentIdentifier(), false, pTag));
+ pool.waitUntilDone(pTag);
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ThreadPoolTest);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/qa/unit/types_test.cxx b/comphelper/qa/unit/types_test.cxx
new file mode 100644
index 0000000000..c69b071991
--- /dev/null
+++ b/comphelper/qa/unit/types_test.cxx
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <comphelper/types.hxx>
+#include <sal/types.h>
+
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+using namespace css;
+
+namespace
+{
+class TypesTest : public CppUnit::TestFixture
+{
+public:
+ void testGetINT64();
+ void testGetINT32();
+ void testGetINT16();
+ void testGetDouble();
+ void testGetFloat();
+ void testGetString();
+
+ CPPUNIT_TEST_SUITE(TypesTest);
+
+ CPPUNIT_TEST(testGetINT64);
+ CPPUNIT_TEST(testGetINT32);
+ CPPUNIT_TEST(testGetINT16);
+ CPPUNIT_TEST(testGetDouble);
+ CPPUNIT_TEST(testGetFloat);
+ CPPUNIT_TEST(testGetString);
+
+ CPPUNIT_TEST_SUITE_END();
+};
+
+void TypesTest::testGetINT64()
+{
+ CPPUNIT_ASSERT_EQUAL(sal_Int64(1337), ::comphelper::getINT64(uno::Any(sal_Int64(1337))));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(sal_Int64(0), ::comphelper::getINT64(aValue));
+}
+
+void TypesTest::testGetINT32()
+{
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1337), ::comphelper::getINT32(uno::Any(sal_Int32(1337))));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), ::comphelper::getINT32(aValue));
+}
+
+void TypesTest::testGetINT16()
+{
+ CPPUNIT_ASSERT_EQUAL(sal_Int16(1337), ::comphelper::getINT16(uno::Any(sal_Int16(1337))));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(sal_Int16(0), ::comphelper::getINT16(aValue));
+}
+
+void TypesTest::testGetDouble()
+{
+ CPPUNIT_ASSERT_EQUAL(1337.1337, ::comphelper::getDouble(uno::Any(1337.1337)));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(0.0, ::comphelper::getDouble(aValue));
+}
+
+void TypesTest::testGetFloat()
+{
+ CPPUNIT_ASSERT_EQUAL(static_cast<float>(1337.0),
+ ::comphelper::getFloat(uno::Any(static_cast<float>(1337.0))));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(static_cast<float>(0.0), ::comphelper::getFloat(aValue));
+}
+
+void TypesTest::testGetString()
+{
+ CPPUNIT_ASSERT_EQUAL(OUString("1337"), ::comphelper::getString(uno::Any(OUString("1337"))));
+
+ uno::Any aValue;
+ CPPUNIT_ASSERT_EQUAL(OUString(""), ::comphelper::getString(aValue));
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TypesTest);
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/comphelper/qa/unit/variadictemplates.cxx b/comphelper/qa/unit/variadictemplates.cxx
new file mode 100644
index 0000000000..6b62204f48
--- /dev/null
+++ b/comphelper/qa/unit/variadictemplates.cxx
@@ -0,0 +1,179 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <optional>
+#include <sal/types.h>
+#include <comphelper/unwrapargs.hxx>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/plugin/TestPlugIn.h>
+
+#include <sstream>
+
+class VariadicTemplatesTest : public CppUnit::TestFixture
+{
+public:
+ void testUnwrapArgs();
+
+ CPPUNIT_TEST_SUITE(VariadicTemplatesTest);
+ CPPUNIT_TEST(testUnwrapArgs);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+namespace {
+
+namespace detail {
+
+template <typename T>
+void extract(
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any> const& seq,
+ sal_Int32 nArg, T & v,
+ ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>
+ const& xErrorContext )
+{
+ if (nArg >= seq.getLength()) {
+ throw ::com::sun::star::lang::IllegalArgumentException(
+ "No such argument available!",
+ xErrorContext, static_cast<sal_Int16>(nArg) );
+ }
+ if (! fromAny(seq[nArg], &v)) {
+ throw ::com::sun::star::lang::IllegalArgumentException(
+ "Cannot extract ANY { "
+ + seq[nArg].getValueType().getTypeName()
+ + " } to " + ::cppu::UnoType<T>::get().getTypeName(),
+ xErrorContext,
+ static_cast<sal_Int16>(nArg) );
+ }
+}
+
+template <typename T>
+void extract(
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any> const& seq,
+ sal_Int32 nArg, ::std::optional<T> & v,
+ ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>
+ const& xErrorContext )
+{
+ if (nArg < seq.getLength()) {
+ T t;
+ extract( seq, nArg, t, xErrorContext );
+ v = t;
+ }
+}
+
+} // namespace detail
+
+template < typename T0, typename T1, typename T2, typename T3, typename T4 >
+void unwrapArgsBaseline(
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > const& seq,
+ T0& v0, T1& v1, T2& v2, T3& v3, T4& v4,
+ ::com::sun::star::uno::Reference<
+ ::com::sun::star::uno::XInterface> const& xErrorContext =
+ ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>() )
+{
+ ::detail::extract( seq, 0, v0, xErrorContext );
+ ::detail::extract( seq, 1, v1, xErrorContext );
+ ::detail::extract( seq, 2, v2, xErrorContext );
+ ::detail::extract( seq, 3, v3, xErrorContext );
+ ::detail::extract( seq, 4, v4, xErrorContext );
+}
+
+}
+
+void VariadicTemplatesTest::testUnwrapArgs() {
+ OUString tmp1 = "Test1";
+ sal_Int32 tmp2 = 42;
+ sal_uInt32 tmp3 = 42;
+ ::com::sun::star::uno::Any tmp6(
+ tmp1
+ );
+ ::com::sun::star::uno::Any tmp7(
+ tmp2
+ );
+ ::com::sun::star::uno::Any tmp8(
+ tmp3
+ );
+ ::com::sun::star::uno::Any tmp9(
+ OUString("Test2")
+ );
+ ::std::optional< ::com::sun::star::uno::Any > tmp10(
+ OUString("Test3")
+ );
+ ::std::optional< ::com::sun::star::uno::Any > tmp11(
+ tmp1
+ );
+
+ // test equality with the baseline and template specialization with
+ // std::optional< T >
+ try {
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > seq1(
+ static_cast< sal_uInt32 >( 5 ) );
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > seq2(
+ static_cast< sal_uInt32 >( 5 ) );
+
+ // tmp11 should be ignored as it is ::std::optional< T >
+ ::comphelper::unwrapArgs( seq1, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 );
+ unwrapArgsBaseline( seq2, tmp6, tmp7, tmp8, tmp9, tmp10 );
+ ::com::sun::star::uno::Any* p1 = seq1.getArray();
+ ::com::sun::star::uno::Any* p2 = seq2.getArray();
+
+ for( sal_Int32 i = 0; i < seq1.getLength() && i < seq2.getLength(); ++i ) {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "seq1 and seq2 are equal",
+ p1[i], p2[i] );
+ }
+ CPPUNIT_ASSERT_MESSAGE( "seq1 and seq2 are equal",
+ bool(seq1 == seq2) );
+ }
+ catch( ::com::sun::star::lang::IllegalArgumentException& err ) {
+ std::stringstream ss;
+ ss << "IllegalArgumentException when unwrapping arguments at: " <<
+ err.ArgumentPosition;
+ CPPUNIT_FAIL( ss.str() );
+ }
+
+ // test argument counting
+ try {
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > seq(
+ static_cast< sal_uInt32 >( 4 ) );
+ ::comphelper::unwrapArgs( seq, tmp6, tmp7, tmp10, tmp11, tmp10, tmp6 );
+ }
+ catch( ::com::sun::star::lang::IllegalArgumentException& err ) {
+ CPPUNIT_ASSERT_EQUAL( static_cast< short >( 5 ), err.ArgumentPosition );
+ }
+
+ OUString test1( "Test2" );
+ OUString test2( "Test2" );
+ OUString test3( "Test3" );
+ OUString test4( "Test4" );
+ OUString test5( "Test5" );
+
+ try {
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > seq(
+ static_cast< sal_uInt32 >( 4 ) );
+ ::comphelper::unwrapArgs( seq, test1, test2, test3, test4, test5 );
+ }
+ catch( ::com::sun::star::lang::IllegalArgumentException& err1 ) {
+ try {
+ ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > seq(
+ static_cast< sal_uInt32 >( 4 ) );
+ unwrapArgsBaseline( seq, test1, test2, test3, test4, test5 );
+ CPPUNIT_FAIL( "unwrapArgs failed while the baseline did not throw" );
+ }
+ catch( ::com::sun::star::lang::IllegalArgumentException& err2 ) {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "err1.ArgumentPosition == err2.ArgumentPosition",
+ err1.ArgumentPosition, err2.ArgumentPosition );
+ }
+ }
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(VariadicTemplatesTest);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */