Remove dynamic exception specifications

...(for now, from LIBO_INTERNAL_CODE only).  See the mail thread starting at
<https://lists.freedesktop.org/archives/libreoffice/2017-January/076665.html>
"Dynamic Exception Specifications" for details.

Most changes have been done automatically by the rewriting loplugin:dynexcspec
(after enabling the rewriting mode, to be committed shortly).  The way it only
removes exception specs from declarations if it also sees a definition, it
identified some dead declarations-w/o-definitions (that have been removed
manually) and some cases where a definition appeared in multiple include files
(which have also been cleaned up manually).  There's also been cases of macro
paramters (that were used to abstract over exception specs) that have become
unused now (and been removed).

Furthermore, some code needed to be cleaned up manually
(avmedia/source/quicktime/ and connectivity/source/drivers/kab/), as I had no
configurations available that would actually build that code.  Missing @throws
documentation has not been applied in such manual clean-up.

Change-Id: I3408691256c9b0c12bc5332de976743626e13960
Reviewed-on: https://gerrit.libreoffice.org/33574
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>

6 files changed, 154 insertions, 235 deletions

diff --git a/testtools/source/bridgetest/bridgetest.cxx b/testtools/source/bridgetest/bridgetest.cxx
index 167719de7c88..bc238c68be32 100644
--- a/testtools/source/bridgetest/bridgetest.cxx
+++ b/testtools/source/bridgetest/bridgetest.cxx
@@ -113,12 +113,12 @@ public:
         {}
 
     // XServiceInfo
-    virtual OUString SAL_CALL getImplementationName() throw (RuntimeException, std::exception) override;
-    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException, std::exception) override;
-    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw (RuntimeException, std::exception) override;
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) override;
+    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 
     // XMain
-    virtual sal_Int32 SAL_CALL run( const Sequence< OUString > & rArgs ) throw (RuntimeException, std::exception) override;
+    virtual sal_Int32 SAL_CALL run( const Sequence< OUString > & rArgs ) override;
 };
 
 
@@ -311,8 +311,7 @@ private:
 public:
     void SAL_CALL callRecursivly(
         const css::uno::Reference< XRecursiveCall >& xCall,
-        sal_Int32 nToCall )
-        throw(css::uno::RuntimeException, std::exception) override
+        sal_Int32 nToCall ) override
         {
             MutexGuard guard( m_mutex );
             if( nToCall )
@@ -1102,7 +1101,6 @@ inline bool makeSurrogate(
 
 
 sal_Int32 TestBridgeImpl::run( const Sequence< OUString > & rArgs )
-    throw (RuntimeException, std::exception)
 {
     bool bRet = false;
     try
@@ -1189,19 +1187,16 @@ sal_Int32 TestBridgeImpl::run( const Sequence< OUString > & rArgs )
 // XServiceInfo
 
 OUString TestBridgeImpl::getImplementationName()
-    throw (RuntimeException, std::exception)
 {
     return OUString( IMPLNAME );
 }
 
 sal_Bool TestBridgeImpl::supportsService( const OUString & rServiceName )
-    throw (RuntimeException, std::exception)
 {
     return cppu::supportsService(this, rServiceName);
 }
 
 Sequence< OUString > TestBridgeImpl::getSupportedServiceNames()
-    throw (RuntimeException, std::exception)
 {
     return bridge_test::getSupportedServiceNames();
 }
diff --git a/testtools/source/bridgetest/constructors.cxx b/testtools/source/bridgetest/constructors.cxx
index 7f1a760d50af..2243b16a4973 100644
--- a/testtools/source/bridgetest/constructors.cxx
+++ b/testtools/source/bridgetest/constructors.cxx
@@ -60,12 +60,10 @@ private:
     virtual ~Impl() override {}
 
     virtual void SAL_CALL initialize(
-        css::uno::Sequence< css::uno::Any > const & arguments)
-        throw (css::uno::Exception, std::exception) override;
+        css::uno::Sequence< css::uno::Any > const & arguments) override;
 };
 
 void Impl::initialize(css::uno::Sequence< css::uno::Any > const & arguments)
-    throw (css::uno::Exception, std::exception)
 {
     bool arg0;
     ::sal_Int8 arg1 = sal_Int8();
@@ -193,25 +191,19 @@ private:
     virtual ~Impl2() override {}
 
     virtual void SAL_CALL initialize(
-        css::uno::Sequence< css::uno::Any > const & arguments)
-        throw (css::uno::Exception, std::exception) override;
+        css::uno::Sequence< css::uno::Any > const & arguments) override;
 
     //XMultiBase1
-    virtual double SAL_CALL getatt1()
-        throw (css::uno::RuntimeException, std::exception) override;
-    virtual void SAL_CALL setatt1( double _att1 )
-        throw (css::uno::RuntimeException, std::exception) override;
-    virtual ::sal_Int32 SAL_CALL fn11( ::sal_Int32 arg )
-        throw (css::uno::RuntimeException, std::exception) override;
-    virtual OUString SAL_CALL fn12( const OUString& arg )
-        throw (css::uno::RuntimeException, std::exception) override;
+    virtual double SAL_CALL getatt1() override;
+    virtual void SAL_CALL setatt1( double _att1 ) override;
+    virtual ::sal_Int32 SAL_CALL fn11( ::sal_Int32 arg ) override;
+    virtual OUString SAL_CALL fn12( const OUString& arg ) override;
 
 
     double m_attr1;
 };
 
 void Impl2::initialize(css::uno::Sequence< css::uno::Any > const & arguments)
