DEV-32777: ensure that stack objects listening on persistent LLEventPumps get

properly disconnected when destroyed.
Break out Debug class and associated macros from lleventcoro_test.cpp into test/debug.h.
Add Debug output to lllogin_test.

4 files changed, 114 insertions, 62 deletions

diff --git a/indra/llcommon/tests/lleventcoro_test.cpp b/indra/llcommon/tests/lleventcoro_test.cpp
index 695b1ca9f4..3a2cda7735 100644
--- a/indra/llcommon/tests/lleventcoro_test.cpp
+++ b/indra/llcommon/tests/lleventcoro_test.cpp
@@ -65,55 +65,7 @@
 #include "tests/wrapllerrs.h"
 #include "stringize.h"
 #include "lleventcoro.h"
-
-/*****************************************************************************
-*   Debugging stuff
-*****************************************************************************/
-// This class is intended to illuminate entry to a given block, exit from the
-// same block and checkpoints along the way. It also provides a convenient
-// place to turn std::cout output on and off.
-class Debug
-{
-public:
-    Debug(const std::string& block):
-        mBlock(block)
-    {
-        (*this)("entry");
-    }
-
-    ~Debug()
-    {
-        (*this)("exit");
-    }
-
-    void operator()(const std::string& status)
-    {
-//      std::cout << mBlock << ' ' << status << std::endl;
-    }
-
-private:
-    const std::string mBlock;
-};
-
-// It's often convenient to use the name of the enclosing function as the name
-// of the Debug block.
-#define DEBUG Debug debug(__FUNCTION__)
-
-// These BEGIN/END macros are specifically for debugging output -- please
-// don't assume you must use such for coroutines in general! They only help to
-// make control flow (as well as exception exits) explicit.
-#define BEGIN                                   \
-{                                               \
-    DEBUG;                                      \
-    try
-
-#define END                                             \
-    catch (...)                                         \
-    {                                                   \
-/*      std::cout << "*** exceptional " << std::flush; */    \
-        throw;                                          \
-    }                                                   \
-}
+#include "../test/debug.h"
 
 /*****************************************************************************
 *   from the banana.cpp example program borrowed for test<1>()
diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index 88ef15a8d9..02dd01e1b0 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -90,6 +90,7 @@ set(test_SOURCE_FILES
 set(test_HEADER_FILES
     CMakeLists.txt
 
+    debug.h
     llpipeutil.h
     llsdtraits.h
     lltut.h
diff --git a/indra/test/debug.h b/indra/test/debug.h
new file mode 100644
index 0000000000..a00659d880
--- /dev/null
+++ b/indra/test/debug.h
@@ -0,0 +1,68 @@
+/**
+ * @file   debug.h
+ * @author Nat Goodspeed
+ * @date   2009-05-28
+ * @brief  Debug output for unit test code
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_DEBUG_H)
+#define LL_DEBUG_H
+
+#include <iostream>
+
+/*****************************************************************************
+*   Debugging stuff
+*****************************************************************************/
+// This class is intended to illuminate entry to a given block, exit from the
+// same block and checkpoints along the way. It also provides a convenient
+// place to turn std::cout output on and off.
+class Debug
+{
+public:
+    Debug(const std::string& block):
+        mBlock(block)
+    {
+        (*this)("entry");
+    }
+
+    ~Debug()
+    {
+        (*this)("exit");
+    }
+
+    void operator()(const std::string& status)
+    {
+#if defined(DEBUG_ON)
+        std::cout << mBlock << ' ' << status << std::endl;
+#endif
+    }
+
+private:
+    const std::string mBlock;
+};
+
+// It's often convenient to use the name of the enclosing function as the name
+// of the Debug block.
+#define DEBUG Debug debug(__FUNCTION__)
+
+// These BEGIN/END macros are specifically for debugging output -- please
+// don't assume you must use such for coroutines in general! They only help to
+// make control flow (as well as exception exits) explicit.
+#define BEGIN                                   \
+{                                               \
+    DEBUG;                                      \
+    try
+
+#define END                                     \
+    catch (...)                                 \
+    {                                           \
+        debug("*** exceptional ");              \
+        throw;                                  \
+    }                                           \
+}
+
+#endif /* ! defined(LL_DEBUG_H) */
diff --git a/indra/viewer_components/login/tests/lllogin_test.cpp b/indra/viewer_components/login/tests/lllogin_test.cpp
index 07c9db1099..b9fe59c0a6 100644
--- a/indra/viewer_components/login/tests/lllogin_test.cpp
+++ b/indra/viewer_components/login/tests/lllogin_test.cpp
@@ -1,8 +1,8 @@
 /**
- * @file   llviewerlogin_test.cpp
+ * @file   lllogin_test.cpp
  * @author Mark Palange
  * @date   2009-02-26
- * @brief  Tests of lllazy.h.
+ * @brief  Tests of lllogin.cpp.
  * 
  * $LicenseInfo:firstyear=2009&license=internal$
  * Copyright (c) 2009, Linden Research, Inc.
@@ -20,24 +20,29 @@
 // other Linden headers
 #include "llsd.h"
 #include "../../../test/lltut.h"
+//#define DEBUG_ON
+#include "../../../test/debug.h"
 #include "llevents.h"
+#include "stringize.h"
 
 /*****************************************************************************
-*   TUT
+*   Helper classes
 *****************************************************************************/
 // This is a listener to receive results from lllogin.
-class LoginListener
+class LoginListener: public LLEventTrackable
 {
 	std::string mName;
 	LLSD mLastEvent;
+    Debug mDebug;
 public:
 	LoginListener(const std::string& name) : 
-		mName(name)
+		mName(name),
+        mDebug(stringize(*this))
 	{}
 
 	bool call(const LLSD& event)
 	{
-		std::cout << "LoginListener called!: " << event << std::endl;
+		mDebug(STRINGIZE("LoginListener called!: " << event));
 		mLastEvent = event;
 		return false;
 	}
@@ -47,15 +52,21 @@ public:
         return pump.listen(mName, boost::bind(&LoginListener::call, this, _1));
 	}
 
-	const LLSD& lastEvent() { return mLastEvent; }
+	LLSD lastEvent() { return mLastEvent; }
+
+    friend std::ostream& operator<<(std::ostream& out, const LoginListener& listener)
+    {
+        return out << "LoginListener(" << listener.mName << ')';
+    }
 };
 
-class LLAresListener
+class LLAresListener: public LLEventTrackable
 {
 	std::string mName;
 	LLSD mEvent;
 	bool mImmediateResponse;
 	bool mMultipleURIResponse;
+    Debug mDebug;
 	
 public:
 	LLAresListener(const std::string& name, 
@@ -64,12 +75,13 @@ public:
 				   ) : 
 		mName(name),
 		mImmediateResponse(i),
-		mMultipleURIResponse(m)
+		mMultipleURIResponse(m),
+        mDebug(stringize(*this))
 	{}
 
 	bool handle_event(const LLSD& event)
 	{
-		std::cout << "LLAresListener called!: " << event << std::endl;
+		mDebug(STRINGIZE("LLAresListener called!: " << event));
 		mEvent = event;
 		if(mImmediateResponse)
 		{
@@ -96,14 +108,20 @@ public:
     {
         return pump.listen(mName, boost::bind(&LLAresListener::handle_event, this, _1));
 	}
+
+    friend std::ostream& operator<<(std::ostream& out, const LLAresListener& listener)
+    {
+        return out << "LLAresListener(" << listener.mName << ')';
+    }
 };
 
-class LLXMLRPCListener
+class LLXMLRPCListener: public LLEventTrackable
 {
 	std::string mName;
 	LLSD mEvent;
 	bool mImmediateResponse;
 	LLSD mResponse;
+    Debug mDebug;
 
 public:
 	LLXMLRPCListener(const std::string& name, 
@@ -112,7 +130,8 @@ public:
 					 ) : 
 		mName(name),
 		mImmediateResponse(i),
-		mResponse(response)
+		mResponse(response),
+        mDebug(stringize(*this))
 	{
 		if(mResponse.isUndefined())
 		{
@@ -131,7 +150,7 @@ public:
 
 	bool handle_event(const LLSD& event)
 	{
-		std::cout << "LLXMLRPCListener called!: " << event << std::endl;
+		mDebug(STRINGIZE("LLXMLRPCListener called!: " << event));
 		mEvent = event;
 		if(mImmediateResponse)
 		{
@@ -149,8 +168,16 @@ public:
     {
         return pump.listen(mName, boost::bind(&LLXMLRPCListener::handle_event, this, _1));
 	}
+
+    friend std::ostream& operator<<(std::ostream& out, const LLXMLRPCListener& listener)
+    {
+        return out << "LLXMLRPCListener(" << listener.mName << ')';
+    }
 };
 
+/*****************************************************************************
+*   TUT
+*****************************************************************************/
 namespace tut
 {
     struct llviewerlogin_data
@@ -168,6 +195,7 @@ namespace tut
     template<> template<>
     void llviewerlogin_object::test<1>()
     {
+        DEBUG;
 		// Testing login with immediate repsonses from Ares and XMLPRC
 		// The response from both requests will come before the post request exits.
 		// This tests an edge case of the login state handling.
@@ -201,6 +229,7 @@ namespace tut
     template<> template<>
     void llviewerlogin_object::test<2>()
     {
+        DEBUG;
 		// Tests a successful login in with delayed responses. 
 		// Also includes 'failure' that cause the login module
 		// To re-attempt connection, once from a basic failure
@@ -292,6 +321,7 @@ namespace tut
     template<> template<>
     void llviewerlogin_object::test<3>()
     {
+        DEBUG;
 		// Test completed response, that fails to login.
 		set_test_name("LLLogin valid response, failure (eg. bad credentials)");
 
@@ -338,6 +368,7 @@ namespace tut
     template<> template<>
     void llviewerlogin_object::test<4>()
     {
+        DEBUG;
 		// Test incomplete response, that end the attempt.
 		set_test_name("LLLogin valid response, failure (eg. bad credentials)");