unotest/source/embindtest/embindtest.cxx | 149 +++++++++++++++++++++++++++++ unotest/source/embindtest/embindtest.idl | 28 +++++ unotest/source/embindtest/embindtest.js | 155 +++++++++++++++++++++++++++++++ 3 files changed, 332 insertions(+)
New commits: commit 24cd81bc29c440a537e12cbd163aea1b5d68e891 Author: Stephan Bergmann <[email protected]> AuthorDate: Thu Feb 22 10:49:14 2024 +0100 Commit: Stephan Bergmann <[email protected]> CommitDate: Fri Feb 23 13:50:25 2024 +0100 unoembind sequence tests Change-Id: I151969acde242bc9c7ee88e2b2da44c8c2101456 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/163816 Tested-by: Jenkins Reviewed-by: Stephan Bergmann <[email protected]> diff --git a/unotest/source/embindtest/embindtest.cxx b/unotest/source/embindtest/embindtest.cxx index 9ab70656541d..152afe551e5b 100644 --- a/unotest/source/embindtest/embindtest.cxx +++ b/unotest/source/embindtest/embindtest.cxx @@ -85,6 +85,155 @@ public: { return value.m1 == -123456 && value.m2 == 100.5 && value.m3 == u"hä"; } + + css::uno::Sequence<sal_Bool> SAL_CALL getSequenceBoolean() override + { + return { true, true, false }; + } + + sal_Bool SAL_CALL isSequenceBoolean(css::uno::Sequence<sal_Bool> const& value) override + { + return value == css::uno::Sequence<sal_Bool>{ true, true, false }; + } + + css::uno::Sequence<sal_Int8> SAL_CALL getSequenceByte() override { return { -12, 1, 12 }; } + + sal_Bool SAL_CALL isSequenceByte(css::uno::Sequence<sal_Int8> const& value) override + { + return value == css::uno::Sequence<sal_Int8>{ -12, 1, 12 }; + } + + css::uno::Sequence<sal_Int16> SAL_CALL getSequenceShort() override + { + return { -1234, 1, 1234 }; + } + + sal_Bool SAL_CALL isSequenceShort(css::uno::Sequence<sal_Int16> const& value) override + { + return value == css::uno::Sequence<sal_Int16>{ -1234, 1, 1234 }; + } + + css::uno::Sequence<sal_uInt16> SAL_CALL getSequenceUnsignedShort() override + { + return { 1, 10, 54321 }; + } + + sal_Bool SAL_CALL isSequenceUnsignedShort(css::uno::Sequence<sal_uInt16> const& value) override + { + return value == css::uno::Sequence<sal_uInt16>{ 1, 10, 54321 }; + } + + css::uno::Sequence<sal_Int32> SAL_CALL getSequenceLong() override + { + return { -123456, 1, 123456 }; + } + + sal_Bool SAL_CALL isSequenceLong(css::uno::Sequence<sal_Int32> const& value) override + { + return value == css::uno::Sequence<sal_Int32>{ -123456, 1, 123456 }; + } + + css::uno::Sequence<sal_uInt32> SAL_CALL getSequenceUnsignedLong() override + { + return { 1, 10, 3456789012 }; + } + + sal_Bool SAL_CALL isSequenceUnsignedLong(css::uno::Sequence<sal_uInt32> const& value) override + { + return value == css::uno::Sequence<sal_uInt32>{ 1, 10, 3456789012 }; + } + + css::uno::Sequence<sal_Int64> SAL_CALL getSequenceHyper() override + { + return { -123456789, 1, 123456789 }; + } + + sal_Bool SAL_CALL isSequenceHyper(css::uno::Sequence<sal_Int64> const& value) override + { + return value == css::uno::Sequence<sal_Int64>{ -123456789, 1, 123456789 }; + } + + css::uno::Sequence<sal_uInt64> SAL_CALL getSequenceUnsignedHyper() override + { + return { 1, 10, 9876543210 }; + } + + sal_Bool SAL_CALL isSequenceUnsignedHyper(css::uno::Sequence<sal_uInt64> const& value) override + { + return value == css::uno::Sequence<sal_uInt64>{ 1, 10, 9876543210 }; + } + + css::uno::Sequence<float> SAL_CALL getSequenceFloat() override + { + return { -10.25, 1.5, 10.75 }; + } + + sal_Bool SAL_CALL isSequenceFloat(css::uno::Sequence<float> const& value) override + { + return value == css::uno::Sequence<float>{ -10.25, 1.5, 10.75 }; + } + + css::uno::Sequence<double> SAL_CALL getSequenceDouble() override + { + return { -100.5, 1.25, 100.75 }; + } + + sal_Bool SAL_CALL isSequenceDouble(css::uno::Sequence<double> const& value) override + { + return value == css::uno::Sequence<double>{ -100.5, 1.25, 100.75 }; + } + + css::uno::Sequence<sal_Unicode> SAL_CALL getSequenceChar() override + { + return { 'a', 'B', u'Ö' }; + } + + sal_Bool SAL_CALL isSequenceChar(css::uno::Sequence<sal_Unicode> const& value) override + { + return value == css::uno::Sequence<sal_Unicode>{ 'a', 'B', u'Ö' }; + } + + css::uno::Sequence<OUString> SAL_CALL getSequenceString() override + { + return { u"foo"_ustr, u"barr"_ustr, u"bazzz"_ustr }; + } + + sal_Bool SAL_CALL isSequenceString(css::uno::Sequence<OUString> const& value) override + { + return value == css::uno::Sequence<OUString>{ u"foo"_ustr, u"barr"_ustr, u"bazzz"_ustr }; + } + + css::uno::Sequence<css::uno::Sequence<OUString>> SAL_CALL getSequenceSequenceString() override + { + return { {}, { u"foo"_ustr, u"barr"_ustr }, { u"baz"_ustr } }; + } + + sal_Bool SAL_CALL + isSequenceSequenceString(css::uno::Sequence<css::uno::Sequence<OUString>> const& value) override + { + return value + == css::uno::Sequence<css::uno::Sequence<OUString>>{ {}, + { u"foo"_ustr, u"barr"_ustr }, + { u"baz"_ustr } }; + } + + css::uno::Sequence<org::libreoffice::embindtest::Struct> SAL_CALL getSequenceStruct() override + { + return { { -123456, -100.5, u"foo"_ustr }, + { 1, 1.25, u"barr"_ustr }, + { 123456, 100.75, u"bazzz"_ustr } }; + } + + sal_Bool SAL_CALL + isSequenceStruct(css::uno::Sequence<org::libreoffice::embindtest::Struct> const& value) override + { + return value + == css::uno::Sequence<org::libreoffice::embindtest::Struct>{ + { -123456, -100.5, u"foo"_ustr }, + { 1, 1.25, u"barr"_ustr }, + { 123456, 100.75, u"bazzz"_ustr } + }; + } }; } diff --git a/unotest/source/embindtest/embindtest.idl b/unotest/source/embindtest/embindtest.idl index 09e5c4096c50..a0884661b395 100644 --- a/unotest/source/embindtest/embindtest.idl +++ b/unotest/source/embindtest/embindtest.idl @@ -42,6 +42,34 @@ interface XTest { boolean isString([in] string value); Struct getStruct(); boolean isStruct([in] Struct value); + sequence<boolean> getSequenceBoolean(); + boolean isSequenceBoolean([in] sequence<boolean> value); + sequence<byte> getSequenceByte(); + boolean isSequenceByte([in] sequence<byte> value); + sequence<short> getSequenceShort(); + boolean isSequenceShort([in] sequence<short> value); + sequence<unsigned short> getSequenceUnsignedShort(); + boolean isSequenceUnsignedShort([in] sequence<unsigned short> value); + sequence<long> getSequenceLong(); + boolean isSequenceLong([in] sequence<long> value); + sequence<unsigned long> getSequenceUnsignedLong(); + boolean isSequenceUnsignedLong([in] sequence<unsigned long> value); + sequence<hyper> getSequenceHyper(); + boolean isSequenceHyper([in] sequence<hyper> value); + sequence<unsigned hyper> getSequenceUnsignedHyper(); + boolean isSequenceUnsignedHyper([in] sequence<unsigned hyper> value); + sequence<float> getSequenceFloat(); + boolean isSequenceFloat([in] sequence<float> value); + sequence<double> getSequenceDouble(); + boolean isSequenceDouble([in] sequence<double> value); + sequence<char> getSequenceChar(); + boolean isSequenceChar([in] sequence<char> value); + sequence<string> getSequenceString(); + boolean isSequenceString([in] sequence<string> value); + sequence<sequence<string> > getSequenceSequenceString(); + boolean isSequenceSequenceString([in] sequence<sequence<string> > value); + sequence<Struct> getSequenceStruct(); + boolean isSequenceStruct([in] sequence<Struct> value); }; singleton Test: XTest; diff --git a/unotest/source/embindtest/embindtest.js b/unotest/source/embindtest/embindtest.js index 9d0349ffe7f2..3d3196cc4c39 100644 --- a/unotest/source/embindtest/embindtest.js +++ b/unotest/source/embindtest/embindtest.js @@ -93,6 +93,161 @@ Module.addOnPostRun(function() { console.assert(v.m3 === 'hä'); console.assert(test.isStruct(v)); } + { + let v = test.getSequenceBoolean(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 1); //TODO: true + console.assert(v.get(1) === 1); //TODO: true + console.assert(v.get(2) === 0); //TODO: false + console.assert(test.isSequenceBoolean(v)); + v.delete(); + } + { + let v = test.getSequenceByte(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -12); + console.assert(v.get(1) === 1); + console.assert(v.get(2) === 12); + console.assert(test.isSequenceByte(v)); + v.delete(); + } + { + let v = test.getSequenceShort(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -1234); + console.assert(v.get(1) === 1); + console.assert(v.get(2) === 1234); + console.assert(test.isSequenceShort(v)); + v.delete(); + } + { + let v = test.getSequenceUnsignedShort(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 1); + console.assert(v.get(1) === 10); + console.assert(v.get(2) === 54321); + console.assert(test.isSequenceUnsignedShort(v)); + v.delete(); + } + { + let v = test.getSequenceLong(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -123456); + console.assert(v.get(1) === 1); + console.assert(v.get(2) === 123456); + console.assert(test.isSequenceLong(v)); + v.delete(); + } + { + let v = test.getSequenceUnsignedLong(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 1); + console.assert(v.get(1) === 10); + console.assert(v.get(2) === 3456789012); + console.assert(test.isSequenceUnsignedLong(v)); + v.delete(); + } + { + let v = test.getSequenceHyper(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -123456789n); + console.assert(v.get(1) === 1n); + console.assert(v.get(2) === 123456789n); + console.assert(test.isSequenceHyper(v)); + v.delete(); + } + { + let v = test.getSequenceUnsignedHyper(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 1n); + console.assert(v.get(1) === 10n); + console.assert(v.get(2) === 9876543210n); + console.assert(test.isSequenceUnsignedHyper(v)); + v.delete(); + } + { + let v = test.getSequenceFloat(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -10.25); + console.assert(v.get(1) === 1.5); + console.assert(v.get(2) === 10.75); + console.assert(test.isSequenceFloat(v)); + v.delete(); + } + { + let v = test.getSequenceDouble(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === -100.5); + console.assert(v.get(1) === 1.25); + console.assert(v.get(2) === 100.75); + console.assert(test.isSequenceDouble(v)); + v.delete(); + } + { + let v = test.getSequenceChar(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 'a'); + console.assert(v.get(1) === 'B'); + console.assert(v.get(2) === 'Ö'); + console.assert(test.isSequenceChar(v)); + v.delete(); + } + { + let v = test.getSequenceString(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0) === 'foo'); + console.assert(v.get(1) === 'barr'); + console.assert(v.get(2) === 'bazzz'); + console.assert(test.isSequenceString(v)); + v.delete(); + } + { + let v = test.getSequenceSequenceString(); + console.log(v); + console.assert(v.size() === 3); + let e0 = v.get(0); + console.assert(e0.size() === 0); + e0.delete(); + let e1 = v.get(1); + console.assert(e1.size() === 2); + console.assert(e1.get(0) === 'foo'); + console.assert(e1.get(1) === 'barr'); + e1.delete(); + let e2 = v.get(2); + console.assert(e2.size() === 1); + console.assert(e2.get(0) === 'baz'); + e2.delete(); + console.assert(test.isSequenceSequenceString(v)); + v.delete(); + } + { + let v = test.getSequenceStruct(); + console.log(v); + console.assert(v.size() === 3); + console.assert(v.get(0).m1 === -123456); + console.assert(v.get(0).m2 === -100.5); + console.assert(v.get(0).m3 === 'foo'); + console.assert(v.get(1).m1 === 1); + console.assert(v.get(1).m2 === 1.25); + console.assert(v.get(1).m3 === 'barr'); + console.assert(v.get(2).m1 === 123456); + console.assert(v.get(2).m2 === 100.75); + console.assert(v.get(2).m3 === 'bazzz'); + console.assert(test.isSequenceStruct(v)); + v.delete(); + } }); /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