-    throw (css::uno::Exception, std::exception)
 {
     ttb::TestPolyStruct< css::uno::Type > arg0;
     ttb::TestPolyStruct< css::uno::Any > arg1;
@@ -394,24 +386,21 @@ void Impl2::initialize(css::uno::Sequence< css::uno::Any > const & arguments)
 
 //XMultiBase1
 double Impl2::getatt1()
-        throw (css::uno::RuntimeException, std::exception)
 {
     return m_attr1;
 }
 
-void Impl2::setatt1( double _att1 )throw (css::uno::RuntimeException, std::exception)
+void Impl2::setatt1( double _att1 )
 {
     m_attr1 = _att1;
 }
 
 ::sal_Int32 Impl2::fn11( ::sal_Int32 arg )
-        throw (css::uno::RuntimeException, std::exception)
 {
     return 11 * arg;
 }
 
 OUString Impl2::fn12( const OUString& arg )
-        throw (css::uno::RuntimeException, std::exception)
 {
     return "12" + arg;
 }
diff --git a/testtools/source/bridgetest/cppobj.cxx b/testtools/source/bridgetest/cppobj.cxx
index ad3fd185b97c..bda776594200 100644
--- a/testtools/source/bridgetest/cppobj.cxx
+++ b/testtools/source/bridgetest/cppobj.cxx
@@ -162,9 +162,9 @@ public:
      }
 
     // XServiceInfo
-    virtual OUString SAL_CALL getImplementationName() throw (RuntimeException, std::exception) override;
-    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException, std::exception) override;
-    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw (RuntimeException, std::exception) override;
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) override;
+    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 
     // XLBTestBase
     virtual void SAL_CALL setValues( sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
@@ -176,8 +176,7 @@ public:
                                      const css::uno::Reference< css::uno::XInterface >& xTest,
                                      const css::uno::Any& rAny,
                                      const css::uno::Sequence<TestElement >& rSequence,
-                                     const TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                     const TestData& rStruct ) override;
 
     virtual TestData SAL_CALL setValues2( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nByte,
                                                 sal_Int16& nShort, sal_uInt16& nUShort,
@@ -188,8 +187,7 @@ public:
                                                 css::uno::Reference< css::uno::XInterface >& xTest,
                                                 css::uno::Any& rAny,
                                                 css::uno::Sequence<TestElement >& rSequence,
-                                                TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                                TestData& rStruct ) override;
 
     virtual TestData SAL_CALL getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nByte,
                                                sal_Int16& nShort, sal_uInt16& nUShort,
@@ -200,231 +198,210 @@ public:
                                                css::uno::Reference< css::uno::XInterface >& xTest,
                                                css::uno::Any& rAny,
                                                css::uno::Sequence< TestElement >& rSequence,
-                                               TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                               TestData& rStruct ) override;
 
