diff --git a/.gitignore b/.gitignore
index 2a03973..a81f27b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,6 +33,13 @@ build/
 # IntelliJ
 .idea/
 
+# Qt-Creator (assuming a project called "redox")
+redox.config
+redox.creaor
+redox.files
+redox.includes
+redox.creator.user
+
 # Todo file
 TODO.md
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6b081b6..4b474cb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -144,7 +144,7 @@ if (examples)
 
   add_executable(binary_data_publish examples/binary_data_publish.cpp)
   target_link_libraries(binary_data_publish redox)
-  
+
   add_executable(pub_sub examples/pub_sub.cpp)
   target_link_libraries(pub_sub redox)
 
@@ -204,7 +204,7 @@ set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 set(CPACK_PACKAGE_VERSION_MAJOR "${REDOX_VERSION_MAJOR}")
 set(CPACK_PACKAGE_VERSION_MINOR "${REDOX_VERSION_MINOR}")
 set(CPACK_PACKAGE_VERSION_PATCH "${REDOX_VERSION_PATCH}")
-set(CPACK_PACKAGE_VERSION_RELEASE "1") # Increase this if a failed build was published
+set(CPACK_PACKAGE_VERSION_RELEASE "1.1") # Increase this if a failed build was published
 set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}-${CPACK_PACKAGE_VERSION_RELEASE}")
 set(CPACK_SYSTEM_NAME "${ARCHITECTURE}")
 set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}.${ARCHITECTURE}")
diff --git a/include/redox/client.hpp b/include/redox/client.hpp
index 12a95bc..9e23af8 100644
--- a/include/redox/client.hpp
+++ b/include/redox/client.hpp
@@ -31,6 +31,7 @@
 #include <string>
 #include <queue>
 #include <set>
+#include <map>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -372,6 +373,8 @@ class Redox {
   std::unordered_map<long, Command<long long int> *> commands_long_long_int_;
   std::unordered_map<long, Command<std::nullptr_t> *> commands_null_;
   std::unordered_map<long, Command<std::vector<std::string>> *> commands_vector_string_;
+  std::unordered_map<long, Command<std::map<std::string,std::string>> *> commands_map_string_;
+  std::unordered_map<long, Command<std::vector<std::map<std::string,std::string>>> *> commands_vectormap_string_;
   std::unordered_map<long, Command<std::set<std::string>> *> commands_set_string_;
   std::unordered_map<long, Command<std::unordered_set<std::string>> *>
       commands_unordered_set_string_;
@@ -390,7 +393,7 @@ class Redox {
   template <class ReplyT> friend void Command<ReplyT>::free();
 
   // Access to call disconnectedCallback
-  template <class ReplyT> friend void Command<ReplyT>::processReply(redisReply *r);
+  template <class ReplyT> friend void Command<ReplyT>::processReply(redisReply *r, const std::string& errorMessage);
 };
 
 // ------------------------------------------------
@@ -408,7 +411,7 @@ Command<ReplyT> &Redox::createCommand(const std::vector<std::string> &cmd,
     }
   }
 
-  auto *c = new Command<ReplyT>(this, commands_created_.fetch_add(1), cmd, 
+  auto *c = new Command<ReplyT>(this, commands_created_.fetch_add(1), cmd,
                                 callback, repeat, after, free_memory, logger_);
 
   std::lock_guard<std::mutex> lg(queue_guard_);
diff --git a/include/redox/command.hpp b/include/redox/command.hpp
index 69b44c4..b7c6f84 100644
--- a/include/redox/command.hpp
+++ b/include/redox/command.hpp
@@ -105,7 +105,7 @@ template <class ReplyT> class Command {
           bool free_memory, log::Logger &logger);
 
   // Handles a new reply from the server
-  void processReply(redisReply *r);
+  void processReply(redisReply *r, const std::string& errorMessage = std::string());
 
   // Invoke a user callback from the reply object. This method is specialized
   // for each ReplyT of Command.
diff --git a/include/redox/subscriber.hpp b/include/redox/subscriber.hpp
index 63a89f4..fa8d00d 100644
--- a/include/redox/subscriber.hpp
+++ b/include/redox/subscriber.hpp
@@ -46,7 +46,7 @@ class Subscriber {
   * Same as .connect() on a Redox instance.
   */
   bool connect(const std::string &host = REDIS_DEFAULT_HOST, const int port = REDIS_DEFAULT_PORT,
-               std::function<void(int)> connection_callback = nullptr) {
+               const std::function<void(int)> &connection_callback = nullptr) {
     return rdx_.connect(host, port, connection_callback);
   }
 
@@ -54,7 +54,7 @@ class Subscriber {
   * Same as .connectUnix() on a Redox instance.
   */
   bool connectUnix(const std::string &path = REDIS_DEFAULT_PATH,
-                   std::function<void(int)> connection_callback = nullptr) {
+                   const std::function<void(int)> &connection_callback = nullptr) {
     return rdx_.connectUnix(path, connection_callback);
   }
 
@@ -80,11 +80,11 @@ class Subscriber {
   * sub_callback: invoked when successfully subscribed
   * err_callback: invoked on some error state
   */
-  void subscribe(const std::string topic,
-                 std::function<void(const std::string &, const std::string &)> msg_callback,
-                 std::function<void(const std::string &)> sub_callback = nullptr,
-                 std::function<void(const std::string &)> unsub_callback = nullptr,
-                 std::function<void(const std::string &, int)> err_callback = nullptr);
+  void subscribe(const std::string& topic,
+                 const std::function<void(const std::string &, const std::string &)> &msg_callback,
+                 const std::function<void(const std::string &)> &sub_callback = nullptr,
+                 const std::function<void(const std::string &)> &unsub_callback = nullptr,
+                 const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   /**
   * Subscribe to a topic with a pattern.
@@ -93,27 +93,27 @@ class Subscriber {
   * sub_callback: invoked when successfully subscribed
   * err_callback: invoked on some error state
   */
-  void psubscribe(const std::string topic,
-                  std::function<void(const std::string &, const std::string &)> msg_callback,
-                  std::function<void(const std::string &)> sub_callback = nullptr,
-                  std::function<void(const std::string &)> unsub_callback = nullptr,
-                  std::function<void(const std::string &, int)> err_callback = nullptr);
+  void psubscribe(const std::string& topic,
+                  const std::function<void(const std::string &, const std::string &)> &msg_callback,
+                  const std::function<void(const std::string &)> &sub_callback = nullptr,
+                  const std::function<void(const std::string &)> &unsub_callback = nullptr,
+                  const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   /**
   * Unsubscribe from a topic.
   *
   * err_callback: invoked on some error state
   */
-  void unsubscribe(const std::string topic,
-                   std::function<void(const std::string &, int)> err_callback = nullptr);
+  void unsubscribe(const std::string& topic,
+                   const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   /**
   * Unsubscribe from a topic with a pattern.
   *
   * err_callback: invoked on some error state
   */
-  void punsubscribe(const std::string topic,
-                    std::function<void(const std::string &, int)> err_callback = nullptr);
+  void punsubscribe(const std::string& topic,
+                    const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   /**
   * Return the topics that are subscribed() to.
@@ -133,15 +133,15 @@ class Subscriber {
 
 private:
   // Base for subscribe and psubscribe
-  void subscribeBase(const std::string cmd_name, const std::string topic,
-                     std::function<void(const std::string &, const std::string &)> msg_callback,
-                     std::function<void(const std::string &)> sub_callback = nullptr,
-                     std::function<void(const std::string &)> unsub_callback = nullptr,
-                     std::function<void(const std::string &, int)> err_callback = nullptr);
+  void subscribeBase(const std::string &cmd_name, const std::string &topic,
+                     const std::function<void(const std::string &, const std::string &)> &msg_callback,
+                     const std::function<void(const std::string &)> &sub_callback = nullptr,
+                     const std::function<void(const std::string &)> &unsub_callback = nullptr,
+                     const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   // Base for unsubscribe and punsubscribe
-  void unsubscribeBase(const std::string cmd_name, const std::string topic,
-                       std::function<void(const std::string &, int)> err_callback = nullptr);
+  void unsubscribeBase(const std::string &cmd_name, const std::string &topic,
+                       const std::function<void(const std::string &, int)> &err_callback = nullptr);
 
   // Underlying Redis client
   Redox rdx_;
diff --git a/src/client.cpp b/src/client.cpp
index 4401035..00b3a7a 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -365,17 +365,27 @@ template <class ReplyT> Command<ReplyT> *Redox::findCommand(long id) {
 template <class ReplyT>
 void Redox::commandCallback(redisAsyncContext *ctx, void *r, void *privdata) {
 
-  Redox *rdx = (Redox *)ctx->data;
-  long id = (long)privdata;
-  redisReply *reply_obj = (redisReply *)r;
+  Redox *rdx = reinterpret_cast<Redox*>(ctx->data);
+  if (rdx == nullptr) {
+    return;
+  }
 
+  redisReply *reply_obj = reinterpret_cast<redisReply*>(r);
+
+  long id = (long)privdata;
   Command<ReplyT> *c = rdx->findCommand<ReplyT>(id);
   if (c == nullptr) {
-    freeReplyObject(reply_obj);
+    if (reply_obj != nullptr) {
+      freeReplyObject(reply_obj);
+    }
     return;
   }
 
-  c->processReply(reply_obj);
+  if (ctx->err) {
+    c->processReply(nullptr, std::string(ctx->errstr));
+  } else {
+    c->processReply(reply_obj);
+  }
 }
 
 template <class ReplyT> bool Redox::submitToServer(Command<ReplyT> *c) {
@@ -460,6 +470,8 @@ void Redox::processQueuedCommands(struct ev_loop *loop, ev_async *async, int rev
     } else if (rdx->processQueuedCommand<nullptr_t>(id)) {
     } else if (rdx->processQueuedCommand<vector<string>>(id)) {
     } else if (rdx->processQueuedCommand<std::set<string>>(id)) {
+    } else if (rdx->processQueuedCommand<map<string,string>>(id)) {
+    } else if (rdx->processQueuedCommand<vector<map<string,string>>>(id)) {
     } else if (rdx->processQueuedCommand<unordered_set<string>>(id)) {
     } else
       throw runtime_error("Command pointer not found in any queue!");
@@ -484,6 +496,8 @@ void Redox::freeQueuedCommands(struct ev_loop *loop, ev_async *async, int revent
     } else if (rdx->freeQueuedCommand<nullptr_t>(id)) {
     } else if (rdx->freeQueuedCommand<vector<string>>(id)) {
     } else if (rdx->freeQueuedCommand<std::set<string>>(id)) {
+    } else if (rdx->freeQueuedCommand<map<string,string>>(id)) {
+    } else if (rdx->freeQueuedCommand<vector<map<string,string>>>(id)) {
     } else if (rdx->freeQueuedCommand<unordered_set<string>>(id)) {
     } else {
     }
@@ -511,10 +525,16 @@ template <class ReplyT> bool Redox::freeQueuedCommand(long id) {
 }
 
 long Redox::freeAllCommands() {
-  return freeAllCommandsOfType<redisReply *>() + freeAllCommandsOfType<string>() +
-         freeAllCommandsOfType<char *>() + freeAllCommandsOfType<int>() +
-         freeAllCommandsOfType<long long int>() + freeAllCommandsOfType<nullptr_t>() +
-         freeAllCommandsOfType<vector<string>>() + freeAllCommandsOfType<std::set<string>>() +
+  return freeAllCommandsOfType<redisReply *>() +
+         freeAllCommandsOfType<string>() +
+         freeAllCommandsOfType<char *>() +
+         freeAllCommandsOfType<int>() +
+         freeAllCommandsOfType<long long int>() +
+         freeAllCommandsOfType<nullptr_t>() +
+         freeAllCommandsOfType<vector<string>>() +
+         freeAllCommandsOfType<std::set<string>>() +
+         freeAllCommandsOfType<map<string,string>>() +
+         freeAllCommandsOfType<vector<map<string,string>>>() +
          freeAllCommandsOfType<unordered_set<string>>();
 }
 
@@ -579,12 +599,19 @@ template <> unordered_map<long, Command<vector<string>> *> &Redox::getCommandMap
   return commands_vector_string_;
 }
 
-template <> unordered_map<long, Command<set<string>> *> &Redox::getCommandMap<set<string>>() {
+template <> unordered_map<long, Command<map<string,string>> *> &Redox::getCommandMap<map<string,string>>() {
+  return commands_map_string_;
+}
+
+template <> unordered_map<long, Command<vector<map<string,string>>> *> &Redox::getCommandMap<vector<map<string,string>>>() {
+  return commands_vectormap_string_;
+}
+
+template <> unordered_map<long, Command<std::set<string>> *> &Redox::getCommandMap<std::set<string>>() {
   return commands_set_string_;
 }
 
-template <>
-unordered_map<long, Command<unordered_set<string>> *> &
+template <> unordered_map<long, Command<unordered_set<string>> *> &
 Redox::getCommandMap<unordered_set<string>>() {
   return commands_unordered_set_string_;
 }
diff --git a/src/command.cpp b/src/command.cpp
index 95907b8..848d934 100644
--- a/src/command.cpp
+++ b/src/command.cpp
@@ -20,13 +20,44 @@
 
 #include <vector>
 #include <set>
+#include <map>
 #include <unordered_set>
+#include <utility>
 
 #include "command.hpp"
 #include "client.hpp"
 
 using namespace std;
 
+namespace {
+
+// Helper function to process replies that should convert into a map
+void parseReplyObject(redisReply* reply_obj, map<string,string>& reply_val) {
+
+    if (reply_obj->type != REDIS_REPLY_ARRAY) {
+      return;
+    }
+
+    for (size_t i = 0; i < reply_obj->elements; i = i + 2) {
+      redisReply *r = *(reply_obj->element + i);
+      size_t next = i + 1;
+      if (next < reply_obj->elements) {
+        redisReply *rnext = *(reply_obj->element + next);
+        reply_val.emplace(
+          std::piecewise_construct,
+          std::forward_as_tuple(r->str, r->len),
+          std::forward_as_tuple(rnext->str, rnext->len));
+      } else {
+        reply_val.emplace(
+          std::piecewise_construct,
+          std::forward_as_tuple(r->str, r->len),
+          std::forward_as_tuple());
+      }
+    }
+}
+
+}
+
 namespace redox {
 
 template <class ReplyT>
@@ -44,14 +75,19 @@ template <class ReplyT> void Command<ReplyT>::wait() {
   waiting_done_ = {false};
 }
 
-template <class ReplyT> void Command<ReplyT>::processReply(redisReply *r) {
+template <class ReplyT> void Command<ReplyT>::processReply(redisReply *r, const std::string& errorMessage) {
 
   last_error_.clear();
   reply_obj_ = r;
 
   if (reply_obj_ == nullptr) {
     reply_status_ = ERROR_REPLY;
-    last_error_ = "Received null redisReply* from hiredis.";
+    if (errorMessage.empty()) {
+        last_error_ = "Received null redisReply* from hiredis.";
+    }
+    else {
+        last_error_ = errorMessage;
+    }
     logger_.error() << last_error_;
     Redox::disconnectedCallback(rdx_->ctx_, REDIS_ERR);
 
@@ -236,6 +272,27 @@ template <> void Command<vector<string>>::parseReplyObject() {
   }
 }
 
+template <> void Command<map<string,string>>::parseReplyObject() {
+
+  if (!isExpectedReply(REDIS_REPLY_ARRAY))
+    return;
+
+  ::parseReplyObject(reply_obj_, reply_val_);
+}
+
+template <> void Command<vector<map<string,string>>>::parseReplyObject() {
+
+  if (!isExpectedReply(REDIS_REPLY_ARRAY))
+    return;
+
+  for (size_t i = 0; i < reply_obj_->elements; i++) {
+      redisReply *r = *(reply_obj_->element + i);
+      map<string,string> reply_val;
+      ::parseReplyObject(r, reply_val);
+      reply_val_.push_back(reply_val);
+  }
+}
+
 template <> void Command<unordered_set<string>>::parseReplyObject() {
 
   if (!isExpectedReply(REDIS_REPLY_ARRAY))
@@ -269,6 +326,8 @@ template class Command<long long int>;
 template class Command<nullptr_t>;
 template class Command<vector<string>>;
 template class Command<set<string>>;
+template class Command<map<string,string>>;
+template class Command<vector<map<string,string>>>;
 template class Command<unordered_set<string>>;
 
 } // End namespace redox
diff --git a/src/subscriber.cpp b/src/subscriber.cpp
index 8847357..32a577d 100644
--- a/src/subscriber.cpp
+++ b/src/subscriber.cpp
@@ -94,11 +94,11 @@ void debugReply(Command<redisReply *> c) {
   cout << "------" << endl;
 }
 
-void Subscriber::subscribeBase(const string cmd_name, const string topic,
-                               function<void(const string &, const string &)> msg_callback,
-                               function<void(const string &)> sub_callback,
-                               function<void(const string &)> unsub_callback,
-                               function<void(const string &, int)> err_callback) {
+void Subscriber::subscribeBase(const string &cmd_name, const string &topic,
+                               const function<void(const string &, const string &)> &msg_callback,
+                               const function<void(const string &)> &sub_callback,
+                               const function<void(const string &)> &unsub_callback,
+                               const function<void(const string &, int)> &err_callback) {
 
   Command<redisReply *> &sub_cmd = rdx_.commandLoop<redisReply *>(
       {cmd_name, topic},
@@ -176,11 +176,11 @@ void Subscriber::subscribeBase(const string cmd_name, const string topic,
   num_pending_subs_++;
 }
 
-void Subscriber::subscribe(const string topic,
-                           function<void(const string &, const string &)> msg_callback,
-                           function<void(const string &)> sub_callback,
-                           function<void(const string &)> unsub_callback,
-                           function<void(const string &, int)> err_callback) {
+void Subscriber::subscribe(const string &topic,
+                           const function<void(const string &, const string &)> &msg_callback,
+                           const function<void(const string &)> &sub_callback,
+                           const function<void(const string &)> &unsub_callback,
+                           const function<void(const string &, int)> &err_callback) {
   lock_guard<mutex> lg(subscribed_topics_guard_);
   if (subscribed_topics_.find(topic) != subscribed_topics_.end()) {
     logger_.warning() << "Already subscribed to " << topic << "!";
@@ -189,11 +189,11 @@ void Subscriber::subscribe(const string topic,
   subscribeBase("SUBSCRIBE", topic, msg_callback, sub_callback, unsub_callback, err_callback);
 }
 
-void Subscriber::psubscribe(const string topic,
-                            function<void(const string &, const string &)> msg_callback,
-                            function<void(const string &)> sub_callback,
-                            function<void(const string &)> unsub_callback,
-                            function<void(const string &, int)> err_callback) {
+void Subscriber::psubscribe(const string &topic,
+                            const function<void(const string &, const string &)> &msg_callback,
+                            const function<void(const string &)> &sub_callback,
+                            const function<void(const string &)> &unsub_callback,
+                            const function<void(const string &, int)> &err_callback) {
   lock_guard<mutex> lg(psubscribed_topics_guard_);
   if (psubscribed_topics_.find(topic) != psubscribed_topics_.end()) {
     logger_.warning() << "Already psubscribed to " << topic << "!";
@@ -202,8 +202,8 @@ void Subscriber::psubscribe(const string topic,
   subscribeBase("PSUBSCRIBE", topic, msg_callback, sub_callback, unsub_callback, err_callback);
 }
 
-void Subscriber::unsubscribeBase(const string cmd_name, const string topic,
-                                 function<void(const string &, int)> err_callback) {
+void Subscriber::unsubscribeBase(const string &cmd_name, const string &topic,
+                                 const function<void(const string &, int)> &err_callback) {
   rdx_.command<redisReply *>({cmd_name, topic}, [topic, err_callback](Command<redisReply *> &c) {
     if (!c.ok()) {
       if (err_callback)
@@ -213,7 +213,7 @@ void Subscriber::unsubscribeBase(const string cmd_name, const string topic,
   });
 }
 
-void Subscriber::unsubscribe(const string topic, function<void(const string &, int)> err_callback) {
+void Subscriber::unsubscribe(const string &topic, const function<void(const string &, int)> &err_callback) {
   lock_guard<mutex> lg(subscribed_topics_guard_);
   if (subscribed_topics_.find(topic) == subscribed_topics_.end()) {
     logger_.warning() << "Cannot unsubscribe from " << topic << ", not subscribed!";
@@ -222,8 +222,8 @@ void Subscriber::unsubscribe(const string topic, function<void(const string &, i
   unsubscribeBase("UNSUBSCRIBE", topic, err_callback);
 }
 
-void Subscriber::punsubscribe(const string topic,
-                              function<void(const string &, int)> err_callback) {
+void Subscriber::punsubscribe(const string &topic,
+                              const function<void(const string &, int)> &err_callback) {
   lock_guard<mutex> lg(psubscribed_topics_guard_);
   if (psubscribed_topics_.find(topic) == psubscribed_topics_.end()) {
     logger_.warning() << "Cannot punsubscribe from " << topic << ", not psubscribed!";
diff --git a/test/test.cpp b/test/test.cpp
index cbafca5..713b09f 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -122,6 +122,12 @@ class RedoxTest : public ::testing::Test {
     c.free();
   }
 
+  template <class ReplyT> void print_and_check_sync(Command<ReplyT> &c) {
+    ASSERT_TRUE(c.ok());
+    cout << "[SYNC] " << c.cmd() << ": " << c.reply() << endl;
+    c.free();
+  }
+
   template <class ReplyT> void print_and_check_sync(Command<ReplyT> &c, const ReplyT &value) {
     ASSERT_TRUE(c.ok());
     EXPECT_EQ(c.reply(), value);
@@ -132,10 +138,9 @@ class RedoxTest : public ::testing::Test {
   /**
   * Check the error
   */
-  template <class ReplyT> void print_and_check_error_sync(Command<ReplyT> &c, const ReplyT &value) {
+  template <class ReplyT> void print_and_check_error_sync(Command<ReplyT> &c) {
     EXPECT_FALSE(c.ok());
     EXPECT_FALSE(c.lastError().empty());
-    //      EXPECT_EQ(value, c.reply());
     cout << c.cmd() << ": " << c.lastError() << endl;
   }
 };
@@ -236,10 +241,65 @@ TEST_F(RedoxTest, IncrSync) {
 TEST_F(RedoxTest, GetSetSyncError) {
   connect();
   print_and_check_sync<string>(rdx.commandSync<string>({"SET", "redox_test:a", "apple"}), "OK");
-  print_and_check_error_sync<int>(rdx.commandSync<int>({"GET", "redox_test:a"}), 3);
+  print_and_check_error_sync<int>(rdx.commandSync<int>({"GET", "redox_test:a"}));
+  rdx.disconnect();
+}
+
+// -------------------------------------------
+// Core unit tests - reply types
+// -------------------------------------------
+
+TEST_F(RedoxTest, MapString) {
+  connect();
+
+  print_and_check_sync(rdx.commandSync<int>({"HSET", "mapstring", "a", "apple"}));
+  print_and_check_sync(rdx.commandSync<int>({"HSET", "mapstring", "b", "beer"}));
+
+  auto& cmd = rdx.commandSync<map<string,string>>({"HGETALL", "mapstring"});
+  ASSERT_TRUE(cmd.ok());
+
+  auto resultMap = cmd.reply();
+  EXPECT_EQ(2, resultMap.size());
+  EXPECT_EQ("apple", resultMap["a"]);
+  EXPECT_EQ("beer", resultMap["b"]);
+
+  cmd.free();
   rdx.disconnect();
 }
 
+TEST_F(RedoxTest, VectorMapString) {
+  connect();
+
+  // This does not return the full command info, because COMMAND returns reply objects that are 3 levels deep.
+  //  However, for testing purposes, this suffices.
+  auto& cmd = rdx.commandSync<vector<map<string,string>>>({"COMMAND"});
+  ASSERT_TRUE(cmd.ok());
+
+  auto resultVector = cmd.reply();
+  cout << "resultVector.size(): " << resultVector.size() << endl;
+
+  bool foundGetCommand = false; // test if we can at least find the get command as a key
+  EXPECT_FALSE(resultVector.empty());
+  for (const auto& resultMap : resultVector)
+  {
+      EXPECT_FALSE(resultMap.empty());
+      cout << "resultMap.size(): " << resultMap.size() << endl;
+
+      if (resultMap.find("get") != resultMap.end())
+      {
+          foundGetCommand = true;
+      }
+  }
+  EXPECT_TRUE(foundGetCommand);
+
+  cmd.free();
+  rdx.disconnect();
+}
+
+// -------------------------------------------
+// Multithreading tests
+// -------------------------------------------
+
 TEST_F(RedoxTest, MultithreadedCRUD) {
   connect();
   int create_count(0);