diff --git a/dune/common/test/CMakeLists.txt b/dune/common/test/CMakeLists.txt
index 7404536181d8584915f8310fe5d4e1346547ad27..e3e3aa29e763d48453a6dbbdf278d8d0577e4666 100644
--- a/dune/common/test/CMakeLists.txt
+++ b/dune/common/test/CMakeLists.txt
@@ -148,7 +148,8 @@ dune_add_test(NAME mpihelpertest2
 dune_add_test(SOURCES overloadsettest.cc
               LINK_LIBRARIES dunecommon)
 
-dune_add_test(SOURCES parameterizedobjecttest.cc
+dune_add_test(NAME parameterizedobjecttest
+              SOURCES parameterizedobjecttest.cc parameterizedobjectfactorysingleton.cc
               LINK_LIBRARIES dunecommon
               )
 
diff --git a/dune/common/test/parameterizedobjectfactorysingleton.cc b/dune/common/test/parameterizedobjectfactorysingleton.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a85955e48bff1452f8c908a076668f4e56e66b72
--- /dev/null
+++ b/dune/common/test/parameterizedobjectfactorysingleton.cc
@@ -0,0 +1,21 @@
+#include "config.h"
+#include <iostream>
+#include <cassert>
+#include <tuple>
+#include <dune/common/parameterizedobject.hh>
+#include <dune/common/parametertree.hh>
+#include <dune/common/shared_ptr.hh>
+
+#include "parameterizedobjectfactorysingleton.hh"
+
+DefineImplementation(InterfaceA, Aix, int);
+DefineImplementation(InterfaceA, Bix, int);
+
+int init_Factory()
+{
+    globalPtrFactory<InterfaceA>().define<Aix>("Aix");
+    globalPtrFactory<InterfaceA>().define("Bix", [](int i) { return Dune::Std::make_unique<Bix>(i); });
+    return 0;
+}
+
+static const int init = init_Factory();
diff --git a/dune/common/test/parameterizedobjectfactorysingleton.hh b/dune/common/test/parameterizedobjectfactorysingleton.hh
new file mode 100644
index 0000000000000000000000000000000000000000..a1507b9ba9657c6386ed1c04d6151811d93eaf06
--- /dev/null
+++ b/dune/common/test/parameterizedobjectfactorysingleton.hh
@@ -0,0 +1,28 @@
+#include <dune/common/parameterizedobject.hh>
+#include <dune/common/singleton.hh>
+#include <string>
+
+#define DefineImplementation(IF,T,PARAM...)     \
+    struct T : public IF {                      \
+        T(PARAM) {}                          \
+        virtual std::string info() {            \
+            return #T;                          \
+        }                                       \
+    }
+
+struct InterfaceA
+{
+    virtual std::string info() = 0;
+};
+
+struct InterfaceB
+{
+    virtual std::string info() = 0;
+};
+
+template<typename Interface>
+Dune::ParameterizedObjectFactory<std::unique_ptr<Interface>(int)> &
+globalPtrFactory()
+{
+    return Dune::Singleton<Dune::ParameterizedObjectFactory<std::unique_ptr<Interface>(int)>>::instance();
+}
diff --git a/dune/common/test/parameterizedobjecttest.cc b/dune/common/test/parameterizedobjecttest.cc
index 323604b97e9e2098c266e3291a6699db3cb515fc..0c561282dee0f6cce7a1a9c1acf647af73fbb067 100644
--- a/dune/common/test/parameterizedobjecttest.cc
+++ b/dune/common/test/parameterizedobjecttest.cc
@@ -2,27 +2,10 @@
 #include <iostream>
 #include <cassert>
 #include <tuple>
-#include <dune/common/parameterizedobject.hh>
 #include <dune/common/parametertree.hh>
 #include <dune/common/shared_ptr.hh>
 
-#define DefineImplementation(IF,T,PARAM...)     \
-    struct T : public IF {                      \
-        T(PARAM) {}                          \
-        virtual std::string info() {            \
-            return #T;                          \
-        }                                       \
-    }
-
-struct InterfaceA
-{
-    virtual std::string info() = 0;
-};
-
-struct InterfaceB
-{
-    virtual std::string info() = 0;
-};
+#include "parameterizedobjectfactorysingleton.hh"
 
 DefineImplementation(InterfaceA, Ai, int);
 DefineImplementation(InterfaceA, Bi, int);
@@ -36,7 +19,6 @@ DefineImplementation(InterfaceB, Bis, int, std::string);
 #define CheckInstance(F,T,PARAM...)             \
     assert(#T == F.create(#T,##PARAM)->info())
 
-
 struct AImp : public InterfaceA
 {
     AImp(std::string s) :
@@ -57,13 +39,16 @@ struct AImp : public InterfaceA
 int main()
 {
     // int as parameter
-    Dune::ParameterizedObjectFactory<std::unique_ptr<InterfaceA>(int)> FactoryA;
-    FactoryA.define<Ai>("Ai");
-    FactoryA.define<Bi>("Bi");
-    FactoryA.define("Ax", [](int i) { return Dune::Std::make_unique<Ax>(); });
-    CheckInstance(FactoryA, Ai, 0);
-    CheckInstance(FactoryA, Bi, 1);
-    CheckInstance(FactoryA, Ax, 1);
+    // Dune::ParameterizedObjectFactory<std::unique_ptr<InterfaceA>(int)> FactoryA;
+    globalPtrFactory<InterfaceA>().define<Ai>("Ai");
+    globalPtrFactory<InterfaceA>().define<Bi>("Bi");
+    globalPtrFactory<InterfaceA>().define("Ax", [](int i) { return Dune::Std::make_unique<Ax>(); });
+    CheckInstance(globalPtrFactory<InterfaceA>(), Ai, 0);
+    CheckInstance(globalPtrFactory<InterfaceA>(), Bi, 1);
+    CheckInstance(globalPtrFactory<InterfaceA>(), Ax, 1);
+    // int as parameter for external factory
+    CheckInstance(globalPtrFactory<InterfaceA>(), Aix, 0);
+    CheckInstance(globalPtrFactory<InterfaceA>(), Bix, 1);
 
     // default constructor
     Dune::ParameterizedObjectFactory<std::shared_ptr<InterfaceA>()> FactoryAd;