-    virtual SmallStruct SAL_CALL echoSmallStruct(const SmallStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual SmallStruct SAL_CALL echoSmallStruct(const SmallStruct& rStruct) override
         { return rStruct; }
-    virtual MediumStruct SAL_CALL echoMediumStruct(const MediumStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual MediumStruct SAL_CALL echoMediumStruct(const MediumStruct& rStruct) override
         { return rStruct; }
-    virtual BigStruct SAL_CALL echoBigStruct(const BigStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual BigStruct SAL_CALL echoBigStruct(const BigStruct& rStruct) override
         { return rStruct; }
-    virtual TwoFloats SAL_CALL echoTwoFloats(const TwoFloats& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual TwoFloats SAL_CALL echoTwoFloats(const TwoFloats& rStruct) override
         { return rStruct; }
-    virtual FourFloats SAL_CALL echoFourFloats(const FourFloats& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual FourFloats SAL_CALL echoFourFloats(const FourFloats& rStruct) override
         { return rStruct; }
-    virtual MixedFloatAndInteger SAL_CALL echoMixedFloatAndInteger(const MixedFloatAndInteger& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual MixedFloatAndInteger SAL_CALL echoMixedFloatAndInteger(const MixedFloatAndInteger& rStruct) override
         { return rStruct; }
-    virtual ThreeByteStruct SAL_CALL echoThreeByteStruct(const ThreeByteStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual ThreeByteStruct SAL_CALL echoThreeByteStruct(const ThreeByteStruct& rStruct) override
         { return rStruct; }
-    virtual sal_Int32 SAL_CALL testPPCAlignment( sal_Int64, sal_Int64, sal_Int32, sal_Int64, sal_Int32 i2 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL testPPCAlignment( sal_Int64, sal_Int64, sal_Int32, sal_Int64, sal_Int32 i2 ) override
         { return i2; }
-    virtual sal_Int32 SAL_CALL testPPC64Alignment( double , double , double , sal_Int32 i1 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL testPPC64Alignment( double , double , double , sal_Int32 i1 ) override
         { return i1; }
-    virtual double SAL_CALL testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) override
         { return d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10; }
-    virtual sal_Bool SAL_CALL getBool() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Bool SAL_CALL getBool() override
         { return _aData.Bool; }
-    virtual sal_Int8 SAL_CALL getByte() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int8 SAL_CALL getByte() override
         { return _aData.Byte; }
-    virtual sal_Unicode SAL_CALL getChar() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Unicode SAL_CALL getChar() override
         { return _aData.Char; }
-    virtual sal_Int16 SAL_CALL getShort() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int16 SAL_CALL getShort() override
         { return _aData.Short; }
-    virtual sal_uInt16 SAL_CALL getUShort() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt16 SAL_CALL getUShort() override
         { return _aData.UShort; }
-    virtual sal_Int32 SAL_CALL getLong() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getLong() override
         { return _aData.Long; }
-    virtual sal_uInt32 SAL_CALL getULong() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt32 SAL_CALL getULong() override
         { return _aData.ULong; }
-    virtual sal_Int64 SAL_CALL getHyper() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int64 SAL_CALL getHyper() override
         { return _aData.Hyper; }
-    virtual sal_uInt64 SAL_CALL getUHyper() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt64 SAL_CALL getUHyper() override
         { return _aData.UHyper; }
-    virtual float SAL_CALL getFloat() throw(css::uno::RuntimeException, std::exception) override
+    virtual float SAL_CALL getFloat() override
         { return _aData.Float; }
-    virtual double SAL_CALL getDouble() throw(css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL getDouble() override
         { return _aData.Double; }
-    virtual TestEnum SAL_CALL getEnum() throw(css::uno::RuntimeException, std::exception) override
+    virtual TestEnum SAL_CALL getEnum() override
         { return _aData.Enum; }
-    virtual OUString SAL_CALL getString() throw(css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL getString() override
         { return _aData.String; }
-    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getInterface(  ) throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getInterface(  ) override
         { return _aData.Interface; }
-    virtual css::uno::Any SAL_CALL getAny() throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Any SAL_CALL getAny() override
         { return _aData.Any; }
-    virtual css::uno::Sequence< TestElement > SAL_CALL getSequence() throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Sequence< TestElement > SAL_CALL getSequence() override
         { return _aData.Sequence; }
-    virtual TestData SAL_CALL getStruct() throw(css::uno::RuntimeException, std::exception) override
+    virtual TestData SAL_CALL getStruct() override
         { return _aStructData; }
 
-    virtual void SAL_CALL setBool( sal_Bool _bool ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setBool( sal_Bool _bool ) override
         { _aData.Bool = _bool; }
-    virtual void SAL_CALL setByte( sal_Int8 _byte ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setByte( sal_Int8 _byte ) override
         { _aData.Byte = _byte; }
-    virtual void SAL_CALL setChar( sal_Unicode _char ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setChar( sal_Unicode _char ) override
         { _aData.Char = _char; }
-    virtual void SAL_CALL setShort( sal_Int16 _short ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setShort( sal_Int16 _short ) override
         { _aData.Short = _short; }
-    virtual void SAL_CALL setUShort( sal_uInt16 _ushort ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setUShort( sal_uInt16 _ushort ) override
         { _aData.UShort = _ushort; }
-    virtual void SAL_CALL setLong( sal_Int32 _long ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setLong( sal_Int32 _long ) override
         { _aData.Long = _long; }
-    virtual void SAL_CALL setULong( sal_uInt32 _ulong ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setULong( sal_uInt32 _ulong ) override
         { _aData.ULong = _ulong; }
-    virtual void SAL_CALL setHyper( sal_Int64 _hyper ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setHyper( sal_Int64 _hyper ) override
         { _aData.Hyper = _hyper; }
-    virtual void SAL_CALL setUHyper( sal_uInt64 _uhyper ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setUHyper( sal_uInt64 _uhyper ) override
         { _aData.UHyper = _uhyper; }
-    virtual void SAL_CALL setFloat( float _float ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setFloat( float _float ) override
         { _aData.Float = _float; }
-    virtual void SAL_CALL setDouble( double _double ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setDouble( double _double ) override
         { _aData.Double = _double; }
-    virtual void SAL_CALL setEnum( TestEnum _enum ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setEnum( TestEnum _enum ) override
         { _aData.Enum = _enum; }
-    virtual void SAL_CALL setString( const OUString& _string ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setString( const OUString& _string ) override
         { _aData.String = _string; }
-    virtual void SAL_CALL setInterface( const css::uno::Reference< css::uno::XInterface >& _interface ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setInterface( const css::uno::Reference< css::uno::XInterface >& _interface ) override
         { _aData.Interface = _interface; }
-    virtual void SAL_CALL setAny( const css::uno::Any& _any ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setAny( const css::uno::Any& _any ) override
         { _aData.Any = _any; }
-    virtual void SAL_CALL setSequence( const css::uno::Sequence<TestElement >& _sequence ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setSequence( const css::uno::Sequence<TestElement >& _sequence ) override
         { _aData.Sequence = _sequence; }
-    virtual void SAL_CALL setStruct( const TestData& _struct ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setStruct( const TestData& _struct ) override
         { _aStructData = _struct; }
 
-    virtual sal_Int32 SAL_CALL getRaiseAttr1() throw (RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getRaiseAttr1() override
     { throw RuntimeException(); }
 
-    virtual void SAL_CALL setRaiseAttr1(sal_Int32)
-        throw (IllegalArgumentException, RuntimeException, std::exception) override
+    virtual void SAL_CALL setRaiseAttr1(sal_Int32) override
     { throw IllegalArgumentException(); }
 
-    virtual sal_Int32 SAL_CALL getRaiseAttr2()
-        throw (IllegalArgumentException, RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getRaiseAttr2() override
     { throw IllegalArgumentException(); }
 
     virtual TestPolyStruct< sal_Bool > SAL_CALL transportPolyBoolean(
-        TestPolyStruct< sal_Bool > const & arg) throw (RuntimeException, std::exception) override
+        TestPolyStruct< sal_Bool > const & arg) override
     { return arg; }
 
-    virtual void SAL_CALL transportPolyHyper(TestPolyStruct< sal_Int64 > &)
-        throw (RuntimeException, std::exception) override {}
+    virtual void SAL_CALL transportPolyHyper(TestPolyStruct< sal_Int64 > &) override {}
 
     virtual void SAL_CALL transportPolySequence(
         TestPolyStruct< Sequence< Any > > const & arg1,
-        TestPolyStruct< Sequence< Any > > & arg2) throw (RuntimeException, std::exception) override
+        TestPolyStruct< Sequence< Any > > & arg2) override
     { arg2 = arg1; }
 
-    virtual TestPolyStruct< sal_Int32 > SAL_CALL getNullPolyLong()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< sal_Int32 > SAL_CALL getNullPolyLong() override
     { return TestPolyStruct< sal_Int32 >(0); /* work around MS compiler bug */ }
 
-    virtual TestPolyStruct< OUString > SAL_CALL getNullPolyString()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< OUString > SAL_CALL getNullPolyString() override
     { return TestPolyStruct< OUString >(); }
 
-    virtual TestPolyStruct< Type > SAL_CALL getNullPolyType()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< Type > SAL_CALL getNullPolyType() override
     { return TestPolyStruct< Type >(); }
 
-    virtual TestPolyStruct< Any > SAL_CALL getNullPolyAny()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< Any > SAL_CALL getNullPolyAny() override
     { return TestPolyStruct< Any >(); }
 
     virtual TestPolyStruct< Sequence< sal_Bool > > SAL_CALL
-    getNullPolySequence() throw (RuntimeException, std::exception) override
+    getNullPolySequence() override
     { return TestPolyStruct< Sequence< sal_Bool > >(); }
 
-    virtual TestPolyStruct< TestEnum > SAL_CALL getNullPolyEnum()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestEnum > SAL_CALL getNullPolyEnum() override
     { return TestPolyStruct< TestEnum >(
         test::testtools::bridgetest::TestEnum_TEST);
           /* work around MS compiler bug */ }
 
-    virtual TestPolyStruct< TestBadEnum > SAL_CALL getNullPolyBadEnum()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestBadEnum > SAL_CALL getNullPolyBadEnum() override
     { return TestPolyStruct< TestBadEnum >(
         test::testtools::bridgetest::TestBadEnum_M);
           /* explicitly instantiate with default enumerator */ }
 
-    virtual TestPolyStruct< TestStruct > SAL_CALL getNullPolyStruct()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestStruct > SAL_CALL getNullPolyStruct() override
     { return TestPolyStruct< TestStruct >(); }
 
     virtual TestPolyStruct< Reference< XBridgeTestBase > > SAL_CALL
-    getNullPolyInterface() throw (RuntimeException, std::exception) override
+    getNullPolyInterface() override
     { return TestPolyStruct< Reference< XBridgeTestBase > >(); }
 
     virtual css::uno::Any SAL_CALL transportAny(
-        const css::uno::Any& value )
-        throw(css::uno::RuntimeException, std::exception) override;
-
-    virtual void SAL_CALL call( sal_Int32 nCallId, sal_Int32 nWaitMUSEC )
-        throw(css::uno::RuntimeException, std::exception) override;
-    virtual void SAL_CALL callOneway( sal_Int32 nCallId, sal_Int32 nWaitMUSEC )
-        throw(css::uno::RuntimeException, std::exception) override;
-    virtual sal_Bool SAL_CALL sequenceOfCallTestPassed(  )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const css::uno::Any& value ) override;
+
+    virtual void SAL_CALL call( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
+    virtual void SAL_CALL callOneway( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
+    virtual sal_Bool SAL_CALL sequenceOfCallTestPassed(  ) override;
     virtual void SAL_CALL startRecursiveCall(
-        const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 
-    virtual Reference< XMulti > SAL_CALL getMulti() throw (RuntimeException, std::exception) override;
+    virtual Reference< XMulti > SAL_CALL getMulti() override;
 
-    virtual OUString SAL_CALL testMulti(Reference< XMulti > const & multi)
-        throw (RuntimeException, std::exception) override;
+    virtual OUString SAL_CALL testMulti(Reference< XMulti > const & multi) override;
 
 public: // XBridgeTest
-    virtual TestData SAL_CALL raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xCOntext )
-        throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception) override;
+    virtual TestData SAL_CALL raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xCOntext ) override;
 
     virtual void SAL_CALL raiseRuntimeExceptionOneway(
-        const OUString& Message, const css::uno::Reference< css::uno::XInterface >& Context )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const OUString& Message, const css::uno::Reference< css::uno::XInterface >& Context ) override;
 
-    virtual sal_Int32 SAL_CALL getRuntimeException() throw(css::uno::RuntimeException, std::exception) override;
-    virtual void SAL_CALL setRuntimeException( sal_Int32 _runtimeexception ) throw(css::uno::RuntimeException, std::exception) override;
+    virtual sal_Int32 SAL_CALL getRuntimeException() override;
+    virtual void SAL_CALL setRuntimeException( sal_Int32 _runtimeexception ) override;
 
     // XBridgeTest2
     virtual Sequence< sal_Bool > SAL_CALL setSequenceBool(
-        const Sequence< sal_Bool >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Bool >& aSeq ) override;
     virtual Sequence< sal_Unicode > SAL_CALL setSequenceChar(
-        const Sequence< sal_Unicode >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Unicode >& aSeq ) override;
     virtual Sequence< sal_Int8 > SAL_CALL setSequenceByte(
-        const Sequence< sal_Int8 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int8 >& aSeq ) override;
     virtual Sequence< sal_Int16 > SAL_CALL setSequenceShort(
-        const Sequence< sal_Int16 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int16 >& aSeq ) override;
     virtual Sequence< sal_uInt16 > SAL_CALL setSequenceUShort(
-        const Sequence< sal_uInt16 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt16 >& aSeq ) override;
     virtual Sequence< sal_Int32 > SAL_CALL setSequenceLong(
-        const Sequence< sal_Int32 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int32 >& aSeq ) override;
     virtual Sequence< sal_uInt32 > SAL_CALL setSequenceULong(
-        const Sequence< sal_uInt32 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt32 >& aSeq ) override;
     virtual Sequence< sal_Int64 > SAL_CALL setSequenceHyper(
-        const Sequence< sal_Int64 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int64 >& aSeq ) override;
     virtual Sequence< sal_uInt64 > SAL_CALL setSequenceUHyper(
-        const Sequence< sal_uInt64 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt64 >& aSeq ) override;
     virtual Sequence< float > SAL_CALL setSequenceFloat(
-        const Sequence< float >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< float >& aSeq ) override;
     virtual Sequence< double > SAL_CALL setSequenceDouble(
-        const Sequence< double >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< double >& aSeq ) override;
     virtual Sequence< TestEnum > SAL_CALL setSequenceEnum(
-        const Sequence< TestEnum >& aSeq ) throw (RuntimeException, std::exception) override ;
+        const Sequence< TestEnum >& aSeq ) override ;
     virtual Sequence< OUString > SAL_CALL setSequenceString(
-        const Sequence< OUString >& aString ) throw (RuntimeException, std::exception) override;
+        const Sequence< OUString >& aString ) override;
     virtual Sequence< Reference< XInterface > > SAL_CALL setSequenceXInterface(
-        const Sequence< Reference< XInterface > >& aSeq )
-        throw (RuntimeException, std::exception) override;
+        const Sequence< Reference< XInterface > >& aSeq ) override;
     virtual Sequence<Any > SAL_CALL setSequenceAny(
-        const Sequence<Any >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence<Any >& aSeq ) override;
     virtual Sequence<TestElement > SAL_CALL setSequenceStruct(
-        const Sequence< TestElement >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< TestElement >& aSeq ) override;
     virtual Sequence< Sequence< sal_Int32 > > SAL_CALL setDim2(
-        const Sequence<Sequence< sal_Int32 > >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence<Sequence< sal_Int32 > >& aSeq ) override;
     virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL setDim3(
-        const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq )
-        throw (RuntimeException, std::exception) override;
+        const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq ) override;
     virtual void SAL_CALL setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
                                 Sequence< sal_Unicode >& aSeqChar,
                                 Sequence< sal_Int8 >& aSeqByte,
@@ -441,8 +418,7 @@ public: // XBridgeTest
                                 Sequence<Reference<XInterface > >& aSeqXInterface,
                                 Sequence< Any >& aSeqAny,
                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
-                                Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception) override;
+                                Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
     virtual void SAL_CALL setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
                              Sequence< sal_Unicode >& aSeqChar,
                              Sequence< sal_Int8 >& aSeqByte,
@@ -459,17 +435,14 @@ public: // XBridgeTest
                              Sequence< Reference< XInterface > >& aSeqXInterface,
                              Sequence< Any >& aSeqAny,
                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
-                             Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception) override;
+                             Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
     virtual void SAL_CALL testConstructorsService(
-        Reference< XComponentContext > const & context)
-        throw (RuntimeException, std::exception) override;
+        Reference< XComponentContext > const & context) override;
     virtual Reference< XCurrentContextChecker > SAL_CALL
-    getCurrentContextChecker()
-        throw (RuntimeException, std::exception) override;
+    getCurrentContextChecker() override;
 
 public:
-    virtual void SAL_CALL callRecursivly( const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) throw(css::uno::RuntimeException, std::exception) override;
+    virtual void SAL_CALL callRecursivly( const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 };
 
 //Dummy class for XComponent implementation
@@ -481,7 +454,7 @@ public:
 
 };
 
-Any Test_Impl::transportAny( const Any & value ) throw ( css::uno::RuntimeException, std::exception)
+Any Test_Impl::transportAny( const Any & value )
 {
     return value;
 }
@@ -499,7 +472,7 @@ void wait(sal_Int32 microSeconds) {
 
 }
 
-void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw(css::uno::RuntimeException, std::exception)
+void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 {
     wait(nWaitMUSEC);
     if( m_bFirstCall )
@@ -514,7 +487,7 @@ void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw(css::uno:
 }
 
 
-void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw (css::uno::RuntimeException, std::exception)
+void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 {
     wait(nWaitMUSEC);
     m_bSequenceOfCallTestPassed = m_bSequenceOfCallTestPassed && (nCallId > m_nLastCallId);
@@ -522,7 +495,7 @@ void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw (cs
 }
 
 
-sal_Bool Test_Impl::sequenceOfCallTestPassed() throw (css::uno::RuntimeException, std::exception)
+sal_Bool Test_Impl::sequenceOfCallTestPassed()
 {
     return m_bSequenceOfCallTestPassed;
 }
@@ -530,7 +503,6 @@ sal_Bool Test_Impl::sequenceOfCallTestPassed() throw (css::uno::RuntimeException
 
 void SAL_CALL Test_Impl::startRecursiveCall(
     const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall )
-    throw(css::uno::RuntimeException, std::exception)
 {
     MutexGuard guard( m_mutex );
     if( nToCall )
@@ -544,7 +516,6 @@ void SAL_CALL Test_Impl::startRecursiveCall(
 void SAL_CALL Test_Impl::callRecursivly(
     const css::uno::Reference< XRecursiveCall >& xCall,
     sal_Int32 nToCall )
-    throw(css::uno::RuntimeException, std::exception)
 {
     MutexGuard guard( m_mutex );
     if( nToCall )
@@ -554,12 +525,11 @@ void SAL_CALL Test_Impl::callRecursivly(
     }
 }
 
-Reference< XMulti > Test_Impl::getMulti() throw (RuntimeException, std::exception) {
+Reference< XMulti > Test_Impl::getMulti() {
     return new testtools::bridgetest::Multi;
 }
 
 OUString Test_Impl::testMulti(Reference< XMulti > const & multi)
-    throw (RuntimeException, std::exception)
 {
     return testtools::bridgetest::testMulti(multi);
 }
@@ -575,7 +545,6 @@ void Test_Impl::setValues( sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
                            const css::uno::Any& rAny,
                            const css::uno::Sequence<TestElement >& rSequence,
                            const TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     assign( _aData,
             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
@@ -593,7 +562,6 @@ TestData Test_Impl::setValues2( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& n
                                 css::uno::Any& rAny,
                                 css::uno::Sequence<TestElement >& rSequence,
                                 TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     assign( _aData,
             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
@@ -617,7 +585,6 @@ TestData Test_Impl::getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nB
                                css::uno::Any& rAny,
                                css::uno::Sequence<TestElement >& rSequence,
                                TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     bBool = _aData.Bool;
     cChar = _aData.Char;
@@ -640,7 +607,6 @@ TestData Test_Impl::getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nB
 }
 
 TestData Test_Impl::raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xContext )
-    throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
 {
     IllegalArgumentException aExc;
     aExc.ArgumentPosition = nArgumentPos;
@@ -650,7 +616,6 @@ TestData Test_Impl::raiseException( sal_Int16 nArgumentPos, const OUString & rMs
 }
 
 void Test_Impl::raiseRuntimeExceptionOneway( const OUString & rMsg, const Reference< XInterface > & xContext )
-    throw(css::uno::RuntimeException, std::exception)
 {
     RuntimeException aExc;
     aExc.Message          = _aData.String = rMsg;
@@ -691,7 +656,6 @@ void dothrow(const RuntimeException& e)
 }
 
 sal_Int32 Test_Impl::getRuntimeException()
-    throw (RuntimeException, std::exception)
 {
     try
     {
@@ -705,7 +669,7 @@ sal_Int32 Test_Impl::getRuntimeException()
     return 0; // for dummy
 }
 
-void Test_Impl::setRuntimeException( sal_Int32 ) throw(css::uno::RuntimeException, std::exception)
+void Test_Impl::setRuntimeException( sal_Int32 )
 {
     RuntimeException aExc;
     aExc.Message          = _aData.String;
@@ -715,91 +679,91 @@ void Test_Impl::setRuntimeException( sal_Int32 ) throw(css::uno::RuntimeExceptio
 
 // XBridgeTest2 -------------------------------------------------------------
 Sequence< sal_Bool > SAL_CALL Test_Impl::setSequenceBool(
-        const Sequence< sal_Bool >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Bool >& aSeq )
 {
     _arBool = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Unicode > SAL_CALL Test_Impl::setSequenceChar(
-        const Sequence< sal_Unicode >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Unicode >& aSeq )
 {
     _arChar = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int8 > SAL_CALL Test_Impl::setSequenceByte(
-        const Sequence< sal_Int8 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int8 >& aSeq )
 {
     _arByte = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int16 > SAL_CALL Test_Impl::setSequenceShort(
-        const Sequence< sal_Int16 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int16 >& aSeq )
 {
     _arShort = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt16 > SAL_CALL Test_Impl::setSequenceUShort(
-        const Sequence< sal_uInt16 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt16 >& aSeq )
 {
     _arUShort = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int32 > SAL_CALL Test_Impl::setSequenceLong(
-        const Sequence< sal_Int32 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int32 >& aSeq )
 {
     _arLong = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt32 > SAL_CALL Test_Impl::setSequenceULong(
-        const Sequence< sal_uInt32 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt32 >& aSeq )
 {
     _arULong = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int64 > SAL_CALL Test_Impl::setSequenceHyper(
-        const Sequence< sal_Int64 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int64 >& aSeq )
 {
     _arHyper = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt64 > SAL_CALL Test_Impl::setSequenceUHyper(
-        const Sequence< sal_uInt64 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt64 >& aSeq )
 {
     _arUHyper = aSeq;
     return aSeq;
 }
 
 Sequence< float > SAL_CALL Test_Impl::setSequenceFloat(
-        const Sequence< float >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< float >& aSeq )
 {
     _arFloat = aSeq;
     return aSeq;
 }
 
 Sequence< double > SAL_CALL Test_Impl::setSequenceDouble(
-    const Sequence< double >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< double >& aSeq )
 {
     _arDouble = aSeq;
     return aSeq;
 }
 
 Sequence< TestEnum > SAL_CALL Test_Impl::setSequenceEnum(
-    const Sequence< TestEnum >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< TestEnum >& aSeq )
 {
     _arEnum = aSeq;
     return aSeq;
 }
 
 Sequence< OUString > SAL_CALL Test_Impl::setSequenceString(
-    const Sequence< OUString >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< OUString >& aSeq )
 {
     _arString = aSeq;
     return aSeq;
@@ -807,28 +771,27 @@ Sequence< OUString > SAL_CALL Test_Impl::setSequenceString(
 
 Sequence< Reference< XInterface > > SAL_CALL Test_Impl::setSequenceXInterface(
         const Sequence< Reference< XInterface > >& aSeq )
-        throw (RuntimeException, std::exception)
 {
     _arObject = aSeq;
     return aSeq;
 }
 
 Sequence<Any > SAL_CALL Test_Impl::setSequenceAny(
-    const Sequence<Any >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence<Any >& aSeq )
 {
     _arAny = aSeq;
     return aSeq;
 }
 
 Sequence<TestElement > SAL_CALL Test_Impl::setSequenceStruct(
-    const Sequence< TestElement >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< TestElement >& aSeq )
 {
     _arStruct = aSeq;
     return aSeq;
 }
 
 Sequence< Sequence< sal_Int32 > > SAL_CALL Test_Impl::setDim2(
-        const Sequence<Sequence< sal_Int32 > >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence<Sequence< sal_Int32 > >& aSeq )
 {
     _arLong2 = aSeq;
     return aSeq;
@@ -836,7 +799,6 @@ Sequence< Sequence< sal_Int32 > > SAL_CALL Test_Impl::setDim2(
 
 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL Test_Impl::setDim3(
         const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq )
-        throw (RuntimeException, std::exception)
 {
     _arLong3 = aSeq;
     return aSeq;
@@ -859,7 +821,6 @@ void SAL_CALL Test_Impl::setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
                                 Sequence< Any >& aSeqAny,
                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
                                 Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception)
 {
     _arBool = aSeqBoolean;
     _arChar = aSeqChar;
@@ -897,7 +858,6 @@ void SAL_CALL Test_Impl::setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
                              Sequence< Any >& aSeqAny,
                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
                              Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception)
 {
     aSeqBoolean = _arBool;
     aSeqChar = _arChar;
@@ -919,7 +879,7 @@ void SAL_CALL Test_Impl::setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
 }
 
 void Test_Impl::testConstructorsService(
-    Reference< XComponentContext > const & context) throw (RuntimeException, std::exception)
+    Reference< XComponentContext > const & context)
 {
     Sequence< sal_Bool > arg14(1); arg14[0] = true;
     Sequence< sal_Int8 > arg15(1); arg15[0] = SAL_MIN_INT8;
@@ -1134,7 +1094,6 @@ void Test_Impl::testConstructorsService(
 }
 
 Reference< XCurrentContextChecker > Test_Impl::getCurrentContextChecker()
-    throw (RuntimeException, std::exception)
 {
     return new testtools::bridgetest::CurrentContextChecker;
 }
@@ -1142,19 +1101,16 @@ Reference< XCurrentContextChecker > Test_Impl::getCurrentContextChecker()
 // XServiceInfo
 
 OUString Test_Impl::getImplementationName()
-    throw (RuntimeException, std::exception)
 {
     return OUString( IMPLNAME );
 }
 
 sal_Bool Test_Impl::supportsService( const OUString & rServiceName )
-    throw (RuntimeException, std::exception)
 {
     return cppu::supportsService(this, rServiceName);
 }
 
 Sequence< OUString > Test_Impl::getSupportedServiceNames()
-    throw (RuntimeException, std::exception)
 {
     return bridge_object::getSupportedServiceNames();
 }
diff --git a/testtools/source/bridgetest/currentcontextchecker.cxx b/testtools/source/bridgetest/currentcontextchecker.cxx
index 5691335b1170..7fa88e73d0b4 100644
--- a/testtools/source/bridgetest/currentcontextchecker.cxx
+++ b/testtools/source/bridgetest/currentcontextchecker.cxx
@@ -51,14 +51,12 @@ public:
     CurrentContext(const CurrentContext&) = delete;
     CurrentContext& operator=(const CurrentContext&) = delete;
 
-    virtual css::uno::Any SAL_CALL getValueByName(OUString const & Name)
-        throw (css::uno::RuntimeException, std::exception) override;
+    virtual css::uno::Any SAL_CALL getValueByName(OUString const & Name) override;
 };
 
 CurrentContext::CurrentContext() {}
 
 css::uno::Any CurrentContext::getValueByName(OUString const & Name)
-    throw (css::uno::RuntimeException, std::exception)
 {
     return Name == KEY ? css::uno::makeAny(OUString(VALUE)) : css::uno::Any();
 }
@@ -73,7 +71,6 @@ sal_Bool testtools::bridgetest::CurrentContextChecker::perform(
     css::uno::Reference<
         ::test::testtools::bridgetest::XCurrentContextChecker > const & other,
     ::sal_Int32 setSteps, ::sal_Int32 checkSteps)
-    throw (css::uno::RuntimeException, std::exception)
 {
     if (setSteps == 0) {
         css::uno::ContextLayer layer(new CurrentContext);
diff --git a/testtools/source/bridgetest/currentcontextchecker.hxx b/testtools/source/bridgetest/currentcontextchecker.hxx
index 1877392129ac..8caeb4ab235f 100644
--- a/testtools/source/bridgetest/currentcontextchecker.hxx
+++ b/testtools/source/bridgetest/currentcontextchecker.hxx
@@ -44,8 +44,7 @@ public:
 
     virtual sal_Bool SAL_CALL perform(
         css::uno::Reference< ::test::testtools::bridgetest::XCurrentContextChecker > const & other,
-        ::sal_Int32 setSteps, ::sal_Int32 checkSteps)
-        throw (css::uno::RuntimeException, std::exception) override;
+        ::sal_Int32 setSteps, ::sal_Int32 checkSteps) override;
 
 private:
     CurrentContextChecker(CurrentContextChecker &) = delete;
diff --git a/testtools/source/bridgetest/multi.hxx b/testtools/source/bridgetest/multi.hxx
index 6ed12840c7a0..f09cbaf93046 100644
--- a/testtools/source/bridgetest/multi.hxx
+++ b/testtools/source/bridgetest/multi.hxx
@@ -38,72 +38,55 @@ class Multi: public cppu::WeakImplHelper< test::testtools::bridgetest::XMulti >
 public:
     Multi(): m_attribute1(0.0), m_attribute3(0.0) {}
 
-    virtual double SAL_CALL getatt1()
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL getatt1() override
     { return m_attribute1; }
 
-    virtual void SAL_CALL setatt1(double value)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setatt1(double value) override
     { m_attribute1 = value; }
 
-    virtual sal_Int32 SAL_CALL fn11(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn11(sal_Int32 arg) override
     { return 11 * arg; }
 
-    virtual OUString SAL_CALL fn12(OUString const & arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL fn12(OUString const & arg) override
     { return "12" + arg; }
 
-    virtual sal_Int32 SAL_CALL fn21(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn21(sal_Int32 arg) override
     { return 21 * arg; }
 
-    virtual OUString SAL_CALL fn22(OUString const & arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL fn22(OUString const & arg) override
     { return "22" + arg; }
 
-    virtual double SAL_CALL getatt3()
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL getatt3() override
     { return m_attribute3; }
 
-    virtual void SAL_CALL setatt3(double value)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setatt3(double value) override
     { m_attribute3 = value; }
 
-    virtual sal_Int32 SAL_CALL fn31(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn31(sal_Int32 arg) override
     { return 31 * arg; }
 
-    virtual OUString SAL_CALL fn32(OUString const & arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL fn32(OUString const & arg) override
     { return "32" + arg; }
 
-    virtual sal_Int32 SAL_CALL fn33()
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn33() override
     { return 33; }
 
-    virtual sal_Int32 SAL_CALL fn41(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn41(sal_Int32 arg) override
     { return 41 * arg; }
 
-    virtual sal_Int32 SAL_CALL fn61(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn61(sal_Int32 arg) override
     { return 61 * arg; }
 
-    virtual OUString SAL_CALL fn62(OUString const & arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL fn62(OUString const & arg) override
     { return "62" + arg; }
 
-    virtual sal_Int32 SAL_CALL fn71(sal_Int32 arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn71(sal_Int32 arg) override
     { return 71 * arg; }
 
-    virtual OUString SAL_CALL fn72(OUString const & arg)
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL fn72(OUString const & arg) override
     { return "72" + arg; }
 
-    virtual sal_Int32 SAL_CALL fn73()
-        throw (css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL fn73() override
     { return 73; }
 
 private: