Introduce css.reflection.Dump singleton

...and revert e1c6f36d8bcc0799281e3a7e244175f682d97cb2 "Add a to_string()
function to the code generated for UNO IDL constant groups".  (But keep the
constants groups the latter had added to cppu/qa/cppumaker/types.idl, and use
them in the newly added CppunitTest_stoc_dump, for better or worse.)

Change-Id: I56e9eaeb1e45b83a72a25eceef13e719dc6f3a1e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/149281
Reviewed-by: Tor Lillqvist <tml@collabora.com>
Tested-by: Jenkins

7 files changed, 635 insertions, 0 deletions

diff --git a/stoc/CppunitTest_stoc_dump.mk b/stoc/CppunitTest_stoc_dump.mk
new file mode 100644
index 000000000000..98f5fe7f8dc3
--- /dev/null
+++ b/stoc/CppunitTest_stoc_dump.mk
@@ -0,0 +1,33 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t; 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/.
+#
+
+$(eval $(call gb_CppunitTest_CppunitTest,stoc_dump))
+
+$(eval $(call gb_CppunitTest_add_exception_objects,stoc_dump, \
+    stoc/test/dump \
+))
+
+$(eval $(call gb_CppunitTest_use_internal_api,stoc_dump, \
+    cppu_qa_cppumaker_types \
+))
+
+$(eval $(call gb_CppunitTest_use_libraries,stoc_dump, \
+    cppu \
+    cppuhelper \
+    sal \
+))
+
+$(eval $(call gb_CppunitTest_use_udk_api,stoc_dump))
+
+$(eval $(call gb_CppunitTest_use_ure,stoc_dump))
+
+$(call gb_CppunitTest_get_target,stoc_dump): \
+    UNO_TYPES += $(call gb_UnoApiTarget_get_target,cppu_qa_cppumaker_types)
+
+# vim: set noet sw=4 ts=4:
diff --git a/stoc/Library_reflection.mk b/stoc/Library_reflection.mk
index eac448030f14..083b2378363b 100644
--- a/stoc/Library_reflection.mk
+++ b/stoc/Library_reflection.mk
@@ -28,6 +28,7 @@ $(eval $(call gb_Library_add_exception_objects,reflection,\
     stoc/source/corereflection/crefl \
     stoc/source/corereflection/crenum \
     stoc/source/corereflection/criface \
+    stoc/source/corereflection/dump \
 ))
 
 # vim:set noet sw=4 ts=4:
