Do not use Ice::Application for Ice testsuite

1 files changed, 202 insertions, 19 deletions

diff --git a/cpp/test/include/TestHelper.h b/cpp/test/include/TestHelper.h
index 20be3f8307a..0c398ee2a79 100644
--- a/cpp/test/include/TestHelper.h
+++ b/cpp/test/include/TestHelper.h
@@ -15,49 +15,113 @@
 #include <string>
 #include <iostream>
 
+#include <IceUtil/Config.h>
+
+#if defined(_MSC_VER) && !defined(TEST_API_EXPORTS)
+#   pragma comment(lib, ICE_LIBNAME("testcommon"))
+#endif
+
+#include <Ice/CommunicatorF.h>
+#include <Ice/ProxyF.h>
+#include <Ice/Initialize.h>
+
+#if defined(ICE_OS_UWP) || (TARGET_OS_IPHONE != 0)
+#   include <Ice/Logger.h>
+#   include <Ice/LocalException.h>
+
+#   include <cassert>
+#   include <cstdlib>
+#   include <string>
+#   include <iostream>
+#endif
+
+#include <IceUtil/IceUtil.h>
+
+#ifndef TEST_API
+#   if defined(ICE_STATIC_LIBS)
+#       define TEST_API /**/
+#   elif defined(TEST_API_EXPORTS)
+#       define TEST_API ICE_DECLSPEC_EXPORT
+#   else
+#       define TEST_API ICE_DECLSPEC_IMPORT
+#   endif
+#endif
+
 namespace Test
 {
 
-class MainHelper : public std::streambuf
+class TEST_API ControllerHelper
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
 {
 public:
 
-    MainHelper()
-    {
-        setp(&data[0], &data[sizeof(data) - 1]);
-    }
+    virtual bool redirect() const = 0;
 
+    virtual std::string getOutput() const = 0;
+    virtual std::string loggerPrefix() const = 0;
+    virtual void join() = 0;
+    virtual void print(const std::string&) = 0;
     virtual void serverReady() = 0;
-
     virtual void shutdown() = 0;
 
-    virtual void waitForCompleted() = 0;
+    virtual int waitSuccess(int) const = 0;
+    virtual void waitReady(int) const = 0;
+};
+ICE_DEFINE_PTR(ControllerHelperPtr, ControllerHelper);
+
+#if defined(ICE_OS_UWP) || (TARGET_OS_IPHONE != 0)
+
+//
+// streambuf redirection implementation
+//
+class StreamHelper : public std::streambuf
+{
+public:
+
+    StreamHelper(ControllerHelperPtr controllerHelper, bool redirect) : _controllerHelper(controllerHelper)
+    {
+        setp(&data[0], &data[sizeof(data) - 1]);
+        if(redirect)
+        {
+            _previousLogger = Ice::getProcessLogger();
+            Ice::setProcessLogger(Ice::getProcessLogger()->cloneWithPrefix(_controllerHelper->loggerPrefix()));
 
-    virtual bool redirect() = 0;
+            _previousCoutBuffer = std::cout.rdbuf();
+            std::cout.rdbuf(this);
 
-    virtual void print(const std::string& msg) = 0;
+            _previousCerrBuffer = std::cerr.rdbuf();
+            std::cerr.rdbuf(this);
+        }
+    }
 
-    virtual void
-    flush()
+    ~StreamHelper()
     {
+        if(_previousLogger)
+        {
+            Ice::setProcessLogger(_previousLogger);
+            std::cout.rdbuf(_previousCoutBuffer);
+            std::cerr.rdbuf(_previousCerrBuffer);
+        }
     }
 
-    virtual void
-    newLine()
+    virtual void flush()
     {
-        print("\n");
     }
 
-private:
+    virtual void newLine()
+    {
+        _controllerHelper->print("\n");
+    }
 
-    //
-    // streambuf redirection implementation
-    //
+private:
 
     int sync()
     {
+        assert(_controllerHelper);
         std::streamsize n = pptr() - pbase();
-        print(std::string(pbase(), static_cast<int>(n)));
+        _controllerHelper->print(std::string(pbase(), static_cast<int>(n)));
         pbump(-static_cast<int>(pptr() - pbase()));
         return 0;
     }
@@ -82,8 +146,127 @@ private:
         return std::streambuf::sputc(c);
     }
 
+    ControllerHelperPtr _controllerHelper;
     char data[1024];
+    Ice::LoggerPtr _previousLogger;
+    std::streambuf* _previousCoutBuffer;
+    std::streambuf* _previousCerrBuffer;
 };
+#endif
+
+class TEST_API TestHelper
+{
+public:
+
+    TestHelper(bool registerPlugins = true);
+    virtual ~TestHelper();
+
+    void setControllerHelper(const ControllerHelperPtr&);
+
+    std::string getTestEndpoint(const std::string&);
+    std::string getTestEndpoint(int num = 0, const std::string& prot = "");
+    static std::string getTestEndpoint(const Ice::PropertiesPtr& properties, int num = 0, const std::string& prot = "");
+
+    std::string getTestHost();
+    static std::string getTestHost(const Ice::PropertiesPtr&);
 
+    std::string getTestProtocol();
+    static std::string getTestProtocol(const Ice::PropertiesPtr&);
+
+    int getTestPort(int port = 0);
+    static int getTestPort(const Ice::PropertiesPtr&, int port = 0);
+
+    static Ice::PropertiesPtr
+    createTestProperties(int&, char*[]);
+
+    Ice::CommunicatorPtr
+    initialize(int& argc, char* argv[], const Ice::PropertiesPtr& properties = ICE_NULLPTR);
+
+    Ice::CommunicatorPtr initialize(int& argc, char* argv[], Ice::InitializationData initData);
+
+    Ice::CommunicatorPtr communicator() const;
+
+    void serverReady();
+    void completed();
+    void shutdown();
+
+    static void shutdownOnInterrupt();
+    static void shutdownOnInterruptCallback(int);
+
+    virtual void run(int argc, char* argv[]) = 0;
+
+private:
+
+    ControllerHelperPtr _controllerHelper;
+    Ice::CommunicatorPtr _communicator;
+    IceUtil::Mutex _mutex;
+};
+
+#if defined(ICE_OS_UWP) || (TARGET_OS_IPHONE != 0)
+
+class TestFailedException
+{
+};
+
+void
+inline testFailed(const char* expr, const char* file, unsigned int line)
+{
+    std::cout << "failed!" << std::endl;
+    std::cout << file << ':' << line << ": assertion `" << expr << "' failed" << std::endl;
+    throw TestFailedException();
 }
+
+#else
+
+void
+inline testFailed(const char* expr, const char* file, unsigned int line)
+{
+    std::cout << "failed!" << std::endl;
+    std::cout << file << ':' << line << ": assertion `" << expr << "' failed" << std::endl;
+    abort();
+}
+
+template<typename T>
+int
+runTest(int argc, char* argv[])
+{
+    int status = 0;
+    try
+    {
+        T helper;
+        helper.run(argc, argv);
+    }
+    catch(const std::exception& ex)
+    {
+        std::cerr << "error: " << ex.what() << std::endl;
+        status = 1;
+    }
+    return status;
+}
+#endif
+
+}
+
+#if defined(ICE_OS_UWP) || (TARGET_OS_IPHONE != 0)
+#   define DEFINE_TEST(HELPER)                                \
+    extern "C"                                                \
+    {                                                         \
+        ICE_DECLSPEC_EXPORT Test::TestHelper* createHelper()  \
+        {                                                     \
+            return new HELPER();                              \
+        }                                                     \
+    }
+
+#else
+
+#   define DEFINE_TEST(HELPER)                          \
+    int main(int argc, char** argv)                     \
+    {                                                   \
+        return Test::runTest<HELPER>(argc, argv);       \
+    }
+
+#endif
+
+#define test(ex) ((ex) ? ((void)0) : Test::testFailed(#ex, __FILE__, __LINE__))
+
 #endif