more information if unit test fails

2 files changed, 188 insertions, 165 deletions

diff --git a/slobrok/src/tests/multi/multi.cpp b/slobrok/src/tests/multi/multi.cpp
index 9a8a7eb41e0..21245c0c57b 100644
--- a/slobrok/src/tests/multi/multi.cpp
+++ b/slobrok/src/tests/multi/multi.cpp
@@ -63,26 +63,26 @@ TEST("multi") {
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("frt.rpc.ping");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(!req->IsError());
 
     // lookup '*' on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // check managed servers on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.internal.listManagedRpcServers");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     Server a("A", 18518);
 
@@ -92,51 +92,51 @@ TEST("multi") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18518");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(!req->IsError());
 
     // lookup '*' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
 
     // lookup 'A' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
 
     // lookup 'B' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("B");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // lookup '*/*' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*/*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     {
         Server b("B", 18519);
@@ -147,7 +147,7 @@ TEST("multi") {
         req->GetParams()->AddString("C");
         req->GetParams()->AddString("tcp/localhost:18519");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(req->IsError());
+        EXPECT_TRUE(req->IsError());
 
         // register server B
         req = orb.AllocRPCRequest(req);
@@ -155,7 +155,7 @@ TEST("multi") {
         req->GetParams()->AddString("B");
         req->GetParams()->AddString("tcp/localhost:18519");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
+        EXPECT_TRUE(!req->IsError());
 
         {
             Server a2("A", 18520);
@@ -166,7 +166,7 @@ TEST("multi") {
             req->GetParams()->AddString("A");
             req->GetParams()->AddString("tcp/localhost:18520");
             sb->InvokeSync(req, 5.0);
-            ASSERT_TRUE(req->IsError());
+            EXPECT_TRUE(req->IsError());
         }
 
         // lookup '*' should give 'AB | BA'
@@ -174,23 +174,23 @@ TEST("multi") {
         req->SetMethodName("slobrok.lookupRpcServer");
         req->GetParams()->AddString("*");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
-        ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-        ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 2);
-        ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 2);
+        EXPECT_TRUE(!req->IsError());
+        EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+        EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 2);
+        EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 2);
         {
             FRT_StringValue *name = req->GetReturn()->GetValue(0)._string_array._pt;
             FRT_StringValue *spec = req->GetReturn()->GetValue(1)._string_array._pt;
             if (strcmp(name[0]._str, "A") == 0) {
-                ASSERT_TRUE(strcmp(name[0]._str, "A") == 0);
-                ASSERT_TRUE(strcmp(name[1]._str, "B") == 0);
-                ASSERT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18518") == 0);
-                ASSERT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18519") == 0);
+                EXPECT_TRUE(strcmp(name[0]._str, "A") == 0);
+                EXPECT_TRUE(strcmp(name[1]._str, "B") == 0);
+                EXPECT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18518") == 0);
+                EXPECT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18519") == 0);
             } else {
-                ASSERT_TRUE(strcmp(name[1]._str, "A") == 0);
-                ASSERT_TRUE(strcmp(name[0]._str, "B") == 0);
-                ASSERT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18518") == 0);
-                ASSERT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18519") == 0);
+                EXPECT_TRUE(strcmp(name[1]._str, "A") == 0);
+                EXPECT_TRUE(strcmp(name[0]._str, "B") == 0);
+                EXPECT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18518") == 0);
+                EXPECT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18519") == 0);
             }
         }
     }