diff --git a/stoc/Module_stoc.mk b/stoc/Module_stoc.mk
index d05c53d55fd3..e94e5be476b4 100644
--- a/stoc/Module_stoc.mk
+++ b/stoc/Module_stoc.mk
@@ -30,6 +30,7 @@ $(eval $(call gb_Module_add_targets,stoc,\
 endif
 
 $(eval $(call gb_Module_add_check_targets,stoc, \
+    CppunitTest_stoc_dump \
     CppunitTest_stoc_uriproc \
 ))
 
diff --git a/stoc/source/corereflection/dump.cxx b/stoc/source/corereflection/dump.cxx
new file mode 100644
index 000000000000..0905393db9bc
--- /dev/null
+++ b/stoc/source/corereflection/dump.cxx
@@ -0,0 +1,358 @@
+/* -*- 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 <bitset>
+
+#include <com/sun/star/container/NoSuchElementException.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/reflection/XConstantTypeDescription.hpp>
+#include <com/sun/star/reflection/XConstantsTypeDescription.hpp>
+#include <com/sun/star/reflection/XDump.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/DeploymentException.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/uno/Type.hxx>
+#include <com/sun/star/uno/TypeClass.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <config_typesizes.h>
+#include <cppu/unotype.hxx>
+#include <cppuhelper/basemutex.hxx>
+#include <cppuhelper/compbase.hxx>
+#include <cppuhelper/interfacecontainer.hxx>
+#include <o3tl/unreachable.hxx>
+#include <osl/mutex.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <sal/types.h>
+#include <typelib/typedescription.h>
+#include <typelib/typedescription.hxx>
+#include <uno/sequence2.h>
+
+namespace com::sun::star::uno
+{
+class XInterface;
+}
+
+namespace
+{
+template <typename T> OUString hex(T value, sal_Int32 width)
+{
+    OUStringBuffer buf(OUString::number(value, 16));
+    while (buf.getLength() < width)
+    {
+        buf.insert(0, '0');
+    }
+    return buf.makeStringAndClear();
+}
+
+css::uno::TypeDescription getTypeDescription(css::uno::Type const& type)
+{
+    typelib_TypeDescription* d = nullptr;
+    type.getDescription(&d);
+    return css::uno::TypeDescription(d);
+}
+
+OUString
+getIdentifier(css::uno::Reference<css::reflection::XConstantTypeDescription> const& constant)
+{
+    auto const n = constant->getName();
+    auto const i = n.lastIndexOf('.');
+    if (i == -1 || i == n.getLength() - 1)
+    {
+        throw css::uno::DeploymentException("bad constant name " + n);
+    }
+    return n.copy(i + 1);
+}
+
+OUString
+dumpBitset(css::uno::Sequence<css::uno::Reference<css::reflection::XConstantTypeDescription>> const&
+               constants,
+           sal_uInt64 value)
+{
+    OUStringBuffer buf;
+    auto a = value;
+    for (auto const& i : constants)
+    {
+        sal_uInt64 c;
+        if ((i->getConstantValue() >>= c) && std::bitset<64>{ c }.count() == 1 && (a & c) != 0)
+        {
+            if (!buf.isEmpty())
+            {
+                buf.append('+');
+            }
+            buf.append(getIdentifier(i));
+            a &= ~c;
+        }
+    }
+    return a == 0 && !buf.isEmpty() ? buf.makeStringAndClear() : OUString::number(value);
+}
+
+class Dump : public cppu::BaseMutex, public cppu::WeakComponentImplHelper<css::reflection::XDump>
+{
+public:
+    explicit Dump(css::uno::Reference<css::uno::XComponentContext> const& context)
+        : WeakComponentImplHelper(m_aMutex)
+        , manager_(context->getValueByName(
+                       "/singletons/com.sun.star.reflection.theTypeDescriptionManager"),
+                   css::uno::UNO_QUERY_THROW)
+    {
+    }
+
+    void SAL_CALL disposing() override
+    {
+        osl::MutexGuard g(m_aMutex);
+        manager_.clear();
+    }
+
+    OUString SAL_CALL dumpValue(css::uno::Any const& value) override
+    {
+        switch (value.getValueTypeClass())
+        {
+            case css::uno::TypeClass_VOID:
+                return "void";
+            case css::uno::TypeClass_BOOLEAN:
+                return OUString::boolean(value.get<bool>());
+            case css::uno::TypeClass_BYTE:
+                return OUString::number(value.get<sal_Int8>());
+            case css::uno::TypeClass_SHORT:
+                return OUString::number(value.get<sal_Int16>());
+            case css::uno::TypeClass_UNSIGNED_SHORT:
+                return OUString::number(value.get<sal_uInt16>());
+            case css::uno::TypeClass_LONG:
+                return OUString::number(value.get<sal_Int32>());
+            case css::uno::TypeClass_UNSIGNED_LONG:
+                return OUString::number(value.get<sal_uInt32>());
+            case css::uno::TypeClass_HYPER:
+                return OUString::number(value.get<sal_Int64>());
+            case css::uno::TypeClass_UNSIGNED_HYPER:
+                return OUString::number(value.get<sal_uInt64>());
+            case css::uno::TypeClass_FLOAT:
+                return OUString::number(value.get<float>());
+            case css::uno::TypeClass_DOUBLE:
+                return OUString::number(value.get<double>());
+            case css::uno::TypeClass_CHAR:
+                return "U+" + hex(value.get<sal_Unicode>(), 16);
+            case css::uno::TypeClass_STRING:
+            {
+                auto const s = value.get<OUString>();
+                OUStringBuffer buf;
+                for (sal_Int32 i = 0; i != s.getLength();)
+                {
+                    auto const c = s.iterateCodePoints(&i);
+                    if (c >= u8' ' && c <= u8'~')
+                    {
+                        if (c == u8'\"' || c == u8'\\')
+                        {
+                            buf.append('\\');
+                        }
+                        buf.append(char(c));
+                    }
+                    else if (c <= 0xFFFF)
+                    {
+                        buf.append("\\u" + hex(c, 4));
+                    }
+                    else
+                    {
+                        buf.append("\\U" + hex(c, 8));
+                    }
+                }
+                return "\"" + buf + "\"";
+            }
+            case css::uno::TypeClass_TYPE:
+                return value.get<css::uno::Type>().getTypeName();
+            case css::uno::TypeClass_SEQUENCE:
+            {
+                css::uno::Type const t(reinterpret_cast<typelib_IndirectTypeDescription const*>(
+                                           getTypeDescription(value.getValueType()).get())
+                                           ->pType);
+                auto const n = getTypeDescription(t).get()->nSize;
+                auto const s = *static_cast<uno_Sequence* const*>(value.getValue());
+                OUStringBuffer buf;
+                for (sal_Int32 i = 0; i != s->nElements; ++i)
+                {
+                    if (i != 0)
+                    {
+                        buf.append(", ");
+                    }
+                    css::uno::Any const e(s->elements + i * n, t);
+                    buf.append(t == cppu::UnoType<css::uno::Any>::get() ? dumpAny(e)
+                                                                        : dumpValue(e));
+                }
+                return "[" + buf + "]";
+            }
+            case css::uno::TypeClass_ENUM:
+            {
+                auto const d = getTypeDescription(value.getValueType());
+                auto const ed = reinterpret_cast<typelib_EnumTypeDescription const*>(d.get());
+                auto const e = *static_cast<sal_Int32 const*>(value.getValue());
+                for (sal_Int32 i = 0; i != ed->nEnumValues; ++i)
+                {
+                    if (ed->pEnumValues[i] == e)
+                    {
+                        return OUString(ed->ppEnumNames[i]);
+                    }
+                }
+                return OUString::number(e);
+            }
+            case css::uno::TypeClass_STRUCT:
+            case css::uno::TypeClass_EXCEPTION:
+            {
+                auto const d = getTypeDescription(value.getValueType());
+                OUStringBuffer buf;
+                dumpCompoundType(reinterpret_cast<typelib_CompoundTypeDescription const*>(d.get()),
+                                 value.getValue(), &buf);
+                return "[" + buf + "]";
+            }
+            case css::uno::TypeClass_INTERFACE:
+            {
+                auto const p = *static_cast<void* const*>(value.getValue());
+                return p == nullptr ? OUString("null")
+                                    : OUString("0x"
+                                               + hex(reinterpret_cast<sal_uIntPtr>(p),
+                                                     SAL_TYPES_SIZEOFPOINTER * 2));
+            }
+            default:
+                O3TL_UNREACHABLE;
+        }
+    }
+
+    OUString SAL_CALL dumpAny(css::uno::Any const& value) override
+    {
+        return "[" + value.getValueType().getTypeName() + ": " + dumpValue(value) + "]";
+    }
+
+    OUString SAL_CALL dumpConstant(OUString const& constantsGroup,
+                                   css::uno::Any const& value) override
+    {
+        css::uno::Reference<css::container::XHierarchicalNameAccess> manager;
+        {
+            osl::MutexGuard g(m_aMutex);
+            if (rBHelper.bDisposed)
+            {
+                throw css::lang::DisposedException("css.reflection.Dumper");
+            }
+            manager = manager_;
+        }
+        css::uno::Reference<css::reflection::XConstantsTypeDescription> g;
+        try
+        {
+            manager_->getByHierarchicalName(constantsGroup) >>= g;
+        }
+        catch (css::container::NoSuchElementException)
+        {
+        }
+        if (!g.is())
+        {
+            throw css::lang::IllegalArgumentException("not a constants group: " + constantsGroup,
+                                                      {}, 0);
+        }
+        auto const s = g->getConstants();
+        switch (value.getValueTypeClass())
+        {
+            case css::uno::TypeClass_BOOLEAN:
+                for (auto const& i : s)
+                {
+                    if (i->getConstantValue() == value)
+                    {
+                        return getIdentifier(i);
+                    }
+                }
+                return OUString::boolean(value.get<bool>());
+            case css::uno::TypeClass_BYTE:
+            case css::uno::TypeClass_SHORT:
+            case css::uno::TypeClass_LONG:
+            case css::uno::TypeClass_HYPER:
+            {
+                auto const v = value.get<sal_Int64>();
+                for (auto const& i : s)
+                {
+                    sal_Int64 c;
+                    if ((i->getConstantValue() >>= c) && c == v)
+                    {
+                        return getIdentifier(i);
+                    }
+                }
+                return v >= 0 ? dumpBitset(s, v) : OUString::number(v);
+            }
+            case css::uno::TypeClass_UNSIGNED_SHORT:
+            case css::uno::TypeClass_UNSIGNED_LONG:
+            case css::uno::TypeClass_UNSIGNED_HYPER:
+            {
+                auto const v = value.get<sal_uInt64>();
+                for (auto const& i : s)
+                {
+                    sal_uInt64 c;
+                    if ((i->getConstantValue() >>= c) && c == v)
+                    {
+                        return getIdentifier(i);
+                    }
+                }
+                return dumpBitset(s, v);
+            }
+            case css::uno::TypeClass_FLOAT:
+            case css::uno::TypeClass_DOUBLE:
+            {
+                auto const v = value.get<double>();
+                for (auto const& i : s)
+                {
+                    double c;
+                    if ((i->getConstantValue() >>= c) && c == v)
+                    {
+                        return getIdentifier(i);
+                    }
+                }
+                return OUString::number(v);
+            }
+            default:
+                throw css::lang::IllegalArgumentException(
+                    "not a numeric type: " + value.getValueTypeName(), {}, 1);
+        }
+    }
+
+private:
+    css::uno::Reference<css::container::XHierarchicalNameAccess> manager_;
+
+    void dumpCompoundType(typelib_CompoundTypeDescription const* description, void const* data,
+                          OUStringBuffer* buffer)
+    {
+        if (auto base = description->pBaseTypeDescription)
+        {
+            dumpCompoundType(base, data, buffer);
+        }
+        for (sal_Int32 i = 0; i != description->nMembers; ++i)
+        {
+            if (!buffer->isEmpty())
+            {
+                buffer->append(", ");
+            }
+            buffer->append(OUString::unacquired(description->ppMemberNames + i) + ": ");
+            css::uno::Type t(description->ppTypeRefs[i]);
+            css::uno::Any const m(static_cast<char const*>(data) + description->pMemberOffsets[i],
+                                  t);
+            buffer->append(t == cppu::UnoType<css::uno::Any>::get() ? dumpAny(m) : dumpValue(m));
+        }
+    }
+};
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_comp_stoc_Dump_get_implementation(css::uno::XComponentContext* context,
+                                               css::uno::Sequence<css::uno::Any> const& arguments)
+{
+    SAL_WARN_IF(arguments.hasElements(), "stoc", "unexpected singleton arguments");
+    return cppu::acquire(new Dump(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/stoc/source/corereflection/reflection.component b/stoc/source/corereflection/reflection.component
index 70ccb68e0402..0210c80904f0 100644
--- a/stoc/source/corereflection/reflection.component
+++ b/stoc/source/corereflection/reflection.component
@@ -25,4 +25,9 @@
     <service name="com.sun.star.reflection.CoreReflection"/>
     <singleton name="com.sun.star.reflection.theCoreReflection"/>
   </implementation>
+  <implementation name="com.sun.star.comp.stoc.Dump"
+      constructor="com_sun_star_comp_stoc_Dump_get_implementation"
+      single-instance="true">
+    <singleton name="com.sun.star.reflection.Dump"/>
+  </implementation>
 </component>
diff --git a/stoc/test/dump.cxx b/stoc/test/dump.cxx
new file mode 100644
index 000000000000..798e05acc2ca
--- /dev/null
+++ b/stoc/test/dump.cxx
@@ -0,0 +1,152 @@
+/* -*- 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 <com/sun/star/beans/PropertyChangeEvent.hpp>
+#include <com/sun/star/reflection/Dump.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/TypeClass.hpp>
+#include <cppuhelper/bootstrap.hxx>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/plugin/TestPlugIn.h>
+#include <test/codemaker/cppumaker/ByteBits.hpp>
+#include <test/codemaker/cppumaker/Constants.hpp>
+#include <test/codemaker/cppumaker/ShortBits.hpp>
+#include <test/codemaker/cppumaker/UnsignedHyperBits.hpp>
+
+namespace
+{
+class Dump : public CppUnit::TestFixture
+{
+public:
+    void setUp() override
+    {
+        dump_ = css::reflection::Dump::get(cppu::defaultBootstrap_InitialComponentContext());
+    }
+
+    void testSequence()
+    {
+        CPPUNIT_ASSERT_EQUAL(OUString("[]"),
+                             dump_->dumpValue(css::uno::Any(css::uno::Sequence<sal_Int32>{})));
+        CPPUNIT_ASSERT_EQUAL(OUString("[1]"),
+                             dump_->dumpValue(css::uno::Any(css::uno::Sequence<sal_Int32>{ 1 })));
+        CPPUNIT_ASSERT_EQUAL(OUString("[1, 2, 3]"), dump_->dumpValue(css::uno::Any(
+                                                        css::uno::Sequence<sal_Int32>{ 1, 2, 3 })));
+        CPPUNIT_ASSERT_EQUAL(OUString("[[long: 1], [string: \"2\"], [[]long: [1, 2]]]"),
+                             (dump_->dumpValue(css::uno::Any(css::uno::Sequence<css::uno::Any>{
+                                 css::uno::Any(sal_Int32(1)), css::uno::Any(OUString("2")),
+                                 css::uno::Any(css::uno::Sequence<sal_Int32>{ 1, 2 }) }))));
+    }
+
+    void testEnum()
+    {
+        CPPUNIT_ASSERT_EQUAL(OUString("ENUM"),
+                             dump_->dumpValue(css::uno::Any(css::uno::TypeClass_ENUM)));
+        CPPUNIT_ASSERT_EQUAL(OUString("-1"),
+                             dump_->dumpValue(css::uno::Any(css::uno::TypeClass(-1))));
+        CPPUNIT_ASSERT_EQUAL(OUString("12345"),
+                             dump_->dumpValue(css::uno::Any(css::uno::TypeClass(12345))));
+    }
+
+    void testStruct()
+    {
+        CPPUNIT_ASSERT_EQUAL(
+            OUString("[Source: null, PropertyName: \"test\", Further: false, PropertyHandle: 3, "
+                     "OldValue: [void: void], NewValue: [long: 5]]"),
+            dump_->dumpValue(css::uno::Any(css::beans::PropertyChangeEvent(
+                {}, "test", false, 3, {}, css::uno::Any(sal_Int32(5))))));
+    }
+
+    void testConstantsGroup()
+    {
+        CPPUNIT_ASSERT_EQUAL(OUString("byteMin"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int8(-128))));
+        CPPUNIT_ASSERT_EQUAL(OUString("byteMax"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int8(127))));
+        CPPUNIT_ASSERT_EQUAL(OUString("longMin"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int32(-2147483648))));
+        CPPUNIT_ASSERT_EQUAL(OUString("longMax"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int32(2147483647))));
+        CPPUNIT_ASSERT_EQUAL(OUString("hyperMin"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(SAL_MIN_INT64)));
+        CPPUNIT_ASSERT_EQUAL(OUString("hyperMax"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(SAL_MAX_INT64)));
+        CPPUNIT_ASSERT_EQUAL(OUString("17"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int32(17))));
+        CPPUNIT_ASSERT_EQUAL(OUString("2147483646"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.Constants",
+                                                 css::uno::Any(sal_Int32(2147483646))));
+
+        CPPUNIT_ASSERT_EQUAL(OUString("0"), dump_->dumpConstant("test.codemaker.cppumaker.ByteBits",
+                                                                css::uno::Any(sal_Int8(0))));
+        CPPUNIT_ASSERT_EQUAL(
+            OUString("BIT0+BIT2"),
+            dump_->dumpConstant("test.codemaker.cppumaker.ByteBits", css::uno::Any(sal_Int8(5))));
+        CPPUNIT_ASSERT_EQUAL(
+            OUString("BIT4"),
+            dump_->dumpConstant("test.codemaker.cppumaker.ByteBits", css::uno::Any(sal_Int8(16))));
+        CPPUNIT_ASSERT_EQUAL(
+            OUString("BIT0+BIT4"),
+            dump_->dumpConstant("test.codemaker.cppumaker.ByteBits", css::uno::Any(sal_Int8(17))));
+        CPPUNIT_ASSERT_EQUAL(OUString("BIT7"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.ByteBits",
+                                                 css::uno::Any(sal_Int8(-128))));
+        CPPUNIT_ASSERT_EQUAL(
+            OUString("ALL"),
+            dump_->dumpConstant("test.codemaker.cppumaker.ByteBits", css::uno::Any(sal_Int8(-1))));
+
+        CPPUNIT_ASSERT_EQUAL(OUString("BIT7"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.ShortBits",
+                                                 css::uno::Any(sal_Int16(128))));
+        CPPUNIT_ASSERT_EQUAL(OUString("ALL"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.ShortBits",
+                                                 css::uno::Any(sal_Int16(-1))));
+
+        CPPUNIT_ASSERT_EQUAL(OUString("BIT63"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.UnsignedHyperBits",
+                                                 css::uno::Any(sal_uInt64(9223372036854775808u))));
+        CPPUNIT_ASSERT_EQUAL(OUString("BIT0+BIT62"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.UnsignedHyperBits",
+                                                 css::uno::Any(sal_uInt64(4611686018427387905))));
+        CPPUNIT_ASSERT_EQUAL(OUString("BIT0+BIT63"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.UnsignedHyperBits",
+                                                 css::uno::Any(sal_uInt64(9223372036854775809u))));
+        CPPUNIT_ASSERT_EQUAL(OUString("ALL"),
+                             dump_->dumpConstant("test.codemaker.cppumaker.UnsignedHyperBits",
+                                                 css::uno::Any(SAL_MAX_UINT64)));
+    }
+
+    CPPUNIT_TEST_SUITE(Dump);
+    CPPUNIT_TEST(testSequence);
+    CPPUNIT_TEST(testEnum);
+    CPPUNIT_TEST(testStruct);
+    CPPUNIT_TEST(testConstantsGroup);
+    CPPUNIT_TEST_SUITE_END();
+
+private:
+    css::uno::Reference<css::reflection::XDump> dump_;
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(Dump);
+}
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/stoc/test/dump.idl b/stoc/test/dump.idl
new file mode 100644
index 000000000000..65bac74a32bf
--- /dev/null
+++ b/stoc/test/dump.idl
@@ -0,0 +1,85 @@
+/* -*- 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/.
+ */
+
+module org { module libreoffice { module test {
+
+constants Constants {
+    const byte byteMin = -128;
+    const byte byteMax = 127;
+    const short shortMin = -32768;
+    const short shortMax = 32767;
+    const unsigned short unsignedShortMin = 0;
+    const unsigned short unsignedShortMax = 65535;
+    const long longMin = -2147483648;
+    const long longMax = 2147483647;
+    const unsigned long unsignedLongMin = 0;
+    const unsigned long unsignedLongMax = 4294967295;
+    const hyper hyperMin = -9223372036854775808;
+    const hyper hyperMax = 9223372036854775807;
+    const unsigned hyper unsignedHyperMin = 0;
+    const unsigned hyper unsignedHyperMax = 18446744073709551615;
+};
+
+constants ByteBits {
+    const byte BIT0 = 1;
+    const byte BIT1 = 2;
+    const byte BIT2 = 4;
+    const byte BIT3 = 8;
+    const byte BIT4 = 16;
+    const byte BIT5 = 32;
+    const byte BIT6 = 64;
+    const byte BIT7 = -128;
+    const byte ALL = -1;
+};
+
+constants ShortBits {
+    const short BIT0 = 1;
+    const short BIT1 = 2;
+    const short BIT2 = 4;
+    const short BIT3 = 8;
+    const short BIT4 = 16;
+    const short BIT5 = 32;
+    const short BIT6 = 64;
+    const short BIT7 = 128;
+    const short BIT8 = 256;
+    const short BIT9 = 512;
+    const short BIT10 = 1024;
+    const short BIT11 = 2048;
+    const short BIT12 = 4096;
+    const short BIT13 = 8192;
+    const short BIT14 = 16384;
+    const short BIT15 = -32768;
+    const short ALL = -1;
+};
+
+constants UnsignedHyperBits {
+    const unsigned hyper BIT0 = 1;
+    const unsigned hyper BIT1 = 2;
+    const unsigned hyper BIT2 = 4;
+    const unsigned hyper BIT3 = 8;
+    const unsigned hyper BIT4 = 16;
+    const unsigned hyper BIT5 = 32;
+    const unsigned hyper BIT6 = 64;
+    const unsigned hyper BIT7 = 128;
+    const unsigned hyper BIT8 = 256;
+    const unsigned hyper BIT9 = 512;
+    const unsigned hyper BIT10 = 1024;
+    const unsigned hyper BIT11 = 2048;
+    const unsigned hyper BIT12 = 4096;
+    const unsigned hyper BIT13 = 8192;
+    const unsigned hyper BIT14 = 16384;
+    const unsigned hyper BIT15 = 32768;
+    const unsigned hyper BIT62 = 4611686018427387904;
+    const unsigned hyper BIT63 = 9223372036854775808;
+    const unsigned hyper ALL = 18446744073709551615;
+};
+
+}; }; };
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */