diff --git a/test/cpp/src/TestClient.cpp b/test/cpp/src/TestClient.cpp
index 1c0254b..7c425a9 100644
--- a/test/cpp/src/TestClient.cpp
+++ b/test/cpp/src/TestClient.cpp
@@ -266,7 +266,12 @@
   uint64_t time_max = 0;
   uint64_t time_tot = 0;
 
-  int failCount = 0;
+  int return_code = 0;
+  int ERR_BASETYPES = 1;
+  int ERR_STRUCTS = 2;
+  int ERR_CONTAINERS = 4;
+  int ERR_EXCEPTIONS = 8;
+
   int test = 0;
   for (test = 0; test < numTests; ++test) {
 
@@ -292,8 +297,9 @@
       testClient.testVoid();
       printf(" = void\n");
     } catch (TApplicationException& tax) {
+      printf("*** FAILED ***\n");
       printf("%s\n", tax.what());
-      failCount++;
+      return_code |= ERR_BASETYPES;
     }
 
     /**
@@ -303,8 +309,10 @@
     string s;
     testClient.testString(s, "Test");
     printf(" = \"%s\"\n", s.c_str());
-    if (s != "Test")
-      failCount++;
+    if (s != "Test") {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * BOOL TEST
@@ -312,14 +320,18 @@
     printf("testBool(true)");
     bool bl = testClient.testBool(true);
     printf(" = %s\n", bl ? "true" : "false");
-    if (bl != true)
-      failCount++;
+    if (bl != true) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     printf("testBool(false)");
     bl = testClient.testBool(false);
     printf(" = %s\n", bl ? "true" : "false");
-    if (bl != false)
-      failCount++;
+    if (bl != false) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * BYTE TEST
@@ -327,8 +339,10 @@
     printf("testByte(1)");
     uint8_t u8 = testClient.testByte(1);
     printf(" = %d\n", (int)u8);
-    if (u8 != 1)
-      failCount++;
+    if (u8 != 1) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * I32 TEST
@@ -336,8 +350,10 @@
     printf("testI32(-1)");
     int32_t i32 = testClient.testI32(-1);
     printf(" = %d\n", i32);
-    if (i32 != -1)
-      failCount++;
+    if (i32 != -1) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * I64 TEST
@@ -345,8 +361,10 @@
     printf("testI64(-34359738368)");
     int64_t i64 = testClient.testI64(-34359738368LL);
     printf(" = %" PRId64 "\n", i64);
-    if (i64 != -34359738368LL)
-      failCount++;
+    if (i64 != -34359738368LL) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * DOUBLE TEST
@@ -354,13 +372,66 @@
     printf("testDouble(-5.2098523)");
     double dub = testClient.testDouble(-5.2098523);
     printf(" = %f\n", dub);
-    if ((dub - (-5.2098523)) > 0.001)
-      failCount++;
+    if ((dub - (-5.2098523)) > 0.001) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_BASETYPES;
+    }
 
     /**
      * BINARY TEST
      */
-    // TODO: add testBinary() call
+    printf("testBinary([-128..127]) = {");
+    const char bin_data[256]
+        = {-128, -127, -126, -125, -124, -123, -122, -121, -120, -119, -118, -117, -116, -115, -114,
+           -113, -112, -111, -110, -109, -108, -107, -106, -105, -104, -103, -102, -101, -100, -99,
+           -98,  -97,  -96,  -95,  -94,  -93,  -92,  -91,  -90,  -89,  -88,  -87,  -86,  -85,  -84,
+           -83,  -82,  -81,  -80,  -79,  -78,  -77,  -76,  -75,  -74,  -73,  -72,  -71,  -70,  -69,
+           -68,  -67,  -66,  -65,  -64,  -63,  -62,  -61,  -60,  -59,  -58,  -57,  -56,  -55,  -54,
+           -53,  -52,  -51,  -50,  -49,  -48,  -47,  -46,  -45,  -44,  -43,  -42,  -41,  -40,  -39,
+           -38,  -37,  -36,  -35,  -34,  -33,  -32,  -31,  -30,  -29,  -28,  -27,  -26,  -25,  -24,
+           -23,  -22,  -21,  -20,  -19,  -18,  -17,  -16,  -15,  -14,  -13,  -12,  -11,  -10,  -9,
+           -8,   -7,   -6,   -5,   -4,   -3,   -2,   -1,   0,    1,    2,    3,    4,    5,    6,
+           7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,   19,   20,   21,
+           22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
+           37,   38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,
+           52,   53,   54,   55,   56,   57,   58,   59,   60,   61,   62,   63,   64,   65,   66,
+           67,   68,   69,   70,   71,   72,   73,   74,   75,   76,   77,   78,   79,   80,   81,
+           82,   83,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,
+           97,   98,   99,   100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+           112,  113,  114,  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,  125,  126,
+           127};
+    try {
+      string bin_result;
+      testClient.testBinary(bin_result, string(bin_data, 256));
+      if (bin_result.size() != 256) {
+        printf("}\n*** FAILED ***\n");
+        printf("invalid length: %lu\n", bin_result.size());
+        return_code |= ERR_BASETYPES;
+      } else {
+        bool first = true;
+        bool failed = false;
+        for (int i = 0; i < 256; ++i) {
+          if (!first)
+            printf(" ,");
+          else
+            first = false;
+          printf("%d", bin_result[i]);
+          if (!failed && bin_result[i] != i - 128) {
+            failed = true;
+          }
+        }
+        printf("}\n");
+        if (failed) {
+          printf("*** FAILED ***\n");
+          return_code |= ERR_BASETYPES;
+        }
+      }
+    } catch (exception& ex) {
+      printf("}\n*** FAILED ***\n");
+      printf("%s\n", ex.what());
+      return_code |= ERR_BASETYPES;
+    }
+
 
     /**
      * STRUCT TEST
@@ -378,8 +449,10 @@
            (int)in.byte_thing,
            in.i32_thing,
            in.i64_thing);
-    if (in != out)
-      failCount++;
+    if (in != out) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     /**
      * NESTED STRUCT TEST
@@ -399,8 +472,10 @@
            in.i32_thing,
            in.i64_thing,
            in2.i32_thing);
-    if (in2 != out2)
-      failCount++;
+    if (in2 != out2) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     /**
      * MAP TEST
@@ -434,13 +509,40 @@
       printf("%d => %d", m_iter->first, m_iter->second);
     }
     printf("}\n");
-    if (mapin != mapout)
-      failCount++;
+    if (mapin != mapout) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_CONTAINERS;
+    }
 
     /**
      * STRING MAP TEST
-     *  missing
      */
+    printf("testStringMap({a => 2, b => blah, some => thing}) = {");
+    map<string, string> smapin;
+    map<string, string> smapout;
+    smapin["a"] = "2";
+    smapin["b"] = "blah";
+    smapin["some"] = "thing";
+    try {
+      testClient.testStringMap(smapout, smapin);
+      first = true;
+      for (map<string, string>::const_iterator it = smapout.begin(); it != smapout.end(); ++it) {
+        if (first)
+          printf(",");
+        else
+          first = false;
+        printf("%s => %s", it->first.c_str(), it->second.c_str());
+      }
+      printf("}\n");
+      if (smapin != smapout) {
+        printf("*** FAILED ***\n");
+        return_code |= ERR_CONTAINERS;
+      }
+    } catch (exception& ex) {
+      printf("}\n*** FAILED ***\n");
+      printf("%s\n", ex.what());
+      return_code |= ERR_CONTAINERS;
+    }
 
     /**
      * SET TEST
@@ -474,8 +576,10 @@
       printf("%d", *s_iter);
     }
     printf("}\n");
-    if (setin != setout)
-      failCount++;
+    if (setin != setout) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_CONTAINERS;
+    }
 
     /**
      * LIST TEST
@@ -509,8 +613,10 @@
       printf("%d", *l_iter);
     }
     printf("}\n");
-    if (listin != listout)
-      failCount++;
+    if (listin != listout) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_CONTAINERS;
+    }
 
     /**
      * ENUM TEST
@@ -518,32 +624,42 @@
     printf("testEnum(ONE)");
     Numberz::type ret = testClient.testEnum(Numberz::ONE);
     printf(" = %d\n", ret);
-    if (ret != Numberz::ONE)
-      failCount++;
+    if (ret != Numberz::ONE) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     printf("testEnum(TWO)");
     ret = testClient.testEnum(Numberz::TWO);
     printf(" = %d\n", ret);
-    if (ret != Numberz::TWO)
-      failCount++;
+    if (ret != Numberz::TWO) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     printf("testEnum(THREE)");
     ret = testClient.testEnum(Numberz::THREE);
     printf(" = %d\n", ret);
-    if (ret != Numberz::THREE)
-      failCount++;
+    if (ret != Numberz::THREE) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     printf("testEnum(FIVE)");
     ret = testClient.testEnum(Numberz::FIVE);
     printf(" = %d\n", ret);
-    if (ret != Numberz::FIVE)
-      failCount++;
+    if (ret != Numberz::FIVE) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     printf("testEnum(EIGHT)");
     ret = testClient.testEnum(Numberz::EIGHT);
     printf(" = %d\n", ret);
-    if (ret != Numberz::EIGHT)
-      failCount++;
+    if (ret != Numberz::EIGHT) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     /**
      * TYPEDEF TEST
@@ -551,8 +667,10 @@
     printf("testTypedef(309858235082523)");
     UserId uid = testClient.testTypedef(309858235082523LL);
     printf(" = %" PRId64 "\n", uid);
-    if (uid != 309858235082523LL)
-      failCount++;
+    if (uid != 309858235082523LL) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
 
     /**
      * NESTED MAP TEST
@@ -571,19 +689,38 @@
       printf("}, ");
     }
     printf("}\n");
+    if (mm.size() != 2 ||
+        mm[-4][-4] != -4 ||
+        mm[-4][-3] != -3 ||
+        mm[-4][-2] != -2 ||
+        mm[-4][-1] != -1 ||
+        mm[4][4] != 4 ||
+        mm[4][3] != 3 ||
+        mm[4][2] != 2 ||
+        mm[4][1] != 1) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_CONTAINERS;
+    }
 
     /**
      * INSANITY TEST
      */
     if (!noinsane) {
       Insanity insane;
-      insane.userMap.insert(make_pair(Numberz::FIVE, 5000));
+      insane.userMap.insert(make_pair(Numberz::FIVE, 5));
+      insane.userMap.insert(make_pair(Numberz::EIGHT, 8));
       Xtruct truck;
-      truck.string_thing = "Truck";
-      truck.byte_thing = 8;
-      truck.i32_thing = 8;
-      truck.i64_thing = 8;
+      truck.string_thing = "Goodbye4";
+      truck.byte_thing = 4;
+      truck.i32_thing = 4;
+      truck.i64_thing = 4;
+      Xtruct truck2;
+      truck2.string_thing = "Hello2";
+      truck2.byte_thing = 2;
+      truck2.i32_thing = 2;
+      truck2.i64_thing = 2;
       insane.xtructs.push_back(truck);
+      insane.xtructs.push_back(truck2);
       printf("testInsanity()");
       map<UserId, map<Numberz::type, Insanity> > whoa;
       testClient.testInsanity(whoa, insane);
@@ -619,14 +756,69 @@
         printf("}, ");
       }
       printf("}\n");
+      bool failed = false;
+      map<UserId, map<Numberz::type, Insanity> >::const_iterator it1 = whoa.find(UserId(1));
+      if (whoa.size() != 2) {
+        failed = true;
+      }
+      if (it1 == whoa.end()) {
+        failed = true;
+      } else {
+        map<Numberz::type, Insanity>::const_iterator it12 = it1->second.find(Numberz::TWO);
+        if (it12 == it1->second.end() || it12->second != insane) {
+          failed = true;
+        }
+        map<Numberz::type, Insanity>::const_iterator it13 = it1->second.find(Numberz::THREE);
+        if (it13 == it1->second.end() || it13->second != insane) {
+          failed = true;
+        }
+      }
+      map<UserId, map<Numberz::type, Insanity> >::const_iterator it2 = whoa.find(UserId(2));
+      if (it2 == whoa.end()) {
+        failed = true;
+      } else {
+        map<Numberz::type, Insanity>::const_iterator it26 = it2->second.find(Numberz::SIX);
+        if (it26 == it1->second.end() || it26->second != Insanity()) {
+          failed = true;
+        }
+      }
+      if (failed) {
+        printf("*** FAILED ***\n");
+        return_code |= ERR_STRUCTS;
+      }
     }