@@ -202,10 +202,10 @@ TEST("multi") {
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("B");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // unregister server A (wrong spec)
     req = orb.AllocRPCRequest(req);
@@ -213,19 +213,19 @@ TEST("multi") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18519");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(req->IsError());
+    EXPECT_TRUE(req->IsError());
 
     // lookup 'A' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18518") == 0);
 
     // unregister server A
     req = orb.AllocRPCRequest(req);
@@ -233,27 +233,27 @@ TEST("multi") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18518");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(!req->IsError());
 
     // lookup 'A' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // lookup '*' on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(!req->IsError());
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // unregister server A on empty slobrok
     req = orb.AllocRPCRequest(req);
@@ -261,7 +261,7 @@ TEST("multi") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18518");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(!req->IsError());
 
 
     FRT_Target     *sb1  = orb.GetTarget(18512);
@@ -277,7 +277,7 @@ TEST("multi") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18518");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(!req->IsError());
 
 
     Server c("C", 18521);
@@ -290,7 +290,7 @@ TEST("multi") {
         req->GetParams()->AddString("C");
         req->GetParams()->AddString("tcp/localhost:18521");
         sb1->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
+        EXPECT_TRUE(!req->IsError());
 
         // register server D
         req = orb.AllocRPCRequest(req);
@@ -298,55 +298,55 @@ TEST("multi") {
         req->GetParams()->AddString("D");
         req->GetParams()->AddString("tcp/localhost:18522");
         sb2->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
+        EXPECT_TRUE(!req->IsError());
 
 	// lookup 'C' should give 'C'
 	req = orb.AllocRPCRequest(req);
 	req->SetMethodName("slobrok.lookupRpcServer");
 	req->GetParams()->AddString("C");
 	sb3->InvokeSync(req, 5.0);
-	ASSERT_TRUE(!req->IsError());
-	ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-	ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-	ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
+	EXPECT_TRUE(!req->IsError());
+	EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+	EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+	EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
 
 	// lookup 'C' should give 'C'
 	req = orb.AllocRPCRequest(req);
 	req->SetMethodName("slobrok.lookupRpcServer");
 	req->GetParams()->AddString("C");
 	sb4->InvokeSync(req, 5.0);
-	ASSERT_TRUE(!req->IsError());
-	ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-	ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-	ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
+	EXPECT_TRUE(!req->IsError());
+	EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+	EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+	EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
 
 	// lookup 'C' should give 'C'
 	req = orb.AllocRPCRequest(req);
 	req->SetMethodName("slobrok.lookupRpcServer");
 	req->GetParams()->AddString("C");
 	sb5->InvokeSync(req, 5.0);
-	ASSERT_TRUE(!req->IsError());
-	ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-	ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-	ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
+	EXPECT_TRUE(!req->IsError());
+	EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+	EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+	EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
 
 	// lookup 'C' should give 'C'
 	req = orb.AllocRPCRequest(req);
 	req->SetMethodName("slobrok.lookupRpcServer");
 	req->GetParams()->AddString("C");
 	sb6->InvokeSync(req, 5.0);
-	ASSERT_TRUE(!req->IsError());
-	ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-	ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-	ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
+	EXPECT_TRUE(!req->IsError());
+	EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+	EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+	EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "C") == 0);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18521") == 0);
 
         FastOS_Thread::Sleep(200);
 
@@ -355,12 +355,12 @@ TEST("multi") {
 	req->SetMethodName("slobrok.lookupRpcServer");
 	req->GetParams()->AddString("D");
 	sb->InvokeSync(req, 5.0);
-	ASSERT_TRUE(!req->IsError());
-	ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-	ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-	ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "D") == 0);
-	ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18522") == 0);
+	EXPECT_TRUE(!req->IsError());
+	EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+	EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+	EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "D") == 0);
+	EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18522") == 0);
     }
 
     orb.ShutDown(true);
diff --git a/slobrok/src/tests/standalone/standalone.cpp b/slobrok/src/tests/standalone/standalone.cpp
index feeec4f508f..55081d1e0a2 100644
--- a/slobrok/src/tests/standalone/standalone.cpp
+++ b/slobrok/src/tests/standalone/standalone.cpp
@@ -52,6 +52,29 @@ Server::~Server()
     _orb.ShutDown(true);
 }
 
+namespace {
+
+bool checkOk(FRT_RPCRequest *req)
+{
+    if (req == NULL) {
+        fprintf(stderr, "req is null pointer, this is bad");
+        return false;
+    }
+    if (req->IsError()) {
+        fprintf(stderr, "req FAILED [code %d]: %s\n",
+                req->GetErrorCode(),
+                req->GetErrorMessage());
+        fprintf(stderr, "req method is: '%s' with params:\n", req->GetMethodName());
+        req->GetParams()->Print();
+        fflush(stdout);
+        return false;
+    } else {
+        return true;
+    }
+}
+
+} // namespace <unnamed>
+
 //-----------------------------------------------------------------------------
 
 TEST("standalone") {
@@ -68,26 +91,26 @@ TEST("standalone") {
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("frt.rpc.ping");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(checkOk(req));
 
     // lookup '*' on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // check managed servers on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.internal.listManagedRpcServers");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     Server a("A", 18542);
 
@@ -97,51 +120,51 @@ TEST("standalone") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18542");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(checkOk(req));
 
     // lookup '*' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
 
     // lookup 'A' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
 
     // lookup 'B' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("B");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // lookup '*/*' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*/*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     {
         Server b("B", 18543);
@@ -152,7 +175,7 @@ TEST("standalone") {
         req->GetParams()->AddString("C");
         req->GetParams()->AddString("tcp/localhost:18543");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(req->IsError());
+        EXPECT_TRUE(!checkOk(req));
 
         // register server B
         req = orb.AllocRPCRequest(req);
@@ -160,7 +183,7 @@ TEST("standalone") {
         req->GetParams()->AddString("B");
         req->GetParams()->AddString("tcp/localhost:18543");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
+        EXPECT_TRUE(checkOk(req));
 
         {
             Server a2("A", 18544);
@@ -171,7 +194,7 @@ TEST("standalone") {
             req->GetParams()->AddString("A");
             req->GetParams()->AddString("tcp/localhost:18544");
             sb->InvokeSync(req, 5.0);
-            ASSERT_TRUE(req->IsError());
+            EXPECT_TRUE(!checkOk(req));
         }
 
         // lookup '*' should give 'AB | BA'
@@ -179,23 +202,23 @@ TEST("standalone") {
         req->SetMethodName("slobrok.lookupRpcServer");
         req->GetParams()->AddString("*");
         sb->InvokeSync(req, 5.0);
-        ASSERT_TRUE(!req->IsError());
-        ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-        ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 2);
-        ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 2);
+        EXPECT_TRUE(checkOk(req));
+        EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+        EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 2);
+        EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 2);
         {
             FRT_StringValue *name = req->GetReturn()->GetValue(0)._string_array._pt;
             FRT_StringValue *spec = req->GetReturn()->GetValue(1)._string_array._pt;
             if (strcmp(name[0]._str, "A") == 0) {
-                ASSERT_TRUE(strcmp(name[0]._str, "A") == 0);
-                ASSERT_TRUE(strcmp(name[1]._str, "B") == 0);
-                ASSERT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18542") == 0);
-                ASSERT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18543") == 0);
+                EXPECT_TRUE(strcmp(name[0]._str, "A") == 0);
+                EXPECT_TRUE(strcmp(name[1]._str, "B") == 0);
+                EXPECT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18542") == 0);
+                EXPECT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18543") == 0);
             } else {
-                ASSERT_TRUE(strcmp(name[1]._str, "A") == 0);
-                ASSERT_TRUE(strcmp(name[0]._str, "B") == 0);
-                ASSERT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18542") == 0);
-                ASSERT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18543") == 0);
+                EXPECT_TRUE(strcmp(name[1]._str, "A") == 0);
+                EXPECT_TRUE(strcmp(name[0]._str, "B") == 0);
+                EXPECT_TRUE(strcmp(spec[1]._str, "tcp/localhost:18542") == 0);
+                EXPECT_TRUE(strcmp(spec[0]._str, "tcp/localhost:18543") == 0);
             }
         }
     }
@@ -207,10 +230,10 @@ TEST("standalone") {
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("B");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // unregister server A (wrong spec)
     req = orb.AllocRPCRequest(req);
@@ -218,19 +241,19 @@ TEST("standalone") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18543");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(req->IsError());
+    EXPECT_TRUE(!checkOk(req));
 
     // lookup 'A' should give 'A'
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
-    ASSERT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 1);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 1);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(0)._string_array._pt[0]._str, "A") == 0);
+    EXPECT_TRUE(strcmp(req->GetReturn()->GetValue(1)._string_array._pt[0]._str, "tcp/localhost:18542") == 0);
 
     // unregister server A
     req = orb.AllocRPCRequest(req);
@@ -238,27 +261,27 @@ TEST("standalone") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18542");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(checkOk(req));
 
     // lookup 'A' should give ''
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("A");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // lookup '*' on empty slobrok
     req = orb.AllocRPCRequest(req);
     req->SetMethodName("slobrok.lookupRpcServer");
     req->GetParams()->AddString("*");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
-    ASSERT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
-    ASSERT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
+    EXPECT_TRUE(checkOk(req));
+    EXPECT_TRUE(strcmp(req->GetReturnSpec(), "SS") == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(0)._string_array._len == 0);
+    EXPECT_TRUE(req->GetReturn()->GetValue(1)._string_array._len == 0);
 
     // unregister server A on empty slobrok
     req = orb.AllocRPCRequest(req);
@@ -266,7 +289,7 @@ TEST("standalone") {
     req->GetParams()->AddString("A");
     req->GetParams()->AddString("tcp/localhost:18542");
     sb->InvokeSync(req, 5.0);
-    ASSERT_TRUE(!req->IsError());
+    EXPECT_TRUE(checkOk(req));
 
     sb->SubRef();
     req->SubRef();