Fix for bugs #1015 and #542 (default properties)

39 files changed, 296 insertions, 245 deletions

diff --git a/cpp/CHANGES b/cpp/CHANGES
index 9b29ad4f56a..a75d1c7925b 100644
--- a/cpp/CHANGES
+++ b/cpp/CHANGES
@@ -1,6 +1,25 @@
 Changes since version 3.0.1
 ---------------------------
 
+- Removed getDefaultProperties() functions, and the global default
+  properties. If you need global properties, you can easily
+  create your own global variable.
+
+- In Ice::Service, main(), run() and initializeCommunicator() take
+  now a third parameter, const InitializationData&. It's defaulted
+  for main() and run().
+
+- The signature of createProperties()-with-parameters is now:
+  PropertiesPtr createProperties(int* argc, char* argv[],
+                                 const PropertiesPtr& defaults = 0);
+  "defaults" represents an optional set of default properties
+  used to initialize the new Properties object. Ice properties 
+  defined on the command-line and properties defined in the Ice
+  config file may override these default properties.
+   
+- Added a new communicator-initialization function:
+  CommunicatorPtr initialize(const InitializationData&);
+
 - Fixed a bug in dumpdb so that it handles object graphs correctly.
 
 - Fixed a bug where the proxy timeout, compress flag and connection
diff --git a/cpp/include/Ice/Initialize.h b/cpp/include/Ice/Initialize.h
index 03a34e854c3..d95cf3ee2a5 100644
--- a/cpp/include/Ice/Initialize.h
+++ b/cpp/include/Ice/Initialize.h
@@ -34,8 +34,8 @@ ICE_API StringSeq argsToStringSeq(int, char*[]);
 ICE_API void stringSeqToArgs(const StringSeq&, int&, char*[]);
 
 ICE_API PropertiesPtr createProperties();
-ICE_API PropertiesPtr createProperties(StringSeq&);
-ICE_API PropertiesPtr createProperties(int&, char*[]);
+ICE_API PropertiesPtr createProperties(StringSeq&, const PropertiesPtr& = 0);
+ICE_API PropertiesPtr createProperties(int&, char*[], const PropertiesPtr& = 0);
 
 //
 // This class is used to notify user of when Ice threads
@@ -67,6 +67,9 @@ struct InitializationData
 
 ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData& = InitializationData(),
 				   Int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(const InitializationData&, Int = ICE_INT_VERSION);
+
 ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithProperties(int&, char*[], const PropertiesPtr&,
 								    Int = ICE_INT_VERSION);
 ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithLogger(int&, char*[], const Ice::LoggerPtr&,
@@ -75,10 +78,6 @@ ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithPropertiesAndLogger(int
 							                     const Ice::LoggerPtr&, 
 									     Int = ICE_INT_VERSION);
 
-ICE_API PropertiesPtr getDefaultProperties();
-ICE_API PropertiesPtr getDefaultProperties(StringSeq&);
-ICE_API PropertiesPtr getDefaultProperties(int&, char*[]);
-
 ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
 ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&);
 
diff --git a/cpp/include/Ice/Service.h b/cpp/include/Ice/Service.h
index e95c013554a..ee945f6026d 100755
--- a/cpp/include/Ice/Service.h
+++ b/cpp/include/Ice/Service.h
@@ -59,7 +59,7 @@ public:
     // The return value is an exit status code: EXIT_FAILURE or
     // EXIT_SUCCESS.
     //
-    int main(int&, char*[]);
+    int main(int&, char*[], const InitializationData& = InitializationData());
 
     //
     // Returns the communicator created by the service.
@@ -101,7 +101,7 @@ public:
     // The return value is an exit status code: EXIT_FAILURE or
     // EXIT_SUCCESS.
     //
-    int run(int&, char*[]);
+    int run(int&, char*[], const InitializationData& = InitializationData());
 
 #ifdef _WIN32
 
@@ -172,7 +172,7 @@ protected:
     //
     // Initialize a communicator.
     //
-    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[]);
+    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
 
     //
     // Log a system error, which includes a description of the
@@ -217,17 +217,19 @@ private:
     bool _nohup;
     bool _service;
     std::string _name;
+  
     static Service* _instance;
 
 #ifdef _WIN32
 
-    int runService(int, char*[]);
+    int runService(int, char*[], const InitializationData&);
     void terminateService(DWORD);
     bool waitForServiceState(SC_HANDLE, DWORD, SERVICE_STATUS&);
     void showServiceStatus(const std::string&, SERVICE_STATUS&);
 
     SERVICE_STATUS_HANDLE _statusHandle;
     std::vector<std::string> _serviceArgs;
+    InitializationData _initData;
 
 public:
 
@@ -236,7 +238,7 @@ public:
 
 #else
 
-    int runDaemon(int, char*[]);
+    int runDaemon(int, char*[], const InitializationData&);
 
     bool _changeDirectory;
     bool _closeFiles;
diff --git a/cpp/src/Glacier2/Glacier2Router.cpp b/cpp/src/Glacier2/Glacier2Router.cpp
index 330761d7fc8..ccb3c85e93a 100644
--- a/cpp/src/Glacier2/Glacier2Router.cpp
+++ b/cpp/src/Glacier2/Glacier2Router.cpp
@@ -53,7 +53,7 @@ protected:
 
     virtual bool start(int, char*[]);
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[]);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
 
 private:
 
@@ -304,26 +304,28 @@ Glacier2::RouterService::stop()
 }
 
 CommunicatorPtr
-Glacier2::RouterService::initializeCommunicator(int& argc, char* argv[])
+Glacier2::RouterService::initializeCommunicator(int& argc, char* argv[], 
+						const InitializationData& initializationData)
 {
-    PropertiesPtr defaultProperties = getDefaultProperties(argc, argv);
-    
+    InitializationData initData = initializationData;
+    initData.properties = createProperties(argc, argv, initializationData.properties);
+ 
     //
     // Glacier2 always runs in thread-per-connection mode.
     //
-    defaultProperties->setProperty("Ice.ThreadPerConnection", "1");
+    initData.properties->setProperty("Ice.ThreadPerConnection", "1");
     
     //
     // Make sure that Glacier2 doesn't use a router.
     //
-    defaultProperties->setProperty("Ice.Default.Router", "");
+    initData.properties->setProperty("Ice.Default.Router", "");
     
     //
     // No active connection management is permitted with
     // Glacier2. Connections must remain established.
     //
-    defaultProperties->setProperty("Ice.ACM.Client", "0");
-    defaultProperties->setProperty("Ice.ACM.Server", "0");
+    initData.properties->setProperty("Ice.ACM.Client", "0");
+    initData.properties->setProperty("Ice.ACM.Server", "0");
     
     //
     // Ice.MonitorConnections defaults to the smaller of Ice.ACM.Client
@@ -331,9 +333,9 @@ Glacier2::RouterService::initializeCommunicator(int& argc, char* argv[])
     // the connection monitor thread for AMI timeouts. We only set
     // this value if it hasn't been set explicitly already.
     //
-    if(defaultProperties->getProperty("Ice.MonitorConnections").empty())
+    if(initData.properties->getProperty("Ice.MonitorConnections").empty())
     {
-	defaultProperties->setProperty("Ice.MonitorConnections", "60");
+	initData.properties->setProperty("Ice.MonitorConnections", "60");
     }
 
     //
@@ -344,7 +346,7 @@ Glacier2::RouterService::initializeCommunicator(int& argc, char* argv[])
     // the clients.
     //
 
-    return Service::initializeCommunicator(argc, argv);
+    return Service::initializeCommunicator(argc, argv, initData);
 }
 
 void
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index fe29d051696..d77c7d1066d 100644
--- a/cpp/src/Ice/CommunicatorI.h
+++ b/cpp/src/Ice/CommunicatorI.h
@@ -69,6 +69,7 @@ private:
     void finishSetup(int&, char*[]);
 
     friend ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData&, Int);