+
+    /**
+     * MULTI TEST
+     */
+    printf("testMulti()\n");
+    try {
+      map<int16_t, string> mul_map;
+      Xtruct mul_result;
+      mul_map[1] = "blah";
+      mul_map[2] = "thing";
+      testClient.testMulti(mul_result, 42, 4242, 424242, mul_map, Numberz::EIGHT, UserId(24));
+      Xtruct xxs;
+      xxs.string_thing = "Hello2";
+      xxs.byte_thing = 42;
+      xxs.i32_thing = 4242;
+      xxs.i64_thing = 424242;
+      if (mul_result != xxs) {
+        printf("*** FAILED ***\n");
+        return_code |= ERR_STRUCTS;
+      }
+    } catch (exception& ex) {
+      printf("*** FAILED ***\n");
+      return_code |= ERR_STRUCTS;
+    }
+
     /* test exception */
 
     try {
       printf("testClient.testException(\"Xception\") =>");
       testClient.testException("Xception");
-      printf("  void\nFAILURE\n");
-      failCount++;
+      printf("  void\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
 
     } catch (Xception& e) {
       printf("  {%u, \"%s\"}\n", e.errorCode, e.message.c_str());
@@ -635,8 +827,8 @@
     try {
       printf("testClient.testException(\"TException\") =>");
       testClient.testException("TException");
-      printf("  void\nFAILURE\n");
-      failCount++;
+      printf("  void\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
 
     } catch (const TException&) {
       printf("  Caught TException\n");
@@ -647,8 +839,8 @@
       testClient.testException("success");
       printf("  void\n");
     } catch (...) {
-      printf("  exception\nFAILURE\n");
-      failCount++;
+      printf("  exception\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
     }
 
     /* test multi exception */
@@ -657,8 +849,8 @@
       printf("testClient.testMultiException(\"Xception\", \"test 1\") =>");
       Xtruct result;
       testClient.testMultiException(result, "Xception", "test 1");
-      printf("  result\nFAILURE\n");
-      failCount++;
+      printf("  result\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
     } catch (Xception& e) {
       printf("  {%u, \"%s\"}\n", e.errorCode, e.message.c_str());
     }
@@ -667,8 +859,8 @@
       printf("testClient.testMultiException(\"Xception2\", \"test 2\") =>");
       Xtruct result;
       testClient.testMultiException(result, "Xception2", "test 2");
-      printf("  result\nFAILURE\n");
-      failCount++;
+      printf("  result\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
 
     } catch (Xception2& e) {
       printf("  {%u, {\"%s\"}}\n", e.errorCode, e.struct_thing.string_thing.c_str());
@@ -680,8 +872,8 @@
       testClient.testMultiException(result, "success", "test 3");
       printf("  {{\"%s\"}}\n", result.string_thing.c_str());
     } catch (...) {
-      printf("  exception\nFAILURE\n");
-      failCount++;
+      printf("  exception\n*** FAILED ***\n");
+      return_code |= ERR_EXCEPTIONS;
     }
 
     /* test oneway void */
@@ -691,8 +883,8 @@
       testClient.testOneway(1);
       uint64_t elapsed = now() - startOneway;
       if (elapsed > 200 * 1000) { // 0.2 seconds
-        printf("  FAILURE - took %.2f ms\n", (double)elapsed / 1000.0);
-        failCount++;
+        printf("*** FAILED *** - took %.2f ms\n", (double)elapsed / 1000.0);
+      return_code |= ERR_BASETYPES;
       } else {
         printf("  success - took %.2f ms\n", (double)elapsed / 1000.0);
       }
@@ -713,7 +905,7 @@
     i32 = testClient.testI32(-1);
     printf(" = %d\n", i32);
     if (i32 != -1)
-      failCount++;
+      return_code |= ERR_BASETYPES;
 
     uint64_t stop = now();
     uint64_t tot = stop - start;
@@ -739,5 +931,5 @@
   printf("Max time: %" PRIu64 " us\n", time_max);
   printf("Avg time: %" PRIu64 " us\n", time_avg);
 
-  return failCount;
+  return return_code;
 }
diff --git a/test/hs/TestClient.hs b/test/hs/TestClient.hs
index 6c25f5b..057a560 100644
--- a/test/hs/TestClient.hs
+++ b/test/hs/TestClient.hs
@@ -26,19 +26,24 @@
 import Data.List.Split
 import Data.String
 import Network
+import Network.URI
 import System.Environment
 import System.Exit
 import System.Posix.Unistd
+import qualified Data.ByteString.Lazy as LBS
 import qualified Data.HashMap.Strict as Map
 import qualified Data.HashSet as Set
 import qualified Data.Vector as Vector
+import qualified System.IO as IO
 
 import ThriftTest_Iface
 import ThriftTest_Types
 import qualified ThriftTest_Client as Client
 
 import Thrift.Transport
+import Thrift.Transport.Framed
 import Thrift.Transport.Handle
+import Thrift.Transport.HttpClient
 import Thrift.Protocol
 import Thrift.Protocol.Binary
 import Thrift.Protocol.Compact
@@ -50,11 +55,34 @@
   , domainSocket :: String
   , transport    :: String
   , protocol     :: ProtocolType
+  -- TODO: Haskell lib does not have SSL support
   , ssl          :: Bool
   , testLoops    :: Int
   }
   deriving (Show, Eq)
 
+data TransportType = Buffered IO.Handle
+                   | Framed (FramedTransport IO.Handle)
+                   | Http HttpClient
+                   | NoTransport String
+
+getTransport :: String -> String -> Int -> (IO TransportType)
+getTransport "buffered" host port = do
+  h <- hOpen (host, PortNumber $ fromIntegral port)
+  IO.hSetBuffering h $ IO.BlockBuffering Nothing
+  return $ Buffered h
+getTransport "framed" host port = do
+  h <- hOpen (host, PortNumber $ fromIntegral port)
+  t <- openFramedTransport h
+  return $ Framed t
+getTransport "http" host port = let uriStr = "http://" ++ host ++ ":" ++ show port in
+                                case parseURI uriStr of
+                                  Nothing -> do return (NoTransport $ "Failed to parse URI: " ++ uriStr)
+                                  Just(uri) -> do
+                                    t <- openHttpClient uri
+                                    return $ Http t
+getTransport t host port = do return (NoTransport $ "Unsupported transport: " ++ t)
+
 data ProtocolType = Binary
                   | Compact
                   | JSON
@@ -71,7 +99,7 @@
   { port         = 9090
   , domainSocket = ""
   , host         = "localhost"
-  , transport    = "framed"
+  , transport    = "buffered"
   , protocol     = Binary
   , ssl          = False
   , testLoops    = 1
@@ -83,29 +111,46 @@
   putStrLn "Starting Tests"
 
   -- VOID Test
+  putStrLn "testVoid"
   Client.testVoid prot
 
   -- String Test
+  putStrLn "testString"
   s <- Client.testString prot "Test"
   when (s /= "Test") exitFailure
 
+  -- Bool Test
+  putStrLn "testBool"
+  bool <- Client.testBool prot True
+  when (not bool) exitFailure
+  putStrLn "testBool"
+  bool <- Client.testBool prot False
+  when (bool) exitFailure
+
   -- Byte Test
+  putStrLn "testByte"
   byte <- Client.testByte prot 1
   when (byte /= 1) exitFailure
 
   -- I32 Test
+  putStrLn "testI32"
   i32 <- Client.testI32 prot (-1)
   when (i32 /= -1) exitFailure
 
   -- I64 Test
+  putStrLn "testI64"
   i64 <- Client.testI64 prot (-34359738368)
   when (i64 /= -34359738368) exitFailure
 
   -- Double Test
+  putStrLn "testDouble"
   dub <- Client.testDouble prot (-5.2098523)
   when (abs (dub + 5.2098523) > 0.001) exitFailure
 
-  -- TODO: call Client.testBinary
+  -- Binary Test
+  putStrLn "testBinary"
+  bin <- Client.testBinary prot (LBS.pack . reverse $ [-128..127])
+  when ((reverse [-128..127]) /= LBS.unpack bin) exitFailure
   
   -- Struct Test
   let structIn = Xtruct{ xtruct_string_thing = "Zero"
@@ -113,6 +158,7 @@
                        , xtruct_i32_thing    = -3
                        , xtruct_i64_thing    = -5
                        }
+  putStrLn "testStruct"
   structOut <- Client.testStruct prot structIn
   when (structIn /= structOut) exitFailure
 
@@ -121,68 +167,83 @@
                       , xtruct2_struct_thing = structIn
                       , xtruct2_i32_thing    = 5
                       }
+  putStrLn "testNest"
   nestOut <- Client.testNest prot nestIn
   when (nestIn /= nestOut) exitSuccess
 
   -- Map Test
   let mapIn = Map.fromList $ map (\i -> (i, i-10)) [1..5]
+  putStrLn "testMap"
   mapOut <- Client.testMap prot mapIn
   when (mapIn /= mapOut) exitSuccess
 
   -- Set Test
   let setIn = Set.fromList [-2..3]
+  putStrLn "testSet"
   setOut <- Client.testSet prot setIn
   when (setIn /= setOut) exitFailure
 
   -- List Test
   let listIn = Vector.fromList [-2..3]
+  putStrLn "testList"
   listOut <- Client.testList prot listIn
   when (listIn /= listOut) exitFailure
 
   -- Enum Test
+  putStrLn "testEnum"
   numz1 <- Client.testEnum prot ONE
   when (numz1 /= ONE) exitFailure
 
+  putStrLn "testEnum"
   numz2 <- Client.testEnum prot TWO
   when (numz2 /= TWO) exitFailure
 
+  putStrLn "testEnum"
   numz5 <- Client.testEnum prot FIVE
   when (numz5 /= FIVE) exitFailure
 
   -- Typedef Test
+  putStrLn "testTypedef"
   uid <- Client.testTypedef prot 309858235082523
   when (uid /= 309858235082523) exitFailure
 
   -- Nested Map Test
+  putStrLn "testMapMap"
   _ <- Client.testMapMap prot 1
 
   -- Exception Test
+  putStrLn "testException"
   exn1 <- try $ Client.testException prot "Xception"
   case exn1 of
     Left (Xception _ _) -> return ()
     _ -> putStrLn (show exn1) >> exitFailure
 
+  putStrLn "testException"
   exn2 <- try $ Client.testException prot "TException"
   case exn2 of
     Left (_ :: SomeException) -> return ()
     Right _ -> exitFailure
 
+  putStrLn "testException"
   exn3 <- try $ Client.testException prot "success"
   case exn3 of
     Left (_ :: SomeException) -> exitFailure
     Right _ -> return ()
 
   -- Multi Exception Test
+  putStrLn "testMultiException"
   multi1 <- try $ Client.testMultiException prot "Xception" "test 1"
   case multi1 of
     Left (Xception _ _) -> return ()
     _ -> exitFailure
 
+  putStrLn "testMultiException"
   multi2 <- try $ Client.testMultiException prot "Xception2" "test 2"
   case multi2 of
     Left (Xception2 _ _) -> return ()
     _ -> exitFailure
 
+  putStrLn "testMultiException"
   multi3 <- try $ Client.testMultiException prot "success" "test 3"
   case multi3 of
     Left (_ :: SomeException) -> exitFailure
@@ -195,12 +256,20 @@
   case options of
     Nothing -> showHelp
     Just Options{..} -> do
-      handle <- hOpen (host, PortNumber $ fromIntegral port)
-      let client = case protocol of
-            Binary  -> runClient $ BinaryProtocol handle
-            Compact -> runClient $ CompactProtocol handle
-            JSON    -> runClient $ JSONProtocol handle
-      replicateM_ testLoops client
+      trans <- Main.getTransport transport host port
+      case trans of
+        Buffered t -> runTest testLoops protocol t
+        Framed t   -> runTest testLoops protocol t
+        Http t     -> runTest testLoops protocol t
+        NoTransport err -> putStrLn err
+  where
+    makeClient p t = case p of
+                       Binary  -> runClient $ BinaryProtocol t
+                       Compact -> runClient $ CompactProtocol t
+                       JSON    -> runClient $ JSONProtocol t
+    runTest loops p t = do
+      let client = makeClient p t
+      replicateM_ loops client
       putStrLn "COMPLETED SUCCESSFULLY"
 
 parseFlags :: [String] -> Options -> Maybe Options
@@ -228,7 +297,7 @@
   \  --port arg (=9090)          Port number to connect\n\
   \  --domain-socket arg         Domain Socket (e.g. /tmp/ThriftTest.thrift),\n\
   \                              instead of host and port\n\
-  \  --transport arg (=buffered) Transport: buffered, framed, http, evhttp\n\
+  \  --transport arg (=buffered) Transport: buffered, framed, http\n\
   \  --protocol arg (=binary)    Protocol: binary, compact, json\n\
   \  --ssl                       Encrypted Transport using SSL\n\
-  \  -n [ --testloops ] arg (=1) Number of Tests"
\ No newline at end of file
+  \  -n [ --testloops ] arg (=1) Number of Tests"
diff --git a/test/hs/TestServer.hs b/test/hs/TestServer.hs
index fb80cf8..a880a5e 100755
--- a/test/hs/TestServer.hs
+++ b/test/hs/TestServer.hs
@@ -32,6 +32,7 @@
 import System.Exit
 import System.IO
 import System.Posix.Unistd
+import qualified System.IO as IO
 import qualified Data.HashMap.Strict as Map
 import qualified Data.HashSet as Set
 import qualified Data.Text.Lazy as Text
@@ -72,6 +73,20 @@
   fromString "nonblocking" = NonBlocking
   fromString _ = error "not a valid server type"
 
+data TransportType = Buffered (Socket -> (IO IO.Handle))
+                   | Framed (Socket -> (IO (FramedTransport IO.Handle)))
+                   | NoTransport String
+
+getTransport :: String -> TransportType
+getTransport "buffered" = Buffered $ \s -> do
+  (h, _, _) <- (accept s)
+  IO.hSetBuffering h $ IO.BlockBuffering Nothing
+  return h
+getTransport "framed" = Framed $ \s -> do
+  (h, _, _) <- (accept s)
+  openFramedTransport h
+getTransport t = NoTransport $ "Unsupported transport: " ++ t
+
 data ProtocolType = Binary
                   | Compact
                   | JSON
@@ -87,8 +102,9 @@
   { port         = 9090
   , domainSocket = ""
   , serverType   = Threaded
-  , transport    = "framed"
+  , transport    = "buffered"
   , protocol     = Binary
+  -- TODO: Haskell lib does not have SSL support
   , ssl          = False
   , workers      = 4
   }
@@ -234,17 +250,24 @@
   case options of
     Nothing -> showHelp
     Just Options{..} -> do
+      case Main.getTransport transport of
+        Buffered f -> runServer protocol f port
+        Framed   f -> runServer protocol f port
+        NoTransport err -> putStrLn err
       System.IO.putStrLn $ "Starting \"" ++ show serverType ++ "\" server (" ++
         show transport ++ ") listen on: " ++ domainSocket ++ show port
-      case protocol of
-        Binary  -> runServer BinaryProtocol port
-        Compact -> runServer CompactProtocol port
-        JSON    -> runServer JSONProtocol port
       where
-        runServer p = runThreadedServer (accepter p) TestHandler ThriftTest.process . PortNumber . fromIntegral
-        accepter p s = do
-          (h, _, _) <- accept s
-          return (p h, p h)
+        acceptor p f socket = do
+          t <- f socket
+          return (p t, p t)
+
+        doRunServer p f = do
+          runThreadedServer (acceptor p f) TestHandler ThriftTest.process . PortNumber . fromIntegral
+
+        runServer p f port = case p of
+          Binary  -> do doRunServer BinaryProtocol f port
+          Compact -> do doRunServer CompactProtocol f port
+          JSON    -> do doRunServer JSONProtocol f port
 
 parseFlags :: [String] -> Options -> Maybe Options
 parseFlags (flag : flags) opts = do
@@ -272,9 +295,9 @@
   \  --domain-socket arg         Unix Domain Socket (e.g. /tmp/ThriftTest.thrift)\n\
   \  --server-type arg (=simple) type of server, \"simple\", \"thread-pool\",\n\
   \                              \"threaded\", or \"nonblocking\"\n\
-  \  --transport arg (=buffered) transport: buffered, framed, http\n\
+  \  --transport arg (=buffered) transport: buffered, framed\n\
   \  --protocol arg (=binary)    protocol: binary, compact, json\n\
   \  --ssl                       Encrypted Transport using SSL\n\
   \  --processor-events          processor-events\n\
   \  -n [ --workers ] arg (=4)   Number of thread pools workers. Only valid for\n\
-  \                              thread-pool server type"
\ No newline at end of file
+  \                              thread-pool server type"
diff --git a/test/known_failures_Linux.json b/test/known_failures_Linux.json
index bf05f93..ee12ebf 100644
--- a/test/known_failures_Linux.json
+++ b/test/known_failures_Linux.json
@@ -1,6 +1,9 @@
 [
+  "c_glib-cpp_binary_buffered-ip",
+  "c_glib-cpp_binary_framed-ip",
   "c_glib-csharp_binary_buffered-ip",
   "c_glib-csharp_binary_framed-ip",
+  "c_glib-hs_binary_buffered-ip",
   "c_glib-hs_binary_framed-ip",
   "c_glib-nodejs_binary_buffered-ip",
   "c_glib-nodejs_binary_framed-ip",
@@ -12,11 +15,8 @@
   "c_glib-rb_binary-accel_framed-ip",
   "c_glib-rb_binary_buffered-ip",
   "c_glib-rb_binary_framed-ip",
-  "cpp-cpp_binary_http-domain",
   "cpp-cpp_binary_http-ip",
   "cpp-cpp_compact_http-domain",
-  "cpp-cpp_compact_http-ip",
-  "cpp-cpp_json_http-domain",
   "cpp-cpp_json_http-ip",
   "cpp-csharp_binary_buffered-ip-ssl",
   "cpp-csharp_binary_framed-ip-ssl",
@@ -24,27 +24,9 @@
   "cpp-csharp_compact_framed-ip-ssl",
   "cpp-csharp_json_buffered-ip-ssl",
   "cpp-csharp_json_framed-ip-ssl",
-  "cpp-hs_binary_buffered-ip-ssl",
-  "cpp-hs_binary_framed-ip",
-  "cpp-hs_binary_framed-ip-ssl",
-  "cpp-hs_binary_http-evhttp-ip",
-  "cpp-hs_binary_http-evhttp-ip-ssl",
-  "cpp-hs_binary_http-ip",
-  "cpp-hs_binary_http-ip-ssl",
-  "cpp-hs_compact_buffered-ip-ssl",
-  "cpp-hs_compact_framed-ip",
-  "cpp-hs_compact_framed-ip-ssl",
-  "cpp-hs_compact_http-evhttp-ip",
-  "cpp-hs_compact_http-evhttp-ip-ssl",
-  "cpp-hs_compact_http-ip",
-  "cpp-hs_compact_http-ip-ssl",
-  "cpp-hs_json_buffered-ip-ssl",
+  "cpp-hs_json_buffered-ip",
   "cpp-hs_json_framed-ip",
-  "cpp-hs_json_framed-ip-ssl",
-  "cpp-hs_json_http-evhttp-ip",
-  "cpp-hs_json_http-evhttp-ip-ssl",
   "cpp-hs_json_http-ip",
-  "cpp-hs_json_http-ip-ssl",
   "cpp-java_binary_http-ip",
   "cpp-java_binary_http-ip-ssl",
   "cpp-java_compact_http-ip",
@@ -92,17 +74,11 @@
   "csharp-go_json_framed-ip",
   "csharp-go_json_framed-ip-ssl",
   "csharp-hs_binary_buffered-ip",
-  "csharp-hs_binary_buffered-ip-ssl",
   "csharp-hs_binary_framed-ip",
-  "csharp-hs_binary_framed-ip-ssl",
   "csharp-hs_compact_buffered-ip",
-  "csharp-hs_compact_buffered-ip-ssl",
   "csharp-hs_compact_framed-ip",
-  "csharp-hs_compact_framed-ip-ssl",
   "csharp-hs_json_buffered-ip",
-  "csharp-hs_json_buffered-ip-ssl",
   "csharp-hs_json_framed-ip",
-  "csharp-hs_json_framed-ip-ssl",
   "csharp-java_binary_buffered-ip",
   "csharp-java_binary_buffered-ip-ssl",
   "csharp-java_binary_framed-fastframed-ip",
@@ -151,21 +127,18 @@
   "csharp-rb_json_framed-ip",
   "go-c_glib_binary_buffered-ip",
   "go-c_glib_binary_framed-ip",
+  "go-cpp_json_buffered-ip",
+  "go-cpp_json_buffered-ip-ssl",
+  "go-cpp_json_framed-ip",
+  "go-cpp_json_framed-ip-ssl",
   "go-csharp_binary_buffered-ip-ssl",
   "go-csharp_binary_framed-ip-ssl",
   "go-csharp_compact_buffered-ip-ssl",
   "go-csharp_compact_framed-ip-ssl",
   "go-csharp_json_buffered-ip-ssl",
   "go-csharp_json_framed-ip-ssl",
-  "go-hs_binary_buffered-ip-ssl",
-  "go-hs_binary_framed-ip",
-  "go-hs_binary_framed-ip-ssl",
-  "go-hs_compact_buffered-ip-ssl",
-  "go-hs_compact_framed-ip",
-  "go-hs_compact_framed-ip-ssl",
-  "go-hs_json_buffered-ip-ssl",
+  "go-hs_json_buffered-ip",
   "go-hs_json_framed-ip",
-  "go-hs_json_framed-ip-ssl",
   "go-nodejs_binary_buffered-ip",
   "go-nodejs_binary_buffered-ip-ssl",
   "go-nodejs_binary_framed-ip",
@@ -182,111 +155,26 @@
   "go-perl_binary_framed-ip-ssl",
   "go-rb_json_buffered-ip",
   "go-rb_json_framed-ip",
-  "hs-c_glib_binary_buffered-ip",
-  "hs-c_glib_binary_framed-ip",
-  "hs-cpp_binary_buffered-ip-ssl",
-  "hs-cpp_binary_evhttp-http-ip",
-  "hs-cpp_binary_evhttp-http-ip-ssl",
-  "hs-cpp_binary_framed-ip",
-  "hs-cpp_binary_framed-ip-ssl",
-  "hs-cpp_binary_http-ip",
-  "hs-cpp_binary_http-ip-ssl",
-  "hs-cpp_compact_buffered-ip-ssl",
-  "hs-cpp_compact_evhttp-http-ip",
-  "hs-cpp_compact_evhttp-http-ip-ssl",
-  "hs-cpp_compact_framed-ip",
-  "hs-cpp_compact_framed-ip-ssl",
-  "hs-cpp_compact_http-ip",
-  "hs-cpp_compact_http-ip-ssl",
   "hs-cpp_json_buffered-ip",
-  "hs-cpp_json_buffered-ip-ssl",
-  "hs-cpp_json_evhttp-http-ip",
-  "hs-cpp_json_evhttp-http-ip-ssl",
   "hs-cpp_json_framed-ip",
-  "hs-cpp_json_framed-ip-ssl",
-  "hs-cpp_json_http-ip",
-  "hs-cpp_json_http-ip-ssl",
-  "hs-csharp_binary_buffered-ip",
-  "hs-csharp_binary_buffered-ip-ssl",
   "hs-csharp_binary_framed-ip",
-  "hs-csharp_binary_framed-ip-ssl",
-  "hs-csharp_compact_buffered-ip",
-  "hs-csharp_compact_buffered-ip-ssl",
   "hs-csharp_compact_framed-ip",
-  "hs-csharp_compact_framed-ip-ssl",
   "hs-csharp_json_buffered-ip",
-  "hs-csharp_json_buffered-ip-ssl",
   "hs-csharp_json_framed-ip",
-  "hs-csharp_json_framed-ip-ssl",
   "hs-go_binary_buffered-ip",
-  "hs-go_binary_buffered-ip-ssl",
   "hs-go_binary_framed-ip",
-  "hs-go_binary_framed-ip-ssl",
   "hs-go_compact_buffered-ip",
-  "hs-go_compact_buffered-ip-ssl",
   "hs-go_compact_framed-ip",
-  "hs-go_compact_framed-ip-ssl",
   "hs-go_json_buffered-ip",
-  "hs-go_json_buffered-ip-ssl",
   "hs-go_json_framed-ip",
-  "hs-go_json_framed-ip-ssl",
-  "hs-java_binary_buffered-ip-ssl",
-  "hs-java_binary_evhttp-http-ip",
-  "hs-java_binary_evhttp-http-ip-ssl",
-  "hs-java_binary_framed-fastframed-ip",
-  "hs-java_binary_framed-fastframed-ip-ssl",
-  "hs-java_binary_framed-ip",
-  "hs-java_binary_framed-ip-ssl",
-  "hs-java_binary_http-ip",
-  "hs-java_binary_http-ip-ssl",
-  "hs-java_compact_buffered-ip-ssl",
-  "hs-java_compact_evhttp-http-ip",
-  "hs-java_compact_evhttp-http-ip-ssl",
-  "hs-java_compact_framed-fastframed-ip",
-  "hs-java_compact_framed-fastframed-ip-ssl",
-  "hs-java_compact_framed-ip",
-  "hs-java_compact_framed-ip-ssl",
-  "hs-java_compact_http-ip",
-  "hs-java_compact_http-ip-ssl",
-  "hs-java_json_buffered-ip-ssl",
-  "hs-java_json_evhttp-http-ip",
-  "hs-java_json_evhttp-http-ip-ssl",
-  "hs-java_json_framed-fastframed-ip",
-  "hs-java_json_framed-fastframed-ip-ssl",
-  "hs-java_json_framed-ip",
-  "hs-java_json_framed-ip-ssl",
-  "hs-java_json_http-ip",
-  "hs-java_json_http-ip-ssl",
   "hs-nodejs_binary_buffered-ip",
-  "hs-nodejs_binary_buffered-ip-ssl",
   "hs-nodejs_binary_framed-ip",
-  "hs-nodejs_binary_framed-ip-ssl",
   "hs-nodejs_compact_buffered-ip",
-  "hs-nodejs_compact_buffered-ip-ssl",
   "hs-nodejs_compact_framed-ip",
-  "hs-nodejs_compact_framed-ip-ssl",
   "hs-nodejs_json_buffered-ip",
-  "hs-nodejs_json_buffered-ip-ssl",
   "hs-nodejs_json_framed-ip",
-  "hs-nodejs_json_framed-ip-ssl",
-  "hs-php_binary_framed-ip",
-  "hs-php_compact_framed-ip",
-  "hs-py_binary-accel_buffered-ip-ssl",
-  "hs-py_binary-accel_framed-ip",
-  "hs-py_binary-accel_framed-ip-ssl",
-  "hs-py_binary_buffered-ip-ssl",
-  "hs-py_binary_framed-ip",
-  "hs-py_binary_framed-ip-ssl",
-  "hs-py_compact_buffered-ip-ssl",
-  "hs-py_compact_framed-ip",
-  "hs-py_compact_framed-ip-ssl",
   "hs-py_json_buffered-ip",
-  "hs-py_json_buffered-ip-ssl",
   "hs-py_json_framed-ip",
-  "hs-py_json_framed-ip-ssl",
-  "hs-rb_binary-accel_framed-ip",
-  "hs-rb_binary_framed-ip",
-  "hs-rb_compact_framed-ip",
   "hs-rb_json_buffered-ip",
   "hs-rb_json_framed-ip",
   "java-csharp_binary_buffered-ip-ssl",
@@ -298,26 +186,28 @@
   "java-csharp_json_buffered-ip-ssl",
   "java-csharp_json_fastframed-framed-ip-ssl",
   "java-csharp_json_framed-ip-ssl",
-  "java-hs_binary_buffered-ip-ssl",
-  "java-hs_binary_fastframed-framed-ip",
-  "java-hs_binary_fastframed-framed-ip-ssl",
-  "java-hs_binary_framed-ip",
-  "java-hs_binary_framed-ip-ssl",
-  "java-hs_compact_buffered-ip-ssl",
-  "java-hs_compact_fastframed-framed-ip",
-  "java-hs_compact_fastframed-framed-ip-ssl",
-  "java-hs_compact_framed-ip",
-  "java-hs_compact_framed-ip-ssl",
-  "java-hs_json_buffered-ip-ssl",
+  "java-hs_json_buffered-ip",
   "java-hs_json_fastframed-framed-ip",
-  "java-hs_json_fastframed-framed-ip-ssl",
   "java-hs_json_framed-ip",
-  "java-hs_json_framed-ip-ssl",
   "java-nodejs_json_buffered-ip",
   "java-nodejs_json_buffered-ip-ssl",
   "java-rb_json_buffered-ip",
   "java-rb_json_fastframed-framed-ip",
   "java-rb_json_framed-ip",
+  "nodejs-c_glib_binary_buffered-ip",
+  "nodejs-c_glib_binary_framed-ip",
+  "nodejs-cpp_binary_buffered-ip",
+  "nodejs-cpp_binary_buffered-ip-ssl",
+  "nodejs-cpp_binary_framed-ip",
+  "nodejs-cpp_binary_framed-ip-ssl",
+  "nodejs-cpp_compact_buffered-ip",
+  "nodejs-cpp_compact_buffered-ip-ssl",
+  "nodejs-cpp_compact_framed-ip",
+  "nodejs-cpp_compact_framed-ip-ssl",
+  "nodejs-cpp_json_buffered-ip",
+  "nodejs-cpp_json_buffered-ip-ssl",
+  "nodejs-cpp_json_framed-ip",
+  "nodejs-cpp_json_framed-ip-ssl",
   "nodejs-csharp_binary_buffered-ip",
   "nodejs-csharp_binary_buffered-ip-ssl",
   "nodejs-csharp_binary_framed-ip",
@@ -330,17 +220,25 @@
   "nodejs-csharp_json_buffered-ip-ssl",
   "nodejs-csharp_json_framed-ip",
   "nodejs-csharp_json_framed-ip-ssl",
-  "nodejs-hs_binary_buffered-ip-ssl",
+  "nodejs-hs_binary_buffered-ip",
   "nodejs-hs_binary_framed-ip",
-  "nodejs-hs_binary_framed-ip-ssl",
-  "nodejs-hs_compact_buffered-ip-ssl",
+  "nodejs-hs_compact_buffered-ip",
   "nodejs-hs_compact_framed-ip",
-  "nodejs-hs_compact_framed-ip-ssl",
   "nodejs-hs_json_buffered-ip",
-  "nodejs-hs_json_buffered-ip-ssl",
   "nodejs-hs_json_framed-ip",
-  "nodejs-hs_json_framed-ip-ssl",
   "nodejs-java_json_buffered-ip-ssl",
+  "nodejs-py_binary-accel_buffered-ip",
+  "nodejs-py_binary-accel_buffered-ip-ssl",
+  "nodejs-py_binary-accel_framed-ip",
+  "nodejs-py_binary-accel_framed-ip-ssl",
+  "nodejs-py_binary_buffered-ip",
+  "nodejs-py_binary_buffered-ip-ssl",
+  "nodejs-py_binary_framed-ip",
+  "nodejs-py_binary_framed-ip-ssl",
+  "nodejs-py_compact_buffered-ip",
+  "nodejs-py_compact_buffered-ip-ssl",
+  "nodejs-py_compact_framed-ip",
+  "nodejs-py_compact_framed-ip-ssl",
   "nodejs-py_json_buffered-ip",
   "nodejs-py_json_buffered-ip-ssl",
   "nodejs-py_json_framed-ip",
@@ -354,116 +252,20 @@
   "nodejs-rb_json_buffered-ip",
   "nodejs-rb_json_framed-ip",
   "perl-php_binary_framed-ip",
-  "py-c_glib_accel-binary_buffered-ip",
-  "py-c_glib_accel-binary_framed-ip",
-  "py-c_glib_binary_buffered-ip",
-  "py-c_glib_binary_framed-ip",
-  "py-cpp_accel-binary_buffered-ip",
-  "py-cpp_accel-binary_buffered-ip-ssl",
-  "py-cpp_accel-binary_framed-ip",
-  "py-cpp_accel-binary_framed-ip-ssl",
-  "py-cpp_binary_buffered-ip",
-  "py-cpp_binary_buffered-ip-ssl",
-  "py-cpp_binary_framed-ip",
-  "py-cpp_binary_framed-ip-ssl",
-  "py-cpp_compact_buffered-ip",
-  "py-cpp_compact_buffered-ip-ssl",
-  "py-cpp_compact_framed-ip",
-  "py-cpp_compact_framed-ip-ssl",
-  "py-cpp_json_buffered-ip",
-  "py-cpp_json_buffered-ip-ssl",
-  "py-cpp_json_framed-ip",
-  "py-cpp_json_framed-ip-ssl",
-  "py-csharp_accel-binary_buffered-ip",
   "py-csharp_accel-binary_buffered-ip-ssl",
-  "py-csharp_accel-binary_framed-ip",
   "py-csharp_accel-binary_framed-ip-ssl",
-  "py-csharp_binary_buffered-ip",
   "py-csharp_binary_buffered-ip-ssl",
-  "py-csharp_binary_framed-ip",
   "py-csharp_binary_framed-ip-ssl",
-  "py-csharp_compact_buffered-ip",
   "py-csharp_compact_buffered-ip-ssl",
-  "py-csharp_compact_framed-ip",
   "py-csharp_compact_framed-ip-ssl",
-  "py-csharp_json_buffered-ip",
   "py-csharp_json_buffered-ip-ssl",
-  "py-csharp_json_framed-ip",
   "py-csharp_json_framed-ip-ssl",
-  "py-go_accel-binary_buffered-ip",
-  "py-go_accel-binary_buffered-ip-ssl",
-  "py-go_accel-binary_framed-ip",
-  "py-go_accel-binary_framed-ip-ssl",
-  "py-go_binary_buffered-ip",
-  "py-go_binary_buffered-ip-ssl",
-  "py-go_binary_framed-ip",
-  "py-go_binary_framed-ip-ssl",
-  "py-go_compact_buffered-ip",
-  "py-go_compact_buffered-ip-ssl",
-  "py-go_compact_framed-ip",
-  "py-go_compact_framed-ip-ssl",
-  "py-go_json_buffered-ip",
-  "py-go_json_buffered-ip-ssl",
-  "py-go_json_framed-ip",
-  "py-go_json_framed-ip-ssl",
-  "py-hs_accel-binary_buffered-ip",
-  "py-hs_accel-binary_buffered-ip-ssl",
-  "py-hs_accel-binary_framed-ip",
-  "py-hs_accel-binary_framed-ip-ssl",
-  "py-hs_binary_buffered-ip",
-  "py-hs_binary_buffered-ip-ssl",
-  "py-hs_binary_framed-ip",
-  "py-hs_binary_framed-ip-ssl",
-  "py-hs_compact_buffered-ip",
-  "py-hs_compact_buffered-ip-ssl",
-  "py-hs_compact_framed-ip",
-  "py-hs_compact_framed-ip-ssl",
   "py-hs_json_buffered-ip",
-  "py-hs_json_buffered-ip-ssl",
   "py-hs_json_framed-ip",
-  "py-hs_json_framed-ip-ssl",
-  "py-java_accel-binary_buffered-ip",
-  "py-java_accel-binary_buffered-ip-ssl",
-  "py-java_accel-binary_framed-fastframed-ip",
-  "py-java_accel-binary_framed-fastframed-ip-ssl",
-  "py-java_accel-binary_framed-ip",
-  "py-java_accel-binary_framed-ip-ssl",
-  "py-java_binary_buffered-ip",
-  "py-java_binary_buffered-ip-ssl",
-  "py-java_binary_framed-fastframed-ip",
-  "py-java_binary_framed-fastframed-ip-ssl",
-  "py-java_binary_framed-ip",
-  "py-java_binary_framed-ip-ssl",
-  "py-java_compact_buffered-ip",
-  "py-java_compact_buffered-ip-ssl",
-  "py-java_compact_framed-fastframed-ip",
-  "py-java_compact_framed-fastframed-ip-ssl",
-  "py-java_compact_framed-ip",
-  "py-java_compact_framed-ip-ssl",
-  "py-java_json_buffered-ip",
-  "py-java_json_buffered-ip-ssl",
-  "py-java_json_framed-fastframed-ip",
-  "py-java_json_framed-fastframed-ip-ssl",
-  "py-java_json_framed-ip",
-  "py-java_json_framed-ip-ssl",
-  "py-nodejs_accel-binary_buffered-ip",
-  "py-nodejs_accel-binary_buffered-ip-ssl",
-  "py-nodejs_accel-binary_framed-ip",
-  "py-nodejs_accel-binary_framed-ip-ssl",
-  "py-nodejs_binary_buffered-ip",
-  "py-nodejs_binary_buffered-ip-ssl",
-  "py-nodejs_binary_framed-ip",
-  "py-nodejs_binary_framed-ip-ssl",
-  "py-nodejs_compact_buffered-ip",
-  "py-nodejs_compact_buffered-ip-ssl",
-  "py-nodejs_compact_framed-ip",
-  "py-nodejs_compact_framed-ip-ssl",
   "py-nodejs_json_buffered-ip",
   "py-nodejs_json_buffered-ip-ssl",
   "py-nodejs_json_framed-ip",
   "py-nodejs_json_framed-ip-ssl",
-  "py-php_json_buffered-ip",
-  "py-php_json_framed-ip",
   "py-rb_accel-binary_buffered-ip",
   "py-rb_accel-binary_framed-ip",
   "py-rb_accel_buffered-ip",
@@ -480,11 +282,11 @@
   "rb-c_glib_accel-binary_framed-ip",
   "rb-c_glib_binary_buffered-ip",
   "rb-c_glib_binary_framed-ip",
+  "rb-cpp_json_buffered-ip",
+  "rb-cpp_json_framed-ip",
   "rb-csharp_json_buffered-ip",
   "rb-csharp_json_framed-ip",
-  "rb-hs_accel-binary_framed-ip",
-  "rb-hs_binary_framed-ip",
-  "rb-hs_compact_framed-ip",
+  "rb-hs_json_buffered-ip",
   "rb-hs_json_framed-ip",
   "rb-nodejs_json_buffered-ip",
   "rb-nodejs_json_framed-ip",
diff --git a/test/perl/TestClient.pl b/test/perl/TestClient.pl
index 40f8f59..9d4aab2 100755
--- a/test/perl/TestClient.pl
+++ b/test/perl/TestClient.pl
@@ -136,11 +136,11 @@
 # BOOL TEST
 #
 print("testBool(1)");
-my $u8 = $testClient->testBool(1);
-print(" = $u8\n");
+my $t = $testClient->testBool(1);
+print(" = $t\n");
 print("testBool(0)");
-my $u8 = $testClient->testBool(0);
-print(" = $u8\n");
+my $f = $testClient->testBool(0);
+print(" = $f\n");
 
 
 #
@@ -321,11 +321,17 @@
 my $insane = new ThriftTest::Insanity();
 $insane->{userMap}->{ThriftTest::Numberz::FIVE} = 5000;
 my $truck = new ThriftTest::Xtruct();
-$truck->string_thing("Truck");
-$truck->byte_thing(8);
-$truck->i32_thing(8);
-$truck->i64_thing(8);
+$truck->string_thing("Hello2");
+$truck->byte_thing(2);
+$truck->i32_thing(2);
+$truck->i64_thing(2);
+my $truck2 = new ThriftTest::Xtruct();
+$truck2->string_thing("Goodbye4");
+$truck2->byte_thing(4);
+$truck2->i32_thing(4);
+$truck2->i64_thing(4);
 push(@{$insane->{xtructs}}, $truck);
+push(@{$insane->{xtructs}}, $truck2);
 
 print("testInsanity()");
 my $whoa = $testClient->testInsanity($insane);
diff --git a/test/perl/TestServer.pl b/test/perl/TestServer.pl
index eebebc8..5bfa640 100644
--- a/test/perl/TestServer.pl
+++ b/test/perl/TestServer.pl
@@ -328,8 +328,8 @@
   my @goodbyes;
   push(@goodbyes, $goodbye);
   my $crazy = new ThriftTest::Insanity({userMap => { ThriftTest::Numberz::EIGHT => 8 }, xtructs => \@goodbyes});
-  my $loony = new ThriftTest::Insanity({userMap => { ThriftTest::Numberz::FIVE  => 5 }, xtructs => \@hellos});
-  my $result = { 1 => { ThriftTest::Numberz::TWO => $crazy, ThriftTest::Numberz::THREE => $crazy },
+  my $loony = new ThriftTest::Insanity();
+  my $result = { 1 => { ThriftTest::Numberz::TWO => $argument, ThriftTest::Numberz::THREE => $argument },
                  2 => { ThriftTest::Numberz::SIX => $loony } };
   return $result;
 }
diff --git a/test/py/TestClient.py b/test/py/TestClient.py
index 592a541..51111a6 100755
--- a/test/py/TestClient.py
+++ b/test/py/TestClient.py
@@ -19,11 +19,11 @@
 # under the License.
 #
 
-import sys, glob, os
-sys.path.insert(0, glob.glob(os.path.join(os.path.dirname(__file__),'../../lib/py/build/lib.*'))[0])
-
-import unittest
+import glob
+import os
+import sys
 import time
+import unittest
 from optparse import OptionParser
 
 parser = OptionParser()
@@ -53,8 +53,10 @@
 parser.set_defaults(framed=False, http_path=None, verbose=1, host='localhost', port=9090, proto='binary')
 options, args = parser.parse_args()
 
-script_dir = os.path.dirname(__file__)
+script_dir = os.path.abspath(os.path.dirname(__file__))
+lib_dir = os.path.join(os.path.dirname(os.path.dirname(script_dir)), 'lib', 'py', 'build', 'lib.*')
 sys.path.insert(0, os.path.join(script_dir, options.genpydir))
+sys.path.insert(0, glob.glob(lib_dir)[0])
 
 from ThriftTest import ThriftTest, SecondService
 from ThriftTest.ttypes import *
@@ -66,6 +68,7 @@
 from thrift.protocol import TCompactProtocol
 from thrift.protocol import TJSONProtocol
 
+
 class AbstractTest(unittest.TestCase):
   def setUp(self):
     if options.http_path:
@@ -95,36 +98,49 @@
     self.transport.close()
 
   def testVoid(self):
+    print('testVoid')
     self.client.testVoid()
 
   def testString(self):
+    print('testString')
     self.assertEqual(self.client.testString('Python' * 20), 'Python' * 20)
     self.assertEqual(self.client.testString(''), '')
 
   def testBool(self):
+    print('testBool')
     self.assertEqual(self.client.testBool(True), True)
     self.assertEqual(self.client.testBool(False), False)
 
   def testByte(self):
+    print('testByte')
     self.assertEqual(self.client.testByte(63), 63)
     self.assertEqual(self.client.testByte(-127), -127)
 
   def testI32(self):
+    print('testI32')
     self.assertEqual(self.client.testI32(-1), -1)
     self.assertEqual(self.client.testI32(0), 0)
 
   def testI64(self):
+    print('testI64')
     self.assertEqual(self.client.testI64(1), 1)
     self.assertEqual(self.client.testI64(-34359738368), -34359738368)
 
   def testDouble(self):
+    print('testDouble')
     self.assertEqual(self.client.testDouble(-5.235098235), -5.235098235)
     self.assertEqual(self.client.testDouble(0), 0)
     self.assertEqual(self.client.testDouble(-1), -1)
 
-  # TODO: def testBinary(self)	...
-	
+  def testBinary(self):
+    if isinstance(self, JSONTest):
+      self.skipTest('JSON protocol does not handle binary correctly.')
+    print('testBinary')
+    val = bytearray([i for i in range(0, 256)])
+    self.assertEqual(bytearray(self.client.testBinary(bytes(val))), val)
+
   def testStruct(self):
+    print('testStruct')
     x = Xtruct()
     x.string_thing = "Zero"
     x.byte_thing = 1
@@ -134,23 +150,26 @@
     self.assertEqual(y, x)
 
   def testNest(self):
-    inner = Xtruct(string_thing="Zero", byte_thing=1, i32_thing=-3,
-      i64_thing=-5)
+    print('testNest')
+    inner = Xtruct(string_thing="Zero", byte_thing=1, i32_thing=-3, i64_thing=-5)
     x = Xtruct2(struct_thing=inner, byte_thing=0, i32_thing=0)
     y = self.client.testNest(x)
     self.assertEqual(y, x)
 
   def testMap(self):
+    print('testMap')
     x = {0:1, 1:2, 2:3, 3:4, -1:-2}
     y = self.client.testMap(x)
     self.assertEqual(y, x)
 
   def testSet(self):
+    print('testSet')
     x = set([8, 1, 42])
     y = self.client.testSet(x)
     self.assertEqual(y, x)
 
   def testList(self):
+    print('testList')
     x = [1, 4, 9, -42]
     y = self.client.testList(x)
     self.assertEqual(y, x)
diff --git a/test/py/TestServer.py b/test/py/TestServer.py
index 89b74da..b5696ca 100755
--- a/test/py/TestServer.py
+++ b/test/py/TestServer.py
@@ -19,10 +19,16 @@
 # under the License.
 #
 from __future__ import division
-import sys, glob, time, os
-sys.path.insert(0, glob.glob(os.path.join(os.path.dirname(__file__),'../../lib/py/build/lib.*'))[0])
+import glob
+import logging
+import os
+import sys
+import time
 from optparse import OptionParser
 
+# Print TServer log to stdout so that the test-runner can redirect it to log files
+logging.basicConfig()
+
 parser = OptionParser()
 parser.add_option('--genpydir', type='string', dest='genpydir',
                   default='gen-py',
@@ -46,8 +52,11 @@
 parser.set_defaults(port=9090, verbose=1, proto='binary')
 options, args = parser.parse_args()
 
-script_dir = os.path.dirname(__file__) #<-- absolute dir the script is in
+script_dir = os.path.realpath(os.path.dirname(__file__))  # <-- absolute dir the script is in
+lib_dir = os.path.join(os.path.dirname(os.path.dirname(script_dir)), 'lib', 'py', 'build', 'lib.*')
+
 sys.path.insert(0, os.path.join(script_dir, options.genpydir))
+sys.path.insert(0, glob.glob(lib_dir)[0])
 
 from ThriftTest import ThriftTest
 from ThriftTest.ttypes import *
@@ -60,65 +69,67 @@
 from thrift.protocol import TJSONProtocol
 from thrift.server import TServer, TNonblockingServer, THttpServer
 
-PROT_FACTORIES = {'binary': TBinaryProtocol.TBinaryProtocolFactory,
+PROT_FACTORIES = {
+    'binary': TBinaryProtocol.TBinaryProtocolFactory,
     'accel': TBinaryProtocol.TBinaryProtocolAcceleratedFactory,
     'compact': TCompactProtocol.TCompactProtocolFactory,
-    'json': TJSONProtocol.TJSONProtocolFactory}
+    'json': TJSONProtocol.TJSONProtocolFactory,
+}
 
-class TestHandler:
 
+class TestHandler(object):
   def testVoid(self):
     if options.verbose > 1:
-      print 'testVoid()'
+      print('testVoid()')
 
   def testString(self, str):
     if options.verbose > 1:
-      print 'testString(%s)' % str
+      print('testString(%s)' % str)
     return str
 
   def testBool(self, boolean):
     if options.verbose > 1:
-      print 'testBool(%s)' % str(boolean).lower()
+      print('testBool(%s)' % str(boolean).lower())
     return boolean
 
   def testByte(self, byte):
     if options.verbose > 1:
-      print 'testByte(%d)' % byte
+      print('testByte(%d)' % byte)
     return byte
 
   def testI16(self, i16):
     if options.verbose > 1:
-      print 'testI16(%d)' % i16
+      print('testI16(%d)' % i16)
     return i16
 
   def testI32(self, i32):
     if options.verbose > 1:
-      print 'testI32(%d)' % i32
+      print('testI32(%d)' % i32)
     return i32
 
   def testI64(self, i64):
     if options.verbose > 1:
-      print 'testI64(%d)' % i64
+      print('testI64(%d)' % i64)
     return i64
 
   def testDouble(self, dub):
     if options.verbose > 1:
-      print 'testDouble(%f)' % dub
+      print('testDouble(%f)' % dub)
     return dub
 
   def testBinary(self, thing):
     if options.verbose > 1:
-      print 'testBinary()' # TODO: hex output
-    return thring
-	
+      print('testBinary()')  # TODO: hex output
+    return thing
+
   def testStruct(self, thing):
     if options.verbose > 1:
-      print 'testStruct({%s, %d, %d, %d})' % (thing.string_thing, thing.byte_thing, thing.i32_thing, thing.i64_thing)
+      print('testStruct({%s, %d, %d, %d})' % (thing.string_thing, thing.byte_thing, thing.i32_thing, thing.i64_thing))
     return thing
 
   def testException(self, arg):
-    #if options.verbose > 1:
-    print 'testException(%s)' % arg
+    # if options.verbose > 1:
+    print('testException(%s)' % arg)
     if arg == 'Xception':
       raise Xception(errorCode=1001, message=arg)
     elif arg == 'TException':
@@ -126,7 +137,7 @@
 
   def testMultiException(self, arg0, arg1):
     if options.verbose > 1:
-      print 'testMultiException(%s, %s)' % (arg0, arg1)
+      print('testMultiException(%s, %s)' % (arg0, arg1))
     if arg0 == 'Xception':
       raise Xception(errorCode=1001, message='This is an Xception')
     elif arg0 == 'Xception2':
@@ -137,54 +148,78 @@
 
   def testOneway(self, seconds):
     if options.verbose > 1:
-      print 'testOneway(%d) => sleeping...' % seconds
-    time.sleep(seconds / 3) # be quick
+      print('testOneway(%d) => sleeping...' % seconds)
+    time.sleep(seconds / 3)  # be quick
     if options.verbose > 1:
-      print 'done sleeping'
+      print('done sleeping')
 
   def testNest(self, thing):
     if options.verbose > 1:
-      print 'testNest(%s)' % thing
+      print('testNest(%s)' % thing)
     return thing
 
   def testMap(self, thing):
     if options.verbose > 1:
-      print 'testMap(%s)' % thing
+      print('testMap(%s)' % thing)
+    return thing
+
+  def testStringMap(self, thing):
+    if options.verbose > 1:
+      print('testStringMap(%s)' % thing)
     return thing
 
   def testSet(self, thing):
     if options.verbose > 1:
-      print 'testSet(%s)' % thing
+      print('testSet(%s)' % thing)
     return thing
 
   def testList(self, thing):
     if options.verbose > 1:
-      print 'testList(%s)' % thing
+      print('testList(%s)' % thing)
     return thing
 
   def testEnum(self, thing):
     if options.verbose > 1:
-      print 'testEnum(%s)' % thing
+      print('testEnum(%s)' % thing)
     return thing
 
   def testTypedef(self, thing):
     if options.verbose > 1:
-      print 'testTypedef(%s)' % thing
+      print('testTypedef(%s)' % thing)
     return thing
 
   def testMapMap(self, thing):
     if options.verbose > 1:
-      print 'testMapMap(%s)' % thing
-    return {thing: {thing: thing}}
+      print('testMapMap(%s)' % thing)
+    return {
+      -4: {
+        -4: -4,
+        -3: -3,
+        -2: -2,
+        -1: -1,
+      },
+      4: {
+        4: 4,
+        3: 3,
+        2: 2,
+        1: 1,
+      },
+    }
 
   def testInsanity(self, argument):
     if options.verbose > 1:
-      print 'testInsanity(%s)' % argument
-    return {123489: {Numberz.ONE:argument}}
+      print('testInsanity(%s)' % argument)
+    return {
+      1: {
+        2: argument,
+        3: argument,
+      },
+      2: {6: Insanity()},
+    }
 
   def testMulti(self, arg0, arg1, arg2, arg3, arg4, arg5):
     if options.verbose > 1:
-      print 'testMulti(%s)' % [arg0, arg1, arg2, arg3, arg4, arg5]
+      print('testMulti(%s)' % [arg0, arg1, arg2, arg3, arg4, arg5])
     return Xtruct(string_thing='Hello2',
                   byte_thing=arg0, i32_thing=arg1, i64_thing=arg2)
 
@@ -212,8 +247,7 @@
 
 # set up server transport and transport factory
 
-rel_path = "../keys/server.pem"
-abs_key_path = os.path.join(script_dir, rel_path)
+abs_key_path = os.path.join(os.path.dirname(script_dir), 'keys', 'server.pem')
 
 host = None
 if options.ssl:
@@ -243,14 +277,15 @@
   from thrift.server import TProcessPoolServer
   server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory)
   server.setNumWorkers(5)
+
   def set_alarm():
     def clean_shutdown(signum, frame):
       for worker in server.workers:
         if options.verbose > 0:
-          print 'Terminating worker: %s' % worker
+          print('Terminating worker: %s' % worker)
         worker.terminate()
       if options.verbose > 0:
-        print 'Requesting server to stop()'
+        print('Requesting server to stop()')
       try:
         server.stop()
       except:
diff --git a/test/rebuild_known_failures.sh b/test/rebuild_known_failures.sh
new file mode 100644
index 0000000..08869fe
--- /dev/null
+++ b/test/rebuild_known_failures.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [ -z $1 ]; then
+  echo Usage: $0 LANGUAGE
+  echo Re-list all failures of a specific LANGUAGE into known_failures_Linux.json
+  echo LANGUAGE should be library name like cpp, java, py etc
+  exit 1
+fi
+
+if [ -z $PYTHON]; then
+  PYTHON=python
+fi
+
+TARGET_LANG=$1
+OUT_FILE=known_failures_Linux.json
+echo Rebuilding known failures for $TARGET_LANG
+
+TMPFILE=.__tmp__rebuild__
+grep -v -e "\"$1-" -e "\-$1_" $OUT_FILE > $TMPFILE
+mv $TMPFILE $OUT_FILE
+$PYTHON test.py --client $1
+$PYTHON test.py -U merge
+$PYTHON test.py --server $1
+$PYTHON test.py -U merge
diff --git a/test/tests.json b/test/tests.json
index d7caccb..cb2f0e2 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -145,19 +145,19 @@
     },
     "client": {
       "timeout": 6,
+      "transports": [
+        "http"
+      ],
       "command": [
         "TestClient"
       ]
     },
     "transports": [
       "buffered",
-      "framed",
-      "http",
-      "http:evhttp"
+      "framed"
     ],
     "sockets": [
-      "ip",
-      "ip-ssl"
+      "ip"
     ],
     "protocols": [
       "compact",
@@ -173,6 +173,7 @@
       "extra_args": ["TSimpleServer"],
       "command": [
         "TestServer.py",
+        "--verbose",
         "--genpydir=gen-py"
       ]
     },