1 files changed, 53 insertions, 22 deletions

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index cbd1077306..cc2c130072 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -36,6 +36,7 @@
 
 #include "linden_common.h"
 #include "llerrorcontrol.h"
+#include "llexception.h"
 #include "lltut.h"
 #include "chained_callback.h"
 #include "stringize.h"
@@ -63,11 +64,6 @@
 #pragma warning (pop)
 #endif
 
-#include <boost/scoped_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/foreach.hpp>
-
 #include <fstream>
 
 void wouldHaveCrashed(const std::string& message);
@@ -176,10 +172,6 @@ public:
     LLTestCallback(bool verbose_mode, std::ostream *stream,
                    std::shared_ptr<LLReplayLog> replayer) :
         mVerboseMode(verbose_mode),
-        mTotalTests(0),
-        mPassedTests(0),
-        mFailedTests(0),
-        mSkippedTests(0),
         // By default, capture a shared_ptr to std::cout, with a no-op "deleter"
         // so that destroying the shared_ptr makes no attempt to delete std::cout.
         mStream(std::shared_ptr<std::ostream>(&std::cout, [](std::ostream*){})),
@@ -215,6 +207,8 @@ public:
     virtual void group_started(const std::string& name) {
         LL_INFOS("TestRunner")<<"Unit test group_started name=" << name << LL_ENDL;
         *mStream << "Unit test group_started name=" << name << std::endl;
+        mGroup = name;
+        mGroupTests = 0;
         super::group_started(name);
     }
 
@@ -227,6 +221,7 @@ public:
     virtual void test_completed(const tut::test_result& tr)
     {
         ++mTotalTests;
+        ++mGroupTests;
 
         // If this test failed, dump requested log messages BEFORE stating the
         // test result.
@@ -314,12 +309,15 @@ public:
         super::run_completed();
     }
 
+    std::string mGroup;
+    int mGroupTests{ 0 };
+
 protected:
-    bool mVerboseMode;
-    int mTotalTests;
-    int mPassedTests;
-    int mFailedTests;
-    int mSkippedTests;
+    bool mVerboseMode{ false };
+    int mTotalTests{ 0 };
+    int mPassedTests{ 0 };
+    int mFailedTests{ 0 };
+    int mSkippedTests{ 0 };
     std::shared_ptr<std::ostream> mStream;
     std::shared_ptr<LLReplayLog> mReplayer;
 };
@@ -647,14 +645,47 @@ int main(int argc, char **argv)
     // a chained_callback subclass must be linked with previous
     mycallback->link();
 
-    if(test_group.empty())
-    {
-        tut::runner.get().run_tests();
-    }
-    else
-    {
-        tut::runner.get().run_tests(test_group);
-    }
+    LL::seh::catcher(
+        // __try
+        [test_group]
+        {
+            if(test_group.empty())
+            {
+                tut::runner.get().run_tests();
+            }
+            else
+            {
+                tut::runner.get().run_tests(test_group);
+            }
+        },
+        // __except
+        [mycallback](U32 code, const std::string& /*stacktrace*/)
+        {
+            static std::map<U32, const char*> codes = {
+                { 0xC0000005, "Access Violation" },
+                { 0xC00000FD, "Stack Overflow" },
+                // ... continue filling in as desired
+            };
+
+            auto found{ codes.find(code) };
+            const char* name = ((found == codes.end())? "unknown" : found->second);
+            auto msg{ stringize("test threw ", std::hex, code, " (", name, ")") };
+
+            // Instead of bombing the whole test run, report this as a test
+            // failure. Arguably, catching structured exceptions should be
+            // hacked into TUT itself.
+            mycallback->test_completed(tut::test_result(
+                mycallback->mGroup,
+                mycallback->mGroupTests+1, // test within group
+                "unknown",                 // test name
+                tut::test_result::ex,      // result: exception
+                // we don't have to throw this exception subclass to use it to
+                // populate the test_result struct
+                Windows_SEH_exception(msg)));
+            // we've left the TUT framework -- finish up by hand
+            mycallback->group_completed(mycallback->mGroup);
+            mycallback->run_completed();
+        });
 
     bool success = (mycallback->getFailedTests() == 0);