+    friend ICE_API CommunicatorPtr initialize(const InitializationData&, Int);
     friend ICE_API ::IceInternal::InstancePtr IceInternal::getInstance(const ::Ice::CommunicatorPtr&);
 
     const ::IceInternal::InstancePtr _instance;
diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index ca108e8db85..90d37f16bc1 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -89,66 +89,21 @@ Ice::createProperties()
 }
 
 PropertiesPtr
-Ice::createProperties(StringSeq& args)
+Ice::createProperties(StringSeq& args, const PropertiesPtr& defaults)
 {
-    return new PropertiesI(args);
+    return new PropertiesI(args, defaults);
 }
 
 PropertiesPtr
-Ice::createProperties(int& argc, char* argv[])
+Ice::createProperties(int& argc, char* argv[], const PropertiesPtr& defaults)
 {
     StringSeq args = argsToStringSeq(argc, argv);
-    PropertiesPtr properties = createProperties(args);
+    PropertiesPtr properties = createProperties(args, defaults);
     stringSeqToArgs(args, argc, argv);
     return properties;
 }
 
-static PropertiesPtr defaultProperties;
-class DefaultPropertiesDestroyer
-{
-public:
-
-    ~DefaultPropertiesDestroyer()
-    {
-	defaultProperties = 0;
-    }
-};
-static DefaultPropertiesDestroyer defaultPropertiesDestroyer;
-static IceUtil::StaticMutex defaultPropMutex = ICE_STATIC_MUTEX_INITIALIZER;
-
-PropertiesPtr
-Ice::getDefaultProperties()
-{
-    IceUtil::StaticMutex::Lock sync(defaultPropMutex);
-    if(!defaultProperties)
-    {
-	defaultProperties = createProperties();
-    }
-    return defaultProperties;
-}
-
-PropertiesPtr
-Ice::getDefaultProperties(StringSeq& args)
-{
-    IceUtil::StaticMutex::Lock sync(defaultPropMutex);
-    if(!defaultProperties)
-    {
-	defaultProperties = createProperties(args);
-    }
-    return defaultProperties;
-}
-
-PropertiesPtr
-Ice::getDefaultProperties(int& argc, char* argv[])
-{
-    StringSeq args = argsToStringSeq(argc, argv);
-    PropertiesPtr properties = getDefaultProperties(args);
-    stringSeqToArgs(args, argc, argv);
-    return properties;
-}
-
-CommunicatorPtr
-Ice::initialize(int& argc, char* argv[], const InitializationData& initData, Int version)
+inline void checkIceVersion(Int version)
 {
 #ifndef ICE_IGNORE_VERSION
     //
@@ -167,23 +122,40 @@ Ice::initialize(int& argc, char* argv[], const InitializationData& initData, Int
 	throw VersionMismatchException(__FILE__, __LINE__);
     }
 #endif
+}
 
-    InitializationData tmpData = initData;
-    if(tmpData.properties == 0)
-    {
-        tmpData.properties = getDefaultProperties(argc, argv);
-    }
-    StringSeq args = argsToStringSeq(argc, argv);
-    args = tmpData.properties->parseIceCommandLineOptions(args);
-    stringSeqToArgs(args, argc, argv);
 
-    CommunicatorI* communicatorI = new CommunicatorI(tmpData);
+CommunicatorPtr
+Ice::initialize(int& argc, char* argv[], const InitializationData& initializationData, Int version)
+{
+    InitializationData initData = initializationData;
+    initData.properties = createProperties(argc, argv, initData.properties);
+
+    CommunicatorI* communicatorI = new CommunicatorI(initData);
     CommunicatorPtr result = communicatorI; // For exception safety.
     communicatorI->finishSetup(argc, argv);
     return result;
 }
 
 CommunicatorPtr
+Ice::initialize(const InitializationData& initData, Int version)
+{
+    //
+    // We can't simply call the other initialize() because this one does NOT read
+    // the config file, while the other one always does.
+    //
+    checkIceVersion(version);
+
+    CommunicatorI* communicatorI = new CommunicatorI(initData);
+    CommunicatorPtr result = communicatorI; // For exception safety.
+    int argc = 0;
+    char* argv[] = { 0 };
+    communicatorI->finishSetup(argc, argv);
+    return result;
+}
+
+
+CommunicatorPtr
 Ice::initializeWithProperties(int& argc, char* argv[], const PropertiesPtr& properties, Int version)
 {
     InitializationData initData;
diff --git a/cpp/src/Ice/PropertiesI.cpp b/cpp/src/Ice/PropertiesI.cpp
index 44e3bfb9b3e..598dd2110a5 100644
--- a/cpp/src/Ice/PropertiesI.cpp
+++ b/cpp/src/Ice/PropertiesI.cpp
@@ -240,11 +240,28 @@ Ice::PropertiesI::PropertiesI(const PropertiesI* p) :
 
 Ice::PropertiesI::PropertiesI()
 {
-    loadConfig();
 }
 
-Ice::PropertiesI::PropertiesI(StringSeq& args)
+Ice::PropertiesI::PropertiesI(StringSeq& args, const PropertiesPtr& defaults)
 {
+    //
+    // Since there is no way to iterate over all Properties, we
+    // assume that defaults (when not null) points to a PropertiesI
+    //
+    if(defaults != 0)
+    {
+	PropertiesI* defaultsI = dynamic_cast<PropertiesI*>(defaults.get());
+	if(defaultsI == 0)
+	{
+	    throw InitializationException(__FILE__, __LINE__,
+					  "Invalid Properties implementation");
+	}
+	
+	IceUtil::Mutex::Lock sync(*defaultsI);
+	_properties = defaultsI->_properties;
+    }
+
+
     StringSeq::iterator q = args.begin();
     if(q != args.end())
     {
@@ -282,6 +299,7 @@ Ice::PropertiesI::PropertiesI(StringSeq& args)
     args = parseIceCommandLineOptions(args);
 }
 
+
 void
 Ice::PropertiesI::parseLine(const string& line)
 {
diff --git a/cpp/src/Ice/PropertiesI.h b/cpp/src/Ice/PropertiesI.h
index 603e1bc2a24..0a8a5622daa 100644
--- a/cpp/src/Ice/PropertiesI.h
+++ b/cpp/src/Ice/PropertiesI.h
@@ -33,14 +33,14 @@ public:
     virtual PropertiesPtr clone();
 
 private:
-
-    PropertiesI(const PropertiesI*);
     PropertiesI();
-    PropertiesI(StringSeq&);
+    PropertiesI(StringSeq&, const PropertiesPtr&);
+    PropertiesI(const PropertiesI*);
 
     friend ICE_API PropertiesPtr createProperties();
-    friend ICE_API PropertiesPtr createProperties(StringSeq&);
-    friend ICE_API PropertiesPtr createProperties(int&, char*[]);
+    friend ICE_API PropertiesPtr createProperties(StringSeq&, const PropertiesPtr&);
+    friend ICE_API PropertiesPtr createProperties(int&, char*[], const PropertiesPtr&);
+
 
     void parseLine(const std::string&);
 
diff --git a/cpp/src/Ice/Service.cpp b/cpp/src/Ice/Service.cpp
index a54b6a369ee..8379d315813 100755
--- a/cpp/src/Ice/Service.cpp
+++ b/cpp/src/Ice/Service.cpp
@@ -189,7 +189,7 @@ Ice::Service::interrupt()
 }
 
 int
-Ice::Service::main(int& argc, char* argv[])
+Ice::Service::main(int& argc, char* argv[], const InitializationData& initData)
 {
     _name = argv[0];
 
@@ -449,7 +449,7 @@ Ice::Service::main(int& argc, char* argv[])
     }
 #endif
 
-    return run(argc, argv);
+    return run(argc, argv, initData);
 }
 
 Ice::CommunicatorPtr
@@ -493,14 +493,14 @@ Ice::Service::checkSystem() const
 }
 
 int
-Ice::Service::run(int& argc, char* argv[])
+Ice::Service::run(int& argc, char* argv[], const InitializationData& initData)
 {
     if(_service)
     {
 #ifdef _WIN32
-        return runService(argc, argv);
+        return runService(argc, argv, initData);
 #else
-        return runDaemon(argc, argv);
+        return runDaemon(argc, argv, initData);
 #endif
     }
 
@@ -521,7 +521,7 @@ Ice::Service::run(int& argc, char* argv[])
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(argc, argv);
+        _communicator = initializeCommunicator(argc, argv, initData);
 
         //
         // Use the configured logger.
@@ -916,9 +916,9 @@ Ice::Service::stop()
 }
 
 Ice::CommunicatorPtr
-Ice::Service::initializeCommunicator(int& argc, char* argv[])
+Ice::Service::initializeCommunicator(int& argc, char* argv[], const InitializationData& initData)
 {
-    return Ice::initialize(argc, argv);
+    return Ice::initialize(argc, argv, initData);
 }
 
 void
@@ -1045,7 +1045,7 @@ Ice::Service::disableInterrupt()
 #ifdef _WIN32
 
 int
-Ice::Service::runService(int argc, char* argv[])
+Ice::Service::runService(int argc, char* argv[], const InitializationData& initData)
 {
     assert(_service);
 
@@ -1070,6 +1070,8 @@ Ice::Service::runService(int argc, char* argv[])
         _serviceArgs.push_back(argv[idx]);
     }
 
+    _initData = initData;
+
     SERVICE_TABLE_ENTRY ste[] =
     {
         { const_cast<char*>(_name.c_str()), Ice_Service_ServiceMain },
@@ -1271,7 +1273,7 @@ Ice::Service::serviceMain(int argc, char* argv[])
     //
     try
     {
-        _communicator = initializeCommunicator(argc, args);
+        _communicator = initializeCommunicator(argc, args, _initData);
     }
     catch(const Ice::Exception& ex)
     {
@@ -1470,7 +1472,7 @@ Ice::ServiceStatusManager::run()
 #else
 
 int
-Ice::Service::runDaemon(int argc, char* argv[])
+Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initData)
 {
     assert(_service);
 
@@ -1650,7 +1652,7 @@ Ice::Service::runDaemon(int argc, char* argv[])
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(argc, argv);
+        _communicator = initializeCommunicator(argc, argv, initData);
 
         if(_closeFiles)
         {
diff --git a/cpp/src/IceGrid/IceGridNode.cpp b/cpp/src/IceGrid/IceGridNode.cpp
index 5cb0a8d01d0..cd1ab743ac1 100644
--- a/cpp/src/IceGrid/IceGridNode.cpp
+++ b/cpp/src/IceGrid/IceGridNode.cpp
@@ -111,7 +111,7 @@ protected:
     virtual bool start(int, char*[]);
     virtual void waitForShutdown();
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[]);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
 
 private:
 
@@ -653,18 +653,20 @@ NodeService::stop()
 }
 
 CommunicatorPtr
-NodeService::initializeCommunicator(int& argc, char* argv[])
+NodeService::initializeCommunicator(int& argc, char* argv[], 
+				    const InitializationData& initializationData)
 {
-    PropertiesPtr defaultProperties = getDefaultProperties(argc, argv);
-    
+    InitializationData initData = initializationData;
+    initData.properties = createProperties(argc, argv, initData.properties);
+
     //
     // Make sure that IceGridNode doesn't use thread-per-connection or
     // collocation optimization
     //
-    defaultProperties->setProperty("Ice.ThreadPerConnection", "");
-    defaultProperties->setProperty("Ice.Default.CollocationOptimization", "0");
+    initData.properties->setProperty("Ice.ThreadPerConnection", "");
+    initData.properties->setProperty("Ice.Default.CollocationOptimization", "0");
 
-    return Service::initializeCommunicator(argc, argv);
+    return Service::initializeCommunicator(argc, argv, initData);
 }
 
 void
diff --git a/cpp/src/IceGrid/IceGridRegistry.cpp b/cpp/src/IceGrid/IceGridRegistry.cpp
index a44c2faac6b..1a2478e46ea 100644
--- a/cpp/src/IceGrid/IceGridRegistry.cpp
+++ b/cpp/src/IceGrid/IceGridRegistry.cpp
@@ -29,7 +29,7 @@ protected:
 
     virtual bool start(int, char*[]);
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[]);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
 
 private:
 
@@ -111,18 +111,20 @@ RegistryService::stop()
 }
 
 CommunicatorPtr
-RegistryService::initializeCommunicator(int& argc, char* argv[])
+RegistryService::initializeCommunicator(int& argc, char* argv[], 
+					const InitializationData& initializationData)
 {
-    PropertiesPtr defaultProperties = getDefaultProperties(argc, argv);
+    InitializationData initData = initializationData;
+    initData.properties = createProperties(argc, argv, initData.properties);
     
     //
     // Make sure that IceGridRegistry doesn't use
     // thread-per-connection or collocation optimization.
     //
-    defaultProperties->setProperty("Ice.ThreadPerConnection", "");
-    defaultProperties->setProperty("Ice.Default.CollocationOptimization", "0");
+    initData.properties->setProperty("Ice.ThreadPerConnection", "");
+    initData.properties->setProperty("Ice.Default.CollocationOptimization", "0");
 
-    return Service::initializeCommunicator(argc, argv);
+    return Service::initializeCommunicator(argc, argv, initData);
 }
 
 void
diff --git a/cpp/src/IcePatch2/Server.cpp b/cpp/src/IcePatch2/Server.cpp
index 1d12361a309..efe193805cf 100644
--- a/cpp/src/IcePatch2/Server.cpp
+++ b/cpp/src/IcePatch2/Server.cpp
@@ -50,7 +50,6 @@ protected:
 
     virtual bool start(int, char*[]);
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[]);
 
 private:
 
@@ -196,11 +195,6 @@ IcePatch2::PatcherService::stop()
     return true;
 }
 
-CommunicatorPtr
-IcePatch2::PatcherService::initializeCommunicator(int& argc, char* argv[])
-{
-    return Service::initializeCommunicator(argc, argv);
-}
 
 void
 IcePatch2::PatcherService::usage(const string& appName)
diff --git a/cpp/test/Glacier2/addressFilter/Client.cpp b/cpp/test/Glacier2/addressFilter/Client.cpp
index a327f1ac5d6..1061478cb94 100755
--- a/cpp/test/Glacier2/addressFilter/Client.cpp
+++ b/cpp/test/Glacier2/addressFilter/Client.cpp
@@ -30,16 +30,17 @@ public:
 int
 main(int argc, char* argv[])
 {
-    PropertiesPtr properties = getDefaultProperties(argc, argv);
-    
+    Ice::InitializationData initData;
+    initData.properties = Ice::createProperties(argc, argv);
+   
     //
     // We want to check whether the client retries for evicted
     // proxies, even with regular retries disabled.
     //
-    properties->setProperty("Ice.RetryIntervals", "-1");
+    initData.properties->setProperty("Ice.RetryIntervals", "-1");
 	
     AttackClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
@@ -81,8 +82,10 @@ AttackClient::run(int argc, char* argv[])
 	    // This is also ok.
 	    //
 	}
-	catch(const LocalException&)
+	catch(const LocalException& e)
 	{
+	    cerr << "The exception is: " << e << endl;
+	    cerr << "-----------------------" << endl;
 	    test("Unexpected local exception" == 0);
 	}
     }
diff --git a/cpp/test/Glacier2/attack/Client.cpp b/cpp/test/Glacier2/attack/Client.cpp
index ab588efa07b..86500f216ec 100644
--- a/cpp/test/Glacier2/attack/Client.cpp
+++ b/cpp/test/Glacier2/attack/Client.cpp
@@ -28,16 +28,17 @@ public:
 int
 main(int argc, char* argv[])
 {
-    PropertiesPtr properties = getDefaultProperties(argc, argv);
-    
+    Ice::InitializationData initData;
+    initData.properties = Ice::createProperties(argc, argv);
+   
     //
     // We want to check whether the client retries for evicted
     // proxies, even with regular retries disabled.
     //
-    properties->setProperty("Ice.RetryIntervals", "-1");
+    initData.properties->setProperty("Ice.RetryIntervals", "-1");
 	
     AttackClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
diff --git a/cpp/test/Glacier2/filters/Client.cpp b/cpp/test/Glacier2/filters/Client.cpp
index a14516a0ca5..a0187228357 100755
--- a/cpp/test/Glacier2/filters/Client.cpp
+++ b/cpp/test/Glacier2/filters/Client.cpp
@@ -16,6 +16,8 @@ using namespace std;
 using namespace Ice;
 using namespace Test;
 
+static Ice::InitializationData initData;
+
 class SessionControlClient : public Application
 {
 public:
@@ -26,17 +28,17 @@ public:
 int
 main(int argc, char* argv[])
 {
-    PropertiesPtr properties = getDefaultProperties(argc, argv);
+    initData.properties = Ice::createProperties(argc, argv);
     
     //
     // We want to check whether the client retries for evicted
     // proxies, even with regular retries disabled.
     //
-    properties->setProperty("Ice.RetryIntervals", "-1");
-    properties->setProperty("Ice.Warn.Connections", "0");
+    initData.properties->setProperty("Ice.RetryIntervals", "-1");
+    initData.properties->setProperty("Ice.Warn.Connections", "0");
 	
     SessionControlClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
@@ -47,7 +49,7 @@ SessionControlClient::run(int argc, char* argv[])
     // to bypass the router for test control operations.
     //
     cout << "accessing test controller... " << flush;
-    Ice::CommunicatorPtr controlComm = Ice::initialize(argc, argv);
+    Ice::CommunicatorPtr controlComm = Ice::initialize(argc, argv, initData);
     TestControllerPrx controller = TestControllerPrx::checkedCast(
 	controlComm->stringToProxy("testController:tcp -p 12013"));
     test(controller);
diff --git a/cpp/test/Glacier2/router/Client.cpp b/cpp/test/Glacier2/router/Client.cpp
index 9f7396fbf48..6e4b2aac4b8 100644
--- a/cpp/test/Glacier2/router/Client.cpp
+++ b/cpp/test/Glacier2/router/Client.cpp
@@ -17,6 +17,8 @@ using namespace std;
 using namespace Ice;
 using namespace Test;
 
+static Ice::InitializationData initData;
+
 class AMI_Callback_initiateConcurrentCallbackI : public AMI_Callback_initiateConcurrentCallback,
 						 public IceUtil::Monitor<IceUtil::Mutex>
 {
@@ -82,9 +84,7 @@ public:
     virtual 
     void run()
     {
-	int argc = 0;
-	char** argv = 0;
-	CommunicatorPtr communicator = initialize(argc, argv);
+	CommunicatorPtr communicator = initialize(initData);
 	ObjectPrx routerBase = communicator->stringToProxy("abc/def:default -p 12347 -t 10000");
 	Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
 	communicator->setDefaultRouter(router);
@@ -191,9 +191,7 @@ public:
     virtual 
     void run()
     {
-	int argc = 0;
-	char** argv = 0;
-	CommunicatorPtr communicator = initialize(argc, argv);
+	CommunicatorPtr communicator = initialize(initData);
 	ObjectPrx routerBase = communicator->stringToProxy("abc/def:default -p 12347 -t 10000");
 	_router = Glacier2::RouterPrx::checkedCast(routerBase);
 	communicator->setDefaultRouter(_router);
@@ -385,11 +383,11 @@ main(int argc, char* argv[])
     // the router before session establishment, as well as after
     // session destruction. Both will cause a ConnectionLostException.
     //
-    Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-    properties->setProperty("Ice.Warn.Connections", "0");
+    initData.properties = Ice::createProperties(argc, argv);
+    initData.properties->setProperty("Ice.Warn.Connections", "0");
 
     CallbackClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
diff --git a/cpp/test/Glacier2/router/Server.cpp b/cpp/test/Glacier2/router/Server.cpp
index 4abf6278033..6ab68f2e12b 100644
--- a/cpp/test/Glacier2/router/Server.cpp
+++ b/cpp/test/Glacier2/router/Server.cpp
@@ -24,12 +24,14 @@ public:
 int
 main(int argc, char* argv[])
 {
-    Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-    properties->setProperty("Ice.Warn.Connections", "0");
-    properties->setProperty("Ice.Warn.Dispatch", "0");
+    Ice::InitializationData initData;
+    initData.properties = Ice::createProperties(argc, argv);
+
+    initData.properties->setProperty("Ice.Warn.Connections", "0");
+    initData.properties->setProperty("Ice.Warn.Dispatch", "0");
 
     CallbackServer app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
diff --git a/cpp/test/Glacier2/sessionControl/Client.cpp b/cpp/test/Glacier2/sessionControl/Client.cpp
index 063d81d4aa8..fe69e104333 100644
--- a/cpp/test/Glacier2/sessionControl/Client.cpp
+++ b/cpp/test/Glacier2/sessionControl/Client.cpp
@@ -27,17 +27,18 @@ public:
 int
 main(int argc, char* argv[])
 {
-    PropertiesPtr properties = getDefaultProperties(argc, argv);
-    
+    Ice::InitializationData initData;
+    initData.properties = Ice::createProperties(argc, argv);
+
     //
     // We want to check whether the client retries for evicted
     // proxies, even with regular retries disabled.
     //
-    properties->setProperty("Ice.RetryIntervals", "-1");
-    properties->setProperty("Ice.Warn.Connections", "0");
+    initData.properties->setProperty("Ice.RetryIntervals", "-1");
+    initData.properties->setProperty("Ice.Warn.Connections", "0");
 	
     SessionControlClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
diff --git a/cpp/test/Glacier2/ssl/Client.cpp b/cpp/test/Glacier2/ssl/Client.cpp
index bbed678607a..4598cf7b266 100755
--- a/cpp/test/Glacier2/ssl/Client.cpp
+++ b/cpp/test/Glacier2/ssl/Client.cpp
@@ -30,11 +30,12 @@ main(int argc, char* argv[])
     // the router before session establishment, as well as after
     // session destruction. Both will cause a ConnectionLostException.
     //
-    Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-    properties->setProperty("Ice.Warn.Connections", "0");
+    Ice::InitializationData initData;
+    initData.properties = Ice::createProperties(argc, argv);
+    initData.properties->setProperty("Ice.Warn.Connections", "0");
 
     CallbackClient app;
-    return app.main(argc, argv);
+    return app.main(argc, argv, initData);
 }
 
 int
diff --git a/cpp/test/Ice/custom/Collocated.cpp b/cpp/test/Ice/custom/Collocated.cpp
index dc1c4eb4f35..f4a5f3e13f1 100644
--- a/cpp/test/Ice/custom/Collocated.cpp
+++ b/cpp/test/Ice/custom/Collocated.cpp
@@ -38,8 +38,8 @@ main(int argc, char** argv)
 
     try
     {
-        Ice::InitializationData initData;
-	initData.properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 	initData.properties->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
 	initData.stringConverter = new Test::StringConverterI();
 	initData.wstringConverter = new Test::WstringConverterI();
diff --git a/cpp/test/Ice/custom/Server.cpp b/cpp/test/Ice/custom/Server.cpp
index 2517e5a53f2..ada96ddd009 100644
--- a/cpp/test/Ice/custom/Server.cpp
+++ b/cpp/test/Ice/custom/Server.cpp
@@ -37,8 +37,8 @@ main(int argc, char** argv)
 
     try
     {
-        Ice::InitializationData initData;
-	initData.properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 	initData.properties->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
 	initData.stringConverter = new Test::StringConverterI();
 	initData.wstringConverter = new Test::WstringConverterI();
diff --git a/cpp/test/Ice/custom/ServerAMD.cpp b/cpp/test/Ice/custom/ServerAMD.cpp
index da682c753b4..d194fe648f0 100644
--- a/cpp/test/Ice/custom/ServerAMD.cpp
+++ b/cpp/test/Ice/custom/ServerAMD.cpp
@@ -37,8 +37,9 @@ main(int argc, char** argv)
 
     try
     {
-        Ice::InitializationData initData;
-	initData.properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	
 	initData.properties->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
 	initData.stringConverter = new Test::StringConverterI();
 	initData.wstringConverter = new Test::WstringConverterI();
diff --git a/cpp/test/Ice/faultTolerance/Client.cpp b/cpp/test/Ice/faultTolerance/Client.cpp
index ece20304dfb..92ebc4fefa3 100644
--- a/cpp/test/Ice/faultTolerance/Client.cpp
+++ b/cpp/test/Ice/faultTolerance/Client.cpp
@@ -64,14 +64,15 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 
 	//
 	// This test aborts servers, so we don't want warnings.
 	//
-	properties->setProperty("Ice.Warn.Connections", "0");
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
diff --git a/cpp/test/Ice/faultTolerance/Server.cpp b/cpp/test/Ice/faultTolerance/Server.cpp
index 55c655b149e..6c7c05832b3 100644
--- a/cpp/test/Ice/faultTolerance/Server.cpp
+++ b/cpp/test/Ice/faultTolerance/Server.cpp
@@ -72,10 +72,11 @@ main(int argc, char* argv[])
 	// our test servers may time out before they are used in the
 	// test.
 	//
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-	properties->setProperty("Ice.ServerIdleTime", "120"); // Two minutes.
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	initData.properties->setProperty("Ice.ServerIdleTime", "120"); // Two minutes.
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
diff --git a/cpp/test/Ice/location/Server.cpp b/cpp/test/Ice/location/Server.cpp
index bdf7066b5d2..e141e427e07 100644
--- a/cpp/test/Ice/location/Server.cpp
+++ b/cpp/test/Ice/location/Server.cpp
@@ -14,7 +14,8 @@
 using namespace std;
 
 int
-run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator,
+    const Ice::InitializationData& initData)
 {
     //
     // Register the server manager. The server manager creates a new
@@ -34,7 +35,7 @@ run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
     //
     ServerLocatorRegistryPtr registry = new ServerLocatorRegistry();
     registry->addObject(adapter->createProxy(communicator->stringToIdentity("ServerManager")));
-    Ice::ObjectPtr object = new ServerManagerI(adapter, registry);
+    Ice::ObjectPtr object = new ServerManagerI(adapter, registry, initData);
     adapter->add(object, communicator->stringToIdentity("ServerManager"));
 
     Ice::LocatorRegistryPrx registryPrx = 
@@ -57,8 +58,12 @@ main(int argc, char* argv[])
 
     try
     {
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
+	assert(initData.properties != communicator->getProperties());
+
+	status = run(argc, argv, communicator, initData);
     }
     catch(const Ice::Exception& ex)
     {
diff --git a/cpp/test/Ice/location/TestI.cpp b/cpp/test/Ice/location/TestI.cpp
index 099da3e0d96..45cd666fb86 100644
--- a/cpp/test/Ice/location/TestI.cpp
+++ b/cpp/test/Ice/location/TestI.cpp
@@ -13,17 +13,24 @@
 
 using namespace Test;
 
-ServerManagerI::ServerManagerI(const Ice::ObjectAdapterPtr& adapter, const ServerLocatorRegistryPtr& registry) :
-    _adapter(adapter), _registry(registry)
+ServerManagerI::ServerManagerI(const Ice::ObjectAdapterPtr& adapter, 
+			       const ServerLocatorRegistryPtr& registry,
+			       const Ice::InitializationData& initData) :
+    _adapter(adapter), _registry(registry), _initData(initData)
 {
+    _initData.properties->setProperty("TestAdapter.Endpoints", "default");
+    _initData.properties->setProperty("TestAdapter.AdapterId", "TestAdapter");
+    _initData.properties->setProperty("TestAdapter.ReplicaGroupId", "ReplicatedAdapter");
+    
+    _initData.properties->setProperty("TestAdapter2.Endpoints", "default");
+    _initData.properties->setProperty("TestAdapter2.AdapterId", "TestAdapter2");
+
+    _initData.properties->setProperty("Ice.PrintAdapterReady", "0");
 }
 
 void
 ServerManagerI::startServer(const Ice::Current& current)
 {
-    int argc = 0;
-    char** argv = 0;
-
     for(::std::vector<Ice::CommunicatorPtr>::const_iterator i = _communicators.begin(); i != _communicators.end(); ++i)
     {
 	(*i)->waitForShutdown();
@@ -39,15 +46,11 @@ ServerManagerI::startServer(const Ice::Current& current)
     // its endpoints with the locator and create references containing
     // the adapter id instead of the endpoints.
     //
-    Ice::CommunicatorPtr serverCommunicator = Ice::initialize(argc, argv);
+    
+    Ice::CommunicatorPtr serverCommunicator = Ice::initialize(_initData);
     _communicators.push_back(serverCommunicator);
-    serverCommunicator->getProperties()->setProperty("TestAdapter.Endpoints", "default");
-    serverCommunicator->getProperties()->setProperty("TestAdapter.AdapterId", "TestAdapter");
-    serverCommunicator->getProperties()->setProperty("TestAdapter.ReplicaGroupId", "ReplicatedAdapter");
-    Ice::ObjectAdapterPtr adapter = serverCommunicator->createObjectAdapter("TestAdapter");
 
-    serverCommunicator->getProperties()->setProperty("TestAdapter2.Endpoints", "default");
-    serverCommunicator->getProperties()->setProperty("TestAdapter2.AdapterId", "TestAdapter2");
+    Ice::ObjectAdapterPtr adapter = serverCommunicator->createObjectAdapter("TestAdapter");
     Ice::ObjectAdapterPtr adapter2 = serverCommunicator->createObjectAdapter("TestAdapter2");
 
     Ice::ObjectPrx locator = serverCommunicator->stringToProxy("locator:default -p 12010");
diff --git a/cpp/test/Ice/location/TestI.h b/cpp/test/Ice/location/TestI.h
index 4bd123d0d4d..c410efc9fdd 100644
--- a/cpp/test/Ice/location/TestI.h
+++ b/cpp/test/Ice/location/TestI.h
@@ -18,7 +18,8 @@ class ServerManagerI : public Test::ServerManager
 {
 public:
 
-    ServerManagerI(const Ice::ObjectAdapterPtr&, const ServerLocatorRegistryPtr&);
+    ServerManagerI(const Ice::ObjectAdapterPtr&, const ServerLocatorRegistryPtr&,
+		   const Ice::InitializationData&);
     
     virtual void startServer(const Ice::Current&);
     virtual void shutdown(const Ice::Current&);
@@ -28,6 +29,7 @@ private:
     Ice::ObjectAdapterPtr _adapter;
     std::vector<Ice::CommunicatorPtr> _communicators;
     ServerLocatorRegistryPtr _registry;
+    Ice::InitializationData _initData;
 };
 
 class HelloI : public Test::Hello
diff --git a/cpp/test/Ice/operations/AllTests.cpp b/cpp/test/Ice/operations/AllTests.cpp
index f3ebb343833..8d8cd2aa77e 100644
--- a/cpp/test/Ice/operations/AllTests.cpp
+++ b/cpp/test/Ice/operations/AllTests.cpp
@@ -15,7 +15,8 @@
 using namespace std;
 
 Test::MyClassPrx
-allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
+allTests(const Ice::CommunicatorPtr& communicator, 
+	 const Ice::InitializationData& initData, bool collocated)
 {
     cout << "testing stringToProxy... " << flush;
     string ref = "test:default -p 12010 -t 10000";
@@ -133,18 +134,18 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
     }
 
     cout << "testing twoway operations... " << flush;
-    void twoways(const Ice::CommunicatorPtr&, const Test::MyClassPrx&);
-    twoways(communicator, cl);
-    twoways(communicator, derived);
+    void twoways(const Ice::CommunicatorPtr&, const Ice::InitializationData&, const Test::MyClassPrx&);
+    twoways(communicator, initData, cl);
+    twoways(communicator, initData, derived);
     derived->opDerived();
     cout << "ok" << endl;
 
     if(!collocated)
     {
 	cout << "testing twoway operations with AMI... " << flush;
-	void twowaysAMI(const Ice::CommunicatorPtr&, const Test::MyClassPrx&);
-	twowaysAMI(communicator, cl);
-	twowaysAMI(communicator, derived);
+	void twowaysAMI(const Ice::CommunicatorPtr&, const Ice::InitializationData&, const Test::MyClassPrx&);
+	twowaysAMI(communicator, initData, cl);
+	twowaysAMI(communicator, initData, derived);
 	cout << "ok" << endl;
 
 	cout << "testing batch oneway operations... " << flush;
diff --git a/cpp/test/Ice/operations/Client.cpp b/cpp/test/Ice/operations/Client.cpp
index 54e2ed2c9ae..6669a1f041a 100644
--- a/cpp/test/Ice/operations/Client.cpp
+++ b/cpp/test/Ice/operations/Client.cpp
@@ -14,10 +14,13 @@
 using namespace std;
 
 int
-run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+run(int argc, char* argv[], 
+    const Ice::CommunicatorPtr& communicator,
+    const Ice::InitializationData& initData)
 {
-    Test::MyClassPrx allTests(const Ice::CommunicatorPtr&, bool);
-    Test::MyClassPrx myClass = allTests(communicator, false);
+    Test::MyClassPrx allTests(const Ice::CommunicatorPtr&, 
+			      const Ice::InitializationData&, bool);
+    Test::MyClassPrx myClass = allTests(communicator, initData, false);
 
     cout << "testing server shutdown... " << flush;
     myClass->shutdown();
@@ -46,24 +49,25 @@ main(int argc, char* argv[])
 	// In this test, we need at least two threads in the
 	// client side thread pool for nested AMI.
 	//
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-	properties->setProperty("Ice.ThreadPool.Client.Size", "2");
-	properties->setProperty("Ice.ThreadPool.Client.SizeWarn", "0");
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	initData.properties->setProperty("Ice.ThreadPool.Client.Size", "2");
+	initData.properties->setProperty("Ice.ThreadPool.Client.SizeWarn", "0");
 
 	//
 	// We must set MessageSizeMax to an explicit values, because
 	// we run tests to check whether Ice.MemoryLimitException is
 	// raised as expected.
 	//
-	properties->setProperty("Ice.MessageSizeMax", "100");
+	initData.properties->setProperty("Ice.MessageSizeMax", "100");
 
 	//
 	// We don't want connection warnings because of the timeout test.
 	//
-	properties->setProperty("Ice.Warn.Connections", "0");
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+	communicator = Ice::initialize(argc, argv, initData);
+	status = run(argc, argv, communicator, initData);
     }
     catch(const Ice::Exception& ex)
     {
diff --git a/cpp/test/Ice/operations/Collocated.cpp b/cpp/test/Ice/operations/Collocated.cpp
index a8016a9f753..ca0e74e0563 100644
--- a/cpp/test/Ice/operations/Collocated.cpp
+++ b/cpp/test/Ice/operations/Collocated.cpp
@@ -13,7 +13,8 @@
 using namespace std;
 
 int
-run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator,
+    const Ice::InitializationData& initData)
 {
     communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
     Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
@@ -22,8 +23,8 @@ run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
     adapter->add(new TestCheckedCastI, communicator->stringToIdentity("context"));
     adapter->activate();
 
-    Test::MyClassPrx allTests(const Ice::CommunicatorPtr&, bool);
-    allTests(communicator, true);
+    Test::MyClassPrx allTests(const Ice::CommunicatorPtr&, const Ice::InitializationData&, bool);
+    allTests(communicator, initData, true);
 
     return EXIT_SUCCESS;
 }
@@ -36,8 +37,10 @@ main(int argc, char* argv[])
 
     try
     {
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
+	status = run(argc, argv, communicator, initData);
     }
     catch(const Ice::Exception& ex)
     {
diff --git a/cpp/test/Ice/operations/Server.cpp b/cpp/test/Ice/operations/Server.cpp
index 568de1dca4c..7e782503d4a 100644
--- a/cpp/test/Ice/operations/Server.cpp
+++ b/cpp/test/Ice/operations/Server.cpp
@@ -34,10 +34,11 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-	properties->setProperty("Ice.Warn.Connections", "0");
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
diff --git a/cpp/test/Ice/operations/ServerAMD.cpp b/cpp/test/Ice/operations/ServerAMD.cpp
index b8c86da48be..084eaeff6d9 100644
--- a/cpp/test/Ice/operations/ServerAMD.cpp
+++ b/cpp/test/Ice/operations/ServerAMD.cpp
@@ -34,9 +34,10 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-	properties->setProperty("Ice.Warn.Connections", "0");
-	communicator = Ice::initialize(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
 
     }
diff --git a/cpp/test/Ice/operations/Twoways.cpp b/cpp/test/Ice/operations/Twoways.cpp
index 4f0693939f2..f9d5465d231 100644
--- a/cpp/test/Ice/operations/Twoways.cpp
+++ b/cpp/test/Ice/operations/Twoways.cpp
@@ -25,7 +25,8 @@
 using namespace std;
 
 void
-twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
+twoways(const Ice::CommunicatorPtr& communicator, const Ice::InitializationData& initializationData,
+	const Test::MyClassPrx& p)
 {
     {
 	p->opVoid();
@@ -645,11 +646,9 @@ twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
 	    //
 	    // Test that default context is obtained correctly from communicator.
 	    //
-	    int argc = 0;
-	    char* argv[] = { "" };
-	    Ice::InitializationData initData;
+	    Ice::InitializationData initData = initializationData;
 	    initData.defaultContext["a"] = "b";
-	    Ice::CommunicatorPtr communicator2 = Ice::initialize(argc, argv, initData);
+	    Ice::CommunicatorPtr communicator2 = Ice::initialize(initData);
 
 	    Test::MyClassPrx c = Test::MyClassPrx::checkedCast(
 	    				communicator2->stringToProxy("test:default -p 12010 -t 10000"));
diff --git a/cpp/test/Ice/operations/TwowaysAMI.cpp b/cpp/test/Ice/operations/TwowaysAMI.cpp
index a356191dbc8..d04c79ba4c7 100644
--- a/cpp/test/Ice/operations/TwowaysAMI.cpp
+++ b/cpp/test/Ice/operations/TwowaysAMI.cpp
@@ -252,7 +252,7 @@ public:
 	test(c2->ice_getIdentity() == _communicator->stringToIdentity("noSuchIdentity"));
 	test(r->ice_getIdentity() == _communicator->stringToIdentity("test"));
 	// We can't do the callbacks below in thread per connection mode.
-	if(!Ice::getDefaultProperties()->getPropertyAsInt("Ice.ThreadPerConnection"))
+	if(!_communicator->getProperties()->getPropertyAsInt("Ice.ThreadPerConnection"))
 	{
 	    r->opVoid();
 	    c1->opVoid();
@@ -284,6 +284,11 @@ class AMI_MyClass_opStructI : public Test::AMI_MyClass_opStruct, public Callback
 {
 public:
 
+    AMI_MyClass_opStructI(const Ice::CommunicatorPtr& communicator) :
+        _communicator(communicator)
+    {
+    }
+
     virtual void ice_response(const ::Test::Structure& rso, const ::Test::Structure& so)
     {
 	test(rso.p == 0);
@@ -292,7 +297,7 @@ public:
 	test(so.e == Test::enum3);
 	test(so.s.s == "a new string");
 	// We can't do the callbacks below in thread per connection mode.
-	if(!Ice::getDefaultProperties()->getPropertyAsInt("Ice.ThreadPerConnection"))
+	if(!_communicator->getProperties()->getPropertyAsInt("Ice.ThreadPerConnection"))
 	{
 	    so.p->opVoid();
 	}
@@ -303,6 +308,10 @@ public:
     {
 	test(false);
     }
+
+private:
+
+    Ice::CommunicatorPtr _communicator;
 };
 
 typedef IceUtil::Handle<AMI_MyClass_opStructI> AMI_MyClass_opStructIPtr;
@@ -863,7 +872,8 @@ public:
 typedef IceUtil::Handle<AMI_MyClass_opDoubleMarshalingI> AMI_MyClass_opDoubleMarshalingIPtr;
 
 void
-twowaysAMI(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
+twowaysAMI(const Ice::CommunicatorPtr& communicator, 
+	   const Ice::InitializationData& initializationData, const Test::MyClassPrx& p)
 {
     {
         // Check that a call to a void operation raises TwowayOnlyException
@@ -960,7 +970,7 @@ twowaysAMI(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
 	si2.e = Test::enum2;
 	si2.s.s = "def";
 	
-	AMI_MyClass_opStructIPtr cb = new AMI_MyClass_opStructI;
+	AMI_MyClass_opStructIPtr cb = new AMI_MyClass_opStructI(communicator);
 	p->opStruct_async(cb, si1, si2);
 	test(cb->check());
     }
@@ -1229,11 +1239,9 @@ twowaysAMI(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
 	    //
 	    // Test that default context is obtained correctly from communicator.
 	    //
-	    int argc = 0;
-            char* argv[] = { "" };
-            Ice::InitializationData initData;
+            Ice::InitializationData initData = initializationData;
             initData.defaultContext["a"] = "b";
-            Ice::CommunicatorPtr communicator2 = Ice::initialize(argc, argv, initData);
+            Ice::CommunicatorPtr communicator2 = Ice::initialize(initData);
 
 	    Test::MyClassPrx c = Test::MyClassPrx::checkedCast(
 				    communicator2->stringToProxy("test:default -p 12010 -t 10000"));
diff --git a/cpp/test/Ice/retry/Client.cpp b/cpp/test/Ice/retry/Client.cpp
index 84df5b77d86..0a8f97f5a82 100644
--- a/cpp/test/Ice/retry/Client.cpp
+++ b/cpp/test/Ice/retry/Client.cpp
@@ -31,19 +31,20 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 
 	//
 	// For this test, we want to disable retries.
 	//
-	properties->setProperty("Ice.RetryIntervals", "-1");
+	initData.properties->setProperty("Ice.RetryIntervals", "-1");
 
 	//
 	// This test kills connections, so we don't want warnings.
 	//
-	properties->setProperty("Ice.Warn.Connections", "0");
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception&)
diff --git a/cpp/test/Ice/timeout/AllTests.cpp b/cpp/test/Ice/timeout/AllTests.cpp
index 694933833dc..3d4a7fdf343 100644
--- a/cpp/test/Ice/timeout/AllTests.cpp
+++ b/cpp/test/Ice/timeout/AllTests.cpp
@@ -299,12 +299,10 @@ allTests(const Ice::CommunicatorPtr& communicator)
 	// Test Ice.Override.Timeout. This property overrides all
 	// endpoint timeouts.
 	//
-	int argc = 0;
-	char* argv[] = { "" };
 	Ice::InitializationData initData;
 	initData.properties = communicator->getProperties()->clone();
 	initData.properties->setProperty("Ice.Override.Timeout", "500");
-	Ice::CommunicatorPtr comm = Ice::initialize(argc, argv, initData);
+	Ice::CommunicatorPtr comm = Ice::initialize(initData);
 	TimeoutPrx to = TimeoutPrx::checkedCast(comm->stringToProxy(sref));
 	try
 	{
@@ -335,12 +333,10 @@ allTests(const Ice::CommunicatorPtr& communicator)
 	//
 	// Test Ice.Override.ConnectTimeout.
 	//
-	int argc = 0;
-	char* argv[] = { "" };
 	Ice::InitializationData initData;
 	initData.properties = communicator->getProperties()->clone();
 	initData.properties->setProperty("Ice.Override.ConnectTimeout", "500");
-	Ice::CommunicatorPtr comm = Ice::initialize(argc, argv, initData);
+	Ice::CommunicatorPtr comm = Ice::initialize(initData);
 	timeout->holdAdapter(750);
 	TimeoutPrx to = TimeoutPrx::uncheckedCast(comm->stringToProxy(sref));
 	try
diff --git a/cpp/test/Ice/timeout/Client.cpp b/cpp/test/Ice/timeout/Client.cpp
index a898c593005..e86880d4538 100644
--- a/cpp/test/Ice/timeout/Client.cpp
+++ b/cpp/test/Ice/timeout/Client.cpp
@@ -31,24 +31,25 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 
 	//
 	// For this test, we want to disable retries.
 	//
-	properties->setProperty("Ice.RetryIntervals", "-1");
+	initData.properties->setProperty("Ice.RetryIntervals", "-1");
 
 	//
 	// This test kills connections, so we don't want warnings.
 	//
-	properties->setProperty("Ice.Warn.Connections", "0");
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
 	//
 	// Check for AMI timeouts every second.
 	//
-	properties->setProperty("Ice.MonitorConnections", "1");
+	initData.properties->setProperty("Ice.MonitorConnections", "1");
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception&)
diff --git a/cpp/test/Ice/timeout/Server.cpp b/cpp/test/Ice/timeout/Server.cpp
index c3625ee948b..b4da1eb153d 100644
--- a/cpp/test/Ice/timeout/Server.cpp
+++ b/cpp/test/Ice/timeout/Server.cpp
@@ -32,14 +32,15 @@ main(int argc, char* argv[])
 
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
 
 	//
 	// This test kills connections, so we don't want warnings.
 	//
-	properties->setProperty("Ice.Warn.Connections", "0");
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
 
-	communicator = Ice::initialize(argc, argv);
+	communicator = Ice::initialize(argc, argv, initData);
 	status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
diff --git a/cpp/test/IceGrid/session/Client.cpp b/cpp/test/IceGrid/session/Client.cpp
index f6df01882f0..3489b53620a 100644
--- a/cpp/test/IceGrid/session/Client.cpp
+++ b/cpp/test/IceGrid/session/Client.cpp
@@ -27,9 +27,10 @@ main(int argc, char* argv[])
     Ice::CommunicatorPtr communicator;
     try
     {
-	Ice::PropertiesPtr properties = Ice::getDefaultProperties(argc, argv);
-	properties->setProperty("Ice.Warn.Connections", "0");
-	communicator = Ice::initialize(argc, argv);
+	Ice::InitializationData initData;
+	initData.properties = Ice::createProperties(argc, argv);
+	initData.properties->setProperty("Ice.Warn.Connections", "0");
+	communicator = Ice::initialize(argc, argv, initData);
 	communicator->getProperties()->parseCommandLineOptions("", Ice::argsToStringSeq(argc, argv));
 	status = run(argc, argv, communicator);
     }