diff --git a/.build.sh b/.build.sh
index 1070cf9b0..1f9c3fcdb 100644
--- a/.build.sh
+++ b/.build.sh
@@ -73,6 +73,7 @@ build_driver() {
   (
     cd build
     cmake -DCMAKE_BUILD_TYPE=Release -D${driver_prefix}_BUILD_SHARED=On -D${driver_prefix}_BUILD_STATIC=On -D${driver_prefix}_BUILD_EXAMPLES=On -D${driver_prefix}_BUILD_UNIT_TESTS=On ..
+    [[ -x $(which clang-format) ]] && make format-check
     make -j${PROCS}
   )
 }
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 000000000..ac09bb743
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,27 @@
+---
+BasedOnStyle: LLVM
+Language: Cpp
+Standard: Cpp03
+AccessModifierOffset: -2
+IndentWidth: 2
+TabWidth: 8
+ColumnLimit: 100
+UseTab: Never
+IndentCaseLabels: true
+AlignAfterOpenBracket: true
+AlignEscapedNewlines: Left
+BreakConstructorInitializers: BeforeComma
+AllowShortBlocksOnASingleLine: false
+DerivePointerAlignment: false
+PointerAlignment: Left
+BinPackParameters: true
+BinPackArguments: true
+AllowShortIfStatementsOnASingleLine: true
+CompactNamespaces: true
+AlignOperands: true
+SpacesInContainerLiterals: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+Cpp11BracedListStyle: false
+AlwaysBreakTemplateDeclarations: true
+BreakBeforeInheritanceComma: true
+...
diff --git a/.gitignore b/.gitignore
index 460003e24..0060e3e0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,7 +50,7 @@ Testing
 Debug
 demo/cassandra_demo
 test/unit_tests/cassandra_test
-src/cassconfig.hpp
+src/driver_config.hpp
 
 # API docs files
 Doxyfile
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 997617b72..6482461eb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,19 +1,43 @@
+2.13.0
+===========
+
+Features
+--------
+* [CPP-745] Exponential reconnection policy with jitter
+* [CPP-769] Use `clang-format` to fix up formatting
+* [CPP-775] Add `clang-format` to Windows
+
+Other
+--------
+* [CPP-743] Move internal components from `namespace cass` to `namespace datastax::internal`
+* [CPP-764] Rename namespace from `cass` to `datastax`
+* [CPP-766] Allow RPM packaging script to build RPM packages for Amazon Linux
+* [CPP-770] Fix header files include guard (\_\_CASS_XXX to DATASTAX_XXX)
+* [CPP-772] Remove per cpp file LOG_FILE attribute to speed up Windows builds
+
+Community
+--------
+* Fixed the location of the '[in]' information for Doxygen. (AlexisWilke)
+* Added header subdirectory installation capability. (accelerated)
+* Changed pkg_config templates to use the library variable name. (accelerated)
+* Fix generation of shlib deps file for debian packages. (jirkasilhan)
+
 2.12.0
 ===========
 
 Features
 --------
-[CPP-751] Call host listener callback for the initial set of hosts
+* [CPP-751] Call host listener callback for the initial set of hosts
 
 Bug Fixes
 --------
-[CPP-755] UDT metadata not being properly populated/updated
+* [CPP-755] UDT metadata not being properly populated/updated
 
 Other
 --------
-[CPP-705] Deprecate DC-aware multi-DC settings (`used_hosts_per_remote_dc`
-          and `allowRemoteDCsForLocalConsistencyLevel `)
-[CPP-720] Streamline custom allocator
+* [CPP-705] Deprecate DC-aware multi-DC settings (`used_hosts_per_remote_dc`
+            and `allowRemoteDCsForLocalConsistencyLevel `)
+* [CPP-720] Streamline custom allocator
 
 2.11.0
 ===========
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7e3e4f10a..523ddcb75 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,7 @@ set(CASS_INCLUDE_DIR "${CASS_ROOT_DIR}/include")
 list(APPEND CMAKE_MODULE_PATH ${CASS_ROOT_DIR}/cmake/modules)
 
 include(CppDriver)
+include(ClangFormat)
 
 CassInitProject(cassandra)
 CassPolicies()
diff --git a/appveyor.ps1 b/appveyor.ps1
index 72c6022ba..24771dfda 100644
--- a/appveyor.ps1
+++ b/appveyor.ps1
@@ -773,7 +773,7 @@ Function Publish-Artifacts {
     }
 
     # Create the Uri and FilePath components for the upload
-    $base_uri = "$($Env:ARTIFACTORY_BASE_URI)/origin/$($Env:APPVEYOR_REPO_BRANCH)/$(Get-Commit-Sha)/windows"
+    $base_uri = "$($Env:ARTIFACTORY_BASE_URI)/$($Env:DRIVER_VERSION)/$(Get-Commit-Sha)/windows"
     $driver_uri = "$($base_uri)/$($driver_type)/v$($Env:DRIVER_VERSION)/$($Env:DRIVER_ARTIFACT_ARCHIVE)"
     $driver_archive = "$($Env:DRIVER_ARTIFACTS_DIR)/$($Env:DRIVER_ARTIFACT_ARCHIVE)"
     $libuv_uri = "$($base_uri)/dependencies/libuv/v$($Env:LIBUV_VERSION)/$($Env:LIBUV_ARTIFACT_ARCHIVE)"
diff --git a/appveyor.yml b/appveyor.yml
index 68e888c4a..71df5120e 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -40,10 +40,10 @@ environment:
   APPVEYOR_IGNORE_COMMIT_FILTERING_ON_TAG: true
   DRIVER_TYPE: CASS
   BOOST_VERSION: 1.69.0
-  LIBSSH2_VERSION: 1.8.2
-  LIBUV_VERSION: 1.28.0
-  OPENSSL_1_0_VERSION: 1.0.2r
-  OPENSSL_1_1_VERSION: 1.1.1b
+  LIBSSH2_VERSION: 1.9.0
+  LIBUV_VERSION: 1.29.1
+  OPENSSL_1_0_VERSION: 1.0.2s
+  OPENSSL_1_1_VERSION: 1.1.1c
   matrix:
     - CMAKE_GENERATOR: Visual Studio 10 2010
       OPENSSL_MAJOR_MINOR: 1.0
diff --git a/build.yaml b/build.yaml
index 1af93b6d9..4d3cce80e 100644
--- a/build.yaml
+++ b/build.yaml
@@ -19,7 +19,7 @@ os:
   - centos/7-64/cpp
   - osx/high-sierra
 env:
-  LIBUV_VERSION: 1.28.0
+  LIBUV_VERSION: 1.29.1
 build:
   - script: |
       . .build.sh
diff --git a/cmake/modules/ClangFormat.cmake b/cmake/modules/ClangFormat.cmake
new file mode 100644
index 000000000..de9d50105
--- /dev/null
+++ b/cmake/modules/ClangFormat.cmake
@@ -0,0 +1,109 @@
+#
+# Format and verify formatting using clang-format
+#
+cmake_minimum_required(VERSION 2.6.4)
+
+include(FindPackageHandleStandardArgs)
+
+if(NOT CLANG_FORMAT_EXE_NAME)
+  set(CLANG_FORMAT_EXE_NAME clang-format)
+endif()
+
+if(CLANG_FORMAT_ROOT_DIR)
+  find_program(CLANG_FORMAT_EXE
+    NAMES ${CLANG_FORMAT_EXE_NAME}
+    PATHS ${CLANG_FORMAT_ROOT_DIR}
+    NO_DEFAULT_PATH)
+endif()
+
+find_program(CLANG_FORMAT_EXE NAMES ${CLANG_FORMAT_EXE_NAME})
+
+find_package_handle_standard_args(CLANG_FORMAT DEFAULT_MSG CLANG_FORMAT_EXE)
+
+mark_as_advanced(CLANG_FORMAT_EXE)
+
+if(CLANG_FORMAT_FOUND)
+  set(CLANG_FORMAT_FILE_EXTENSIONS ${CLANG_FORMAT_CXX_FILE_EXTENSIONS} *.cpp *.hpp *.c *.h)
+  file(GLOB_RECURSE CLANG_FORMAT_ALL_SOURCE_FILES ${CLANG_FORMAT_FILE_EXTENSIONS})
+
+  set(CLANG_FORMAT_EXCLUDE_PATTERNS ${CLANG_FORMAT_EXCLUDE_PATTERNS} "/CMakeFiles/" "cmake" "/build/" "/vendor/" "/third_party/" "cassandra.h" "dse.h")
+
+  foreach(SOURCE_FILE ${CLANG_FORMAT_ALL_SOURCE_FILES})
+    foreach(EXCLUDE_PATTERN ${CLANG_FORMAT_EXCLUDE_PATTERNS})
+      string(FIND ${SOURCE_FILE} ${EXCLUDE_PATTERN} EXCLUDE_FOUND)
+      if(NOT ${EXCLUDE_FOUND} EQUAL -1)
+        list(REMOVE_ITEM CLANG_FORMAT_ALL_SOURCE_FILES ${SOURCE_FILE})
+      endif()
+    endforeach()
+  endforeach()
+
+  if(WIN32)
+    set(CLANG_FORMAT_FILENAME "clang-format.files")
+    set(CLANG_FORMAT_ABSOLUTE_FILENAME "${CMAKE_BINARY_DIR}/${CLANG_FORMAT_FILENAME}")
+    if (EXISTS ${CLANG_FORMAT_ABSOLUTE_FILENAME})
+      file(REMOVE ${CLANG_FORMAT_ABSOLUTE_FILENAME})
+    endif()
+
+    set(COUNT 1)
+    file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR} CMAKE_WINDOWS_BINARY_DIR)
+    foreach(SOURCE_FILE ${CLANG_FORMAT_ALL_SOURCE_FILES})
+      file(RELATIVE_PATH RELATIVE_SOURCE_FILE ${CMAKE_BINARY_DIR} ${SOURCE_FILE})
+      file(TO_NATIVE_PATH ${RELATIVE_SOURCE_FILE} NATIVE_RELATIVE_SOURCE_FILE)
+
+      if(COUNT EQUAL 50)
+        file(APPEND ${CLANG_FORMAT_ABSOLUTE_FILENAME} " ${NATIVE_RELATIVE_SOURCE_FILE}\n")
+        set(COUNT 1)
+      else()
+        file(APPEND ${CLANG_FORMAT_ABSOLUTE_FILENAME} " ${NATIVE_RELATIVE_SOURCE_FILE}")
+        MATH(EXPR COUNT "${COUNT} + 1")
+      endif()
+    endforeach()
+
+    file(TO_NATIVE_PATH ${CLANG_FORMAT_EXE} CLANG_FORMAT_EXE)
+    file(WRITE "${CMAKE_BINARY_DIR}/clang-format-windows.bat"
+               "@REM Generated clang-format script for Windows\r\n"
+               "@ECHO OFF\r\n"
+               "SETLOCAL ENABLEDELAYEDEXPANSION\r\n"
+               "SET IS_FAILED_CHECK=0\r\n"
+               "PUSHD ${CMAKE_WINDOWS_BINARY_DIR}>NUL\r\n"
+               "FOR /F \"TOKENS=*\" %%A IN (${CLANG_FORMAT_FILENAME}) do (\r\n"
+               "  IF %1 EQU 1 (\r\n"
+               "    \"${CLANG_FORMAT_EXE}\" -i -fallback-style=none -style=file %%A\r\n"
+               "    IF NOT !ERRORLEVEL! EQU 0 (\r\n"
+               "      SET IS_FAILED_CHECK=1\r\n"
+               "    )\r\n"
+               "  )\r\n"
+               "  IF %1 EQU 2 (\r\n"
+               "    \"${CLANG_FORMAT_EXE}\" -output-replacements-xml -fallback-style=none -style=file %%A 2>&1 | FINDSTR /C:\"replacement offset\">NUL\r\n"
+               "    IF !ERRORLEVEL! EQU 0 (\r\n"
+               "      SET IS_FAILED_CHECK=1\r\n"
+               "    )\r\n"
+               "  )\r\n"
+               ")\r\n"
+               "IF NOT !IS_FAILED_CHECK! EQU 0 (\r\n"
+               "  POPD\r\n"
+               "  EXIT /B 1\r\n"
+               ")\r\n"
+               "POPD\r\n"
+               "ENDLOCAL\r\n"
+               "EXIT /B 0\r\n")
+
+    add_custom_target(format
+      COMMENT "Format source files using clang-format"
+      COMMAND "${CMAKE_WINDOWS_BINARY_DIR}\\clang-format-windows.bat" 1)
+
+    add_custom_target(format-check
+      COMMENT "Verify source files formatting using clang-format"
+      COMMAND "${CMAKE_WINDOWS_BINARY_DIR}\\clang-format-windows.bat" 2)
+  else()
+    add_custom_target(format
+      COMMENT "Format source files using clang-format"
+      COMMAND ${CLANG_FORMAT_EXE} -i -fallback-style=none -style=file ${CLANG_FORMAT_ALL_SOURCE_FILES})
+
+    add_custom_target(format-check
+      COMMENT "Verify source files formatting using clang-format"
+      COMMAND ! ${CLANG_FORMAT_EXE} -output-replacements-xml -fallback-style=none -style=file ${CLANG_FORMAT_ALL_SOURCE_FILES} | tee replacements.xml | grep -q "replacement offset")
+  endif()
+else()
+  message(STATUS "Unable to find clang-format. Not creating format targets.")
+endif()
diff --git a/cmake/modules/CppDriver.cmake b/cmake/modules/CppDriver.cmake
index 7eaaf520d..61f16470a 100644
--- a/cmake/modules/CppDriver.cmake
+++ b/cmake/modules/CppDriver.cmake
@@ -810,25 +810,6 @@ macro(CassSetCompilerFlags)
       add_definitions("/MP")
     endif()
 
-    # Enable link time optimization for all MSVC build configurations
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL")
-    set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} /LTCG")
-    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG")
-    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG")
-
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /GL")
-    string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO}")
-    set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
-    string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO}")
-    set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
-    string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
-    set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
-
-    set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /GL")
-    set(CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL "${CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL} /LTCG")
-    set(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /LTCG")
-    set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /LTCG")
-
     # On Visual C++ -pedantic flag is not used,
     # -fPIC is not used on Windows platform (all DLLs are
     # relocable), -Wall generates about 30k stupid warnings
@@ -1001,18 +982,12 @@ macro(CassFindSourceFiles)
   endif()
 
   set(CASS_ALL_SOURCE_FILES ${CASS_SRC_FILES} ${CASS_API_HEADER_FILES} ${CASS_INC_FILES})
-
-  # Shorten the source file pathing for log messages
-  foreach(SRC_FILE ${CASS_SRC_FILES})
-    string(REPLACE "${CASS_ROOT_DIR}/" "" LOG_FILE_ ${SRC_FILE})
-    set_source_files_properties(${SRC_FILE} PROPERTIES COMPILE_FLAGS -DLOG_FILE_=\\\"${LOG_FILE_}\\\")
-  endforeach()
 endmacro()
 
 #------------------------
 # CassConfigure
 #
-# Generate cassconfig.hpp from cassconfig.hpp.in
+# Generate driver_config.hpp from driver_config.hpp.in
 #
 # Input: CASS_ROOT_DIR, CASS_SRC_DIR
 #------------------------
@@ -1048,6 +1023,6 @@ macro(CassConfigure)
     check_cxx_source_compiles("int main() { return __builtin_bswap64(42); }" HAVE_BUILTIN_BSWAP64)
   endif()
 
-  # Generate the cassconfig.hpp file
-  configure_file(${CASS_ROOT_DIR}/cassconfig.hpp.in ${CASS_SRC_DIR}/cassconfig.hpp)
+  # Generate the driver_config.hpp file
+  configure_file(${CASS_ROOT_DIR}/driver_config.hpp.in ${CASS_SRC_DIR}/driver_config.hpp)
 endmacro()
diff --git a/cmake/modules/ExternalProject-OpenSSL.cmake b/cmake/modules/ExternalProject-OpenSSL.cmake
index d86a7de1d..dff9f0f94 100644
--- a/cmake/modules/ExternalProject-OpenSSL.cmake
+++ b/cmake/modules/ExternalProject-OpenSSL.cmake
@@ -21,8 +21,8 @@ endif()
 # OpenSSL related CMake options
 option(OPENSSL_VERSION "OpenSSL version to build and install")
 if(NOT OPENSSL_VERSION)
-  # TODO: Should we default to OpenSSL 1.1 (e.g. 1.1.1b)?
-  set(OPENSSL_VERSION "1.0.2r")
+  # TODO: Should we default to OpenSSL 1.1 (e.g. 1.1.1c)?
+  set(OPENSSL_VERSION "1.0.2s")
 endif()
 option(OPENSSL_INSTALL_PREFIX "OpenSSL installation prefix location")
 if(CASS_USE_ZLIB)
diff --git a/cmake/modules/ExternalProject-libssh2.cmake b/cmake/modules/ExternalProject-libssh2.cmake
index 4bc3493c8..ae4fa638a 100644
--- a/cmake/modules/ExternalProject-libssh2.cmake
+++ b/cmake/modules/ExternalProject-libssh2.cmake
@@ -22,7 +22,7 @@ if(NOT LIBSSH2_INSTALL_PREFIX)
 endif()
 option(LIBSSH2_VERSION "libssh2 version to build and install")
 if(NOT LIBSSH2_VERSION)
-  set(LIBSSH2_VERSION "1.8.2")
+  set(LIBSSH2_VERSION "1.9.0")
 endif()
 set(LIBSSH2_VERSION ${LIBSSH2_VERSION} CACHE STRING "libssh2 version to build and install" FORCE)
 
diff --git a/cmake/modules/ExternalProject-libuv.cmake b/cmake/modules/ExternalProject-libuv.cmake
index 71dbc13cf..1d7f4ed3b 100644
--- a/cmake/modules/ExternalProject-libuv.cmake
+++ b/cmake/modules/ExternalProject-libuv.cmake
@@ -22,7 +22,7 @@ if(NOT LIBUV_INSTALL_PREFIX)
 endif()
 option(LIBUV_VERSION "libuv version to build and install")
 if(NOT LIBUV_VERSION)
-  set(LIBUV_VERSION "1.28.0")
+  set(LIBUV_VERSION "1.29.1")
 endif()
 set(LIBUV_VERSION ${LIBUV_VERSION} CACHE STRING "libuv version to build and install" FORCE)
 
diff --git a/docs.yaml b/docs.yaml
index 47c3f2ab1..bf151fdf4 100644
--- a/docs.yaml
+++ b/docs.yaml
@@ -52,10 +52,13 @@ rewrites:
   - ^examples/(.*): https://github.com/datastax/cpp-driver/blob/master/examples/\1
   - http://www.datastax.com/documentation/cql/3.1: https://docs.datastax.com/en/archived/cql/3.1
   - http://www.datastax.com/documentation/cassandra/2.: https://docs.datastax.com/en/archived/cassandra/2.
+  - http://downloads.datastax.com/cpp-driver: https://downloads.datastax.com/cpp-driver/
 rules:
   use_path_nav_files_only: true
 
 versions:
+  - name: "2.13"
+    ref: 2.13.0
   - name: "2.12"
     ref: 2.12.0
   - name: "2.11"
diff --git a/cassconfig.hpp.in b/driver_config.hpp.in
similarity index 78%
rename from cassconfig.hpp.in
rename to driver_config.hpp.in
index a1c1c8b89..43d8a6df2 100644
--- a/cassconfig.hpp.in
+++ b/driver_config.hpp.in
@@ -1,5 +1,5 @@
-#ifndef __CASSANDRA_CONFIG_HPP_INCLUDED__
-#define __CASSANDRA_CONFIG_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DRIVER_CONFIG_HPP
+#define DATASTAX_INTERNAL_DRIVER_CONFIG_HPP
 
 #cmakedefine HAVE_OPENSSL
 #cmakedefine HAVE_STD_ATOMIC
diff --git a/examples/async/async.c b/examples/async/async.c
index 50428510f..1c7382a75 100644
--- a/examples/async/async.c
+++ b/examples/async/async.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -41,7 +41,6 @@ void print_error(CassFuture* future) {
   fprintf(stderr, "Error: %.*s\n", (int)message_length, message);
 }
 
-
 CassCluster* create_cluster(const char* hosts) {
   CassCluster* cluster = cass_cluster_new();
   cass_cluster_set_contact_points(cluster, hosts);
@@ -90,7 +89,7 @@ void insert_into_async(CassSession* session, const char* key) {
 
   size_t i;
   for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
-     char key_buffer[64];
+    char key_buffer[64];
     statement = cass_statement_new(query, 6);
 
     sprintf(key_buffer, "%s%u", key, (unsigned int)i);
@@ -135,13 +134,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.async (key text, \
+  execute_query(session, "CREATE TABLE examples.async (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
diff --git a/examples/auth/auth.c b/examples/auth/auth.c
index cdfa27bc7..7cc8491e3 100644
--- a/examples/auth/auth.c
+++ b/examples/auth/auth.c
@@ -35,8 +35,7 @@ typedef struct Credentials_ {
   const char* username;
 } Credentials;
 
-void on_auth_initial(CassAuthenticator* auth,
-                       void* data) {
+void on_auth_initial(CassAuthenticator* auth, void* data) {
   /*
    * This callback is used to initiate a request to begin an authentication
    * exchange. Required resources can be acquired and initialized here.
@@ -52,7 +51,7 @@ void on_auth_initial(CassAuthenticator* auth,
    * authentication callbacks were set and is available to all
    * authentication exchanges.
    */
-  const Credentials* credentials = (const Credentials *)data;
+  const Credentials* credentials = (const Credentials*)data;
 
   size_t username_size = strlen(credentials->username);
   size_t password_size = strlen(credentials->password);
@@ -68,20 +67,14 @@ void on_auth_initial(CassAuthenticator* auth,
   memcpy(response + username_size + 2, credentials->password, password_size);
 }
 
-void on_auth_challenge(CassAuthenticator* auth,
-                       void* data,
-                       const char* token,
-                       size_t token_size) {
+void on_auth_challenge(CassAuthenticator* auth, void* data, const char* token, size_t token_size) {
   /*
    * Not used for plain text authentication, but this is to be used
    * for handling an authentication challenge initiated by the server.
    */
 }
 
-void on_auth_success(CassAuthenticator* auth,
-                     void* data,
-                     const char* token,
-                     size_t token_size ) {
+void on_auth_success(CassAuthenticator* auth, void* data, const char* token, size_t token_size) {
   /*
    * Not used for plain text authentication, but this is to be used
    * for handling the success phase of an exchange.
@@ -104,17 +97,10 @@ int main(int argc, char* argv[]) {
   char* hosts = "127.0.0.1,127.0.0.2,127.0.0.3";
 
   /* Setup authentication callbacks and credentials */
-  CassAuthenticatorCallbacks auth_callbacks = {
-    on_auth_initial,
-    on_auth_challenge,
-    on_auth_success,
-    on_auth_cleanup
-  };
-
-  Credentials credentials = {
-    "cassandra",
-    "cassandra"
-  };
+  CassAuthenticatorCallbacks auth_callbacks = { on_auth_initial, on_auth_challenge, on_auth_success,
+                                                on_auth_cleanup };
+
+  Credentials credentials = { "cassandra", "cassandra" };
 
   /* Add contact points */
   if (argc > 1) {
@@ -123,10 +109,7 @@ int main(int argc, char* argv[]) {
   cass_cluster_set_contact_points(cluster, hosts);
 
   /* Set custom authentication callbacks and credentials */
-  cass_cluster_set_authenticator_callbacks(cluster,
-                                           &auth_callbacks,
-                                           NULL,
-                                           &credentials);
+  cass_cluster_set_authenticator_callbacks(cluster, &auth_callbacks, NULL, &credentials);
 
   /* Provide the cluster object as configuration to connect the session */
   connect_future = cass_session_connect(session, cluster);
@@ -138,8 +121,7 @@ int main(int argc, char* argv[]) {
     const char* message;
     size_t message_length;
     cass_future_error_message(connect_future, &message, &message_length);
-    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
-                                                        message);
+    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message);
   }
 
   cass_future_free(connect_future);
diff --git a/examples/basic/basic.c b/examples/basic/basic.c
index 60cea5566..29fb73f71 100644
--- a/examples/basic/basic.c
+++ b/examples/basic/basic.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -92,7 +92,8 @@ CassError insert_into_basic(CassSession* session, const char* key, const Basic*
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
-  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
+  const char* query =
+      "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
 
   statement = cass_statement_new(query, 6);
 
@@ -175,13 +176,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
diff --git a/examples/batch/batch.c b/examples/batch/batch.c
index e91296e93..e1b0efb9b 100644
--- a/examples/batch/batch.c
+++ b/examples/batch/batch.c
@@ -26,15 +26,15 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
 struct Pair_ {
-    const char* key;
-    const char* value;
+  const char* key;
+  const char* value;
 };
 
 typedef struct Pair_ Pair;
@@ -105,7 +105,8 @@ CassError prepare_insert_into_batch(CassSession* session, const CassPrepared** p
   return rc;
 }
 
-CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepared* prepared, const Pair* pairs) {
+CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepared* prepared,
+                                          const Pair* pairs) {
   CassError rc = CASS_OK;
   CassFuture* future = NULL;
   CassBatch* batch = cass_batch_new(CASS_BATCH_TYPE_LOGGED);
@@ -120,13 +121,15 @@ CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepar
   }
 
   {
-    CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES ('c', '3')", 0);
+    CassStatement* statement =
+        cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES ('c', '3')", 0);
     cass_batch_add_statement(batch, statement);
     cass_statement_free(statement);
   }
 
   {
-    CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES (?, ?)", 2);
+    CassStatement* statement =
+        cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES (?, ?)", 2);
     cass_statement_bind_string(statement, 0, "d");
     cass_statement_bind_string(statement, 1, "4");
     cass_batch_add_statement(batch, statement);
@@ -147,14 +150,13 @@ CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepar
   return rc;
 }
 
-
 int main(int argc, char* argv[]) {
   CassCluster* cluster = NULL;
   CassSession* session = cass_session_new();
   const CassPrepared* prepared = NULL;
   char* hosts = "127.0.0.1";
 
-  Pair pairs[] = { {"a", "1"}, {"b", "2"}, { NULL, NULL} };
+  Pair pairs[] = { { "a", "1" }, { "b", "2" }, { NULL, NULL } };
 
   if (argc > 1) {
     hosts = argv[1];
@@ -167,13 +169,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.pairs (key text, \
+  execute_query(session, "CREATE TABLE examples.pairs (key text, \
                                               value text, \
                                               PRIMARY KEY (key));");
 
diff --git a/examples/bind_by_name/bind_by_name.c b/examples/bind_by_name/bind_by_name.c
index b364ba1ce..c5d7c2b83 100644
--- a/examples/bind_by_name/bind_by_name.c
+++ b/examples/bind_by_name/bind_by_name.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -106,7 +106,8 @@ CassError prepare_query(CassSession* session, const char* query, const CassPrepa
   return rc;
 }
 
-CassError insert_into_basic(CassSession* session, const CassPrepared* prepared, const char* key, const Basic* basic) {
+CassError insert_into_basic(CassSession* session, const CassPrepared* prepared, const char* key,
+                            const Basic* basic) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -135,7 +136,8 @@ CassError insert_into_basic(CassSession* session, const CassPrepared* prepared,
   return rc;
 }
 
-CassError select_from_basic(CassSession* session, const CassPrepared * prepared, const char* key, Basic* basic) {
+CassError select_from_basic(CassSession* session, const CassPrepared* prepared, const char* key,
+                            Basic* basic) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -183,10 +185,9 @@ int main(int argc, char* argv[]) {
   const CassPrepared* select_prepared = NULL;
   char* hosts = "127.0.0.1";
 
-  const char* insert_query
-    = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
-  const char* select_query
-    = "SELECT * FROM examples.basic WHERE key = ?";
+  const char* insert_query =
+      "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
+  const char* select_query = "SELECT * FROM examples.basic WHERE key = ?";
 
   if (argc > 1) {
     hosts = argv[1];
@@ -199,25 +200,21 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
                                               PRIMARY KEY (key));");
 
-
   if (prepare_query(session, insert_query, &insert_prepared) == CASS_OK) {
     insert_into_basic(session, insert_prepared, "prepared_test", &input);
     cass_prepared_free(insert_prepared);
   }
 
-  if (prepare_query(session, select_query,  &select_prepared) == CASS_OK) {
+  if (prepare_query(session, select_query, &select_prepared) == CASS_OK) {
     select_from_basic(session, select_prepared, "prepared_test", &output);
 
     assert(input.bln == output.bln);
diff --git a/examples/callbacks/callbacks.c b/examples/callbacks/callbacks.c
index 28ae3bdbd..d388dcd8e 100644
--- a/examples/callbacks/callbacks.c
+++ b/examples/callbacks/callbacks.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <uv.h>
 
@@ -76,14 +76,14 @@ CassCluster* create_cluster(const char* hosts) {
   return cluster;
 }
 
-void connect_session(CassSession* session, const CassCluster* cluster, CassFutureCallback callback) {
+void connect_session(CassSession* session, const CassCluster* cluster,
+                     CassFutureCallback callback) {
   CassFuture* future = cass_session_connect(session, cluster);
   cass_future_set_callback(future, callback, session);
   cass_future_free(future);
 }
 
-void execute_query(CassSession* session, const char* query,
-                   CassFutureCallback callback) {
+void execute_query(CassSession* session, const char* query, CassFutureCallback callback) {
   CassStatement* statement = cass_statement_new(query, 0);
   CassFuture* future = cass_session_execute(session, statement);
   cass_future_set_callback(future, callback, session);
@@ -113,9 +113,7 @@ void on_create_keyspace(CassFuture* future, void* data) {
     print_error(future);
   }
 
-  execute_query((CassSession*)data,
-                "USE examples",
-                on_set_keyspace);
+  execute_query((CassSession*)data, "USE examples", on_set_keyspace);
 }
 
 void on_set_keyspace(CassFuture* future, void* data) {
@@ -163,10 +161,8 @@ void on_insert(CassFuture* future, void* data) {
     signal_exit();
   } else {
     const char* select_query = "SELECT * FROM callbacks";
-    CassStatement* statement
-        = cass_statement_new(select_query, 0);
-    CassFuture* select_future
-        = cass_session_execute((CassSession*)data, statement);
+    CassStatement* statement = cass_statement_new(select_query, 0);
+    CassFuture* select_future = cass_session_execute((CassSession*)data, statement);
 
     cass_future_set_callback(select_future, on_select, data);
 
diff --git a/examples/collections/collections.c b/examples/collections/collections.c
index cdfee3b0a..9256474b3 100644
--- a/examples/collections/collections.c
+++ b/examples/collections/collections.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -175,16 +175,13 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '1' };");
 
-  execute_query(session,
-                "CREATE TABLE examples.collections (key text, \
+  execute_query(session, "CREATE TABLE examples.collections (key text, \
                                                     items set<text>, \
                                                     PRIMARY KEY (key))");
 
-
   insert_into_collections(session, "test", items);
   select_from_collections(session, "test");
 
diff --git a/examples/date_time/data_time.c b/examples/date_time/data_time.c
index 78d4b9e44..c721bedf3 100644
--- a/examples/date_time/data_time.c
+++ b/examples/date_time/data_time.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 
 #include "cassandra.h"
@@ -169,13 +169,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.date_time (key text PRIMARY KEY,  d date, t time)");
+  execute_query(session, "CREATE TABLE examples.date_time (key text PRIMARY KEY,  d date, t time)");
 
   insert_into(session, "test");
   select_from(session, "test");
diff --git a/examples/duration/duration.c b/examples/duration/duration.c
index 0dc34cf62..d9c161a2c 100644
--- a/examples/duration/duration.c
+++ b/examples/duration/duration.c
@@ -25,8 +25,8 @@
   For more information, please refer to <http://unlicense.org/>
 */
 
-#include <stdio.h>
 #include "cassandra.h"
+#include <stdio.h>
 
 #define NANOS_IN_A_SEC (1000LL * 1000LL * 1000LL)
 
@@ -76,7 +76,8 @@ CassError execute_query(CassSession* session, const char* query) {
   return rc;
 }
 
-CassError insert_into(CassSession* session, const char* key, cass_int32_t months, cass_int32_t days, cass_int64_t nanos) {
+CassError insert_into(CassSession* session, const char* key, cass_int32_t months, cass_int32_t days,
+                      cass_int64_t nanos) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -156,14 +157,11 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE IF NOT EXISTS examples WITH replication = { "
-                "'class': 'SimpleStrategy', 'replication_factor': '3' };");
-
+  execute_query(session, "CREATE KEYSPACE IF NOT EXISTS examples WITH replication = { "
+                         "'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-  execute_query(session,
-                "CREATE TABLE IF NOT EXISTS examples.duration "
-                "(key text PRIMARY KEY, d duration)");
+  execute_query(session, "CREATE TABLE IF NOT EXISTS examples.duration "
+                         "(key text PRIMARY KEY, d duration)");
 
   /* Insert some rows into the table and read them back out */
 
diff --git a/examples/execution_profiles/execution_profiles.c b/examples/execution_profiles/execution_profiles.c
index fbf322bc7..91b97546e 100644
--- a/examples/execution_profiles/execution_profiles.c
+++ b/examples/execution_profiles/execution_profiles.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -98,9 +98,7 @@ CassError execute_query(CassSession* session, const char* query) {
   return rc;
 }
 
-CassError insert_into_examples(CassSession* session,
-                               const char* profile_name,
-                               const char* key,
+CassError insert_into_examples(CassSession* session, const char* profile_name, const char* key,
                                const cass_bool_t value) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
@@ -134,9 +132,7 @@ CassError insert_into_examples(CassSession* session,
   return rc;
 }
 
-CassError select_from_examples(CassSession* session,
-                               const char* profile_name,
-                               const char* key,
+CassError select_from_examples(CassSession* session, const char* profile_name, const char* key,
                                cass_bool_t* return_value) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
@@ -165,8 +161,7 @@ CassError select_from_examples(CassSession* session,
     if (row) {
       const CassValue* value = cass_row_get_column_by_name(row, "value");
       cass_value_get_bool(value, return_value);
-      printf("SELECT: Key = %s | Value = %s\n",
-             key,
+      printf("SELECT: Key = %s | Value = %s\n", key,
              (*return_value == cass_true ? "true" : "false"));
     }
 
@@ -195,14 +190,10 @@ int main(int argc, char* argv[]) {
 
   /* Create and set execution profiles; freeing once added to configuration */
   profile = create_reduced_latency_write_execution_profile();
-  cass_cluster_set_execution_profile(cluster,
-                                     "reduced_latency",
-                                     profile);
+  cass_cluster_set_execution_profile(cluster, "reduced_latency", profile);
   cass_execution_profile_free(profile);
   profile = create_quorum_execution_profile();
-  cass_cluster_set_execution_profile(cluster,
-                                     "quorum",
-                                     profile);
+  cass_cluster_set_execution_profile(cluster, "quorum", profile);
   cass_execution_profile_free(profile);
 
   /* Provide the cluster object as configuration to connect the session */
@@ -213,12 +204,10 @@ int main(int argc, char* argv[]) {
   }
 
   /* Create a keyspace and table for the execution profile example  */
-  execute_query(session,
-                "CREATE KEYSPACE IF NOT EXISTS examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE IF NOT EXISTS examples WITH replication = { \
                   'class': 'SimpleStrategy', 'replication_factor': '3' \
                 }");
-  execute_query(session,
-                "CREATE TABLE IF NOT EXISTS examples.execution_profiles ( \
+  execute_query(session, "CREATE TABLE IF NOT EXISTS examples.execution_profiles ( \
                   key text PRIMARY KEY, \
                   value boolean \
                 )");
diff --git a/examples/host_listener/host_listener.c b/examples/host_listener/host_listener.c
index 6186a001c..e7b83ccc3 100644
--- a/examples/host_listener/host_listener.c
+++ b/examples/host_listener/host_listener.c
@@ -27,13 +27,10 @@
 
 #include <cassandra.h>
 
-
 #include <stdio.h>
 #include <uv.h>
 
-void on_signal(uv_signal_t* handle, int signum) {
-  uv_signal_stop(handle);
-}
+void on_signal(uv_signal_t* handle, int signum) { uv_signal_stop(handle); }
 
 void on_host_listener(CassHostListenerEvent event, CassInet inet, void* data);
 
diff --git a/examples/logging/logging.c b/examples/logging/logging.c
index edc0509c0..1643822fb 100644
--- a/examples/logging/logging.c
+++ b/examples/logging/logging.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -61,12 +61,9 @@ CassError connect_session(CassSession* session, const CassCluster* cluster) {
 
 void on_log(const CassLogMessage* message, void* data) {
   FILE* log_file = (FILE*)data;
-  fprintf(log_file, "%u.%03u [%s] (%s:%d:%s): %s\n",
-          (unsigned int)(message->time_ms / 1000),
-          (unsigned int)(message->time_ms % 1000),
-          cass_log_level_string(message->severity),
-          message->file, message->line, message->function,
-          message->message);
+  fprintf(log_file, "%u.%03u [%s] (%s:%d:%s): %s\n", (unsigned int)(message->time_ms / 1000),
+          (unsigned int)(message->time_ms % 1000), cass_log_level_string(message->severity),
+          message->file, message->line, message->function, message->message);
 }
 
 int main(int argc, char* argv[]) {
diff --git a/examples/maps/maps.c b/examples/maps/maps.c
index 2575b6081..b940c20b1 100644
--- a/examples/maps/maps.c
+++ b/examples/maps/maps.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -139,9 +139,7 @@ CassError select_from_maps(CassSession* session, const char* key) {
     if (cass_result_row_count(result) > 0) {
       const CassRow* row = cass_result_first_row(result);
 
-      CassIterator* iterator
-          = cass_iterator_from_map(
-              cass_row_get_column(row, 0));
+      CassIterator* iterator = cass_iterator_from_map(cass_row_get_column(row, 0));
 
       while (cass_iterator_next(iterator)) {
         const char* key;
@@ -168,7 +166,9 @@ int main(int argc, char* argv[]) {
   CassSession* session = cass_session_new();
   char* hosts = "127.0.0.1";
 
-  const Pair items[] = { { "apple", 1 }, { "orange", 2 }, { "banana", 3 }, { "mango", 4 }, { NULL, 0 } };
+  const Pair items[] = {
+    { "apple", 1 }, { "orange", 2 }, { "banana", 3 }, { "mango", 4 }, { NULL, 0 }
+  };
 
   if (argc > 1) {
     hosts = argv[1];
@@ -181,16 +181,13 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                 'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-  execute_query(session,
-                "CREATE TABLE examples.maps (key text, \
+  execute_query(session, "CREATE TABLE examples.maps (key text, \
                 items map<text, int>, \
                 PRIMARY KEY (key))");
 
-
   insert_into_maps(session, "test", items);
   select_from_maps(session, "test");
 
diff --git a/examples/named_parameters/named_parameters.c b/examples/named_parameters/named_parameters.c
index de6774fd0..67892f5b4 100644
--- a/examples/named_parameters/named_parameters.c
+++ b/examples/named_parameters/named_parameters.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -92,8 +92,8 @@ CassError insert_into_basic(CassSession* session, const char* key, const Basic*
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
 
-  const char* query
-    = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (:k, :b, :f, :d, :i32, :i64);";
+  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (:k, :b, "
+                      ":f, :d, :i32, :i64);";
 
   statement = cass_statement_new(query, 6);
 
@@ -124,8 +124,7 @@ CassError select_from_basic(CassSession* session, const char* key, Basic* basic)
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
 
-  const char* query
-    = "SELECT * FROM examples.basic WHERE key = ?";
+  const char* query = "SELECT * FROM examples.basic WHERE key = ?";
 
   statement = cass_statement_new(query, 1);
 
@@ -178,19 +177,15 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
                                               PRIMARY KEY (key));");
 
-
   insert_into_basic(session, "named_parameters", &input);
   select_from_basic(session, "named_parameters", &output);
 
diff --git a/examples/paging/paging.c b/examples/paging/paging.c
index 5f46d6a2f..4276c02fa 100644
--- a/examples/paging/paging.c
+++ b/examples/paging/paging.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -183,13 +183,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.paging (key timeuuid, \
+  execute_query(session, "CREATE TABLE examples.paging (key timeuuid, \
                                                value text, \
                                                PRIMARY KEY (key));");
 
diff --git a/examples/perf/perf.c b/examples/perf/perf.c
index 90004b8fb..ec90c2455 100644
--- a/examples/perf/perf.c
+++ b/examples/perf/perf.c
@@ -26,10 +26,10 @@
 */
 
 #include <assert.h>
-#include <string.h>
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <math.h>
+#include <string.h>
 
 #include <uv.h>
 
@@ -51,12 +51,12 @@
 #if defined(_MSC_VER) && defined(_DEBUG)
 #include <windows.h>
 const DWORD MS_VC_EXCEPTION = 0x406D1388;
-#pragma pack(push,8)
+#pragma pack(push, 8)
 typedef struct tagTHREADNAME_INFO {
-  DWORD dwType; /* Must be 0x1000. */
-  LPCSTR szName; /* Pointer to name (in user addr space). */
+  DWORD dwType;     /* Must be 0x1000. */
+  LPCSTR szName;    /* Pointer to name (in user addr space). */
   DWORD dwThreadID; /* Thread ID (-1=caller thread). */
-  DWORD dwFlags; /* Reserved for future use, must be zero. */
+  DWORD dwFlags;    /* Reserved for future use, must be zero. */
 } THREADNAME_INFO;
 #pragma pack(pop)
 void set_thread_name(const char* thread_name) {
@@ -66,13 +66,11 @@ void set_thread_name(const char* thread_name) {
   info.dwThreadID = -1;
   info.dwFlags = 0;
 #pragma warning(push)
-#pragma warning(disable: 6320 6322)
+#pragma warning(disable : 6320 6322)
   __try {
-    RaiseException(MS_VC_EXCEPTION,
-                   0,
-                   sizeof(info) / sizeof(ULONG_PTR),
-                   (ULONG_PTR*) &info);
-  } __except (EXCEPTION_EXECUTE_HANDLER) { }
+    RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
+  } __except (EXCEPTION_EXECUTE_HANDLER) {
+  }
 #pragma warning(pop)
 }
 #endif
@@ -256,7 +254,8 @@ void run_insert_queries(void* data) {
   CassSession* session = (CassSession*)data;
 
   const CassPrepared* insert_prepared = NULL;
-  const char* insert_query = "INSERT INTO stress.songs (id, title, album, artist, tags) VALUES (?, ?, ?, ?, ?);";
+  const char* insert_query =
+      "INSERT INTO stress.songs (id, title, album, artist, tags) VALUES (?, ?, ?, ?, ?);";
 
 #if USE_PREPARED
   if (prepare_query(session, insert_query, &insert_prepared) == CASS_OK) {
@@ -310,11 +309,12 @@ void run_select_queries(void* data) {
   int i;
   CassSession* session = (CassSession*)data;
   const CassPrepared* select_prepared = NULL;
-  const char* select_query = "SELECT * FROM stress.songs WHERE id = a98d21b2-1900-11e4-b97b-e5e358e71e0d";
+  const char* select_query =
+      "SELECT * FROM stress.songs WHERE id = a98d21b2-1900-11e4-b97b-e5e358e71e0d";
 
 #if defined(_MSC_VER) && defined(_DEBUG)
   char thread_name[32];
-  sprintf(thread_name, "Perf - %lu", (unsigned long) (GetThreadId(uv_thread_self())));
+  sprintf(thread_name, "Perf - %lu", (unsigned long)(GetThreadId(uv_thread_self())));
   set_thread_name(thread_name);
 #endif
 
@@ -367,11 +367,11 @@ int main(int argc, char* argv[]) {
                          "title text, album text, artist text, "
                          "tags set<text>, data blob)");
 
-  execute_query(session,
-                "INSERT INTO stress.songs (id, title, album, artist, tags) VALUES "
-                "(a98d21b2-1900-11e4-b97b-e5e358e71e0d, "
-                "'La Petite Tonkinoise', 'Bye Bye Blackbird', 'Joséphine Baker', { 'jazz', '2013' });");
-
+  execute_query(
+      session,
+      "INSERT INTO stress.songs (id, title, album, artist, tags) VALUES "
+      "(a98d21b2-1900-11e4-b97b-e5e358e71e0d, "
+      "'La Petite Tonkinoise', 'Bye Bye Blackbird', 'Joséphine Baker', { 'jazz', '2013' });");
 
   for (i = 0; i < NUM_THREADS; ++i) {
 #if DO_SELECTS
@@ -383,19 +383,21 @@ int main(int argc, char* argv[]) {
 
   while (status_wait(&status, 5) > 0) {
     cass_session_get_metrics(session, &metrics);
-    printf("rate stats (requests/second): mean %f 1m %f 5m %f 10m %f\n",
-           metrics.requests.mean_rate,
-           metrics.requests.one_minute_rate,
-           metrics.requests.five_minute_rate,
+    printf("rate stats (requests/second): mean %f 1m %f 5m %f 10m %f\n", metrics.requests.mean_rate,
+           metrics.requests.one_minute_rate, metrics.requests.five_minute_rate,
            metrics.requests.fifteen_minute_rate);
   }
 
   cass_session_get_metrics(session, &metrics);
-  printf("final stats (microseconds): min %llu max %llu median %llu 75th %llu 95th %llu 98th %llu 99th %llu 99.9th %llu\n",
+  printf("final stats (microseconds): min %llu max %llu median %llu 75th %llu 95th %llu 98th %llu "
+         "99th %llu 99.9th %llu\n",
          (unsigned long long int)metrics.requests.min, (unsigned long long int)metrics.requests.max,
-         (unsigned long long int)metrics.requests.median, (unsigned long long int)metrics.requests.percentile_75th,
-         (unsigned long long int)metrics.requests.percentile_95th, (unsigned long long int)metrics.requests.percentile_98th,
-         (unsigned long long int)metrics.requests.percentile_99th, (unsigned long long int)metrics.requests.percentile_999th);
+         (unsigned long long int)metrics.requests.median,
+         (unsigned long long int)metrics.requests.percentile_75th,
+         (unsigned long long int)metrics.requests.percentile_95th,
+         (unsigned long long int)metrics.requests.percentile_98th,
+         (unsigned long long int)metrics.requests.percentile_99th,
+         (unsigned long long int)metrics.requests.percentile_999th);
 
   for (i = 0; i < NUM_THREADS; ++i) {
     uv_thread_join(&threads[i]);
diff --git a/examples/prepared/prepared.c b/examples/prepared/prepared.c
index a11a37686..6d21fff30 100644
--- a/examples/prepared/prepared.c
+++ b/examples/prepared/prepared.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -91,7 +91,8 @@ CassError insert_into_basic(CassSession* session, const char* key, const Basic*
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
-  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
+  const char* query =
+      "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
 
   statement = cass_statement_new(query, 6);
 
@@ -137,7 +138,8 @@ CassError prepare_select_from_basic(CassSession* session, const CassPrepared** p
   return rc;
 }
 
-CassError select_from_basic(CassSession* session, const CassPrepared * prepared, const char* key, Basic* basic) {
+CassError select_from_basic(CassSession* session, const CassPrepared* prepared, const char* key,
+                            Basic* basic) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -194,13 +196,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
diff --git a/examples/schema_meta/schema_meta.c b/examples/schema_meta/schema_meta.c
index 4647ef82e..7f0927833 100644
--- a/examples/schema_meta/schema_meta.c
+++ b/examples/schema_meta/schema_meta.c
@@ -25,8 +25,8 @@
   For more information, please refer to <http://unlicense.org/>
 */
 
-#include <stdio.h>
 #include <cassandra.h>
+#include <stdio.h>
 
 void print_keyspace_meta(const CassKeyspaceMeta* meta, int indent);
 void print_table_meta(const CassTableMeta* meta, int indent);
@@ -64,12 +64,14 @@ void print_table(CassSession* session, const char* keyspace, const char* table)
   cass_schema_meta_free(schema_meta);
 }
 
-void print_function(CassSession* session, const char* keyspace, const char* function, const char* arguments) {
+void print_function(CassSession* session, const char* keyspace, const char* function,
+                    const char* arguments) {
   const CassSchemaMeta* schema_meta = cass_session_get_schema_meta(session);
   const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta, keyspace);
 
   if (keyspace_meta != NULL) {
-    const CassFunctionMeta* function_meta = cass_keyspace_meta_function_by_name(keyspace_meta, function, arguments);
+    const CassFunctionMeta* function_meta =
+        cass_keyspace_meta_function_by_name(keyspace_meta, function, arguments);
     if (function_meta != NULL) {
       print_function_meta(function_meta, 0);
     } else {
@@ -82,12 +84,14 @@ void print_function(CassSession* session, const char* keyspace, const char* func
   cass_schema_meta_free(schema_meta);
 }
 
-void print_aggregate(CassSession* session, const char* keyspace, const char* aggregate, const char* arguments) {
+void print_aggregate(CassSession* session, const char* keyspace, const char* aggregate,
+                     const char* arguments) {
   const CassSchemaMeta* schema_meta = cass_session_get_schema_meta(session);
   const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta, keyspace);
 
   if (keyspace_meta != NULL) {
-    const CassAggregateMeta* aggregate_meta = cass_keyspace_meta_aggregate_by_name(keyspace_meta, aggregate, arguments);
+    const CassAggregateMeta* aggregate_meta =
+        cass_keyspace_meta_aggregate_by_name(keyspace_meta, aggregate, arguments);
     if (aggregate_meta != NULL) {
       print_aggregate_meta(aggregate_meta, 0);
     } else {
@@ -144,23 +148,19 @@ int main(int argc, char* argv[]) {
 
     execute_query(session, "DROP KEYSPACE IF EXISTS examples;");
 
-    execute_query(session,
-                  "CREATE KEYSPACE examples WITH replication = { \
+    execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                   'class': 'SimpleStrategy', 'replication_factor': '3' }");
 
     print_keyspace(session, "examples");
 
-    execute_query(session,
-                  "CREATE TABLE examples.schema_meta (key text, \
+    execute_query(session, "CREATE TABLE examples.schema_meta (key text, \
                   value bigint, \
                   PRIMARY KEY (key))");
 
-    execute_query(session,
-                  "CREATE INDEX schema_meta_idx \
+    execute_query(session, "CREATE INDEX schema_meta_idx \
                     ON examples.schema_meta (value)");
 
-    execute_query(session,
-                  "CREATE FUNCTION \
+    execute_query(session, "CREATE FUNCTION \
                      examples.avg_state(state tuple<int, bigint>, val int) \
                   CALLED ON NULL INPUT RETURNS tuple<int, bigint> \
                   LANGUAGE java AS \
@@ -169,8 +169,7 @@ int main(int argc, char* argv[]) {
                       state.setLong(1, state.getLong(1) + val.intValue()); \
                     } \
                     return state;'");
-    execute_query(session,
-                  "CREATE FUNCTION \
+    execute_query(session, "CREATE FUNCTION \
                      examples.avg_final (state tuple<int, bigint>) \
                   CALLED ON NULL INPUT RETURNS double \
                   LANGUAGE java AS \
@@ -180,8 +179,7 @@ int main(int argc, char* argv[]) {
                     r /= state.getInt(0); \
                     return Double.valueOf(r);'");
 
-    execute_query(session,
-                  "CREATE AGGREGATE examples.average(int) \
+    execute_query(session, "CREATE AGGREGATE examples.average(int) \
                   SFUNC avg_state STYPE tuple<int, bigint> FINALFUNC avg_final \
                   INITCOND(0, 0)");
 
@@ -292,7 +290,8 @@ void print_schema_bytes(const CassValue* value) {
 
   cass_value_get_bytes(value, &bytes, &b_length);
   printf("0x");
-  for (i = 0; i < b_length; ++i) printf("%02x", bytes[i]);
+  for (i = 0; i < b_length; ++i)
+    printf("%02x", bytes[i]);
 }
 
 void print_schema_list(const CassValue* value) {
diff --git a/examples/simple/simple.c b/examples/simple/simple.c
index 93fd86209..bd7176707 100644
--- a/examples/simple/simple.c
+++ b/examples/simple/simple.c
@@ -25,8 +25,8 @@
   For more information, please refer to <http://unlicense.org/>
 */
 
-#include <stdio.h>
 #include <cassandra.h>
+#include <stdio.h>
 
 int main(int argc, char* argv[]) {
   /* Setup and connect to cluster */
@@ -62,8 +62,7 @@ int main(int argc, char* argv[]) {
         const char* release_version;
         size_t release_version_length;
         cass_value_get_string(value, &release_version, &release_version_length);
-        printf("release_version: '%.*s'\n", (int)release_version_length,
-               release_version);
+        printf("release_version: '%.*s'\n", (int)release_version_length, release_version);
       }
 
       cass_result_free(result);
@@ -72,8 +71,7 @@ int main(int argc, char* argv[]) {
       const char* message;
       size_t message_length;
       cass_future_error_message(result_future, &message, &message_length);
-      fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
-                                                            message);
+      fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message);
     }
 
     cass_statement_free(statement);
@@ -83,8 +81,7 @@ int main(int argc, char* argv[]) {
     const char* message;
     size_t message_length;
     cass_future_error_message(connect_future, &message, &message_length);
-    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
-                                                        message);
+    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message);
   }
 
   cass_future_free(connect_future);
diff --git a/examples/ssl/ssl.c b/examples/ssl/ssl.c
index 3cc7d68af..c6c4b6b1d 100644
--- a/examples/ssl/ssl.c
+++ b/examples/ssl/ssl.c
@@ -25,9 +25,9 @@
   For more information, please refer to <http://unlicense.org/>
 */
 
-#include <stdio.h>
-#include <openssl/ssl.h>
 #include <cassandra.h>
+#include <openssl/ssl.h>
+#include <stdio.h>
 
 int load_trusted_cert_file(const char* file, CassSsl* ssl) {
   CassError rc;
@@ -35,7 +35,7 @@ int load_trusted_cert_file(const char* file, CassSsl* ssl) {
   long cert_size;
   size_t bytes_read;
 
-  FILE *in = fopen(file, "rb");
+  FILE* in = fopen(file, "rb");
   if (in == NULL) {
     fprintf(stderr, "Error loading certificate file '%s'\n", file);
     return 0;
@@ -49,7 +49,7 @@ int load_trusted_cert_file(const char* file, CassSsl* ssl) {
   bytes_read = fread(cert, 1, cert_size, in);
   fclose(in);
 
-  if (bytes_read == (size_t) cert_size) {
+  if (bytes_read == (size_t)cert_size) {
     rc = cass_ssl_add_trusted_cert_n(ssl, cert, cert_size);
     if (rc != CASS_OK) {
       fprintf(stderr, "Error loading SSL certificate: %s\n", cass_error_desc(rc));
@@ -105,8 +105,7 @@ int main(int argc, char* argv[]) {
         const char* release_version;
         size_t release_version_length;
         cass_value_get_string(value, &release_version, &release_version_length);
-        printf("release_version: '%.*s'\n", (int)release_version_length,
-               release_version);
+        printf("release_version: '%.*s'\n", (int)release_version_length, release_version);
       }
 
       cass_result_free(result);
@@ -115,19 +114,17 @@ int main(int argc, char* argv[]) {
       const char* message;
       size_t message_length;
       cass_future_error_message(result_future, &message, &message_length);
-      fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
-                                                            message);
+      fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message);
     }
 
     cass_statement_free(statement);
     cass_future_free(result_future);
   } else {
-      /* Handle error */
-      const char* message;
-      size_t message_length;
-      cass_future_error_message(connect_future, &message, &message_length);
-      fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
-                                                          message);
+    /* Handle error */
+    const char* message;
+    size_t message_length;
+    cass_future_error_message(connect_future, &message, &message_length);
+    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message);
   }
 
   cass_future_free(connect_future);
diff --git a/examples/tracing/tracing.c b/examples/tracing/tracing.c
index 573b20d3f..4c4c94091 100644
--- a/examples/tracing/tracing.c
+++ b/examples/tracing/tracing.c
@@ -25,8 +25,8 @@
   For more information, please refer to <http://unlicense.org/>
 */
 
-#include <stdio.h>
 #include <cassandra.h>
+#include <stdio.h>
 
 void print_error(const char* context, CassFuture* future) {
   const char* message;
@@ -35,9 +35,7 @@ void print_error(const char* context, CassFuture* future) {
   fprintf(stderr, "%s: %.*s\n", context, (int)message_length, message);
 }
 
-const CassResult* run_tracing_query(CassSession* session,
-                                    const char* query,
-                                    CassUuid tracing_id) {
+const CassResult* run_tracing_query(CassSession* session, const char* query, CassUuid tracing_id) {
   CassError rc = CASS_OK;
   CassFuture* future = NULL;
   const CassResult* result = NULL;
@@ -74,8 +72,7 @@ void print_tracing_data(CassSession* session, CassFuture* future) {
   /* Query the tracing tables using the retrieved tracing ID */
 
   /* Get information for the tracing session */
-  result = run_tracing_query(session,
-                             "SELECT * FROM system_traces.sessions WHERE session_id = ?",
+  result = run_tracing_query(session, "SELECT * FROM system_traces.sessions WHERE session_id = ?",
                              tracing_id);
 
   if (result) {
@@ -86,13 +83,10 @@ void print_tracing_data(CassSession* session, CassFuture* future) {
       const CassRow* row = cass_result_first_row(result);
 
       /* Get the command type that was run and how long it took */
-      cass_value_get_string(cass_row_get_column_by_name(row, "command"),
-                            &command, &command_length);
-      cass_value_get_int32(cass_row_get_column_by_name(row, "duration"),
-                           &duration);
+      cass_value_get_string(cass_row_get_column_by_name(row, "command"), &command, &command_length);
+      cass_value_get_int32(cass_row_get_column_by_name(row, "duration"), &duration);
 
-      printf("Request command \"%.*s\" took %f milliseconds:\n",
-             (int)command_length, command,
+      printf("Request command \"%.*s\" took %f milliseconds:\n", (int)command_length, command,
              duration / 1000.0);
     }
 
@@ -100,8 +94,7 @@ void print_tracing_data(CassSession* session, CassFuture* future) {
   }
 
   /* Get the events that happened during the tracing session */
-  result = run_tracing_query(session,
-                             "SELECT * FROM system_traces.events WHERE session_id = ?",
+  result = run_tracing_query(session, "SELECT * FROM system_traces.events WHERE session_id = ?",
                              tracing_id);
 
   if (result) {
@@ -120,18 +113,14 @@ void print_tracing_data(CassSession* session, CassFuture* future) {
         /* Get the activity for the event which host happened on, and how long
          * it took.
          */
-        cass_value_get_string(cass_row_get_column_by_name(row, "activity"),
-                              &activity, &activity_length);
-        cass_value_get_inet(cass_row_get_column_by_name(row, "source"),
-                            &source);
-        cass_value_get_int32(cass_row_get_column_by_name(row, "source_elapsed"),
-                             &source_elapsed);
+        cass_value_get_string(cass_row_get_column_by_name(row, "activity"), &activity,
+                              &activity_length);
+        cass_value_get_inet(cass_row_get_column_by_name(row, "source"), &source);
+        cass_value_get_int32(cass_row_get_column_by_name(row, "source_elapsed"), &source_elapsed);
 
         cass_inet_string(source, source_str);
-        printf("%2d) Event on host %s (%f milliseconds): \"%.*s\"\n",
-               event_count++,
-               source_str, source_elapsed / 1000.0,
-               (int)activity_length, activity);
+        printf("%2d) Event on host %s (%f milliseconds): \"%.*s\"\n", event_count++, source_str,
+               source_elapsed / 1000.0, (int)activity_length, activity);
       }
 
       cass_iterator_free(iterator);
@@ -181,8 +170,7 @@ int main(int argc, char* argv[]) {
         const char* release_version;
         size_t release_version_length;
         cass_value_get_string(value, &release_version, &release_version_length);
-        printf("release_version: '%.*s'\n", (int)release_version_length,
-               release_version);
+        printf("release_version: '%.*s'\n", (int)release_version_length, release_version);
       } else {
         printf("No rows returned\n");
       }
diff --git a/examples/tuple/tuple.c b/examples/tuple/tuple.c
index 516586c5b..d2522792d 100644
--- a/examples/tuple/tuple.c
+++ b/examples/tuple/tuple.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -160,7 +160,7 @@ CassError select_from_tuple(CassSession* session) {
     result = cass_future_get_result(future);
     rows = cass_iterator_from_result(result);
 
-    while(cass_iterator_next(rows)) {
+    while (cass_iterator_next(rows)) {
       CassUuid id;
       char id_str[CASS_UUID_STRING_LENGTH];
       const CassRow* row = cass_iterator_get_row(rows);
@@ -173,7 +173,7 @@ CassError select_from_tuple(CassSession* session) {
 
       printf("id %s ", id_str);
 
-      while(cass_iterator_next(item)) {
+      while (cass_iterator_next(item)) {
         const CassValue* value = cass_iterator_get_value(item);
 
         if (!cass_value_is_null(value)) {
@@ -224,12 +224,11 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' }");
 
-  execute_query(session,
-                "CREATE TABLE examples.tuples (id timeuuid, item frozen<tuple<text, bigint>>, PRIMARY KEY(id))");
+  execute_query(session, "CREATE TABLE examples.tuples (id timeuuid, item frozen<tuple<text, "
+                         "bigint>>, PRIMARY KEY(id))");
 
   insert_into_tuple(session);
   select_from_tuple(session);
diff --git a/examples/udt/udt.c b/examples/udt/udt.c
index f49c76daf..391deb3bb 100644
--- a/examples/udt/udt.c
+++ b/examples/udt/udt.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -166,7 +166,7 @@ CassError select_from_udt(CassSession* session) {
     result = cass_future_get_result(future);
     rows = cass_iterator_from_result(result);
 
-    while(cass_iterator_next(rows)) {
+    while (cass_iterator_next(rows)) {
       CassUuid id;
       char id_str[CASS_UUID_STRING_LENGTH];
       const CassRow* row = cass_iterator_get_row(rows);
@@ -179,7 +179,7 @@ CassError select_from_udt(CassSession* session) {
 
       printf("id %s ", id_str);
 
-      while(fields != NULL && cass_iterator_next(fields)) {
+      while (fields != NULL && cass_iterator_next(fields)) {
         const char* field_name;
         size_t field_name_length;
         const CassValue* field_value = NULL;
@@ -204,7 +204,8 @@ CassError select_from_udt(CassSession* session) {
               CassIterator* phone_fields = cass_iterator_fields_from_user_type(phone_value);
               assert(cass_value_type(phone_value) == CASS_VALUE_TYPE_UDT);
               while (cass_iterator_next(phone_fields)) {
-                const CassValue* phone_number_value = cass_iterator_get_user_type_field_value(phone_fields);
+                const CassValue* phone_number_value =
+                    cass_iterator_get_user_type_field_value(phone_fields);
                 cass_int32_t i;
                 cass_value_get_int32(phone_number_value, &i);
                 printf("%d ", i);
@@ -248,18 +249,16 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' }");
 
-  execute_query(session,
-                "CREATE TYPE examples.phone_numbers (phone1 int, phone2 int)");
+  execute_query(session, "CREATE TYPE examples.phone_numbers (phone1 int, phone2 int)");
 
-  execute_query(session,
-                "CREATE TYPE examples.address (street text, city text, zip int, phone set<frozen<phone_numbers>>)");
+  execute_query(session, "CREATE TYPE examples.address (street text, city text, zip int, phone "
+                         "set<frozen<phone_numbers>>)");
 
-  execute_query(session,
-                "CREATE TABLE examples.udt (id timeuuid, address frozen<address>, PRIMARY KEY(id))");
+  execute_query(
+      session, "CREATE TABLE examples.udt (id timeuuid, address frozen<address>, PRIMARY KEY(id))");
 
   schema_meta = cass_session_get_schema_meta(session);
 
diff --git a/examples/uuids/uuids.c b/examples/uuids/uuids.c
index 36e5c2cbd..7161ec06f 100644
--- a/examples/uuids/uuids.c
+++ b/examples/uuids/uuids.c
@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -150,9 +150,7 @@ CassError select_from_log(CassSession* session, const char* key) {
 
       cass_uuid_string(time, time_str);
 
-      printf("%.*s %s %.*s\n", (int)key_length, key,
-                               time_str,
-                               (int)entry_length, entry);
+      printf("%.*s %s %.*s\n", (int)key_length, key, time_str, (int)entry_length, entry);
     }
 
     cass_result_free(result);
@@ -182,16 +180,12 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.log (key text, time timeuuid, entry text, \
+  execute_query(session, "CREATE TABLE examples.log (key text, time timeuuid, entry text, \
                                               PRIMARY KEY (key, time));");
 
-
   cass_uuid_gen_time(uuid_gen, &uuid);
   insert_into_log(session, "test", uuid, "Log entry #1");
 
diff --git a/gtests/src/integration/bignumber.hpp b/gtests/src/integration/bignumber.hpp
index 5caf8f99a..9b4dfe80a 100644
--- a/gtests/src/integration/bignumber.hpp
+++ b/gtests/src/integration/bignumber.hpp
@@ -24,8 +24,7 @@
 
 #include <openssl/bn.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Helper class for working with Java byte arrays (e.g. BigInteger and
@@ -34,11 +33,11 @@ namespace driver {
 class BigNumber {
 public:
   BigNumber()
-    : scale_(0) { }
+      : scale_(0) {}
 
   BigNumber(const std::string& big_number)
-    : big_number_(BN_new())
-    , scale_(0) {
+      : big_number_(BN_new())
+      , scale_(0) {
     BIGNUM* bignum = big_number_.get();
     std::string copy = test::Utils::trim(big_number);
 
@@ -61,8 +60,8 @@ class BigNumber {
   }
 
   BigNumber(const unsigned char* bytes, size_t bytes_length, int32_t scale)
-    : big_number_(BN_new())
-    , scale_(scale) {
+      : big_number_(BN_new())
+      , scale_(scale) {
     if (bytes && bytes_length > 0) {
       // Determine if value is negative and handle two's complement
       bool is_negative = ((bytes[0] & 0x80) != 0);
@@ -141,9 +140,7 @@ class BigNumber {
    *
    * @return Scale for number
    */
-  int32_t scale() const {
-    return scale_;
-  }
+  int32_t scale() const { return scale_; }
 
   /**
    * Get the string representation of the big number
@@ -158,7 +155,7 @@ class BigNumber {
     result.assign(decimal);
     OPENSSL_free(decimal);
 
-    //Normalize - strip leading zeros
+    // Normalize - strip leading zeros
     result.erase(0, result.find_first_not_of('0'));
     if (result.size() == 0) {
       result = "0";
@@ -167,9 +164,7 @@ class BigNumber {
     // Return the value as integer or decimal (depending)
     if (scale_ > 0) {
       size_t decimal_location = result.size() - scale_;
-      return result.substr(0, decimal_location)
-             + "."
-             + result.substr(decimal_location);
+      return result.substr(0, decimal_location) + "." + result.substr(decimal_location);
     }
     return result;
   }
@@ -217,7 +212,6 @@ class BigNumber {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_BIG_NUMBER_HPP__
diff --git a/gtests/src/integration/driver_utils.cpp b/gtests/src/integration/driver_utils.cpp
index 3c0ba2cfa..b507d3e87 100644
--- a/gtests/src/integration/driver_utils.cpp
+++ b/gtests/src/integration/driver_utils.cpp
@@ -24,16 +24,18 @@
 #include "request_handler.hpp"
 #include "statement.hpp"
 
-std::vector<std::string> test::driver::internals::Utils::attempted_hosts(
-  CassFuture* future) {
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+std::vector<std::string> test::driver::internals::Utils::attempted_hosts(CassFuture* future) {
   std::vector<std::string> attempted_hosts;
   if (future) {
-    cass::Future* cass_future = static_cast<cass::Future*>(future);
-    if (cass_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      cass::ResponseFuture* response = static_cast<cass::ResponseFuture*>(cass_future);
-      cass::AddressVec attempted_addresses = response->attempted_addresses();
-      for (cass::AddressVec::iterator iterator = attempted_addresses.begin();
-        iterator != attempted_addresses.end(); ++iterator) {
+    Future* cass_future = static_cast<Future*>(future);
+    if (cass_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      ResponseFuture* response = static_cast<ResponseFuture*>(cass_future);
+      AddressVec attempted_addresses = response->attempted_addresses();
+      for (AddressVec::iterator iterator = attempted_addresses.begin();
+           iterator != attempted_addresses.end(); ++iterator) {
         attempted_hosts.push_back(iterator->to_string().c_str());
       }
       std::sort(attempted_hosts.begin(), attempted_hosts.end());
@@ -48,9 +50,8 @@ unsigned int test::driver::internals::Utils::connect_timeout(CassCluster* cluste
 
 std::string test::driver::internals::Utils::contact_points(CassCluster* cluster) {
   std::string contact_points;
-  const cass::ContactPointList& contact_points_list =
-    cluster->config().contact_points();
-  for (cass::ContactPointList::const_iterator it = contact_points_list.begin();
+  const ContactPointList& contact_points_list = cluster->config().contact_points();
+  for (ContactPointList::const_iterator it = contact_points_list.begin();
        it != contact_points_list.end(); ++it) {
     if (contact_points.size() > 0) {
       contact_points.push_back(',');
@@ -61,36 +62,32 @@ std::string test::driver::internals::Utils::contact_points(CassCluster* cluster)
 }
 
 std::string test::driver::internals::Utils::driver_name() {
-  return cass::driver_name();
+  return datastax::internal::driver_name();
 }
 
 std::string test::driver::internals::Utils::driver_version() {
-  return cass::driver_version();
+  return datastax::internal::driver_version();
 }
 
 std::string test::driver::internals::Utils::host(CassFuture* future) {
   if (future) {
-    cass::Future* cass_future = static_cast<cass::Future*>(future);
-    if (cass_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      return static_cast<cass::ResponseFuture*>(cass_future)->address().to_string().c_str();
+    Future* cass_future = static_cast<Future*>(future);
+    if (cass_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      return static_cast<ResponseFuture*>(cass_future)->address().to_string().c_str();
     }
   }
   return "";
 }
 
-int64_t test::driver::internals::Utils::murmur3_hash(
-  const std::string& value) {
-  return cass::MurmurHash3_x64_128(value.data(), value.size(), 0);
+int64_t test::driver::internals::Utils::murmur3_hash(const std::string& value) {
+  return MurmurHash3_x64_128(value.data(), value.size(), 0);
 }
 
-int test::driver::internals::Utils::port(CassCluster* cluster) {
-  return cluster->config().port();
-}
+int test::driver::internals::Utils::port(CassCluster* cluster) { return cluster->config().port(); }
 
-void test::driver::internals::Utils::set_record_attempted_hosts(
-  CassStatement* statement, bool enable) {
+void test::driver::internals::Utils::set_record_attempted_hosts(CassStatement* statement,
+                                                                bool enable) {
   if (statement) {
-    static_cast<cass::Statement*>(statement)
-      ->set_record_attempted_addresses(enable);
+    static_cast<Statement*>(statement)->set_record_attempted_addresses(enable);
   }
 }
diff --git a/gtests/src/integration/driver_utils.hpp b/gtests/src/integration/driver_utils.hpp
index fd86730a3..f86620ef4 100644
--- a/gtests/src/integration/driver_utils.hpp
+++ b/gtests/src/integration/driver_utils.hpp
@@ -23,9 +23,7 @@
 #include <string>
 #include <vector>
 
-namespace test {
-namespace driver {
-namespace internals {
+namespace test { namespace driver { namespace internals {
 
 class Utils {
 public:
@@ -101,8 +99,6 @@ class Utils {
   static void set_record_attempted_hosts(CassStatement* statement, bool enable);
 };
 
-} // namespace internals
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::internals
 
 #endif // __TEST_DRIVER_UTILS_HPP__
diff --git a/gtests/src/integration/exception.hpp b/gtests/src/integration/exception.hpp
index a0b32d669..2500d8991 100644
--- a/gtests/src/integration/exception.hpp
+++ b/gtests/src/integration/exception.hpp
@@ -35,7 +35,7 @@ class Exception : public std::runtime_error {
    * @param message Exception message
    */
   Exception(const std::string& message)
-    : std::runtime_error(message) {}
+      : std::runtime_error(message) {}
 
   /**
    * Destructor
@@ -55,8 +55,8 @@ class CassException : public Exception {
    * @param error_code Error code
    */
   CassException(const std::string& message, const CassError error_code)
-    : Exception(message)
-    , error_code_(error_code) {}
+      : Exception(message)
+      , error_code_(error_code) {}
 
   /**
    * Exception class that contains an error code
@@ -67,14 +67,14 @@ class CassException : public Exception {
    */
   CassException(const std::string& message, const CassError error_code,
                 const std::string& error_message)
-    : Exception(message)
-    , error_code_(error_code)
-    , error_message_(error_message) { }
+      : Exception(message)
+      , error_code_(error_code)
+      , error_message_(error_message) {}
 
   /**
    * Destructor
    */
-  virtual ~CassException() throw() { }
+  virtual ~CassException() throw() {}
 
   /**
    * Get the error code associated with the exception
@@ -88,9 +88,7 @@ class CassException : public Exception {
    *
    * @return Error description
    */
-  const std::string error_description() {
-    return std::string(cass_error_desc(error_code()));
-  }
+  const std::string error_description() { return std::string(cass_error_desc(error_code())); }
 
   /**
    * Get the error message associated with the exception
diff --git a/gtests/src/integration/integration.cpp b/gtests/src/integration/integration.cpp
index 827d28f69..3d08f52ab 100644
--- a/gtests/src/integration/integration.cpp
+++ b/gtests/src/integration/integration.cpp
@@ -34,32 +34,32 @@
 bool Integration::skipped_message_displayed_ = false;
 
 Integration::Integration()
-  : ccm_(NULL)
-  , session_()
-  , keyspace_name_("")
-  , table_name_("")
-  , system_schema_keyspaces_("system.schema_keyspaces")
-  , uuid_generator_()
-  , server_version_(Options::server_version())
-  , number_dc1_nodes_(1)
-  , number_dc2_nodes_(0)
-  , replication_factor_(0)
-  , replication_strategy_("")
-  , contact_points_("")
-  , is_password_authenticator_(false)
-  , is_client_authentication_(false)
-  , is_ssl_(false)
-  , is_with_vnodes_(false)
-  , is_randomized_contact_points_(false)
-  , is_schema_metadata_(false)
-  , is_ccm_start_requested_(true)
-  , is_ccm_start_node_individually_(false)
-  , is_session_requested_(true)
-  , is_test_chaotic_(false)
-  , is_beta_protocol_(Options::is_beta_protocol())
-  , protocol_version_(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION)
-  , create_keyspace_query_("")
-  , start_time_(0ull) {
+    : ccm_(NULL)
+    , session_()
+    , keyspace_name_("")
+    , table_name_("")
+    , system_schema_keyspaces_("system.schema_keyspaces")
+    , uuid_generator_()
+    , server_version_(Options::server_version())
+    , number_dc1_nodes_(1)
+    , number_dc2_nodes_(0)
+    , replication_factor_(0)
+    , replication_strategy_("")
+    , contact_points_("")
+    , is_password_authenticator_(false)
+    , is_client_authentication_(false)
+    , is_ssl_(false)
+    , is_with_vnodes_(false)
+    , is_randomized_contact_points_(false)
+    , is_schema_metadata_(false)
+    , is_ccm_start_requested_(true)
+    , is_ccm_start_node_individually_(false)
+    , is_session_requested_(true)
+    , is_test_chaotic_(false)
+    , is_beta_protocol_(Options::is_beta_protocol())
+    , protocol_version_(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION)
+    , create_keyspace_query_("")
+    , start_time_(0ull) {
   // Determine if the schema keyspaces table should be updated
   // TODO: Make cass_version (and dse_version) available for all tests
   CCM::CassVersion cass_version = server_version_;
@@ -79,7 +79,7 @@ Integration::Integration()
   if (type_param) {
     std::vector<std::string> tokens = explode(test_information->test_case_name(), '/');
     for (std::vector<std::string>::const_iterator iterator = tokens.begin();
-      iterator < tokens.end(); ++iterator) {
+         iterator < tokens.end(); ++iterator) {
       std::string token = *iterator;
 
       // Determine if we are looking at the last token
@@ -89,9 +89,7 @@ Integration::Integration()
         if (!(tokenStream >> number).fail()) {
           std::vector<std::string> type_param_tokens = explode(type_param, ':');
           size_t size = type_param_tokens.size();
-          test_case_name_ += test::Utils::replace_all(type_param_tokens[size - 1],
-                                                      ">",
-                                                      "");
+          test_case_name_ += test::Utils::replace_all(type_param_tokens[size - 1], ">", "");
         }
       } else {
         test_case_name_ += token + "_";
@@ -110,7 +108,8 @@ Integration::Integration()
 Integration::~Integration() {
   try {
     session_.close(false);
-  } catch (...) {}
+  } catch (...) {
+  }
 
   // Reset the skipped message displayed state
   skipped_message_displayed_ = false;
@@ -130,11 +129,9 @@ void Integration::SetUp() {
   }
   replication_strategy_ = default_replication_strategy();
 
-
   // Generate the keyspace query
-  create_keyspace_query_ = format_string(SIMPLE_KEYSPACE_FORMAT,
-                                         keyspace_name_.c_str(),
-                                         replication_strategy_.c_str());
+  create_keyspace_query_ =
+      format_string(SIMPLE_KEYSPACE_FORMAT, keyspace_name_.c_str(), replication_strategy_.c_str());
 
   // Create the data center nodes vector
   std::vector<unsigned short> data_center_nodes;
@@ -142,28 +139,19 @@ void Integration::SetUp() {
   data_center_nodes.push_back(number_dc2_nodes_);
 
   try {
-    //Create and start the CCM cluster (if not already created)
-    ccm_ = new CCM::Bridge(server_version_,
-      Options::use_git(), Options::branch_tag(),
-      Options::use_install_dir(), Options::install_dir(),
-      Options::is_dse(), dse_workload_,
-      Options::cluster_prefix(),
-      Options::dse_credentials(),
-      Options::dse_username(), Options::dse_password(),
-      Options::deployment_type(), Options::authentication_type(),
-      Options::host(), Options::port(),
-      Options::username(), Options::password(),
-      Options::public_key(), Options::private_key(),
-      Options::is_verbose_ccm());
-    if (ccm_->create_cluster(data_center_nodes,
-                             is_with_vnodes_,
-                             is_password_authenticator_,
-                             is_ssl_,
-                             is_client_authentication_)) {
+    // Create and start the CCM cluster (if not already created)
+    ccm_ = new CCM::Bridge(
+        server_version_, Options::use_git(), Options::branch_tag(), Options::use_install_dir(),
+        Options::install_dir(), Options::is_dse(), dse_workload_, Options::cluster_prefix(),
+        Options::dse_credentials(), Options::dse_username(), Options::dse_password(),
+        Options::deployment_type(), Options::authentication_type(), Options::host(),
+        Options::port(), Options::username(), Options::password(), Options::public_key(),
+        Options::private_key(), Options::is_verbose_ccm());
+    if (ccm_->create_cluster(data_center_nodes, is_with_vnodes_, is_password_authenticator_,
+                             is_ssl_, is_client_authentication_)) {
       if (is_ccm_start_requested_) {
         if (is_ccm_start_node_individually_) {
-          for (unsigned short node = 1;
-            node <= (number_dc1_nodes_ + number_dc2_nodes_); ++node) {
+          for (unsigned short node = 1; node <= (number_dc1_nodes_ + number_dc2_nodes_); ++node) {
             if (is_password_authenticator_) {
               ccm_->start_node(node, "-Dcassandra.superuser_setup_delay_ms=0");
             } else {
@@ -181,8 +169,8 @@ void Integration::SetUp() {
     }
 
     // Generate the default contact points
-    contact_points_ = generate_contact_points(ccm_->get_ip_prefix(),
-                      number_dc1_nodes_ + number_dc2_nodes_);
+    contact_points_ =
+        generate_contact_points(ccm_->get_ip_prefix(), number_dc1_nodes_ + number_dc2_nodes_);
 
     // Determine if the session connection should be established
     if (is_session_requested_ && is_ccm_start_requested_) {
@@ -210,9 +198,9 @@ void Integration::TearDown() {
     std::stringstream use_keyspace_query;
     use_keyspace_query << "DROP KEYSPACE " << keyspace_name_;
     try {
-      session_.execute(use_keyspace_query.str(), CASS_CONSISTENCY_ANY, false,
-                       false);
-    } catch (...) { }
+      session_.execute(use_keyspace_query.str(), CASS_CONSISTENCY_ANY, false, false);
+    } catch (...) {
+    }
   }
 
   // Determine if the CCM cluster should be destroyed
@@ -230,13 +218,13 @@ std::string Integration::default_keyspace() {
 
   // Clean up the initial keyspace name (remove category information)
   keyspace_name_ = to_lower(test_case_name_) + "_" + to_lower(test_name_);
-  keyspace_name_ = replace_all(keyspace_name_, "tests", ""); //TODO: Rename integration tests (remove 's' or add 's')
+  keyspace_name_ = replace_all(keyspace_name_, "tests",
+                               ""); // TODO: Rename integration tests (remove 's' or add 's')
   keyspace_name_ = replace_all(keyspace_name_, "test", "");
   keyspace_name_ = replace_all(keyspace_name_, "integration", "");
-  for (TestCategory::iterator iterator = TestCategory::begin();
-    iterator != TestCategory::end(); ++iterator) {
-    keyspace_name_ = replace_all(keyspace_name_,
-      "_" + to_lower(iterator->name()) + "_", "");
+  for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
+       ++iterator) {
+    keyspace_name_ = replace_all(keyspace_name_, "_" + to_lower(iterator->name()) + "_", "");
   }
 
   // Generate the keyspace name
@@ -246,17 +234,15 @@ std::string Integration::default_keyspace() {
 
 unsigned short Integration::default_replication_factor() {
   // Calculate and return the default replication factor
-  return (number_dc1_nodes_ % 2 == 0)
-    ? number_dc1_nodes_ / 2
-    : (number_dc1_nodes_ + 1) / 2;
+  return (number_dc1_nodes_ % 2 == 0) ? number_dc1_nodes_ / 2 : (number_dc1_nodes_ + 1) / 2;
 }
 
 std::string Integration::default_replication_strategy() {
   // Determine the replication strategy
   std::stringstream replication_strategy_s;
   if (number_dc2_nodes_ > 0) {
-    replication_strategy_s << "'NetworkTopologyStrategy', 'dc1': "
-      << number_dc1_nodes_ << ", " << "'dc2': " << number_dc2_nodes_;
+    replication_strategy_s << "'NetworkTopologyStrategy', 'dc1': " << number_dc1_nodes_ << ", "
+                           << "'dc2': " << number_dc2_nodes_;
   } else {
     replication_strategy_s << "'SimpleStrategy', 'replication_factor': ";
 
@@ -279,10 +265,8 @@ std::string Integration::default_select_all() {
 }
 
 int64_t Integration::default_select_count() {
-  Result result = session_.execute(format_string(SELECT_COUNT_FORMAT,
-                                                 table_name_.c_str()));
-  EXPECT_EQ(CASS_OK, result.error_code()) << "Unable to get Row Count: "
-    << result.error_message();
+  Result result = session_.execute(format_string(SELECT_COUNT_FORMAT, table_name_.c_str()));
+  EXPECT_EQ(CASS_OK, result.error_code()) << "Unable to get Row Count: " << result.error_message();
   return result.first_row().next().as<BigInteger>().value();
 }
 
@@ -324,7 +308,8 @@ void Integration::connect(Cluster cluster) {
     } else {
       server_version_ = ccm_->get_cassandra_version();
     }
-    TEST_LOG("Branch/Tag Option was Used: Retrieved server version is " << server_version_.to_string());
+    TEST_LOG("Branch/Tag Option was Used: Retrieved server version is "
+             << server_version_.to_string());
   }
 
   // Create the keyspace for the integration test
@@ -346,21 +331,19 @@ void Integration::connect() {
 test::driver::Cluster Integration::default_cluster(bool is_with_default_contact_points /*= true*/) {
   // Create the default cluster object
   Cluster cluster = Cluster::build()
-    .with_randomized_contact_points(is_randomized_contact_points_)
-    .with_schema_metadata(is_schema_metadata_);
+                        .with_randomized_contact_points(is_randomized_contact_points_)
+                        .with_schema_metadata(is_schema_metadata_);
   if (is_with_default_contact_points) {
     cluster.with_contact_points(contact_points_);
   }
-  if (server_version_ >= "3.10" &&
-      protocol_version_ == CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION) {
+  if (server_version_ >= "3.10" && protocol_version_ == CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION) {
     cluster.with_beta_protocol(is_beta_protocol_);
   } else {
     cluster.with_protocol_version(protocol_version_);
   }
 
   // Assign the execution profiles to the cluster object (if available)
-  for(ExecutionProfile::Map::iterator it = profiles_.begin();
-      it != profiles_.end(); ++it) {
+  for (ExecutionProfile::Map::iterator it = profiles_.begin(); it != profiles_.end(); ++it) {
     cluster.with_execution_profile(it->first, it->second);
   }
   return cluster;
@@ -369,7 +352,7 @@ test::driver::Cluster Integration::default_cluster(bool is_with_default_contact_
 void Integration::enable_cluster_tracing(bool enable /*= true*/) {
   std::vector<std::string> active_nodes = ccm_->cluster_ip_addresses();
   for (std::vector<std::string>::iterator iterator = active_nodes.begin();
-    iterator != active_nodes.end(); ++iterator) {
+       iterator != active_nodes.end(); ++iterator) {
     // Get the node number from the IP address
     std::string node_ip_address = *iterator;
     std::stringstream node_value;
@@ -382,8 +365,7 @@ void Integration::enable_cluster_tracing(bool enable /*= true*/) {
   }
 }
 
-bool Integration::decommission_node(unsigned int node,
-                                    bool is_force /*= false */) {
+bool Integration::decommission_node(unsigned int node, bool is_force /*= false */) {
   // Decommission the requested node
   bool status = ccm_->decommission_node(node, is_force);
   if (status) {
@@ -401,9 +383,8 @@ bool Integration::start_node(unsigned int node) {
   // Stop the requested node
   if (ccm_->is_node_down(node, true)) {
     bool status = ccm_->start_node(node);
-    std::vector<unsigned int>::iterator it = std::find(stopped_nodes_.begin(),
-                                                       stopped_nodes_.end(),
-                                                       node);
+    std::vector<unsigned int>::iterator it =
+        std::find(stopped_nodes_.begin(), stopped_nodes_.end(), node);
     if (it != stopped_nodes_.end()) {
       stopped_nodes_.erase(it);
     }
@@ -450,12 +431,10 @@ std::string Integration::format_string(const char* format, ...) const {
   return buffer;
 }
 
-void Integration::maybe_shrink_name(std::string& name)
-{
+void Integration::maybe_shrink_name(std::string& name) {
   if (name.size() > ENTITY_MAXIMUM_LENGTH) {
     // Update the name with a UUID (first portions of v4 UUID)
-    std::vector<std::string> uuid_octets = explode(
-      uuid_generator_.generate_timeuuid().str(), '-');
+    std::vector<std::string> uuid_octets = explode(uuid_generator_.generate_timeuuid().str(), '-');
     std::string id = uuid_octets[0] + uuid_octets[3];
     name = name.substr(0, ENTITY_MAXIMUM_LENGTH - id.size()) + id;
   }
@@ -463,8 +442,7 @@ void Integration::maybe_shrink_name(std::string& name)
 
 bool Integration::wait_for_logger(size_t expected_count) {
   start_timer();
-  while (elapsed_time() < LOGGER_MAXIMUM_WAIT_TIME_MS
-         && logger_.count() < expected_count) {
+  while (elapsed_time() < LOGGER_MAXIMUM_WAIT_TIME_MS && logger_.count() < expected_count) {
     msleep(LOGGER_WAIT_FOR_NAP_MS);
   }
   return logger_.count() >= expected_count;
diff --git a/gtests/src/integration/integration.hpp b/gtests/src/integration/integration.hpp
index c88fee7a3..c7d7a9734 100644
--- a/gtests/src/integration/integration.hpp
+++ b/gtests/src/integration/integration.hpp
@@ -36,14 +36,12 @@
 #include "values.hpp"
 
 // Macros for grouping tests together
-#define GROUP_TEST_F(group_name, test_case, test_name) \
-  TEST_F(test_case, group_name##_##test_name)
+#define GROUP_TEST_F(group_name, test_case, test_name) TEST_F(test_case, group_name##_##test_name)
 #define GROUP_TYPED_TEST_P(group_name, test_case, test_name) \
   TYPED_TEST_P(test_case, group_name##_##test_name)
 
 // Macros to use for grouping integration tests together
-#define GROUP_INTEGRATION_TEST(server_type) \
-  GROUP_CONCAT(Integration, server_type)
+#define GROUP_INTEGRATION_TEST(server_type) GROUP_CONCAT(Integration, server_type)
 #define INTEGRATION_TEST_F(server_type, test_case, test_name) \
   GROUP_TEST_F(Integration##_##server_type, test_case, test_name)
 #define INTEGRATION_TYPED_TEST_P(server_type, test_case, test_name) \
@@ -64,52 +62,50 @@
 #define CASSANDRA_INTEGRATION_DISABLED_TYPED_TEST_P(test_case, test_name) \
   INTEGRATION_DISABLED_TYPED_TEST_P(Cassandra, test_case, test_name)
 
-//TODO: Create SKIP_SUITE macro; reduces noise and makes sense for certain suites
+// TODO: Create SKIP_SUITE macro; reduces noise and makes sense for certain suites
 
-#define SKIP_TEST(message) \
-  if (!Integration::skipped_message_displayed_) { \
+#define SKIP_TEST(message)                                \
+  if (!Integration::skipped_message_displayed_) {         \
     std::cout << "[ SKIPPED  ] " << message << std::endl; \
-    Integration::skipped_message_displayed_ = true; \
-  } \
+    Integration::skipped_message_displayed_ = true;       \
+  }                                                       \
   return;
 
-#define CHECK_FAILURE \
+#define CHECK_FAILURE       \
   if (this->HasFailure()) { \
-    return; \
+    return;                 \
   }
 
 #define SKIP_TEST_VERSION(server_version_string, version_string) \
-  SKIP_TEST("Unsupported for Apache Cassandra Version " \
-    << server_version_string << ": Server version " \
-    << version_string << "+ is required")
-
-#define CHECK_VERSION(version) do { \
-  CCM::CassVersion cass_version = this->server_version_; \
-  if (Options::is_dse()) { \
-    cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version(); \
-  } \
-  if (cass_version < #version) { \
-    SKIP_TEST_VERSION(cass_version.to_string(), #version) \
-  } \
-} while(0)
-
-#define CHECK_OPTIONS_VERSION(version) \
-  if (Options::server_version() < #version) { \
+  SKIP_TEST("Unsupported for Apache Cassandra Version "          \
+            << server_version_string << ": Server version " << version_string << "+ is required")
+
+#define CHECK_VERSION(version)                                                      \
+  do {                                                                              \
+    CCM::CassVersion cass_version = this->server_version_;                          \
+    if (Options::is_dse()) {                                                        \
+      cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version(); \
+    }                                                                               \
+    if (cass_version < #version) {                                                  \
+      SKIP_TEST_VERSION(cass_version.to_string(), #version)                         \
+    }                                                                               \
+  } while (0)
+
+#define CHECK_OPTIONS_VERSION(version)                                 \
+  if (Options::server_version() < #version) {                          \
     SKIP_TEST_VERSION(Options::server_version().to_string(), #version) \
   }
 
-#define CHECK_VALUE_TYPE_VERSION(type) \
-  CCM::CassVersion cass_version = this->server_version_; \
-  if (Options::is_dse()) { \
+#define CHECK_VALUE_TYPE_VERSION(type)                                            \
+  CCM::CassVersion cass_version = this->server_version_;                          \
+  if (Options::is_dse()) {                                                        \
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version(); \
-  } \
-  if (cass_version < type::supported_server_version()) { \
-    SKIP_TEST_VERSION(cass_version.to_string(), \
-                      type::supported_server_version()) \
+  }                                                                               \
+  if (cass_version < type::supported_server_version()) {                          \
+    SKIP_TEST_VERSION(cass_version.to_string(), type::supported_server_version()) \
   }
 
-#define CHECK_CONTINUE(flag, message) \
-  ASSERT_TRUE(flag) << message; \
+#define CHECK_CONTINUE(flag, message) ASSERT_TRUE(flag) << message;
 
 #define CASSANDRA_KEY_VALUE_TABLE_FORMAT "CREATE TABLE %s (key %s PRIMARY KEY, value %s)"
 #define CASSANDRA_KEY_VALUE_INSERT_FORMAT "INSERT INTO %s (key, value) VALUES(%s, %s)"
@@ -455,8 +451,7 @@ class Integration : public testing::Test {
    * @param number_of_nodes Total number of nodes in the cluster
    * @return Comma delimited IP address (e.g. contact points)
    */
-  std::string generate_contact_points(const std::string& ip_prefix,
-    size_t number_of_nodes);
+  std::string generate_contact_points(const std::string& ip_prefix, size_t number_of_nodes);
 
   /**
    * Variable argument string formatter
@@ -481,9 +476,7 @@ class Integration : public testing::Test {
   /**
    * Start the timer to calculate the elapsed time
    */
-  inline void start_timer() {
-    start_time_ = uv_hrtime();
-  }
+  inline void start_timer() { start_time_ = uv_hrtime(); }
 
   /**
    * Stop the timer - Calculate the elapsed time and reset the timer
@@ -501,9 +494,7 @@ class Integration : public testing::Test {
    *
    * @return Current working directory
    */
-  inline static std::string cwd() {
-    return Utils::cwd();
-  }
+  inline static std::string cwd() { return Utils::cwd(); }
 
   /**
    * Determine if a string contains another string
@@ -512,8 +503,7 @@ class Integration : public testing::Test {
    * @param search String to find
    * @return True if string is contained in other string; false otherwise
    */
-  inline static bool contains(const std::string& input,
-    const std::string& search) {
+  inline static bool contains(const std::string& input, const std::string& search) {
     return Utils::contains(input, search);
   }
 
@@ -525,7 +515,7 @@ class Integration : public testing::Test {
    * @return An array/vector representation of the string
    */
   inline static std::vector<std::string> explode(const std::string& input,
-    const char delimiter = ' ') {
+                                                 const char delimiter = ' ') {
     return Utils::explode(input, delimiter);
   }
 
@@ -557,18 +547,14 @@ class Integration : public testing::Test {
    *
    * @param path Directory/Path to create
    */
-  inline static void mkdir(const std::string& path) {
-    Utils::mkdir(path);
-  }
+  inline static void mkdir(const std::string& path) { Utils::mkdir(path); }
 
   /**
    * Cross platform millisecond granularity sleep
    *
    * @param milliseconds Time in milliseconds to sleep
    */
-  inline static void msleep(unsigned int milliseconds) {
-    Utils::msleep(milliseconds);
-  }
+  inline static void msleep(unsigned int milliseconds) { Utils::msleep(milliseconds); }
 
   /**
    * Replace all occurrences of a string from the input string
@@ -578,8 +564,8 @@ class Integration : public testing::Test {
    * @param to String to replace with
    * @return Input string with replacement
    */
-  inline static std::string replace_all(const std::string& input,
-    const std::string& from, const std::string& to) {
+  inline static std::string replace_all(const std::string& input, const std::string& from,
+                                        const std::string& to) {
     return Utils::replace_all(input, from, to);
   }
 
@@ -588,9 +574,7 @@ class Integration : public testing::Test {
    *
    * @param input String to convert to lowercase
    */
-  inline static std::string to_lower(const std::string& input) {
-    return Utils::to_lower(input);
-  }
+  inline static std::string to_lower(const std::string& input) { return Utils::to_lower(input); }
 
   /**
    * Remove the leading and trailing whitespace from a string
@@ -598,9 +582,7 @@ class Integration : public testing::Test {
    * @param input String to trim
    * @return Trimmed string
    */
-  inline static std::string trim(const std::string& input) {
-    return Utils::trim(input);
-  }
+  inline static std::string trim(const std::string& input) { return Utils::trim(input); }
 
   /**
    * Shrink the given name if the name is longer than allowable by the server
diff --git a/gtests/src/integration/logger.cpp b/gtests/src/integration/logger.cpp
index 6db09bbb4..e8ad5008e 100644
--- a/gtests/src/integration/logger.cpp
+++ b/gtests/src/integration/logger.cpp
@@ -25,19 +25,20 @@
 #include <iostream>
 #include <sstream>
 
+using namespace datastax::internal;
 using namespace test::driver;
 
 #define LOGGER_DIRECTORY "log"
 #ifdef _WIN32
-# define FILE_MODE 0
-# define LOCALTIME(tm, time) localtime_s(tm, time)
+#define FILE_MODE 0
+#define LOCALTIME(tm, time) localtime_s(tm, time)
 #else
-# define FILE_MODE S_IRWXU | S_IRWXG | S_IROTH
-# define LOCALTIME(tm, time) localtime_r(time, tm)
+#define FILE_MODE S_IRWXU | S_IRWXG | S_IROTH
+#define LOCALTIME(tm, time) localtime_r(time, tm)
 #endif
 
 Logger::Logger()
-  : count_(0) { }
+    : count_(0) {}
 
 Logger::~Logger() {
   if (output_.is_open()) {
@@ -52,7 +53,7 @@ void Logger::initialize(const std::string& test_case, const std::string& test_na
   std::vector<std::string> path_tokens = Utils::explode(path, Utils::PATH_SEPARATOR);
   std::string mkdir_path;
   for (std::vector<std::string>::const_iterator iterator = path_tokens.begin();
-    iterator < path_tokens.end(); ++iterator) {
+       iterator < path_tokens.end(); ++iterator) {
     mkdir_path += *iterator + Utils::PATH_SEPARATOR;
     Utils::mkdir(mkdir_path);
   }
@@ -75,22 +76,20 @@ void Logger::initialize(const std::string& test_case, const std::string& test_na
 }
 
 void Logger::add_critera(const std::string& criteria) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.push_back(criteria);
 }
 
 void test::driver::Logger::clear_critera() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.clear();
 }
 
-size_t Logger::count() {
-  return count_;
-}
+size_t Logger::count() { return count_; }
 
 void Logger::log(const CassLogMessage* log, void* data) {
   Logger* logger = static_cast<Logger*>(data);
-  cass::ScopedMutex lock(&(logger->mutex_));
+  ScopedMutex lock(&(logger->mutex_));
 
   // Get the log message
   std::string message = log->message;
@@ -105,27 +104,24 @@ void Logger::log(const CassLogMessage* log, void* data) {
   // Create the date formatted output
   std::stringstream date;
   int month = (date_time.tm_mon + 1);
-  date << date_time.tm_year + 1900 << "/"
-    << (month < 10 ? "0" : "") << month << "/"
-    << (date_time.tm_mday < 10 ? "0" : "") << date_time.tm_mday;
+  date << date_time.tm_year + 1900 << "/" << (month < 10 ? "0" : "") << month << "/"
+       << (date_time.tm_mday < 10 ? "0" : "") << date_time.tm_mday;
 
   // Create the formatted time
   std::stringstream time;
   time << (date_time.tm_hour < 10 ? "0" : "") << date_time.tm_hour << ":"
-    << (date_time.tm_min < 10 ? "0" : "") << date_time.tm_min << ":"
-    << (date_time.tm_sec < 10 ? "0" : "") << date_time.tm_sec << "."
-    << std::setfill('0') << std::setw(3) << milliseconds;
+       << (date_time.tm_min < 10 ? "0" : "") << date_time.tm_min << ":"
+       << (date_time.tm_sec < 10 ? "0" : "") << date_time.tm_sec << "." << std::setfill('0')
+       << std::setw(3) << milliseconds;
 
   // Create the formatted log message and output to the file
   std::string severity = cass_log_level_string(log->severity);
-  logger->output_ << date.str() << " " << time.str() << " "
-                  << severity << ": " << message
-                  << " (" << log->file << ":" << log->line << ") " << std::endl;
-
+  logger->output_ << date.str() << " " << time.str() << " " << severity << ": " << message << " ("
+                  << log->file << ":" << log->line << ") " << std::endl;
 
   // Determine if the log message matches any of the criteria
   for (std::vector<std::string>::const_iterator iterator = logger->search_criteria_.begin();
-      iterator != logger->search_criteria_.end(); ++iterator) {
+       iterator != logger->search_criteria_.end(); ++iterator) {
     if (message.find(*iterator) != std::string::npos) {
       ++logger->count_;
     }
@@ -133,13 +129,12 @@ void Logger::log(const CassLogMessage* log, void* data) {
 }
 
 void test::driver::Logger::reset() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.clear();
   count_ = 0;
 }
 
 void test::driver::Logger::reset_count() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   count_ = 0;
 }
-
diff --git a/gtests/src/integration/logger.hpp b/gtests/src/integration/logger.hpp
index f8694080d..82ea20233 100644
--- a/gtests/src/integration/logger.hpp
+++ b/gtests/src/integration/logger.hpp
@@ -26,8 +26,7 @@
 #include <string>
 #include <vector>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Logger class for handling log messages from the driver
@@ -108,8 +107,6 @@ class Logger {
   static void log(const CassLogMessage* log, void* data);
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_LOGGER_HPP__
-
diff --git a/gtests/src/integration/main.cpp b/gtests/src/integration/main.cpp
index 6ea5ca1e3..c9b2bcdd4 100644
--- a/gtests/src/integration/main.cpp
+++ b/gtests/src/integration/main.cpp
@@ -31,23 +31,19 @@
 class BootstrapListener : public testing::EmptyTestEventListener {
 public:
   BootstrapListener()
-    : is_settings_displayed_(false) {}
+      : is_settings_displayed_(false) {}
 
   /**
    * Set the current test category being executed
    *
    * @param category Current category
    */
-  void set_category(TestCategory category) {
-    category_ = category;
-  }
+  void set_category(TestCategory category) { category_ = category; }
 
   void OnTestProgramStart(const testing::UnitTest& unit_test) {
     if (!is_settings_displayed_) {
       std::cout << "Starting DataStax C/C++ Driver Integration Test" << std::endl;
-      std::cout << "  Cassandra driver v"
-                << CASS_VERSION_MAJOR << "."
-                << CASS_VERSION_MINOR << "."
+      std::cout << "  Cassandra driver v" << CASS_VERSION_MAJOR << "." << CASS_VERSION_MINOR << "."
                 << CASS_VERSION_PATCH;
       if (!std::string(CASS_VERSION_SUFFIX).empty()) {
         std::cout << "-" << CASS_VERSION_SUFFIX;
@@ -88,12 +84,11 @@ class BootstrapListener : public testing::EmptyTestEventListener {
  * @param base_filter Base filter being applied to exclusion
  * @return Filter pattern to execute for the given category
  */
-std::string generate_filter(TestCategory category,
-  const std::string& base_filter) {
+std::string generate_filter(TestCategory category, const std::string& base_filter) {
   // Create the exclusion filter by iterating over the available categories
   std::string exclude_filter;
-  for (TestCategory::iterator iterator = TestCategory::begin();
-    iterator != TestCategory::end(); ++iterator) {
+  for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
+       ++iterator) {
     if (category != *iterator) {
       exclude_filter += ":" + iterator->filter();
     }
@@ -120,10 +115,10 @@ int main(int argc, char* argv[]) {
 #if defined(_WIN32) && defined(_DEBUG)
   // Add the memory leak checking to the listener callbacks
   listeners.Append(new MemoryLeakListener());
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   // Google test statically initializes heap objects; mark all leaks as reported
   VLDMarkAllLeaksAsReported();
-# endif
+#endif
 #endif
 
   // Initialize the options for the integration test
@@ -133,7 +128,7 @@ int main(int argc, char* argv[]) {
     const std::string base_filter = ::testing::GTEST_FLAG(filter);
     std::set<TestCategory> categories = Options::categories();
     for (std::set<TestCategory>::iterator iterator = categories.begin();
-      iterator != categories.end(); ++iterator) {
+         iterator != categories.end(); ++iterator) {
       // Update the filtering based on the current category
       ::testing::GTEST_FLAG(filter) = generate_filter(*iterator, base_filter);
       listener->set_category(*iterator);
@@ -143,7 +138,7 @@ int main(int argc, char* argv[]) {
         exit_status = 1;
       }
     }
-    //TODO: Write a custom start and end report for all categories executed
+    // TODO: Write a custom start and end report for all categories executed
     std::cout << "Finishing DataStax C/C++ Driver Integration Test" << std::endl;
     return exit_status;
   }
diff --git a/gtests/src/integration/nullable_value.hpp b/gtests/src/integration/nullable_value.hpp
index 65c7093dd..a37a96f1e 100644
--- a/gtests/src/integration/nullable_value.hpp
+++ b/gtests/src/integration/nullable_value.hpp
@@ -27,30 +27,21 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Create a comparable template to act as an interface for comparing
  * values.
  */
-template<typename T>
+template <typename T>
 class Comparable {
-  friend bool operator==(const T& lhs, const T& rhs) {
-    return lhs.compare(rhs) == 0;
-  }
+  friend bool operator==(const T& lhs, const T& rhs) { return lhs.compare(rhs) == 0; }
 
-  friend bool operator!=(const T& lhs, const T& rhs) {
-    return lhs.compare(rhs) != 0;
-  }
+  friend bool operator!=(const T& lhs, const T& rhs) { return lhs.compare(rhs) != 0; }
 
-  friend bool operator<(const T& lhs, const T& rhs) {
-    return lhs.compare(rhs) <= -1;
-  }
+  friend bool operator<(const T& lhs, const T& rhs) { return lhs.compare(rhs) <= -1; }
 
-  friend bool operator>(const T& lhs, const T& rhs) {
-    return lhs.compare(rhs) >= -1;
-  }
+  friend bool operator>(const T& lhs, const T& rhs) { return lhs.compare(rhs) >= -1; }
 };
 
 /**
@@ -59,14 +50,14 @@ class Comparable {
  * value type and other miscellaneous needs for testing; while also allowing the
  * value to be NULL.
  */
-template<typename T>
+template <typename T>
 class NullableValue : public Comparable<NullableValue<T> > {
 public:
   /**
    * Constructor for a NULL value
    */
   NullableValue()
-    : is_null_(true) { };
+      : is_null_(true){};
 
   /**
    * Constructor for a nullable value; convenience constructor
@@ -74,8 +65,8 @@ class NullableValue : public Comparable<NullableValue<T> > {
    * @param value Typed value
    */
   explicit NullableValue(const typename T::ConvenienceType& value)
-    : is_null_(false)
-    , value_(value) { }
+      : is_null_(false)
+      , value_(value) {}
 
   /**
    * Constructor for a nullable value using the wrapped type
@@ -83,8 +74,8 @@ class NullableValue : public Comparable<NullableValue<T> > {
    * @param value Wrapped type value
    */
   explicit NullableValue(const T& value)
-    : is_null_(false)
-    , value_(value) { }
+      : is_null_(false)
+      , value_(value) {}
 
   /**
    * Constructor for a nullable value using the drivers primitive/collection
@@ -93,7 +84,7 @@ class NullableValue : public Comparable<NullableValue<T> > {
    * @param value CassValue from driver query
    */
   explicit NullableValue(const CassValue* value)
-    : is_null_(false) {
+      : is_null_(false) {
     initialize(value);
   }
 
@@ -102,27 +93,21 @@ class NullableValue : public Comparable<NullableValue<T> > {
    *
    * @param collection Collection to append the value to
    */
-  void append(Collection collection) {
-    value_.append(collection);
-  }
+  void append(Collection collection) { value_.append(collection); }
 
   /**
    * Get the CQL type
    *
    * @return CQL type name
    */
-  std::string cql_type() const {
-    return value_.cql_type();
-  }
+  std::string cql_type() const { return value_.cql_type(); }
 
   /**
    * Get the CQL value (for embedded simple statements)
    *
    * @return CQL type value
    */
-  std::string cql_value() const {
-    return value_.cql_value();
-  }
+  std::string cql_value() const { return value_.cql_value(); }
 
   /**
    * Comparison operation for Comparable template
@@ -172,27 +157,21 @@ class NullableValue : public Comparable<NullableValue<T> > {
    *
    * @return True if value is NULL; false otherwise
    */
-  bool is_null() const {
-    return is_null_;
-  }
+  bool is_null() const { return is_null_; }
 
   /**
    * Get the maximum value
    *
    * @return Maximum value
    */
-  static NullableValue<T> max() {
-    return NullableValue<T>(T::max());
-  }
+  static NullableValue<T> max() { return NullableValue<T>(T::max()); }
 
   /**
    * Get the minimum value
    *
    * @return Minimum value
    */
-  static NullableValue<T> min() {
-    return NullableValue<T>(T::min());
-  }
+  static NullableValue<T> min() { return NullableValue<T>(T::min()); }
 
   /**
    * Set the value to a index in the tuple
@@ -216,8 +195,7 @@ class NullableValue : public Comparable<NullableValue<T> > {
    */
   void set(UserType user_type, const std::string& name) {
     if (is_null_) {
-      ASSERT_EQ(CASS_OK,
-                cass_user_type_set_null_by_name(user_type.get(), name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_user_type_set_null_by_name(user_type.get(), name.c_str()));
     } else {
       value_.set(user_type, name);
     }
@@ -246,8 +224,7 @@ class NullableValue : public Comparable<NullableValue<T> > {
    */
   void statement_bind(Statement statement, const std::string& name) {
     if (is_null_) {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(),
-                                                          name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(), name.c_str()));
     } else {
       value_.statement_bind(statement, name);
     }
@@ -269,42 +246,34 @@ class NullableValue : public Comparable<NullableValue<T> > {
    *
    * @return Minimum server version allowed for value
    */
-  static std::string supported_server_version() {
-    return T::supported_server_version();
-  }
+  static std::string supported_server_version() { return T::supported_server_version(); }
 
   /**
    * Get the driver value
    *
    * @return Driver value
    */
-  typename T::ValueType value() const {
-    return value_.value();
-  }
+  typename T::ValueType value() const { return value_.value(); }
 
   /**
    * Get the wrapped value
    *
    * @return Wrapped value type (templated type)
    */
-  T wrapped_value() const {
-    return value_;
-  }
+  T wrapped_value() const { return value_; }
 
   /**
    * Get the type of value the native driver value is
    *
    * @return Value type of the native driver value
    */
-  CassValueType value_type() const {
-    return value_.value_type();
-  }
+  CassValueType value_type() const { return value_.value_type(); }
 
-  NullableValue<T> operator -(const NullableValue<T>& rhs) {
+  NullableValue<T> operator-(const NullableValue<T>& rhs) {
     return NullableValue<T>(value_ - rhs.value_);
   }
 
-  NullableValue<T> operator +(const NullableValue<T>& rhs) {
+  NullableValue<T> operator+(const NullableValue<T>& rhs) {
     return NullableValue<T>(value_ + rhs.value_);
   }
 
@@ -319,15 +288,12 @@ class NullableValue : public Comparable<NullableValue<T> > {
   T value_;
 };
 
-template<typename T>
-inline std::ostream& operator<<(std::ostream& output_stream,
-                               const NullableValue<T>& value) {
+template <typename T>
+inline std::ostream& operator<<(std::ostream& output_stream, const NullableValue<T>& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_NULLBALE_VALUE_HPP__
diff --git a/gtests/src/integration/objects/cluster.hpp b/gtests/src/integration/objects/cluster.hpp
index 50a572a1e..07949e300 100644
--- a/gtests/src/integration/objects/cluster.hpp
+++ b/gtests/src/integration/objects/cluster.hpp
@@ -26,8 +26,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped cluster object (builder)
@@ -38,7 +37,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * Create the cluster for the builder object
    */
   Cluster()
-    : Object<CassCluster, cass_cluster_free>(cass_cluster_new()) { }
+      : Object<CassCluster, cass_cluster_free>(cass_cluster_new()) {}
 
   /**
    * Create the cluster for the builder object
@@ -46,7 +45,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @param cluster Already defined cluster object to utilize
    */
   Cluster(CassCluster* cluster)
-    : Object<CassCluster, cass_cluster_free>(cluster) { }
+      : Object<CassCluster, cass_cluster_free>(cluster) {}
 
   /**
    * Create the cluster object from a shared reference
@@ -54,21 +53,19 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @param cluster Shared reference
    */
   Cluster(Ptr cluster)
-    : Object<CassCluster, cass_cluster_free>(cluster) { }
+      : Object<CassCluster, cass_cluster_free>(cluster) {}
 
   /**
    * Destroy the cluster
    */
-  virtual ~Cluster() {};
+  virtual ~Cluster(){};
 
   /**
    * Build/Create the cluster
    *
    * @return Cluster object
    */
-  static Cluster build() {
-    return Cluster();
-  }
+  static Cluster build() { return Cluster(); }
 
   /**
    * Sets the custom authenticator
@@ -76,8 +73,8 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
   Cluster& with_authenticator_callbacks(const CassAuthenticatorCallbacks* exchange_callbacks,
                                         CassAuthenticatorDataCleanupCallback cleanup_callback,
                                         void* data) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_authenticator_callbacks(get(),
-              exchange_callbacks, cleanup_callback, data));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_authenticator_callbacks(get(), exchange_callbacks,
+                                                                cleanup_callback, data));
     return *this;
   }
 
@@ -89,8 +86,8 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_beta_protocol(bool enable = false) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_use_beta_protocol_version(get(),
-              (enable == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_use_beta_protocol_version(
+                           get(), (enable == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -129,8 +126,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_contact_points(const std::string& contact_points) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_contact_points(get(),
-      contact_points.c_str()));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_contact_points(get(), contact_points.c_str()));
     return *this;
   }
 
@@ -142,8 +138,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_local_address(const std::string& name) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_local_address(get(),
-      name.c_str()));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_local_address(get(), name.c_str()));
     return *this;
   }
 
@@ -157,8 +152,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_core_connections_per_host(unsigned int connections = 1u) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_core_connections_per_host(get(),
-      connections));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_core_connections_per_host(get(), connections));
     return *this;
   }
 
@@ -169,8 +163,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * param password Password
    * @return Cluster object
    */
-  Cluster& with_credentials(const char* username,
-                            const char* password) {
+  Cluster& with_credentials(const char* username, const char* password) {
     cass_cluster_set_credentials(get(), username, password);
     return *this;
   }
@@ -182,10 +175,8 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @param profile Execution profile to add to the cluster
    * @return Cluster object
    */
-  Cluster& with_execution_profile(const std::string& name,
-                                  ExecutionProfile profile) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_execution_profile(get(),
-              name.c_str(), profile.get()));
+  Cluster& with_execution_profile(const std::string& name, ExecutionProfile profile) {
+    EXPECT_EQ(CASS_OK, cass_cluster_set_execution_profile(get(), name.c_str(), profile.get()));
     return *this;
   }
 
@@ -196,11 +187,8 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @param data User data supplied to the callback (default: NULL)
    * @return Cluster object
    */
-  Cluster& with_host_listener_callback(CassHostListenerCallback callback,
-                                       void* data = NULL) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_host_listener_callback(get(),
-                                                               callback,
-                                                               data));
+  Cluster& with_host_listener_callback(CassHostListenerCallback callback, void* data = NULL) {
+    EXPECT_EQ(CASS_OK, cass_cluster_set_host_listener_callback(get(), callback, data));
     return *this;
   }
 
@@ -215,8 +203,8 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_hostname_resolution(bool enable = true) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_use_hostname_resolution(get(),
-      (enable == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_use_hostname_resolution(
+                           get(), (enable == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -246,13 +234,11 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    *                                      otherwise false
    * @return Cluster object
    */
-  Cluster& with_load_balance_dc_aware(const std::string& local_dc,
-                                      size_t used_hosts_per_remote_dc,
+  Cluster& with_load_balance_dc_aware(const std::string& local_dc, size_t used_hosts_per_remote_dc,
                                       bool allow_remote_dcs_for_local_cl) {
-    EXPECT_EQ(CASS_OK,
-              cass_cluster_set_load_balance_dc_aware(get(), local_dc.c_str(),
-              used_hosts_per_remote_dc,
-              (allow_remote_dcs_for_local_cl == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_load_balance_dc_aware(
+                           get(), local_dc.c_str(), used_hosts_per_remote_dc,
+                           (allow_remote_dcs_for_local_cl == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -274,9 +260,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_no_compact(bool enable = true) {
-    EXPECT_EQ(CASS_OK,
-              cass_cluster_set_no_compact(get(),
-                                          enable == true ? cass_true : cass_false));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_no_compact(get(), enable == true ? cass_true : cass_false));
     return *this;
   }
 
@@ -300,8 +284,7 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    * @return Cluster object
    */
   Cluster& with_protocol_version(int protocol_version) {
-    EXPECT_EQ(CASS_OK, cass_cluster_set_protocol_version(get(),
-      protocol_version));
+    EXPECT_EQ(CASS_OK, cass_cluster_set_protocol_version(get(), protocol_version));
     return *this;
   }
 
@@ -314,18 +297,18 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
    */
   Cluster& with_randomized_contact_points(bool enable = true) {
     cass_cluster_set_use_randomized_contact_points(get(),
-      (enable == true ? cass_true : cass_false));
+                                                   (enable == true ? cass_true : cass_false));
     return *this;
   }
 
   /**
-   * Sets the amount of time to wait before attempting to reconnect.
+   * Sets the constant reconnection policy.
    *
-   * @param wait_time_ms Wait time in milliseconds (default: 2000)
+   * @param delay_ms Delay in milliseconds (default: 2000)
    * @return Cluster object
    */
-  Cluster& with_reconnect_wait_time(unsigned int wait_time_ms) {
-    cass_cluster_set_reconnect_wait_time(get(), wait_time_ms);
+  Cluster& with_constant_reconnect(unsigned int delay_ms) {
+    cass_cluster_set_constant_reconnect(get(), delay_ms);
     return *this;
   }
 
@@ -381,7 +364,6 @@ class Cluster : public Object<CassCluster, cass_cluster_free> {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_CLUSTER_HPP__
diff --git a/gtests/src/integration/objects/collection.hpp b/gtests/src/integration/objects/collection.hpp
index 3da79a8ac..2d6332289 100644
--- a/gtests/src/integration/objects/collection.hpp
+++ b/gtests/src/integration/objects/collection.hpp
@@ -27,8 +27,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped collection object
@@ -38,7 +37,7 @@ class Collection : public Object<CassCollection, cass_collection_free> {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
 
   /**
@@ -47,7 +46,7 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    * @param column Column to retrieve collection from
    */
   Collection(const CassValue* column)
-    : is_null_(true) {
+      : is_null_(true) {
     initialize(column);
   }
 
@@ -57,8 +56,7 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    * @param collection Collection to append the value to
    */
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-      cass_collection_append_collection(collection.get(), get()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_collection(collection.get(), get()));
   }
 
   /**
@@ -96,12 +94,10 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    */
   void set(UserType user_type, const std::string& name) {
     if (is_null_) {
-      ASSERT_EQ(CASS_OK,
-        cass_user_type_set_null_by_name(user_type.get(), name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_user_type_set_null_by_name(user_type.get(), name.c_str()));
     } else {
       ASSERT_EQ(CASS_OK,
-        cass_user_type_set_collection_by_name(user_type.get(), name.c_str(),
-        get()));
+                cass_user_type_set_collection_by_name(user_type.get(), name.c_str(), get()));
     }
   }
 
@@ -113,8 +109,7 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    *              statement
    */
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK,
-      cass_statement_bind_collection(statement.get(), index, get()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_collection(statement.get(), index, get()));
   }
 
 protected:
@@ -152,9 +147,9 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    * @param count Size of the collection (default: 1)
    */
   Collection(CassCollectionType collection_type, size_t count = 1)
-    : Object<CassCollection, cass_collection_free>(cass_collection_new(collection_type, count))
-    , collection_type_(collection_type)
-    , is_null_(true) { }
+      : Object<CassCollection, cass_collection_free>(cass_collection_new(collection_type, count))
+      , collection_type_(collection_type)
+      , is_null_(true) {}
 
   /**
    * Append the value to the collection
@@ -163,7 +158,7 @@ class Collection : public Object<CassCollection, cass_collection_free> {
    * @throws Exception If collection is not able to have values added to it
    *         (e.g. The collection was generated from server result)
    */
-  template<typename T>
+  template <typename T>
   void append(T value) {
     ASSERT_TRUE(!value.is_null());
     value.append(*this);
@@ -181,7 +176,8 @@ class Collection : public Object<CassCollection, cass_collection_free> {
     // Ensure the value is a collection
     ASSERT_TRUE(value != NULL) << "Invalid CassValue: Value should not be null";
     if (!cass_value_is_null(value)) {
-      ASSERT_TRUE(cass_value_is_collection(value)) << "Invalid CassValue: Value is not a collection";
+      ASSERT_TRUE(cass_value_is_collection(value))
+          << "Invalid CassValue: Value is not a collection";
 
       // Determine the type of collection from the value type
       CassValueType value_type = cass_value_type(value);
@@ -211,7 +207,6 @@ class Collection : public Object<CassCollection, cass_collection_free> {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_COLLECTION_HPP__
diff --git a/gtests/src/integration/objects/custom_payload.hpp b/gtests/src/integration/objects/custom_payload.hpp
index 53b845a24..dc2d55d35 100644
--- a/gtests/src/integration/objects/custom_payload.hpp
+++ b/gtests/src/integration/objects/custom_payload.hpp
@@ -29,26 +29,24 @@
 #include <string>
 #include <utility>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Custom payload object
  */
-class CustomPayload
-  : public Object<CassCustomPayload, cass_custom_payload_free> {
+class CustomPayload : public Object<CassCustomPayload, cass_custom_payload_free> {
 public:
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   /**
    * Create an empty custom payload object
    */
   CustomPayload()
-    : Object<CassCustomPayload, cass_custom_payload_free>(cass_custom_payload_new()) { }
+      : Object<CassCustomPayload, cass_custom_payload_free>(cass_custom_payload_new()) {}
 
   /**
    * Create the custom payload from a response future
@@ -56,7 +54,7 @@ class CustomPayload
    * @param column Column to retrieve custom payload from
    */
   CustomPayload(Future future)
-    : Object<CassCustomPayload, cass_custom_payload_free>(cass_custom_payload_new()) {
+      : Object<CassCustomPayload, cass_custom_payload_free>(cass_custom_payload_new()) {
     initialize(future);
   }
 
@@ -67,9 +65,7 @@ class CustomPayload
    * @param value Blob/Bytes to set to the custom payload
    */
   void set(const std::string& name, Blob value) {
-    cass_custom_payload_set(get(),
-                            name.c_str(),
-                            value.wrapped_value().data(),
+    cass_custom_payload_set(get(), name.c_str(), value.wrapped_value().data(),
                             value.wrapped_value().size());
 
     // Update the local items map and the count
@@ -81,9 +77,7 @@ class CustomPayload
    *
    * @return The number of items in the custom payload
    */
-  size_t item_count() {
-    return items_.size();
-  }
+  size_t item_count() { return items_.size(); }
 
   /**
    * Get the item from the custom payload at the specified index
@@ -106,9 +100,7 @@ class CustomPayload
    *
    * @return The custom payload as a map of key/value pairs
    */
-  std::map<std::string, Blob> items() {
-    return items_;
-  }
+  std::map<std::string, Blob> items() { return items_; }
 
 protected:
   /**
@@ -132,17 +124,16 @@ class CustomPayload
       size_t name_length;
       const cass_byte_t* value;
       size_t value_size;
-      ASSERT_EQ(CASS_OK, cass_future_custom_payload_item(future.get(),
-                i, &name, &name_length, &value, &value_size));
+      ASSERT_EQ(CASS_OK, cass_future_custom_payload_item(future.get(), i, &name, &name_length,
+                                                         &value, &value_size));
 
       // Add the item to the map of items for the custom payload
       items_[std::string(name, name_length)] =
-        Blob(std::string(reinterpret_cast<const char*>(value), value_size));
+          Blob(std::string(reinterpret_cast<const char*>(value), value_size));
     }
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_CUSTOM_PAYLOAD_HPP__
diff --git a/gtests/src/integration/objects/execution_profile.hpp b/gtests/src/integration/objects/execution_profile.hpp
index 2ba909762..27ec94b58 100644
--- a/gtests/src/integration/objects/execution_profile.hpp
+++ b/gtests/src/integration/objects/execution_profile.hpp
@@ -16,8 +16,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped execution profile object (builder)
@@ -30,7 +29,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * Create the execution profile for the builder object
    */
   ExecutionProfile()
-    : Object<CassExecProfile, cass_execution_profile_free>(cass_execution_profile_new()) { }
+      : Object<CassExecProfile, cass_execution_profile_free>(cass_execution_profile_new()) {}
 
   /**
    * Create the execution profile for the builder object
@@ -38,7 +37,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @param profile Already defined execution profile object to utilize
    */
   ExecutionProfile(CassExecProfile* profile)
-    : Object<CassExecProfile, cass_execution_profile_free>(profile) {}
+      : Object<CassExecProfile, cass_execution_profile_free>(profile) {}
 
   /**
    * Create the execution profile object from a shared reference
@@ -46,16 +45,14 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @param profile Shared reference
    */
   ExecutionProfile(Ptr profile)
-    : Object<CassExecProfile, cass_execution_profile_free>(profile) {}
+      : Object<CassExecProfile, cass_execution_profile_free>(profile) {}
 
   /**
    * Build/Create the execution profile
    *
    * @return Execution profile object
    */
-  static ExecutionProfile build() {
-    return ExecutionProfile();
-  }
+  static ExecutionProfile build() { return ExecutionProfile(); }
 
   /**
    * Append/Assign/Set the blacklist hosts for statement/batch execution
@@ -64,22 +61,18 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_blacklist_filtering(const std::string& hosts) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_blacklist_filtering(get(),
-                hosts.c_str()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_blacklist_filtering(get(), hosts.c_str()));
     return *this;
   }
 
   /**
-  * Append/Assign/Set the blacklist data centers for statement/batch execution
-  *
-  * @param dcs A comma delimited list of data center names
-  * @return Execution profile object
-  */
+   * Append/Assign/Set the blacklist data centers for statement/batch execution
+   *
+   * @param dcs A comma delimited list of data center names
+   * @return Execution profile object
+   */
   ExecutionProfile& with_blacklist_dc_filtering(const std::string& dcs) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_blacklist_dc_filtering(get(),
-              dcs.c_str()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_blacklist_dc_filtering(get(), dcs.c_str()));
     return *this;
   }
 
@@ -90,8 +83,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_consistency(CassConsistency consistency) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_consistency(get(), consistency));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_consistency(get(), consistency));
     return *this;
   }
 
@@ -103,9 +95,8 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_latency_aware_routing(bool enable = true) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_latency_aware_routing(get(),
-                (enable == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_latency_aware_routing(
+                           get(), (enable == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -128,14 +119,12 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_latency_aware_routing_settings(double exclusion_threshold,
-                                                        uint64_t scale_ms,
-                                                        uint64_t retry_period_ms,
+                                                        uint64_t scale_ms, uint64_t retry_period_ms,
                                                         uint64_t update_rate_ms,
                                                         uint64_t min_measured) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_latency_aware_routing_settings(get(),
-                exclusion_threshold, scale_ms, retry_period_ms, update_rate_ms,
-                min_measured));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_latency_aware_routing_settings(
+                           get(), exclusion_threshold, scale_ms, retry_period_ms, update_rate_ms,
+                           min_measured));
     return *this;
   }
 
@@ -156,10 +145,9 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
   ExecutionProfile& with_load_balance_dc_aware(const std::string& local_dc,
                                                size_t used_hosts_per_remote_dc,
                                                bool allow_remote_dcs_for_local_cl) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_load_balance_dc_aware(get(),
-                local_dc.c_str(), used_hosts_per_remote_dc,
-                (allow_remote_dcs_for_local_cl == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_load_balance_dc_aware(
+                           get(), local_dc.c_str(), used_hosts_per_remote_dc,
+                           (allow_remote_dcs_for_local_cl == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -169,8 +157,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_load_balance_round_robin() {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_load_balance_round_robin(get()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_load_balance_round_robin(get()));
     return *this;
   }
 
@@ -180,8 +167,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_no_speculative_execution_policy() {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_no_speculative_execution_policy(get()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_no_speculative_execution_policy(get()));
     return *this;
   }
 
@@ -192,8 +178,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_request_timeout(uint64_t timeout_ms) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_request_timeout(get(), timeout_ms));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_request_timeout(get(), timeout_ms));
     return *this;
   }
 
@@ -204,8 +189,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_retry_policy(RetryPolicy retry_policy) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_retry_policy(get(), retry_policy.get()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_retry_policy(get(), retry_policy.get()));
     return *this;
   }
 
@@ -217,8 +201,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_serial_consistency(CassConsistency serial_consistency) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_serial_consistency(get(),serial_consistency));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_serial_consistency(get(), serial_consistency));
     return *this;
   }
 
@@ -233,10 +216,8 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    */
   ExecutionProfile& with_constant_speculative_execution_policy(cass_int64_t constant_delay_ms,
                                                                int max_speculative_executions) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_constant_speculative_execution_policy(get(),
-                                                                               constant_delay_ms,
-                                                                               max_speculative_executions));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_constant_speculative_execution_policy(
+                           get(), constant_delay_ms, max_speculative_executions));
     return *this;
   }
 
@@ -248,9 +229,8 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_token_aware_routing(bool enable = true) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_token_aware_routing(get(),
-                (enable == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_token_aware_routing(
+                           get(), (enable == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -263,9 +243,8 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_token_aware_routing_shuffle_replicas(bool enable = true) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_token_aware_routing_shuffle_replicas(get(),
-                (enable == true ? cass_true : cass_false)));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_token_aware_routing_shuffle_replicas(
+                           get(), (enable == true ? cass_true : cass_false)));
     return *this;
   }
 
@@ -276,9 +255,7 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_whitelist_filtering(const std::string& hosts) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_whitelist_filtering(get(),
-                hosts.c_str()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_whitelist_filtering(get(), hosts.c_str()));
     return *this;
   }
 
@@ -289,14 +266,11 @@ class ExecutionProfile : public Object<CassExecProfile, cass_execution_profile_f
    * @return Execution profile object
    */
   ExecutionProfile& with_whitelist_dc_filtering(const std::string& dcs) {
-    EXPECT_EQ(CASS_OK,
-              cass_execution_profile_set_whitelist_dc_filtering(get(),
-                dcs.c_str()));
+    EXPECT_EQ(CASS_OK, cass_execution_profile_set_whitelist_dc_filtering(get(), dcs.c_str()));
     return *this;
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_EXECUTION_PROFILE_HPP__
\ No newline at end of file
diff --git a/gtests/src/integration/objects/future.hpp b/gtests/src/integration/objects/future.hpp
index df034713f..b9e87c4a7 100644
--- a/gtests/src/integration/objects/future.hpp
+++ b/gtests/src/integration/objects/future.hpp
@@ -26,8 +26,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped future object
@@ -38,7 +37,7 @@ class Future : public Object<CassFuture, cass_future_free> {
    * Create the empty future object
    */
   Future()
-    : Object<CassFuture, cass_future_free>() {}
+      : Object<CassFuture, cass_future_free>() {}
 
   /**
    * Create the future object from the native driver object
@@ -46,7 +45,7 @@ class Future : public Object<CassFuture, cass_future_free> {
    * @param future Native driver object
    */
   Future(CassFuture* future)
-    : Object<CassFuture, cass_future_free>(future) {}
+      : Object<CassFuture, cass_future_free>(future) {}
 
   /**
    * Create the future object from a shared reference
@@ -54,7 +53,7 @@ class Future : public Object<CassFuture, cass_future_free> {
    * @param future Shared reference
    */
   Future(Ptr future)
-    : Object<CassFuture, cass_future_free>(future) {}
+      : Object<CassFuture, cass_future_free>(future) {}
 
   /**
    * Get the attempted hosts/addresses of the future (sorted)
@@ -70,18 +69,14 @@ class Future : public Object<CassFuture, cass_future_free> {
    *
    * @return Error code of the future
    */
-  CassError error_code() {
-    return cass_future_error_code(get());
-  }
+  CassError error_code() { return cass_future_error_code(get()); }
 
   /**
    * Get the human readable description of the error code
    *
    * @return Error description
    */
-  const std::string error_description() {
-    return std::string(cass_error_desc(error_code()));
-  }
+  const std::string error_description() { return std::string(cass_error_desc(error_code())); }
 
   /**
    * Get the error message of the future if an error occurred
@@ -100,18 +95,14 @@ class Future : public Object<CassFuture, cass_future_free> {
    *
    * @return Host/Address
    */
-  const std::string host() {
-    return internals::Utils::host(get());
-  }
+  const std::string host() { return internals::Utils::host(get()); }
 
   /**
    * Get the result from the future
    *
    * @return Result from future
    */
-  const CassResult* result() {
-    return cass_future_get_result(get());
-  }
+  const CassResult* result() { return cass_future_get_result(get()); }
 
   /**
    * Wait for the future to resolve itself
@@ -122,8 +113,7 @@ class Future : public Object<CassFuture, cass_future_free> {
   void wait(bool assert_ok = true) {
     CassError wait_code = error_code();
     if (assert_ok) {
-      ASSERT_EQ(CASS_OK, wait_code)
-        << error_description() << ": " << error_message();
+      ASSERT_EQ(CASS_OK, wait_code) << error_description() << ": " << error_message();
     }
   }
 
@@ -134,7 +124,7 @@ class Future : public Object<CassFuture, cass_future_free> {
    * @param timeout Timeout (in microseconds) for the future to resolve itself
    *                (default: 60s)
    * @param assert_true True if timeout should be asserted; false otherwise
-      *                 (default: true)
+   *                 (default: true)
    */
   void wait_timed(cass_duration_t timeout = 60000000, bool assert_true = true) {
     cass_bool_t timed_out = cass_future_wait_timed(get(), timeout);
@@ -144,7 +134,6 @@ class Future : public Object<CassFuture, cass_future_free> {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_FUTURE_HPP__
diff --git a/gtests/src/integration/objects/iterator.hpp b/gtests/src/integration/objects/iterator.hpp
index a7c056627..695fe9851 100644
--- a/gtests/src/integration/objects/iterator.hpp
+++ b/gtests/src/integration/objects/iterator.hpp
@@ -22,8 +22,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 class Iterator : public Object<CassIterator, cass_iterator_free> {
 public:
@@ -31,7 +30,7 @@ class Iterator : public Object<CassIterator, cass_iterator_free> {
    * Create the empty iterator object
    */
   Iterator()
-    : Object<CassIterator, cass_iterator_free>() {}
+      : Object<CassIterator, cass_iterator_free>() {}
 
   /**
    * Create the iterator object from the native driver object
@@ -39,7 +38,7 @@ class Iterator : public Object<CassIterator, cass_iterator_free> {
    * @param iterator Native driver object
    */
   Iterator(CassIterator* iterator)
-    : Object<CassIterator, cass_iterator_free>(iterator) {}
+      : Object<CassIterator, cass_iterator_free>(iterator) {}
 
   /**
    * Create the future object from a shared reference
@@ -47,10 +46,9 @@ class Iterator : public Object<CassIterator, cass_iterator_free> {
    * @param future Shared reference
    */
   Iterator(Ptr iterator)
-    : Object<CassIterator, cass_iterator_free>(iterator) {}
+      : Object<CassIterator, cass_iterator_free>(iterator) {}
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_ITERATOR_HPP__
diff --git a/gtests/src/integration/objects/object_base.hpp b/gtests/src/integration/objects/object_base.hpp
index 0da3c9480..5f7d94fc5 100644
--- a/gtests/src/integration/objects/object_base.hpp
+++ b/gtests/src/integration/objects/object_base.hpp
@@ -20,13 +20,12 @@
 #include "shared_ptr.hpp"
 #include "tlog.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Template deleter class for driver objects that utilize a freeing function
  */
-template<class T, void (*free_function)(T*)>
+template <class T, void (*free_function)(T*)>
 class Deleter {
 public:
   void operator()(T* object) {
@@ -39,7 +38,7 @@ class Deleter {
 /**
  * Template object class for driver objects
  */
-template<class T, void (*free_function)(T*)>
+template <class T, void (*free_function)(T*)>
 class Object {
 public:
   typedef Deleter<T, free_function> Dtor;
@@ -49,7 +48,7 @@ class Object {
    * Create an empty object
    */
   Object()
-    : object_(NULL) { }
+      : object_(NULL) {}
 
   /**
    * Create the object with the native pointer object
@@ -57,7 +56,7 @@ class Object {
    * @param object Native pointer object
    */
   Object(T* object)
-    : object_(object) { }
+      : object_(object) {}
 
   /**
    * Create the object with the reference pointer object
@@ -65,7 +64,7 @@ class Object {
    * @param object Shared reference pointer object
    */
   Object(Ptr object)
-    : object_(object) { }
+      : object_(object) {}
 
   /**
    * Get the object pointer
@@ -95,9 +94,7 @@ class Object {
    *
    * @return True if object pointer is valid; false otherwise
    */
-  operator bool() const {
-    return object_.get() != NULL;
-  }
+  operator bool() const { return object_.get() != NULL; }
 
   /**
    * Conversion operator for determining if the pointer used for the object is
@@ -105,9 +102,7 @@ class Object {
    *
    * @return True if object pointer is valid; false otherwise
    */
-  operator bool() {
-    return object_.get() != NULL;
-  }
+  operator bool() { return object_.get() != NULL; }
 
 protected:
   /**
@@ -126,9 +121,7 @@ class Object {
    *
    * @param object Object reference
    */
-  void set(T* object) {
-    object_ = object;
-  }
+  void set(T* object) { object_ = object; }
 
 private:
   /**
@@ -137,7 +130,6 @@ class Object {
   Ptr object_;
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_OBJECT_BASE_HPP__
diff --git a/gtests/src/integration/objects/prepared.hpp b/gtests/src/integration/objects/prepared.hpp
index 3a373d253..8d51e09b5 100644
--- a/gtests/src/integration/objects/prepared.hpp
+++ b/gtests/src/integration/objects/prepared.hpp
@@ -22,8 +22,7 @@
 
 #include "objects/statement.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped prepared object
@@ -34,7 +33,7 @@ class Prepared : public Object<const CassPrepared, cass_prepared_free> {
    * Create the empty prepared object
    */
   Prepared()
-    : Object<const CassPrepared, cass_prepared_free>() {}
+      : Object<const CassPrepared, cass_prepared_free>() {}
 
   /**
    * Create the prepared object from the native driver object
@@ -42,7 +41,7 @@ class Prepared : public Object<const CassPrepared, cass_prepared_free> {
    * @param prepared Native driver object
    */
   Prepared(const CassPrepared* prepared)
-    : Object<const CassPrepared, cass_prepared_free>(prepared) {}
+      : Object<const CassPrepared, cass_prepared_free>(prepared) {}
 
   /**
    * Create the prepared object from a shared reference
@@ -50,16 +49,14 @@ class Prepared : public Object<const CassPrepared, cass_prepared_free> {
    * @param prepared Shared reference
    */
   Prepared(Ptr prepared)
-    : Object<const CassPrepared, cass_prepared_free>(prepared) {}
+      : Object<const CassPrepared, cass_prepared_free>(prepared) {}
 
   /**
    * Bind the prepared object and create a statement
    *
    * @return Statement
    */
-  Statement bind() {
-    return Statement(cass_prepared_bind(get()));
-  }
+  Statement bind() { return Statement(cass_prepared_bind(get())); }
 
   /**
    * Get the data type for a given column index
@@ -87,9 +84,7 @@ class Prepared : public Object<const CassPrepared, cass_prepared_free> {
    * @param index The column index to retrieve the value type
    * @return Value type at the specified column index
    */
-  CassValueType value_type(size_t index) {
-    return cass_data_type_type(data_type(index));
-  }
+  CassValueType value_type(size_t index) { return cass_data_type_type(data_type(index)); }
 
   /**
    * Get the value type for a given column name
@@ -97,12 +92,9 @@ class Prepared : public Object<const CassPrepared, cass_prepared_free> {
    * @param name The column name to retrieve the value type
    * @return Value type at the specified column index
    */
-  CassValueType value_type(const std::string& name) {
-    return cass_data_type_type(data_type(name));
-  }
+  CassValueType value_type(const std::string& name) { return cass_data_type_type(data_type(name)); }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_PREPARED_HPP__
diff --git a/gtests/src/integration/objects/result.hpp b/gtests/src/integration/objects/result.hpp
index 68908ffc8..da70ad06d 100644
--- a/gtests/src/integration/objects/result.hpp
+++ b/gtests/src/integration/objects/result.hpp
@@ -30,8 +30,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 // Forward declarations
 class Row;
@@ -45,13 +44,13 @@ class Result : public Object<const CassResult, cass_result_free> {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   /**
    * Create an empty result object
    */
-  Result() { }
+  Result() {}
 
   /**
    * Create the result object from the native driver object
@@ -59,7 +58,7 @@ class Result : public Object<const CassResult, cass_result_free> {
    * @param result Native driver object
    */
   Result(const CassResult* result)
-    : Object<const CassResult, cass_result_free>(result) { }
+      : Object<const CassResult, cass_result_free>(result) {}
 
   /**
    * Create the result object from a shared reference
@@ -67,7 +66,7 @@ class Result : public Object<const CassResult, cass_result_free> {
    * @param result Shared reference
    */
   Result(Ptr result)
-    : Object<const CassResult, cass_result_free>(result) { }
+      : Object<const CassResult, cass_result_free>(result) {}
 
   /**
    * Create the result object from a future object
@@ -75,63 +74,51 @@ class Result : public Object<const CassResult, cass_result_free> {
    * @param future Wrapped driver object
    */
   Result(Future future)
-    : Object<const CassResult, cass_result_free>(future.result())
-    , future_(future)
-    , custom_payload_(future) { }
+      : Object<const CassResult, cass_result_free>(future.result())
+      , future_(future)
+      , custom_payload_(future) {}
 
   /**
    * Get the attempted host/address of the future
    *
    * @return Attempted host/address
    */
-  const std::vector<std::string> attempted_hosts() {
-    return future_.attempted_hosts();
-  }
+  const std::vector<std::string> attempted_hosts() { return future_.attempted_hosts(); }
 
   /**
    * Get the error code from the future
    *
    * @return Error code of the future
    */
-  CassError error_code() {
-    return future_.error_code();
-  }
+  CassError error_code() { return future_.error_code(); }
 
   /**
    * Get the human readable description of the error code
    *
    * @return Error description
    */
-  const std::string error_description() {
-    return future_.error_description();
-  }
+  const std::string error_description() { return future_.error_description(); }
 
   /**
    * Get the error message of the future if an error occurred
    *
    * @return Error message
    */
-  const std::string error_message() {
-    return future_.error_message();
-  }
+  const std::string error_message() { return future_.error_message(); }
 
   /**
    * Get the host/address of the future
    *
    * @return Host/Address
    */
-  const std::string host() {
-    return future_.host();
-  }
+  const std::string host() { return future_.host(); }
 
   /**
    * Get the number of columns from the result
    *
    * @return The number of columns in the result
    */
-  size_t column_count() {
-    return cass_result_column_count(get());
-  }
+  size_t column_count() { return cass_result_column_count(get()); }
 
   /**
    * Get the column names from the result
@@ -162,9 +149,7 @@ class Result : public Object<const CassResult, cass_result_free> {
    *
    * @return The number of rows in the result
    */
-  size_t row_count() {
-    return cass_result_row_count(get());
-  }
+  size_t row_count() { return cass_result_row_count(get()); }
 
   /**
    * Get the rows from the result
@@ -179,18 +164,14 @@ class Result : public Object<const CassResult, cass_result_free> {
    *
    * @return True if result is empty; false otherwise
    */
-  bool is_empty() {
-    return row_count() == 0;
-  }
+  bool is_empty() { return row_count() == 0; }
 
   /**
    * Get the custom payload associated with the result
    *
    * @return Custom payload
    */
-  CustomPayload custom_payload() {
-    return custom_payload_;
-  }
+  CustomPayload custom_payload() { return custom_payload_; }
 
   /**
    * Get the tracing ID from the result's future.
@@ -228,15 +209,15 @@ class Column {
    * @param parent The result object for the column
    */
   Column(const CassValue* value, const Result& parent)
-    : value_(value)
-    , parent_(parent) { }
+      : value_(value)
+      , parent_(parent) {}
 
   /**
    * Get the value as a specific type
    *
    * @return The value as a value type
    */
-  template<class T>
+  template <class T>
   T as() const {
     return T(value_);
   }
@@ -264,8 +245,8 @@ class Row {
    * @param parent The result object for the row
    */
   Row(const CassRow* row, const Result& parent)
-    : row_(row)
-    , parent_(parent) {
+      : row_(row)
+      , parent_(parent) {
     if (row != NULL) {
       iterator_ = cass_iterator_from_row(row);
     } else {
@@ -279,7 +260,7 @@ class Row {
    * @param name Name of the column to retrieve
    * @return The value as a value type
    */
-  template<typename T>
+  template <typename T>
   T column_by_name(const std::string& name) {
     return T(cass_row_get_column_by_name(row_, name.c_str()));
   }
@@ -289,13 +270,9 @@ class Row {
    *
    * @return The total number of columns in a row
    */
-  size_t column_count() {
-    return parent_.column_count();
-  }
+  size_t column_count() { return parent_.column_count(); }
 
-  const CassRow* get() {
-    return row_;
-  }
+  const CassRow* get() { return row_; }
 
   /**
    * Get the next column
@@ -337,26 +314,22 @@ class Rows {
    * @param parent The result object for these rows
    */
   Rows(Iterator iterator, Result parent)
-    : iterator_(iterator)
-    , parent_(parent) { }
+      : iterator_(iterator)
+      , parent_(parent) {}
 
   /**
    * Get the total number of columns in a row
    *
    * @return The total number of columns in a row
    */
-  size_t column_count() {
-    return parent_.column_count();
-  }
+  size_t column_count() { return parent_.column_count(); }
 
   /**
    * Get the total number of rows
    *
    * @return The total number of rows
    */
-  size_t row_count() {
-    return parent_.row_count();
-  }
+  size_t row_count() { return parent_.row_count(); }
 
   /**
    * Get the next row
@@ -382,7 +355,6 @@ class Rows {
   Result parent_;
 };
 
-
 inline Row Result::first_row() {
   if (cass_result_row_count(get()) == 0) {
     throw Exception("No first row available");
@@ -390,11 +362,8 @@ inline Row Result::first_row() {
   return Row(cass_result_first_row(get()), *this);
 }
 
-inline Rows Result::rows() {
-  return Rows(cass_iterator_from_result(get()), *this);
-}
+inline Rows Result::rows() { return Rows(cass_iterator_from_result(get()), *this); }
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_RESULT_HPP__
diff --git a/gtests/src/integration/objects/retry_policy.hpp b/gtests/src/integration/objects/retry_policy.hpp
index ef59e1402..0d51d0486 100644
--- a/gtests/src/integration/objects/retry_policy.hpp
+++ b/gtests/src/integration/objects/retry_policy.hpp
@@ -20,8 +20,7 @@
 
 #include "objects/object_base.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped retry policy object
@@ -34,7 +33,7 @@ class RetryPolicy : public Object<CassRetryPolicy, cass_retry_policy_free> {
    * @param retry_policy Native driver object
    */
   RetryPolicy(CassRetryPolicy* retry_policy)
-    : Object<CassRetryPolicy, cass_retry_policy_free>(retry_policy) {}
+      : Object<CassRetryPolicy, cass_retry_policy_free>(retry_policy) {}
 
   /**
    * Create the retry policy object from the shared reference
@@ -42,7 +41,7 @@ class RetryPolicy : public Object<CassRetryPolicy, cass_retry_policy_free> {
    * @param retry_policy Shared reference
    */
   RetryPolicy(Ptr retry_policy)
-    : Object<CassRetryPolicy, cass_retry_policy_free>(retry_policy) {}
+      : Object<CassRetryPolicy, cass_retry_policy_free>(retry_policy) {}
 };
 
 /**
@@ -55,7 +54,7 @@ class DefaultRetryPolicy : public RetryPolicy {
    * policy object
    */
   DefaultRetryPolicy()
-    : RetryPolicy(cass_retry_policy_default_new()) {}
+      : RetryPolicy(cass_retry_policy_default_new()) {}
 };
 
 /**
@@ -68,7 +67,7 @@ class DowngradingConsistencyRetryPolicy : public RetryPolicy {
    * driver downgrading consistency retry policy object
    */
   DowngradingConsistencyRetryPolicy()
-    : RetryPolicy(cass_retry_policy_downgrading_consistency_new()) {}
+      : RetryPolicy(cass_retry_policy_downgrading_consistency_new()) {}
 };
 
 /**
@@ -81,7 +80,7 @@ class FallthroughRetryPolicy : public RetryPolicy {
    * fallthrough retry policy object
    */
   FallthroughRetryPolicy()
-    : RetryPolicy(cass_retry_policy_fallthrough_new()) {}
+      : RetryPolicy(cass_retry_policy_fallthrough_new()) {}
 };
 
 /**
@@ -96,10 +95,9 @@ class LoggingRetryPolicy : public RetryPolicy {
    * @param child_policy Child retry policy being logged (CASS_LOG_INFO)
    */
   LoggingRetryPolicy(RetryPolicy child_policy)
-    : RetryPolicy(cass_retry_policy_logging_new(child_policy.get())) {}
+      : RetryPolicy(cass_retry_policy_logging_new(child_policy.get())) {}
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_RETRY_POLICY_HPP__
diff --git a/gtests/src/integration/objects/schema.hpp b/gtests/src/integration/objects/schema.hpp
index dc22bf512..e5273d63f 100644
--- a/gtests/src/integration/objects/schema.hpp
+++ b/gtests/src/integration/objects/schema.hpp
@@ -21,8 +21,7 @@
 
 #include "objects/object_base.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 // Forward declarations
 class Keyspace;
@@ -37,13 +36,14 @@ class Schema : public Object<const CassSchemaMeta, cass_schema_meta_free> {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
 
   /**
    * Default constructor
    */
-  Schema() : Object<const CassSchemaMeta, cass_schema_meta_free>(NULL) {}
+  Schema()
+      : Object<const CassSchemaMeta, cass_schema_meta_free>(NULL) {}
 
   /**
    * Create a schema object
@@ -51,7 +51,7 @@ class Schema : public Object<const CassSchemaMeta, cass_schema_meta_free> {
    * @param schema_meta Native driver object
    */
   Schema(const CassSchemaMeta* schema_meta)
-    : Object<const CassSchemaMeta, cass_schema_meta_free>(schema_meta) {}
+      : Object<const CassSchemaMeta, cass_schema_meta_free>(schema_meta) {}
 
   /**
    * Get the keyspace metadata for a given keyspace
@@ -62,9 +62,7 @@ class Schema : public Object<const CassSchemaMeta, cass_schema_meta_free> {
    */
   Keyspace keyspace(const std::string& name);
 
-  const CassVersion version() const {
-    return cass_schema_meta_version(get());
-  }
+  const CassVersion version() const { return cass_schema_meta_version(get()); }
 };
 
 /**
@@ -75,14 +73,14 @@ class Keyspace {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
 
   /**
    * Default constructor
    */
   Keyspace()
-    : keyspace_meta_(NULL) {}
+      : keyspace_meta_(NULL) {}
 
   /**
    * Create the keyspace object
@@ -91,18 +89,15 @@ class Keyspace {
    * @param parent The schema object for the keyspace metadata
    */
   Keyspace(const CassKeyspaceMeta* keyspace_meta, const Schema& parent)
-    : keyspace_meta_(keyspace_meta)
-    , parent_(parent) {}
-
+      : keyspace_meta_(keyspace_meta)
+      , parent_(parent) {}
 
   /**
    * Determine if the keyspace is virtual
    *
    * @return true if virtual, otherwise false
    */
-  bool is_virtual() const {
-    return cass_keyspace_meta_is_virtual(keyspace_meta_) == cass_true;
-  }
+  bool is_virtual() const { return cass_keyspace_meta_is_virtual(keyspace_meta_) == cass_true; }
 
   /**
    * Get the UserType type object for a given user type
@@ -144,7 +139,7 @@ class Table {
    * Default constructor
    */
   Table()
-    : table_meta_(NULL) {}
+      : table_meta_(NULL) {}
 
   /**
    * Create the table object
@@ -153,17 +148,15 @@ class Table {
    * @param parent The keyspace object that owns the table
    */
   Table(const CassTableMeta* table_meta, const Keyspace& parent)
-    : table_meta_(table_meta)
-    , parent_(parent) {}
+      : table_meta_(table_meta)
+      , parent_(parent) {}
 
   /**
    * Determine if the table is virtual
    *
    * @return true if virtual, otherwise false
    */
-  bool is_virtual() const {
-    return cass_table_meta_is_virtual(table_meta_) == cass_true;
-  }
+  bool is_virtual() const { return cass_table_meta_is_virtual(table_meta_) == cass_true; }
 
   const CassTableMeta* get() const { return table_meta_; }
 
@@ -192,17 +185,15 @@ class UserTypeType {
    * @param parent The keyspace object for the UserType type
    */
   UserTypeType(const CassDataType* data_type, const Keyspace& parent)
-    : data_type_(data_type)
-    , parent_(parent) {}
+      : data_type_(data_type)
+      , parent_(parent) {}
 
   /**
    * Get the data type
    *
    * @return Native driver data type
    */
-  const CassDataType* data_type() const {
-    return data_type_;
-  }
+  const CassDataType* data_type() const { return data_type_; }
 
 private:
   /**
@@ -215,10 +206,8 @@ class UserTypeType {
   Keyspace parent_;
 };
 
-
 inline Keyspace Schema::keyspace(const std::string& name) {
-  const CassKeyspaceMeta* keyspace_meta
-      = cass_schema_meta_keyspace_by_name(get(), name.c_str());
+  const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(get(), name.c_str());
   if (keyspace_meta == NULL) {
     throw Exception("Unable to get metadata for keyspace: " + name);
   }
@@ -226,8 +215,8 @@ inline Keyspace Schema::keyspace(const std::string& name) {
 }
 
 inline UserTypeType Keyspace::user_type(const std::string& name) {
-  const CassDataType* data_type
-      = cass_keyspace_meta_user_type_by_name(keyspace_meta_, name.c_str());
+  const CassDataType* data_type =
+      cass_keyspace_meta_user_type_by_name(keyspace_meta_, name.c_str());
   if (data_type == NULL) {
     throw Exception("Unable to get metadata for user type: " + name);
   }
@@ -235,15 +224,13 @@ inline UserTypeType Keyspace::user_type(const std::string& name) {
 }
 
 inline Table Keyspace::table(const std::string& name) {
-  const CassTableMeta* table =
-    cass_keyspace_meta_table_by_name(keyspace_meta_, name.c_str());
+  const CassTableMeta* table = cass_keyspace_meta_table_by_name(keyspace_meta_, name.c_str());
   if (table == NULL) {
     throw Exception("Unable to get metadata for table: " + name);
   }
   return Table(table, *this);
 }
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_SCHEMA_HPP__
diff --git a/gtests/src/integration/objects/session.hpp b/gtests/src/integration/objects/session.hpp
index 706a6ac6f..f15e3e2f6 100644
--- a/gtests/src/integration/objects/session.hpp
+++ b/gtests/src/integration/objects/session.hpp
@@ -28,27 +28,27 @@
 
 #include "exception.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped session object
  */
 class Session : public Object<CassSession, cass_session_free> {
-friend class Cluster;
+  friend class Cluster;
+
 public:
   class Exception : public test::CassException {
   public:
     Exception(const std::string& message, const CassError error_code,
               const std::string& error_message)
-      : test::CassException(message, error_code, error_message) { }
+        : test::CassException(message, error_code, error_message) {}
   };
 
   /**
    * Create the default session object
    */
   Session()
-    : Object<CassSession, cass_session_free>(cass_session_new()) { }
+      : Object<CassSession, cass_session_free>(cass_session_new()) {}
 
   /**
    * Create the session object from the native driver object
@@ -56,7 +56,7 @@ friend class Cluster;
    * @param session Native driver object
    */
   Session(CassSession* session)
-    : Object<CassSession, cass_session_free>(session) { }
+      : Object<CassSession, cass_session_free>(session) {}
 
   /**
    * Create the session object from a shared reference
@@ -64,7 +64,7 @@ friend class Cluster;
    * @param session Shared reference
    */
   Session(Ptr session)
-    : Object<CassSession, cass_session_free>(session) { }
+      : Object<CassSession, cass_session_free>(session) {}
 
   /**
    * Close the active session
@@ -82,27 +82,21 @@ friend class Cluster;
    *
    * @return Error code of the future
    */
-  CassError connect_error_code() {
-    return connect_future_.error_code();
-  }
+  CassError connect_error_code() { return connect_future_.error_code(); }
 
   /**
    * Get the human readable description of the error code during the connection
    *
    * @return Error description
    */
-  const std::string connect_error_description() {
-    return connect_future_.error_description();
-  }
+  const std::string connect_error_description() { return connect_future_.error_description(); }
 
   /**
    * Get the error message that occurred during the connection
    *
    * @return Error message
    */
-  const std::string connect_error_message() {
-    return connect_future_.error_message();
-  }
+  const std::string connect_error_message() { return connect_future_.error_message(); }
 
   /**
    * Execute a batch statement synchronously
@@ -144,9 +138,8 @@ friend class Cluster;
    *                  CASS_OK; false otherwise (default: true)
    * @return Result object
    */
-  Result execute(const std::string& query,
-    CassConsistency consistency = CASS_CONSISTENCY_LOCAL_ONE,
-    bool is_idempotent = false, bool assert_ok = true) {
+  Result execute(const std::string& query, CassConsistency consistency = CASS_CONSISTENCY_LOCAL_ONE,
+                 bool is_idempotent = false, bool assert_ok = true) {
     Statement statement(query);
     statement.set_consistency(consistency);
     statement.set_idempotent(is_idempotent);
@@ -184,8 +177,8 @@ friend class Cluster;
    * @return Future object
    */
   Future execute_async(const std::string& query,
-    CassConsistency consistency = CASS_CONSISTENCY_LOCAL_ONE,
-    bool is_idempotent = false) {
+                       CassConsistency consistency = CASS_CONSISTENCY_LOCAL_ONE,
+                       bool is_idempotent = false) {
     Statement statement(query);
     statement.set_consistency(consistency);
     statement.set_idempotent(is_idempotent);
@@ -235,15 +228,14 @@ friend class Cluster;
     if (keyspace.empty()) {
       session.connect_future_ = cass_session_connect(session.get(), cluster);
     } else {
-      session.connect_future_ = cass_session_connect_keyspace(session.get(),
-        cluster, keyspace.c_str());
+      session.connect_future_ =
+          cass_session_connect_keyspace(session.get(), cluster, keyspace.c_str());
     }
     session.connect_future_.wait(false);
     if (assert_ok && session.connect_error_code() != CASS_OK) {
-      throw Exception("Unable to Establish Session Connection: "
-                      + session.connect_error_description(),
-                      session.connect_error_code(),
-                      session.connect_error_message());
+      throw Exception("Unable to Establish Session Connection: " +
+                          session.connect_error_description(),
+                      session.connect_error_code(), session.connect_error_message());
     }
     return session;
   }
@@ -252,7 +244,6 @@ friend class Cluster;
   Future connect_future_;
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_SESSION_HPP__
diff --git a/gtests/src/integration/objects/statement.cpp b/gtests/src/integration/objects/statement.cpp
index 2f9940b60..b00a663b0 100644
--- a/gtests/src/integration/objects/statement.cpp
+++ b/gtests/src/integration/objects/statement.cpp
@@ -19,7 +19,5 @@
 #include "objects/custom_payload.hpp"
 
 void test::driver::Statement::set_custom_payload(CustomPayload custom_payload) {
-  ASSERT_EQ(CASS_OK, cass_statement_set_custom_payload(get(),
-            custom_payload.get()));
+  ASSERT_EQ(CASS_OK, cass_statement_set_custom_payload(get(), custom_payload.get()));
 }
-
diff --git a/gtests/src/integration/objects/statement.hpp b/gtests/src/integration/objects/statement.hpp
index 6d444ef67..4a80e3402 100644
--- a/gtests/src/integration/objects/statement.hpp
+++ b/gtests/src/integration/objects/statement.hpp
@@ -28,8 +28,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 // Forward declaration for circular dependency
 class CustomPayload;
@@ -43,14 +42,14 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * Create an empty statement
    */
   Statement()
-    : Object<CassStatement, cass_statement_free>() { }
+      : Object<CassStatement, cass_statement_free>() {}
   /**
    * Create the statement object from the native driver statement object
    *
    * @param statement Native driver object
    */
   Statement(CassStatement* statement)
-    : Object<CassStatement, cass_statement_free>(statement) { }
+      : Object<CassStatement, cass_statement_free>(statement) {}
 
   /**
    * Create the statement object from the shared reference
@@ -58,7 +57,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param statement Shared reference
    */
   Statement(Ptr statement)
-    : Object<CassStatement, cass_statement_free>(statement) { }
+      : Object<CassStatement, cass_statement_free>(statement) {}
 
   /**
    * Create the statement object from a query
@@ -68,8 +67,8 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    *                        (default: 0)
    */
   Statement(const std::string& query, size_t parameter_count = 0)
-    : Object<CassStatement, cass_statement_free>(cass_statement_new(query.c_str(),
-      parameter_count)) { }
+      : Object<CassStatement, cass_statement_free>(
+            cass_statement_new(query.c_str(), parameter_count)) {}
 
   /**
    * Add a key index specifier to the statement.
@@ -90,7 +89,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param index Index to bind the value to
    * @param value<T> Value to bind to the statement at given index
    */
-  template<typename T>
+  template <typename T>
   void bind(size_t index, T value) {
     value.statement_bind(*this, index);
   }
@@ -101,7 +100,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param name Column name to bind the value to
    * @param value<T> Value to bind to the statement at given index
    */
-  template<typename T>
+  template <typename T>
   void bind(const std::string& name, T value) {
     value.statement_bind(*this, name);
   }
@@ -139,8 +138,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param enable True if statement is idempotent; false otherwise
    */
   void set_idempotent(bool enable) {
-    ASSERT_EQ(CASS_OK, cass_statement_set_is_idempotent(get(),
-      enable ? cass_true : cass_false));
+    ASSERT_EQ(CASS_OK, cass_statement_set_is_idempotent(get(), enable ? cass_true : cass_false));
   }
 
   /**
@@ -159,8 +157,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param enable True if attempted host should be recorded; false otherwise
    */
   void set_record_attempted_hosts(bool enable) {
-    return internals::Utils::set_record_attempted_hosts(get(),
-      enable);
+    return internals::Utils::set_record_attempted_hosts(get(), enable);
   }
 
   /**
@@ -169,8 +166,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param timeout_ms Timeout in milliseconds
    */
   void set_request_timeout(uint64_t timeout_ms) {
-    ASSERT_EQ(CASS_OK, cass_statement_set_request_timeout(get(),
-      timeout_ms));
+    ASSERT_EQ(CASS_OK, cass_statement_set_request_timeout(get(), timeout_ms));
   }
 
   /**
@@ -179,8 +175,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param retry_policy Retry policy to use for the statement
    */
   void set_retry_policy(RetryPolicy retry_policy) {
-    ASSERT_EQ(CASS_OK, cass_statement_set_retry_policy(get(),
-      retry_policy.get()));
+    ASSERT_EQ(CASS_OK, cass_statement_set_retry_policy(get(), retry_policy.get()));
   }
 
   /**
@@ -189,8 +184,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param serial_consistency Serial consistency to use for the statement
    */
   void set_serial_consistency(CassConsistency serial_consistency) {
-    ASSERT_EQ(CASS_OK, cass_statement_set_serial_consistency(get(),
-      serial_consistency));
+    ASSERT_EQ(CASS_OK, cass_statement_set_serial_consistency(get(), serial_consistency));
   }
 
   /**
@@ -199,8 +193,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param enabled
    */
   void set_tracing(bool enabled) {
-    ASSERT_EQ(CASS_OK,
-              cass_statement_set_tracing(get(), enabled ? cass_true : cass_false));
+    ASSERT_EQ(CASS_OK, cass_statement_set_tracing(get(), enabled ? cass_true : cass_false));
   }
 
   /**
@@ -210,8 +203,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param port
    */
   void set_host(const std::string& host, int port) {
-    ASSERT_EQ(CASS_OK,
-              cass_statement_set_host(get(), host.c_str(), port));
+    ASSERT_EQ(CASS_OK, cass_statement_set_host(get(), host.c_str(), port));
   }
 
   /**
@@ -221,8 +213,7 @@ class Statement : public Object<CassStatement, cass_statement_free> {
    * @param port
    */
   void set_host(const CassInet* host, int port) {
-    ASSERT_EQ(CASS_OK,
-              cass_statement_set_host_inet(get(), host, port));
+    ASSERT_EQ(CASS_OK, cass_statement_set_host_inet(get(), host, port));
   }
 };
 
@@ -237,7 +228,7 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param batch_type Type of batch to create (default: Unlogged)
    */
   Batch(CassBatchType batch_type = CASS_BATCH_TYPE_UNLOGGED)
-    : Object<CassBatch, cass_batch_free>(cass_batch_new(batch_type)) {}
+      : Object<CassBatch, cass_batch_free>(cass_batch_new(batch_type)) {}
 
   /**
    * Create the batch object from the native driver batch object
@@ -245,7 +236,7 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param batch Native driver object
    */
   Batch(CassBatch* batch)
-    : Object<CassBatch, cass_batch_free>(batch) {}
+      : Object<CassBatch, cass_batch_free>(batch) {}
 
   /**
    * Create the batch object from the shared reference
@@ -253,7 +244,7 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param batch Shared reference
    */
   Batch(Ptr batch)
-    : Object<CassBatch, cass_batch_free>(batch) {}
+      : Object<CassBatch, cass_batch_free>(batch) {}
 
   /**
    * Add a statement (query or bound) to the batch
@@ -263,11 +254,10 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    *                  CASS_OK; false otherwise (default: true)
    */
   void add(Statement statement, bool assert_ok = true) {
-    CassError error_code = cass_batch_add_statement(get(),
-      statement.get());
+    CassError error_code = cass_batch_add_statement(get(), statement.get());
     if (assert_ok) {
       ASSERT_EQ(CASS_OK, error_code)
-        << "Unable to Add Statement to Batch: " << cass_error_desc(error_code);
+          << "Unable to Add Statement to Batch: " << cass_error_desc(error_code);
     }
   }
 
@@ -297,8 +287,7 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param enable True if statement in a batch is idempotent; false otherwise
    */
   void set_idempotent(bool enable) {
-    ASSERT_EQ(CASS_OK, cass_batch_set_is_idempotent(get(),
-      enable ? cass_true : cass_false));
+    ASSERT_EQ(CASS_OK, cass_batch_set_is_idempotent(get(), enable ? cass_true : cass_false));
   }
 
   /**
@@ -307,8 +296,7 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param timeout_ms Timeout in milliseconds
    */
   void set_request_timeout(uint64_t timeout_ms) {
-    ASSERT_EQ(CASS_OK, cass_batch_set_request_timeout(get(),
-      timeout_ms));
+    ASSERT_EQ(CASS_OK, cass_batch_set_request_timeout(get(), timeout_ms));
   }
 
   /**
@@ -326,12 +314,10 @@ class Batch : public Object<CassBatch, cass_batch_free> {
    * @param serial_consistency Serial consistency to use for the batch
    */
   void set_serial_consistency(CassConsistency serial_consistency) {
-    ASSERT_EQ(CASS_OK, cass_batch_set_serial_consistency(get(),
-      serial_consistency));
+    ASSERT_EQ(CASS_OK, cass_batch_set_serial_consistency(get(), serial_consistency));
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_STATEMENT_HPP__
diff --git a/gtests/src/integration/objects/tuple.hpp b/gtests/src/integration/objects/tuple.hpp
index 3be7985d8..313927baf 100644
--- a/gtests/src/integration/objects/tuple.hpp
+++ b/gtests/src/integration/objects/tuple.hpp
@@ -25,8 +25,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Tuple object
@@ -38,7 +37,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
 
   /**
@@ -47,9 +46,9 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    * @param size Number of elements in the tuple
    */
   Tuple(size_t size)
-    : Object<CassTuple, cass_tuple_free>(cass_tuple_new(size))
-    , size_(size)
-    , is_null_(true) {}
+      : Object<CassTuple, cass_tuple_free>(cass_tuple_new(size))
+      , size_(size)
+      , is_null_(true) {}
 
   /**
    * Create the tuple from a particular column
@@ -57,8 +56,8 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    * @param column Column to retrieve tuple from
    */
   Tuple(const CassValue* column)
-    : size_(0)
-    , is_null_(true) {
+      : size_(0)
+      , is_null_(true) {
     initialize(column);
   }
 
@@ -67,9 +66,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    *
    * @return True if tuple is NULL; false otherwise
    */
-  bool is_null() {
-    return is_null_;
-  }
+  bool is_null() { return is_null_; }
 
   /**
    * Get the next value
@@ -92,7 +89,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    * @throws Exception If tuple is not able to have values added to it (e.g.
    *         The tuple was generated from server result)
    */
-  template<typename T>
+  template <typename T>
   void set(T value, size_t index) {
     value.set(*this, index);
     is_null_ = false;
@@ -103,9 +100,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    *
    * @return The number of elements in the tuple
    */
-  size_t size() {
-    return size_;
-  }
+  size_t size() { return size_; }
 
   /**
    * Get the current value from the tuple iterator (retrieved from server)
@@ -113,7 +108,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    * @return Current value in the tuple
    * @throws Exception If iterator is not valid
    */
-  template<typename T>
+  template <typename T>
   T value() {
     if (iterator_) {
       return T(cass_iterator_get_value(iterator_.get()));
@@ -126,7 +121,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    *
    * @return The tuple as a vector of a single type
    */
-  template<typename T>
+  template <typename T>
   std::vector<T> values() {
     std::vector<T> result;
     const CassValue* value;
@@ -144,8 +139,7 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
    *              statement
    */
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK,
-      cass_statement_bind_tuple(statement.get(), index, get()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_tuple(statement.get(), index, get()));
   }
 
 protected:
@@ -184,7 +178,6 @@ class Tuple : public Object<CassTuple, cass_tuple_free> {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_TUPLE_HPP__
diff --git a/gtests/src/integration/objects/user_type.hpp b/gtests/src/integration/objects/user_type.hpp
index daac83473..8aae29528 100644
--- a/gtests/src/integration/objects/user_type.hpp
+++ b/gtests/src/integration/objects/user_type.hpp
@@ -25,8 +25,7 @@
 
 #include <gtest/gtest.h>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * User type object
@@ -41,7 +40,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    * @param data_type The data type that makes up the user type
    */
   UserType(const CassDataType* data_type)
-    : is_null_(true) {
+      : is_null_(true) {
     initialize(data_type);
   }
 
@@ -51,8 +50,8 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    * @param column Column to retrieve user type from
    */
   UserType(const CassValue* column)
-    : size_(0)
-    , is_null_(true) {
+      : size_(0)
+      , is_null_(true) {
     initialize(column);
   }
 
@@ -61,9 +60,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    *
    * @return True if user type is NULL; false otherwise
    */
-  bool is_null() {
-    return is_null_;
-  }
+  bool is_null() { return is_null_; }
 
   /**
    * Set the value in the user type
@@ -73,7 +70,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    * @throws Exception If user type is not able to have values added to it (e.g.
    *         The user type was generated from server result)
    */
-  template<typename T>
+  template <typename T>
   void set(T value, const std::string& name) {
     value.set(*this, name);
     is_null_ = false;
@@ -84,9 +81,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    *
    * @return The number of elements in the user type
    */
-  size_t size() {
-    return size_;
-  }
+  size_t size() { return size_; }
 
   /**
    * Get a field value from the user type
@@ -94,7 +89,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    * @return Value of the field in the user type
    * @throws Exception If value is not available
    */
-  template<typename T>
+  template <typename T>
   T value(const std::string& name) {
     ValuesMap::iterator iterator = values_.find(name);
     if (iterator != values_.end()) {
@@ -108,7 +103,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    *
    * @return A map of all the fields where the value is a single type
    */
-  template<typename T>
+  template <typename T>
   std::map<std::string, T> values() {
     std::map<std::string, T> result;
     while (cass_iterator_next(iterator_.get())) {
@@ -124,7 +119,6 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
     return result;
   }
 
-
   /**
    * Bind the user type to a statement at the given index
    *
@@ -133,8 +127,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
    *              statement
    */
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK,
-      cass_statement_bind_user_type(statement.get(), index, get()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_user_type(statement.get(), index, get()));
   }
 
 protected:
@@ -173,7 +166,6 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
     iterator_ = cass_iterator_fields_from_user_type(value);
   }
 
-
   /**
    * Initialize the user type from the data type
    *
@@ -188,8 +180,7 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
       // Get the user type field name
       const char* name;
       size_t name_length;
-      ASSERT_EQ(CASS_OK,
-        cass_data_type_sub_type_name(data_type, i, &name, &name_length));
+      ASSERT_EQ(CASS_OK, cass_data_type_sub_type_name(data_type, i, &name, &name_length));
 
       // Create a temporary place holder for the field value
       std::string field(name, name_length);
@@ -198,12 +189,10 @@ class UserType : public Object<CassUserType, cass_user_type_free> {
     }
 
     // Create the user type from the data type
-    Object<CassUserType, cass_user_type_free>::set(
-      cass_user_type_new_from_data_type(data_type));
+    Object<CassUserType, cass_user_type_free>::set(cass_user_type_new_from_data_type(data_type));
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_USER_DATA_TYPE_HPP__
diff --git a/gtests/src/integration/objects/uuid_gen.hpp b/gtests/src/integration/objects/uuid_gen.hpp
index 3082e3867..129c080bd 100644
--- a/gtests/src/integration/objects/uuid_gen.hpp
+++ b/gtests/src/integration/objects/uuid_gen.hpp
@@ -22,8 +22,7 @@
 
 #include "values.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Wrapped UUID generator object
@@ -34,7 +33,7 @@ class UuidGen : public Object<CassUuidGen, cass_uuid_gen_free> {
    * Create the UUID generator object
    */
   UuidGen()
-    : Object<CassUuidGen, cass_uuid_gen_free>(cass_uuid_gen_new()) {}
+      : Object<CassUuidGen, cass_uuid_gen_free>(cass_uuid_gen_new()) {}
 
   /**
    * Create the UUID generator object with custom node information
@@ -42,7 +41,7 @@ class UuidGen : public Object<CassUuidGen, cass_uuid_gen_free> {
    * @param node Node to use for custom node information
    */
   UuidGen(cass_uint64_t node)
-    : Object<CassUuidGen, cass_uuid_gen_free>(cass_uuid_gen_new_with_node(node)) {}
+      : Object<CassUuidGen, cass_uuid_gen_free>(cass_uuid_gen_new_with_node(node)) {}
 
   /**
    * Create the UUID generator object from the native driver object
@@ -50,7 +49,7 @@ class UuidGen : public Object<CassUuidGen, cass_uuid_gen_free> {
    * @param uuid_gen Native driver object
    */
   UuidGen(CassUuidGen* uuid_gen)
-    : Object<CassUuidGen, cass_uuid_gen_free>(uuid_gen) {}
+      : Object<CassUuidGen, cass_uuid_gen_free>(uuid_gen) {}
 
   /**
    * Create the UUID generator object from a shared reference
@@ -58,7 +57,7 @@ class UuidGen : public Object<CassUuidGen, cass_uuid_gen_free> {
    * @param uuid_gen Shared reference
    */
   UuidGen(Ptr uuid_gen)
-    : Object<CassUuidGen, cass_uuid_gen_free>(uuid_gen) {}
+      : Object<CassUuidGen, cass_uuid_gen_free>(uuid_gen) {}
 
   virtual ~UuidGen() {}
 
@@ -97,7 +96,6 @@ class UuidGen : public Object<CassUuidGen, cass_uuid_gen_free> {
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_UUID_GEN_HPP__
diff --git a/gtests/src/integration/options.cpp b/gtests/src/integration/options.cpp
index 33e351d9d..fc371c7da 100644
--- a/gtests/src/integration/options.cpp
+++ b/gtests/src/integration/options.cpp
@@ -23,8 +23,8 @@
 #include <algorithm>
 #include <iostream>
 
-#define DEFAULT_OPTIONS_CASSSANDRA_VERSION CCM::CassVersion("3.11.3")
-#define DEFAULT_OPTIONS_DSE_VERSION CCM::DseVersion("6.0.4")
+#define DEFAULT_OPTIONS_CASSSANDRA_VERSION CCM::CassVersion("3.11.4")
+#define DEFAULT_OPTIONS_DSE_VERSION CCM::DseVersion("6.0.8")
 
 // Initialize the defaults for all the options
 bool Options::is_initialized_ = false;
@@ -91,8 +91,7 @@ bool Options::initialize(int argc, char* argv[]) {
       // Integration test options
       if (key == "--keep-clusters") {
         is_keep_clusters_ = true;
-      }
-      else if (key == "--log-tests") {
+      } else if (key == "--log-tests") {
         if (!value.empty()) {
           is_log_tests_ = bool_value(value);
         } else {
@@ -104,7 +103,8 @@ bool Options::initialize(int argc, char* argv[]) {
         if (!value.empty()) {
           server_version_ = CCM::CassVersion(value);
         } else {
-          std::cerr << "Missing Server Version: Using default " << server_version_.to_string() << std::endl;
+          std::cerr << "Missing Server Version: Using default " << server_version_.to_string()
+                    << std::endl;
         }
       } else if (key == "--dse") {
         is_dse_ = true;
@@ -119,7 +119,8 @@ bool Options::initialize(int argc, char* argv[]) {
       } else if (key == "--dse-credentials") {
         bool is_found = false;
         if (!value.empty()) {
-          for (CCM::DseCredentialsType::iterator iterator = CCM::DseCredentialsType::begin(); iterator != CCM::DseCredentialsType::end(); ++iterator) {
+          for (CCM::DseCredentialsType::iterator iterator = CCM::DseCredentialsType::begin();
+               iterator != CCM::DseCredentialsType::end(); ++iterator) {
             if (*iterator == value) {
               dse_credentials_type_ = *iterator;
               is_found = true;
@@ -128,7 +129,8 @@ bool Options::initialize(int argc, char* argv[]) {
           }
         }
         if (!is_found) {
-          std::cerr << "Invalid DSE Credentials Type: Using default " << dse_credentials_type_.to_string() << std::endl;
+          std::cerr << "Invalid DSE Credentials Type: Using default "
+                    << dse_credentials_type_.to_string() << std::endl;
         }
       } else if (key == "--git") {
         use_git_ = true;
@@ -138,7 +140,9 @@ bool Options::initialize(int argc, char* argv[]) {
       } else if (key == "--install-dir") {
         use_install_dir_ = true;
         if (value.empty()) {
-          std::cerr << "Disabling the Use of the Installation Directory: Installation directory must not be empty" << std::endl;
+          std::cerr << "Disabling the Use of the Installation Directory: Installation directory "
+                       "must not be empty"
+                    << std::endl;
           use_install_dir_ = false;
         } else {
           install_dir_ = value;
@@ -153,12 +157,12 @@ bool Options::initialize(int argc, char* argv[]) {
         if (!value.empty()) {
           std::vector<std::string> categories = test::Utils::explode(value, ':');
           for (std::vector<std::string>::iterator iterator = categories.begin();
-            iterator != categories.end(); ++iterator) {
+               iterator != categories.end(); ++iterator) {
             try {
               categories_.insert(*iterator);
             } catch (TestCategory::Exception& tce) {
               std::cerr << "Invalid Category: " << *iterator << " will be ignored"
-                << " (" << tce.what() << ")" << std::endl;
+                        << " (" << tce.what() << ")" << std::endl;
             }
           }
         } else {
@@ -167,15 +171,16 @@ bool Options::initialize(int argc, char* argv[]) {
       } else if (key == "--verbose") {
         if (!value.empty() && !bool_value(value)) {
           std::vector<std::string> components = test::Utils::explode(value, ',');
-          for (std::vector<std::string>::iterator it = components.begin(),
-              end = components.end(); it != end; ++it) {
+          for (std::vector<std::string>::iterator it = components.begin(), end = components.end();
+               it != end; ++it) {
             std::string component = test::Utils::to_lower(*it);
             if (component == "ccm") {
               is_verbose_ccm_ = true;
             } else if (component == "integration") {
               is_verbose_integration_ = true;
             } else {
-              std::cerr << "Invalid Component \"" << *it << "\": Available components are [ccm, integration]" << std::endl;
+              std::cerr << "Invalid Component \"" << *it
+                        << "\": Available components are [ccm, integration]" << std::endl;
             }
           }
         } else {
@@ -189,7 +194,8 @@ bool Options::initialize(int argc, char* argv[]) {
       else if (key == "--authentication") {
         bool is_found = false;
         if (!value.empty()) {
-          for (CCM::AuthenticationType::iterator iterator = CCM::AuthenticationType::begin(); iterator != CCM::AuthenticationType::end(); ++iterator) {
+          for (CCM::AuthenticationType::iterator iterator = CCM::AuthenticationType::begin();
+               iterator != CCM::AuthenticationType::end(); ++iterator) {
             if (*iterator == value) {
               authentication_type_ = *iterator;
               is_found = true;
@@ -198,12 +204,14 @@ bool Options::initialize(int argc, char* argv[]) {
           }
         }
         if (!is_found) {
-          std::cerr << "Invalid Authentication Type: Using default " << authentication_type_.to_string() << std::endl;
+          std::cerr << "Invalid Authentication Type: Using default "
+                    << authentication_type_.to_string() << std::endl;
         }
       } else if (key == "--deployment") {
         bool is_found = false;
         if (!value.empty()) {
-          for (CCM::DeploymentType::iterator iterator = CCM::DeploymentType::begin(); iterator != CCM::DeploymentType::end(); ++iterator) {
+          for (CCM::DeploymentType::iterator iterator = CCM::DeploymentType::begin();
+               iterator != CCM::DeploymentType::end(); ++iterator) {
             if (*iterator == value) {
               deployment_type_ = *iterator;
               is_found = true;
@@ -212,7 +220,8 @@ bool Options::initialize(int argc, char* argv[]) {
           }
         }
         if (!is_found) {
-          std::cerr << "Invalid Deployment Type: Using default " << deployment_type_.to_string() << std::endl;
+          std::cerr << "Invalid Deployment Type: Using default " << deployment_type_.to_string()
+                    << std::endl;
         }
       } else if (key == "--host") {
         if (!value.empty()) {
@@ -221,7 +230,7 @@ bool Options::initialize(int argc, char* argv[]) {
           std::cerr << "Missing Host: Using default " << host_ << std::endl;
         }
       } else if (key == "--port") {
-        //Convert the value
+        // Convert the value
         if (!value.empty()) {
           std::stringstream ss(value);
           if (!(ss >> port_).fail()) {
@@ -260,8 +269,8 @@ bool Options::initialize(int argc, char* argv[]) {
 
     // Determine if the options should have their defaults reset
     if (categories_.empty()) {
-      for (TestCategory::iterator iterator = TestCategory::begin();
-        iterator != TestCategory::end(); ++iterator) {
+      for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
+           ++iterator) {
         // Only add the DSE test category if DSE is enabled
         if (*iterator != TestCategory::DSE || is_dse_) {
           categories_.insert(*iterator);
@@ -277,7 +286,8 @@ bool Options::initialize(int argc, char* argv[]) {
       // Determine if the DSE credentials type should be updated
       if (dse_credentials_type_ == CCM::DseCredentialsType::USERNAME_PASSWORD) {
         if (dse_username_.empty() || dse_password_.empty()) {
-          std::cerr << "Invalid Username and/or Password: Default to INI_FILE DSE credentials" << std::endl;
+          std::cerr << "Invalid Username and/or Password: Default to INI_FILE DSE credentials"
+                    << std::endl;
           dse_credentials_type_ = CCM::DseCredentialsType::INI_FILE;
         }
       }
@@ -292,75 +302,102 @@ bool Options::initialize(int argc, char* argv[]) {
 
 void Options::print_help() {
   std::cout << std::endl << "Integration Test Options:" << std::endl;
-  std::cout << "  --log-tests=(yes|no)" << std::endl << "      "
-    << "Enable/Disable logging of driver messages per test to a file." << std::endl
-    << "      The default is " << (log_tests() ? "yes" : "no") << "." << std::endl;
+  std::cout << "  --log-tests=(yes|no)" << std::endl
+            << "      "
+            << "Enable/Disable logging of driver messages per test to a file." << std::endl
+            << "      The default is " << (log_tests() ? "yes" : "no") << "." << std::endl;
   std::cout << std::endl << "CCM Options:" << std::endl;
-  std::cout << "  --version=[VERSION]" << std::endl << "      "
-    << "Cassandra/DSE version to use." << std::endl
-    << "      Default:" << std::endl
-    << "        Cassandra Version: " << server_version().to_string() << std::endl
-    << "        DSE Version: " << DEFAULT_OPTIONS_DSE_VERSION.to_string() << std::endl;
+  std::cout << "  --version=[VERSION]" << std::endl
+            << "      "
+            << "Cassandra/DSE version to use." << std::endl
+            << "      Default:" << std::endl
+            << "        Cassandra Version: " << server_version().to_string() << std::endl
+            << "        DSE Version: " << DEFAULT_OPTIONS_DSE_VERSION.to_string() << std::endl;
   std::string categories;
-  for (TestCategory::iterator iterator = TestCategory::begin();
-    iterator != TestCategory::end(); ++iterator) {
+  for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
+       ++iterator) {
     if (iterator != TestCategory::begin()) {
       categories += "|";
     }
     categories += iterator->name();
   }
-  std::cout << "  --category=[" << categories << "]" << std::endl << "      "
-    << "Run only the categories whose name matches one of the available" << std::endl
-    << "      categories; ':' separates two categories. The default is all categories" << std::endl
-    << "      being executed."  << std::endl;
-  std::cout << "  --dse" << std::endl << "      "
-    << "Indicate server version supplied is DSE." << std::endl;
-  std::cout << "  --dse-credentials=(USERNAME_PASSWORD|INI_FILE)" << std::endl << "      "
-    << "DSE credentials to use for download authentication. The default is " << std::endl
-    << "      " << dse_credentials().to_string() << "." << std::endl;
-  std::cout << "  --dse-username=[USERNAME]" << std::endl << "      "
-    << "Username to use for DSE download authentication." << std::endl;
-  std::cout << "  --dse-password=[PASSWORD]" << std::endl << "      "
-    << "Password to use for DSE download authentication." << std::endl;
-  std::cout << "  --git" << std::endl << "      "
-    << "Indicate Cassandra/DSE server download should be obtained from" << std::endl
-    << "      ASF/GitHub." << std::endl;
-  std::cout << "  --git=[BRANCH_OR_TAG]" << std::endl << "      "
-    << "Indicate Cassandra/DSE server branch/tag should be obtained from" << std::endl
-    << "      ASF/GitHub." << std::endl;
-  std::cout << "  --install-dir=[INSTALL_DIR]" << std::endl << "      "
-    << "Indicate Cassandra/DSE installation directory to use." << std::endl;
-  std::cout << "  --prefix=[PREFIX]" << std::endl << "      "
-    << "CCM cluster prefix. The default is " << cluster_prefix() << "." << std::endl;
+  std::cout << "  --category=[" << categories << "]" << std::endl
+            << "      "
+            << "Run only the categories whose name matches one of the available" << std::endl
+            << "      categories; ':' separates two categories. The default is all categories"
+            << std::endl
+            << "      being executed." << std::endl;
+  std::cout << "  --dse" << std::endl
+            << "      "
+            << "Indicate server version supplied is DSE." << std::endl;
+  std::cout << "  --dse-credentials=(USERNAME_PASSWORD|INI_FILE)" << std::endl
+            << "      "
+            << "DSE credentials to use for download authentication. The default is " << std::endl
+            << "      " << dse_credentials().to_string() << "." << std::endl;
+  std::cout << "  --dse-username=[USERNAME]" << std::endl
+            << "      "
+            << "Username to use for DSE download authentication." << std::endl;
+  std::cout << "  --dse-password=[PASSWORD]" << std::endl
+            << "      "
+            << "Password to use for DSE download authentication." << std::endl;
+  std::cout << "  --git" << std::endl
+            << "      "
+            << "Indicate Cassandra/DSE server download should be obtained from" << std::endl
+            << "      ASF/GitHub." << std::endl;
+  std::cout << "  --git=[BRANCH_OR_TAG]" << std::endl
+            << "      "
+            << "Indicate Cassandra/DSE server branch/tag should be obtained from" << std::endl
+            << "      ASF/GitHub." << std::endl;
+  std::cout << "  --install-dir=[INSTALL_DIR]" << std::endl
+            << "      "
+            << "Indicate Cassandra/DSE installation directory to use." << std::endl;
+  std::cout << "  --prefix=[PREFIX]" << std::endl
+            << "      "
+            << "CCM cluster prefix. The default is " << cluster_prefix() << "." << std::endl;
 #ifdef CASS_USE_LIBSSH2
-  std::cout << "  --authentication=(USERNAME_PASSWORD|PUBLIC_KEY)" << std::endl << "      "
-    << "Authentication to use for remote deployment. The default is" << std::endl
-    << "      " << authentication_type().to_string() << "." << std::endl;
-  std::cout << "  --deployment=(LOCAL|REMOTE)" << std::endl << "      "
-    << "Deployment to use. The default is " << deployment_type().to_string() << "." << std::endl;
-  std::cout << "  --host=[IP_ADDRESS]" << std::endl << "      "
-    << "IP address to use for remote deployment. The default is " << host() << "." << std::endl;
-  std::cout << "  --port=[PORT]" << std::endl << "      "
-    << "Port to use for remote deployment. The default is " << port() << "." << std::endl;
-  std::cout << "  --username=[USERNAME]" << std::endl << "      "
-    << "Username to use for remote deployment. The default is " << username() << "." << std::endl;
-  std::cout << "  --password=[PASSWORD]" << std::endl << "      "
-    << "Password to use for remote deployment. The default is " << password() << "." << std::endl;
-  std::cout << "  --public-key=[FILENAME]" << std::endl << "      "
-    << "Public key filename to use for remote deployment. The default is" << std::endl
-    << "      " << public_key() << "." << std::endl;
-  std::cout << "  --private-key=[FILENAME]" << std::endl << "      "
-    << "Private key filename to use for remote deployment. The default is" << std::endl
-    << "      " << private_key() << "." << std::endl;
+  std::cout << "  --authentication=(USERNAME_PASSWORD|PUBLIC_KEY)" << std::endl
+            << "      "
+            << "Authentication to use for remote deployment. The default is" << std::endl
+            << "      " << authentication_type().to_string() << "." << std::endl;
+  std::cout << "  --deployment=(LOCAL|REMOTE)" << std::endl
+            << "      "
+            << "Deployment to use. The default is " << deployment_type().to_string() << "."
+            << std::endl;
+  std::cout << "  --host=[IP_ADDRESS]" << std::endl
+            << "      "
+            << "IP address to use for remote deployment. The default is " << host() << "."
+            << std::endl;
+  std::cout << "  --port=[PORT]" << std::endl
+            << "      "
+            << "Port to use for remote deployment. The default is " << port() << "." << std::endl;
+  std::cout << "  --username=[USERNAME]" << std::endl
+            << "      "
+            << "Username to use for remote deployment. The default is " << username() << "."
+            << std::endl;
+  std::cout << "  --password=[PASSWORD]" << std::endl
+            << "      "
+            << "Password to use for remote deployment. The default is " << password() << "."
+            << std::endl;
+  std::cout << "  --public-key=[FILENAME]" << std::endl
+            << "      "
+            << "Public key filename to use for remote deployment. The default is" << std::endl
+            << "      " << public_key() << "." << std::endl;
+  std::cout << "  --private-key=[FILENAME]" << std::endl
+            << "      "
+            << "Private key filename to use for remote deployment. The default is" << std::endl
+            << "      " << private_key() << "." << std::endl;
 #endif
-  std::cout << "  --keep-clusters" << std::endl << "      "
-    << "Indicate CCM clusters should not be removed after tests terminate."
-    << std::endl;
-  std::cout << "  --verbose(=ccm,integration)" << std::endl << "      "
-    << "Enable verbose output for component(s)." << std::endl;
-  std::cout << "  --disable-beta-protocol" << std::endl << "      "
-    << "Disable beta protocol use by default." << std::endl << "      "
-    << "NOTE: Individual tests may override this setting." << std::endl;
+  std::cout << "  --keep-clusters" << std::endl
+            << "      "
+            << "Indicate CCM clusters should not be removed after tests terminate." << std::endl;
+  std::cout << "  --verbose(=ccm,integration)" << std::endl
+            << "      "
+            << "Enable verbose output for component(s)." << std::endl;
+  std::cout << "  --disable-beta-protocol" << std::endl
+            << "      "
+            << "Disable beta protocol use by default." << std::endl
+            << "      "
+            << "NOTE: Individual tests may override this setting." << std::endl;
   std::cout << std::endl;
 }
 
@@ -411,25 +448,15 @@ void Options::print_settings() {
 #endif
 }
 
-bool Options::is_help() {
-  return is_help_;
-}
+bool Options::is_help() { return is_help_; }
 
-bool Options::keep_clusters() {
-  return is_keep_clusters_;
-}
+bool Options::keep_clusters() { return is_keep_clusters_; }
 
-bool Options::log_tests() {
-  return is_log_tests_;
-}
+bool Options::log_tests() { return is_log_tests_; }
 
-CCM::CassVersion Options::server_version() {
-  return server_version_;
-}
+CCM::CassVersion Options::server_version() { return server_version_; }
 
-bool Options::is_dse() {
-  return is_dse_;
-}
+bool Options::is_dse() { return is_dse_; }
 
 CCM::DseCredentialsType Options::dse_credentials() {
   // Static initialization cannot be guaranteed
@@ -439,33 +466,19 @@ CCM::DseCredentialsType Options::dse_credentials() {
   return dse_credentials_type_;
 }
 
-const std::string& Options::dse_username() {
-  return dse_username_;
-}
+const std::string& Options::dse_username() { return dse_username_; }
 
-const std::string& Options::dse_password() {
-  return dse_password_;
-}
+const std::string& Options::dse_password() { return dse_password_; }
 
-bool Options::use_git() {
-  return use_git_;
-}
+bool Options::use_git() { return use_git_; }
 
-const std::string& Options::branch_tag() {
-  return branch_tag_;
-}
+const std::string& Options::branch_tag() { return branch_tag_; }
 
-bool Options::use_install_dir() {
-  return use_install_dir_;
-}
+bool Options::use_install_dir() { return use_install_dir_; }
 
-const std::string& Options::install_dir() {
-  return install_dir_;
-}
+const std::string& Options::install_dir() { return install_dir_; }
 
-const std::string& Options::cluster_prefix() {
-  return cluster_prefix_;
-}
+const std::string& Options::cluster_prefix() { return cluster_prefix_; }
 
 CCM::DeploymentType Options::deployment_type() {
   // Static initialization cannot be guaranteed
@@ -483,73 +496,44 @@ CCM::AuthenticationType Options::authentication_type() {
   return authentication_type_;
 }
 
-std::set<TestCategory> Options::categories() {
-  return categories_;
-}
+std::set<TestCategory> Options::categories() { return categories_; }
 
-const std::string& Options::host() {
-  return host_;
-}
+const std::string& Options::host() { return host_; }
 
-std::string Options::host_prefix() {
-  return host_.substr(0, host_.size() - 1);
-}
+std::string Options::host_prefix() { return host_.substr(0, host_.size() - 1); }
 
-short Options::port() {
-  return port_;
-}
+short Options::port() { return port_; }
 
-const std::string& Options::username() {
-  return username_;
-}
+const std::string& Options::username() { return username_; }
 
-const std::string& Options::password() {
-  return password_;
-}
+const std::string& Options::password() { return password_; }
 
-const std::string& Options::public_key() {
-  return public_key_;
-}
+const std::string& Options::public_key() { return public_key_; }
 
-const std::string& Options::private_key() {
-  return private_key_;
-}
+const std::string& Options::private_key() { return private_key_; }
 
 SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > Options::ccm() {
-  return new CCM::Bridge( \
-    Options::server_version(),
-    Options::use_git(), Options::branch_tag(), \
-    Options::use_install_dir(), Options::install_dir(), \
-    Options::is_dse(), CCM::Bridge::DEFAULT_DSE_WORKLOAD, \
-    Options::cluster_prefix(), \
-    Options::dse_credentials(), \
-    Options::dse_username(), Options::dse_password(), \
-    Options::deployment_type(), Options::authentication_type(), \
-    Options::host(), Options::port(), \
-    Options::username(), Options::password(), \
-    Options::public_key(), Options::private_key(),
-    Options::is_verbose_ccm());
+  return new CCM::Bridge(Options::server_version(), Options::use_git(), Options::branch_tag(),
+                         Options::use_install_dir(), Options::install_dir(), Options::is_dse(),
+                         CCM::Bridge::DEFAULT_DSE_WORKLOAD, Options::cluster_prefix(),
+                         Options::dse_credentials(), Options::dse_username(),
+                         Options::dse_password(), Options::deployment_type(),
+                         Options::authentication_type(), Options::host(), Options::port(),
+                         Options::username(), Options::password(), Options::public_key(),
+                         Options::private_key(), Options::is_verbose_ccm());
 }
 
-bool Options::is_verbose_ccm() {
-  return is_verbose_ccm_;
-}
+bool Options::is_verbose_ccm() { return is_verbose_ccm_; }
 
-bool Options::is_verbose_integration() {
-  return is_verbose_integration_;
-}
+bool Options::is_verbose_integration() { return is_verbose_integration_; }
 
-bool Options::is_beta_protocol() {
-  return is_beta_protocol_;
-}
+bool Options::is_beta_protocol() { return is_beta_protocol_; }
 
-Options::Options() {
-}
+Options::Options() {}
 
 bool Options::bool_value(const std::string& value) {
   std::string lower_value = test::Utils::to_lower(value);
-  if (lower_value == "yes" || lower_value == "true" ||
-      lower_value == "on" || lower_value == "0") {
+  if (lower_value == "yes" || lower_value == "true" || lower_value == "on" || lower_value == "0") {
     return true;
   }
   return false;
diff --git a/gtests/src/integration/options.hpp b/gtests/src/integration/options.hpp
index 583797bcc..fa1600b35 100644
--- a/gtests/src/integration/options.hpp
+++ b/gtests/src/integration/options.hpp
@@ -354,4 +354,3 @@ class Options {
 };
 
 #endif // __OPTIONS_HPP__
-
diff --git a/gtests/src/integration/policies.hpp b/gtests/src/integration/policies.hpp
index 61a66c87b..0a7f3a5f9 100644
--- a/gtests/src/integration/policies.hpp
+++ b/gtests/src/integration/policies.hpp
@@ -21,4 +21,3 @@
 #include "policies/next_host_retry_policy.hpp"
 
 #endif // __TEST_POLICIES_HPP__
-
diff --git a/gtests/src/integration/policies/ignore_retry_policy.hpp b/gtests/src/integration/policies/ignore_retry_policy.hpp
index 6f928466a..c22f9be13 100644
--- a/gtests/src/integration/policies/ignore_retry_policy.hpp
+++ b/gtests/src/integration/policies/ignore_retry_policy.hpp
@@ -21,16 +21,15 @@
 
 #include "retry_policy.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Retry policy that will create an ignore decision for retry
  */
-class IgnoreRetryPolicy : public cass::DefaultRetryPolicy {
+class IgnoreRetryPolicy : public datastax::internal::core::DefaultRetryPolicy {
 public:
   IgnoreRetryPolicy()
-    : cass::DefaultRetryPolicy() { }
+      : datastax::internal::core::DefaultRetryPolicy() {}
 
   /**
    * Create an instance of the retry policy for use with the driver
@@ -38,43 +37,34 @@ class IgnoreRetryPolicy : public cass::DefaultRetryPolicy {
    * @return Driver ready retry policy
    */
   static ::test::driver::RetryPolicy policy() {
-    cass::RetryPolicy* policy = new IgnoreRetryPolicy();
+    datastax::internal::core::RetryPolicy* policy = new IgnoreRetryPolicy();
     policy->inc_ref();
     return CassRetryPolicy::to(policy);
   }
 
-  RetryDecision on_read_timeout(const cass::Request* request,
-                                CassConsistency cl,
-                                int received,
-                                int required,
-                                bool data_recevied,
+  RetryDecision on_read_timeout(const datastax::internal::core::Request* request,
+                                CassConsistency cl, int received, int required, bool data_recevied,
                                 int num_retries) const {
     return RetryDecision::ignore();
   }
-  RetryDecision on_write_timeout(const cass::Request* request,
-                                 CassConsistency cl,
-                                 int received,
-                                 int required,
-                                 CassWriteType write_type,
-                                 int num_retries) const {
+  RetryDecision on_write_timeout(const datastax::internal::core::Request* request,
+                                 CassConsistency cl, int received, int required,
+                                 CassWriteType write_type, int num_retries) const {
     return RetryDecision::ignore();
   }
-  virtual RetryDecision on_unavailable(const cass::Request* request,
-                                       CassConsistency cl,
-                                       int required,
-                                       int alive,
+  virtual RetryDecision on_unavailable(const datastax::internal::core::Request* request,
+                                       CassConsistency cl, int required, int alive,
                                        int num_retries) const {
     return RetryDecision::ignore();
   }
-  virtual RetryDecision on_request_error(const cass::Request* request,
+  virtual RetryDecision on_request_error(const datastax::internal::core::Request* request,
                                          CassConsistency cl,
-                                         const cass::ErrorResponse* error,
+                                         const datastax::internal::core::ErrorResponse* error,
                                          int num_retries) const {
     return RetryDecision::ignore();
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __ALWAYS_IGNORE_RETRY_POLICY_HPP__
diff --git a/gtests/src/integration/policies/next_host_retry_policy.hpp b/gtests/src/integration/policies/next_host_retry_policy.hpp
index 8974ecbf1..59d3fe90d 100644
--- a/gtests/src/integration/policies/next_host_retry_policy.hpp
+++ b/gtests/src/integration/policies/next_host_retry_policy.hpp
@@ -21,16 +21,15 @@
 
 #include "retry_policy.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Retry policy that will retry the statement on the next host
  */
-class NextHostRetryPolicy : public cass::DefaultRetryPolicy {
+class NextHostRetryPolicy : public datastax::internal::core::DefaultRetryPolicy {
 public:
   NextHostRetryPolicy()
-    : cass::DefaultRetryPolicy() { }
+      : datastax::internal::core::DefaultRetryPolicy() {}
 
   /**
    * Create an instance of the retry policy for use with the driver
@@ -38,43 +37,34 @@ class NextHostRetryPolicy : public cass::DefaultRetryPolicy {
    * @return Driver ready retry policy
    */
   static ::test::driver::RetryPolicy policy() {
-    cass::RetryPolicy* policy = new NextHostRetryPolicy();
+    datastax::internal::core::RetryPolicy* policy = new NextHostRetryPolicy();
     policy->inc_ref();
     return CassRetryPolicy::to(policy);
   }
 
-  RetryDecision on_read_timeout(const cass::Request* request,
-                                CassConsistency cl,
-                                int received,
-                                int required,
-                                bool data_recevied,
+  RetryDecision on_read_timeout(const datastax::internal::core::Request* request,
+                                CassConsistency cl, int received, int required, bool data_recevied,
                                 int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  RetryDecision on_write_timeout(const cass::Request* request,
-                                 CassConsistency cl,
-                                 int received,
-                                 int required,
-                                 CassWriteType write_type,
-                                 int num_retries) const {
+  RetryDecision on_write_timeout(const datastax::internal::core::Request* request,
+                                 CassConsistency cl, int received, int required,
+                                 CassWriteType write_type, int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  virtual RetryDecision on_unavailable(const cass::Request* request,
-                                       CassConsistency cl,
-                                       int required,
-                                       int alive,
+  virtual RetryDecision on_unavailable(const datastax::internal::core::Request* request,
+                                       CassConsistency cl, int required, int alive,
                                        int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  virtual RetryDecision on_request_error(const cass::Request* request,
+  virtual RetryDecision on_request_error(const datastax::internal::core::Request* request,
                                          CassConsistency cl,
-                                         const cass::ErrorResponse* error,
+                                         const datastax::internal::core::ErrorResponse* error,
                                          int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
 };
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __NEXT_HOST_RETRY_POLICY_HPP__
diff --git a/gtests/src/integration/rest_client.cpp b/gtests/src/integration/rest_client.cpp
index a50a2febb..2e36de389 100644
--- a/gtests/src/integration/rest_client.cpp
+++ b/gtests/src/integration/rest_client.cpp
@@ -25,6 +25,8 @@
 #define HTTP_EOL "\r\n"
 #define OUTPUT_BUFFER_SIZE 10240ul
 
+using namespace datastax::internal::core;
+
 // Static initializations
 uv_buf_t RestClient::write_buf_;
 uv_write_t RestClient::write_req_;
@@ -48,12 +50,11 @@ struct HttpRequest {
 };
 
 const Response RestClient::send_request(const Request& request) {
-    // Initialize the loop
+  // Initialize the loop
   uv_loop_t loop;
   int error_code = uv_loop_init(&loop);
-  if(error_code != 0) {
-    throw Exception("Unable to Send Request: " +
-                    std::string(uv_strerror(error_code)));
+  if (error_code != 0) {
+    throw Exception("Unable to Send Request: " + std::string(uv_strerror(error_code)));
   };
 
   // Initialize the HTTP request
@@ -62,40 +63,33 @@ const Response RestClient::send_request(const Request& request) {
   http_request.loop = &loop;
 
   // Create the IPv4 socket address
-  const cass::Address address(request.address.c_str(),
-                              static_cast<int>(request.port));
+  const Address address(request.address.c_str(), static_cast<int>(request.port));
 
   // Initialize the client TCP request
   uv_tcp_t tcp;
   tcp.data = &http_request;
   error_code = uv_tcp_init(&loop, &tcp);
   if (error_code != 0) {
-    TEST_LOG_ERROR("Unable to Initialize TCP Request: " +
-      std::string(uv_strerror(error_code)));
+    TEST_LOG_ERROR("Unable to Initialize TCP Request: " + std::string(uv_strerror(error_code)));
   }
   error_code = uv_tcp_keepalive(&tcp, 1, 60);
   if (error_code != 0) {
-    TEST_LOG_ERROR("Unable to Set TCP KeepAlive: " +
-      std::string(uv_strerror(error_code)));
+    TEST_LOG_ERROR("Unable to Set TCP KeepAlive: " + std::string(uv_strerror(error_code)));
   }
 
   // Start the request and attach the HTTP request to send to the REST server
   uv_connect_t connect;
   connect.data = &http_request;
-  uv_tcp_connect(&connect, &tcp,
-    address.addr(),
-    handle_connected);
+  uv_tcp_connect(&connect, &tcp, address.addr(), handle_connected);
 
-    uv_run(&loop, UV_RUN_DEFAULT);
-    uv_loop_close(&loop);
+  uv_run(&loop, UV_RUN_DEFAULT);
+  uv_loop_close(&loop);
 
   // Return the response from the request
   return http_request.response;
 }
 
-void RestClient::handle_allocation(uv_handle_t* handle,
-                                   size_t suggested_size,
-                                   uv_buf_t* buffer) {
+void RestClient::handle_allocation(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buffer) {
   buffer->base = new char[OUTPUT_BUFFER_SIZE];
   buffer->len = OUTPUT_BUFFER_SIZE;
 }
@@ -104,8 +98,7 @@ void RestClient::handle_connected(uv_connect_t* req, int status) {
   HttpRequest* request = static_cast<HttpRequest*>(req->data);
 
   if (status < 0) {
-    TEST_LOG_ERROR("Unable to Connect to HTTP Server: "
-      << uv_strerror(status));
+    TEST_LOG_ERROR("Unable to Connect to HTTP Server: " << uv_strerror(status));
     uv_close(reinterpret_cast<uv_handle_t*>(req->handle), NULL);
   } else {
     // Create the buffer to write to the stream
@@ -118,8 +111,7 @@ void RestClient::handle_connected(uv_connect_t* req, int status) {
   }
 }
 
-void RestClient::handle_response(uv_stream_t* stream,
-                                 ssize_t buffer_length,
+void RestClient::handle_response(uv_stream_t* stream, ssize_t buffer_length,
                                  const uv_buf_t* buffer) {
   HttpRequest* request = static_cast<HttpRequest*>(stream->data);
 
@@ -170,12 +162,10 @@ const std::string RestClient::generate_http_message(const Request& request) {
 
   // Generate the headers
   bool is_post = request.method == Request::HTTP_METHOD_POST;
-  message
-    << "Host: " << request.address << ":" << request.port << HTTP_EOL
-    << (is_post ? "Content-Type: application/json" HTTP_EOL : "")
-    << "Content-Length: "<< ((is_post) ? request.content.size() : 0) << HTTP_EOL
-    << "Connection: close" << HTTP_EOL << HTTP_EOL
-    << (is_post ? request.content : "");
+  message << "Host: " << request.address << ":" << request.port << HTTP_EOL
+          << (is_post ? "Content-Type: application/json" HTTP_EOL : "")
+          << "Content-Length: " << ((is_post) ? request.content.size() : 0) << HTTP_EOL
+          << "Connection: close" << HTTP_EOL << HTTP_EOL << (is_post ? request.content : "");
 
   // Return the HTTP message
   TEST_LOG("[HTTP Message]: " << message.str());
diff --git a/gtests/src/integration/rest_client.hpp b/gtests/src/integration/rest_client.hpp
index 99a18b165..76638818b 100644
--- a/gtests/src/integration/rest_client.hpp
+++ b/gtests/src/integration/rest_client.hpp
@@ -30,11 +30,7 @@ struct Request {
   /**
    * HTTP request method
    */
-  enum Method {
-    HTTP_METHOD_DELETE = 0,
-    HTTP_METHOD_GET,
-    HTTP_METHOD_POST
-  };
+  enum Method { HTTP_METHOD_DELETE = 0, HTTP_METHOD_GET, HTTP_METHOD_POST };
 
   /**
    * Host address IPv4
@@ -72,7 +68,7 @@ struct Response {
   int status_code;
 
   Response()
-    : status_code(200 /* OK */) { }
+      : status_code(200 /* OK */) {}
 };
 
 /**
@@ -84,7 +80,7 @@ class RestClient {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   /**
@@ -117,8 +113,7 @@ class RestClient {
    * @param suggested_size The size (in bytes) to allocate for the buffer
    * @param buf Buffer to be allocated
    */
-  static void handle_allocation(uv_handle_t* handle, size_t suggested_size,
-    uv_buf_t* buffer);
+  static void handle_allocation(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buffer);
 
   /**
    * Handle the connect (callback) when the connection has been established to
@@ -138,9 +133,7 @@ class RestClient {
    *              will equal <b>UV_EOF</b>
    * @param buf Buffer to read from
    */
-  static void handle_response(uv_stream_t* stream,
-                              ssize_t nread,
-                              const uv_buf_t* buf);
+  static void handle_response(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
 
   /**
    * Generate the HTTP message for the REST request.
@@ -149,7 +142,6 @@ class RestClient {
    * @return String representing the REST request HTTP message
    */
   static const std::string generate_http_message(const Request& request);
-
 };
 
 #endif // __TEST_REST_CLIENT_HPP__
diff --git a/gtests/src/integration/shared_ptr.hpp b/gtests/src/integration/shared_ptr.hpp
index 7174bf2f2..50aefd106 100644
--- a/gtests/src/integration/shared_ptr.hpp
+++ b/gtests/src/integration/shared_ptr.hpp
@@ -16,8 +16,8 @@
 
 #ifndef __SHARED_PTR_HPP__
 #define __SHARED_PTR_HPP__
-#include "scoped_ptr.hpp"
 #include "ref_counted.hpp"
+#include "scoped_ptr.hpp"
 
 template <class T>
 struct StdDeleter {
@@ -27,24 +27,20 @@ struct StdDeleter {
 /**
  * Reference counted objects container
  */
-template<typename T, class D = cass::DefaultDeleter<T> >
-class ObjectRef : public cass::RefCounted< ObjectRef<T, D> > {
+template <typename T, class D = datastax::internal::DefaultDeleter<T> >
+class ObjectRef : public datastax::internal::RefCounted<ObjectRef<T, D> > {
 public:
   ObjectRef(T* ptr)
-    : ptr_(ptr) {}
+      : ptr_(ptr) {}
 
-  virtual ~ObjectRef() {
-    D()(ptr_);
-  }
+  virtual ~ObjectRef() { D()(ptr_); }
 
   /**
    * Get the native object
    *
    * @return The native object
    */
-  T* get() {
-    return ptr_;
-  }
+  T* get() { return ptr_; }
 
 private:
   /**
@@ -56,28 +52,22 @@ class ObjectRef : public cass::RefCounted< ObjectRef<T, D> > {
 /**
  * Shared pointer for object references
  */
-template<typename T, class D = cass::DefaultDeleter<T> >
+template <typename T, class D = datastax::internal::DefaultDeleter<T> >
 class SharedPtr {
 public:
   SharedPtr(T* ptr = NULL)
-    : object_(NULL) {
+      : object_(NULL) {
     if (ptr) {
       ObjectRef<T, D>* object_ref = new ObjectRef<T, D>(ptr);
-      object_ = cass::SharedRefPtr<ObjectRef<T, D> >(object_ref);
+      object_ = datastax::internal::SharedRefPtr<ObjectRef<T, D> >(object_ref);
     }
   }
 
-  T* operator->() {
-    return get();
-  }
+  T* operator->() { return get(); }
 
-  T& operator*() {
-    return *get();
-  }
+  T& operator*() { return *get(); }
 
-  operator bool() const {
-    return object_;
-  }
+  operator bool() const { return object_; }
 
   /**
    * Get the native object from the object reference
@@ -97,11 +87,12 @@ class SharedPtr {
     }
     return NULL;
   }
+
 private:
   /**
    * Object reference
    */
-  cass::SharedRefPtr<ObjectRef<T, D> > object_;
+  datastax::internal::SharedRefPtr<ObjectRef<T, D> > object_;
 };
 
 #endif // __SHARED_PTR_HPP__
diff --git a/gtests/src/integration/simulacron/priming_requests.hpp b/gtests/src/integration/simulacron/priming_requests.hpp
index 9ab1716ee..f5bb950ba 100644
--- a/gtests/src/integration/simulacron/priming_requests.hpp
+++ b/gtests/src/integration/simulacron/priming_requests.hpp
@@ -35,11 +35,11 @@ class Request {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   Request()
-    : then_(new Success()) { };
+      : then_(new Success()){};
 
   /**
    * Generate the JSON for the priming request
@@ -80,8 +80,7 @@ class Request {
    * @param consistency Consistency levels for the request
    * @return PrimingRequest instance
    */
-  Request& with_consistencies(
-    const std::vector<CassConsistency>& consistency) {
+  Request& with_consistencies(const std::vector<CassConsistency>& consistency) {
     when_.with_consistencies(consistency);
     return *this;
   }
@@ -98,11 +97,11 @@ class Request {
   }
 
   /**
-  * Set a response for the request
-  *
-  * @param result Response to the request
-  * @return PrimingRequest instance
-  */
+   * Set a response for the request
+   *
+   * @param result Response to the request
+   * @return PrimingRequest instance
+   */
   Request& with_result(Result* result) {
     then_ = result;
     return *this;
@@ -110,7 +109,8 @@ class Request {
 
 private:
   class When {
-  friend class Request;
+    friend class Request;
+
   private:
     /**
      * Consistency levels
@@ -121,7 +121,7 @@ class Request {
      */
     std::string query_;
 
-    When() {};
+    When(){};
 
     /**
      * Build the when section for the priming request
@@ -136,7 +136,7 @@ class Request {
         writer.Key("consistency");
         writer.StartArray();
         for (std::vector<CassConsistency>::iterator iterator = consistencies_.begin();
-          iterator != consistencies_.end(); ++iterator) {
+             iterator != consistencies_.end(); ++iterator) {
           writer.String(cass_consistency_string(*iterator));
         }
         writer.EndArray();
@@ -171,9 +171,7 @@ class Request {
      *
      * @param query Query for the request
      */
-    void with_query(const std::string& query) {
-      query_ = query;
-    }
+    void with_query(const std::string& query) { query_ = query; }
   };
 
 private:
diff --git a/gtests/src/integration/simulacron/priming_rows.hpp b/gtests/src/integration/simulacron/priming_rows.hpp
index 41d2d5b41..e9791b029 100644
--- a/gtests/src/integration/simulacron/priming_rows.hpp
+++ b/gtests/src/integration/simulacron/priming_rows.hpp
@@ -22,12 +22,12 @@
 
 #include "cassandra.h"
 
-#include <rapidjson/stringbuffer.h>
 #include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
 
 #include <map>
-#include <string>
 #include <sstream>
+#include <string>
 #include <vector>
 
 namespace prime {
@@ -38,16 +38,17 @@ class Rows;
  * Priming row
  */
 class Row {
-friend class Rows;
+  friend class Rows;
+
 public:
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
   typedef std::pair<std::string, std::string> Column;
 
-  Row() { };
+  Row(){};
 
   /**
    * Add a column|value pair
@@ -57,22 +58,19 @@ friend class Rows;
    * @param value Value for the column
    * @return PrimingRow instance
    */
-  Row& add_column(const std::string& name,
-                  const CassValueType value_type,
+  Row& add_column(const std::string& name, const CassValueType value_type,
                   const std::string& value) {
     std::string cql_type = test::Utils::scalar_cql_type(value_type);
-    if (value_type == CASS_VALUE_TYPE_LIST ||
-      value_type == CASS_VALUE_TYPE_MAP ||
-      value_type == CASS_VALUE_TYPE_SET) {
-      throw Exception("Value Type " + cql_type + "Needs to be Parameterized: "
-        "Use add_column(string name, string cql_value_type, string value) instead");
-     }
-
-    //TODO: Add types when supported by Simulacron
-    if (value_type == CASS_VALUE_TYPE_CUSTOM ||
-      value_type == CASS_VALUE_TYPE_UDT) {
-      throw Exception("Value Type is not Supported by Simulacron: "
-        + cql_type);
+    if (value_type == CASS_VALUE_TYPE_LIST || value_type == CASS_VALUE_TYPE_MAP ||
+        value_type == CASS_VALUE_TYPE_SET) {
+      throw Exception("Value Type " + cql_type +
+                      "Needs to be Parameterized: "
+                      "Use add_column(string name, string cql_value_type, string value) instead");
+    }
+
+    // TODO: Add types when supported by Simulacron
+    if (value_type == CASS_VALUE_TYPE_CUSTOM || value_type == CASS_VALUE_TYPE_UDT) {
+      throw Exception("Value Type is not Supported by Simulacron: " + cql_type);
     }
 
     return add_column(name, cql_type, value);
@@ -86,10 +84,9 @@ friend class Rows;
    * @param value Value for the column
    * @return PrimingRow instance
    */
-  Row& add_column(const std::string& name,
-                  const std::string& cql_value_type,
+  Row& add_column(const std::string& name, const std::string& cql_value_type,
                   const std::string& value) {
-    //TODO: Add validation (mainly for parameterized types)
+    // TODO: Add validation (mainly for parameterized types)
     // Ensure the column doesn't already exist
     if (columns_.find(name) != columns_.end()) {
       throw Exception("Unable to Add Column: Already Exists [" + name + "]");
@@ -107,13 +104,10 @@ friend class Rows;
    *         otherwise
    */
   bool operator==(const Row& rhs) const {
-    return columns_.size() == rhs.columns_.size()
-      && std::equal(columns_.begin(), columns_.end(), rhs.columns_.begin(),
-        ColumnsKeyEquality());
-  }
-  bool operator!=(const Row& rhs) const {
-    return !(*this == rhs);
+    return columns_.size() == rhs.columns_.size() &&
+           std::equal(columns_.begin(), columns_.end(), rhs.columns_.begin(), ColumnsKeyEquality());
   }
+  bool operator!=(const Row& rhs) const { return !(*this == rhs); }
 
 protected:
   /**
@@ -125,8 +119,7 @@ friend class Rows;
     writer.Key("column_types");
     writer.StartObject();
 
-    for (Map::iterator iterator = columns_.begin(); iterator != columns_.end();
-      ++iterator) {
+    for (Map::iterator iterator = columns_.begin(); iterator != columns_.end(); ++iterator) {
       std::string name = iterator->first;
       std::string cql_type = iterator->second.first;
       writer.Key(name.c_str());
@@ -144,21 +137,19 @@ friend class Rows;
   void build_row(rapidjson::PrettyWriter<rapidjson::StringBuffer>& writer) {
     writer.StartObject();
 
-    for (Map::iterator iterator = columns_.begin(); iterator != columns_.end();
-      ++iterator) {
+    for (Map::iterator iterator = columns_.begin(); iterator != columns_.end(); ++iterator) {
       std::string name = iterator->first;
       std::string value = iterator->second.second;
 
       // Add the column|value pair
       writer.Key(name.c_str());
-      bool is_array = value.compare(0, 1, "[")  == 0 &&
-        value.compare(value.size() - 1, 1, "]") == 0;
+      bool is_array = value.compare(0, 1, "[") == 0 && value.compare(value.size() - 1, 1, "]") == 0;
       if (is_array) {
         value = value.substr(1, value.size() - 2);
         writer.StartArray();
         std::vector<std::string> values = test::Utils::explode(value, ',');
-        for (std::vector<std::string>::iterator iterator = values.begin();
-          iterator != values.end(); ++iterator) {
+        for (std::vector<std::string>::iterator iterator = values.begin(); iterator != values.end();
+             ++iterator) {
           writer.String((*iterator).c_str());
         }
         writer.EndArray();
@@ -200,15 +191,16 @@ friend class Rows;
  * Priming rows
  */
 class Rows {
-friend class Success;
+  friend class Success;
+
 public:
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
-  Rows() { };
+  Rows(){};
 
   /**
    * Add a row
@@ -219,8 +211,7 @@ friend class Success;
    */
   Rows& add_row(const Row& columns) {
     if (!rows_.empty() && rows_.front() != columns) {
-      throw Exception(
-        "Unable to Add Row: Columns are incompatible with previous row(s)");
+      throw Exception("Unable to Add Row: Columns are incompatible with previous row(s)");
     }
     rows_.push_back(columns);
     return *this;
@@ -231,9 +222,7 @@ friend class Success;
    *
    * @return True if rows are empty; false otherwise
    */
-  bool empty() const {
-    return rows_.empty();
-  }
+  bool empty() const { return rows_.empty(); }
 
 protected:
   /**
@@ -254,8 +243,7 @@ friend class Success;
     // Iterate over the rows and add each row to the rows object array
     rows.Key("rows");
     rows.StartArray();
-    for (std::vector<Row>::iterator iterator = rows_.begin();
-      iterator != rows_.end(); ++iterator) {
+    for (std::vector<Row>::iterator iterator = rows_.begin(); iterator != rows_.end(); ++iterator) {
       iterator->build_row(rows);
     }
     rows.EndArray();
diff --git a/gtests/src/integration/simulacron/results/close_connection.hpp b/gtests/src/integration/simulacron/results/close_connection.hpp
index 1182baaa6..52305e0ff 100644
--- a/gtests/src/integration/simulacron/results/close_connection.hpp
+++ b/gtests/src/integration/simulacron/results/close_connection.hpp
@@ -26,11 +26,7 @@
 /**
  * Enumeration for 'close_type' property
  */
-enum CloseType {
-  CLOSE_TYPE_DISCONNECT,
-  CLOSE_TYPE_SHUTDOWN_READ,
-  CLOSE_TYPE_SHUTDOWN_WRITE
-};
+enum CloseType { CLOSE_TYPE_DISCONNECT, CLOSE_TYPE_SHUTDOWN_READ, CLOSE_TYPE_SHUTDOWN_WRITE };
 
 /**
  * Enumeration for disconnect 'scope' property
@@ -55,13 +51,13 @@ class CloseConnection : public Result {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   CloseConnection()
-    : Result("close_connection")
-    , close_type_(CLOSE_TYPE_DISCONNECT)
-    , scope_(DISCONNECT_SCOPE_CONNECTION) { }
+      : Result("close_connection")
+      , close_type_(CLOSE_TYPE_DISCONNECT)
+      , scope_(DISCONNECT_SCOPE_CONNECTION) {}
 
   /**
    * Fully construct the 'close_connection' result
@@ -71,12 +67,10 @@ class CloseConnection : public Result {
    * @param scope The scope (connection, node, data center, cluster) at which to
    *              close the associated connection(s)
    */
-  CloseConnection(unsigned long delay_in_ms,
-                  CloseType close_type,
-                  DisconnectScope scope)
-    : Result("close_connection", delay_in_ms)
-    , close_type_(close_type)
-    , scope_(scope) { }
+  CloseConnection(unsigned long delay_in_ms, CloseType close_type, DisconnectScope scope)
+      : Result("close_connection", delay_in_ms)
+      , close_type_(close_type)
+      , scope_(scope) {}
 
   /**
    * Set a fixed delay to the response time of a result
@@ -135,7 +129,7 @@ class CloseConnection : public Result {
    * @return String representation of the close type property
    */
   std::string get_close_type(CloseType type) const {
-    switch(type) {
+    switch (type) {
       case CLOSE_TYPE_DISCONNECT:
         return "disconnect";
       case CLOSE_TYPE_SHUTDOWN_READ:
@@ -144,11 +138,10 @@ class CloseConnection : public Result {
         return "shutdown_write";
       default:
         std::stringstream message;
-        message << "Unsupported Close Type: " << type
-          << " will need to be added";
+        message << "Unsupported Close Type: " << type << " will need to be added";
         throw Exception(message.str());
         break;
-     }
+    }
   }
 
   /**
@@ -158,7 +151,7 @@ class CloseConnection : public Result {
    * @return String representation of the disconnect scope property
    */
   std::string get_disconnect_scope(DisconnectScope disconnect_scope) const {
-    switch(disconnect_scope) {
+    switch (disconnect_scope) {
       case DISCONNECT_SCOPE_CONNECTION:
         return "connection";
       case DISCONNECT_SCOPE_NODE:
@@ -169,11 +162,10 @@ class CloseConnection : public Result {
         return "cluster";
       default:
         std::stringstream message;
-        message << "Unsupported Disconnect Scope: " << disconnect_scope
-          << " will need to be added";
+        message << "Unsupported Disconnect Scope: " << disconnect_scope << " will need to be added";
         throw Exception(message.str());
         break;
-     }
+    }
   }
 
 private:
diff --git a/gtests/src/integration/simulacron/results/result.hpp b/gtests/src/integration/simulacron/results/result.hpp
index f5380ec42..ba303c7df 100644
--- a/gtests/src/integration/simulacron/results/result.hpp
+++ b/gtests/src/integration/simulacron/results/result.hpp
@@ -19,8 +19,8 @@
 
 #include <string>
 
-#include <rapidjson/stringbuffer.h>
 #include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
 
 namespace prime {
 
@@ -29,7 +29,7 @@ namespace prime {
  */
 class Result {
 public:
-  virtual ~Result() { }
+  virtual ~Result() {}
 
   /**
    * Generate the JSON for the base result
@@ -55,8 +55,8 @@ class Result {
    * @param result String value for the JSON result value
    */
   Result(const std::string& result)
-    : delay_in_ms_(0)
-    , result_(result) { }
+      : delay_in_ms_(0)
+      , result_(result) {}
 
   /**
    * Protected constructor for base result type
@@ -65,8 +65,8 @@ class Result {
    * @param delay_in_ms Delay in milliseconds before forwarding result
    */
   Result(const std::string& result, unsigned long delay_in_ms)
-    : delay_in_ms_(delay_in_ms)
-    , result_(result) { }
+      : delay_in_ms_(delay_in_ms)
+      , result_(result) {}
 
 private:
   /**
diff --git a/gtests/src/integration/simulacron/results/success.hpp b/gtests/src/integration/simulacron/results/success.hpp
index 85f3e4584..891e7eae8 100644
--- a/gtests/src/integration/simulacron/results/success.hpp
+++ b/gtests/src/integration/simulacron/results/success.hpp
@@ -41,11 +41,11 @@ class Row {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
   typedef std::pair<std::string, std::string> Column;
 
-  Row() { }
+  Row() {}
 
   /**
    * Add a column|value pair
@@ -55,22 +55,19 @@ class Row {
    * @param value Value for the column
    * @return PrimingRow instance
    */
-  Row& add_column(const std::string& name,
-                  const CassValueType value_type,
+  Row& add_column(const std::string& name, const CassValueType value_type,
                   const std::string& value) {
     std::string cql_type = test::Utils::scalar_cql_type(value_type);
-    if (value_type == CASS_VALUE_TYPE_LIST ||
-      value_type == CASS_VALUE_TYPE_MAP ||
-      value_type == CASS_VALUE_TYPE_SET) {
-      throw Exception("Value Type " + cql_type + "Needs to be Parameterized: "
-        "Use add_column(string name, string cql_value_type, string value) instead");
-     }
-
-    //TODO: Add types when supported by Simulacron
-    if (value_type == CASS_VALUE_TYPE_CUSTOM ||
-      value_type == CASS_VALUE_TYPE_UDT) {
-      throw Exception("Value Type is not Supported by Simulacron: "
-        + cql_type);
+    if (value_type == CASS_VALUE_TYPE_LIST || value_type == CASS_VALUE_TYPE_MAP ||
+        value_type == CASS_VALUE_TYPE_SET) {
+      throw Exception("Value Type " + cql_type +
+                      "Needs to be Parameterized: "
+                      "Use add_column(string name, string cql_value_type, string value) instead");
+    }
+
+    // TODO: Add types when supported by Simulacron
+    if (value_type == CASS_VALUE_TYPE_CUSTOM || value_type == CASS_VALUE_TYPE_UDT) {
+      throw Exception("Value Type is not Supported by Simulacron: " + cql_type);
     }
 
     return add_column(name, cql_type, value);
@@ -84,10 +81,9 @@ class Row {
    * @param value Value for the column
    * @return PrimingRow instance
    */
-  Row& add_column(const std::string& name,
-                  const std::string& cql_value_type,
+  Row& add_column(const std::string& name, const std::string& cql_value_type,
                   const std::string& value) {
-    //TODO: Add validation (mainly for parameterized types)
+    // TODO: Add validation (mainly for parameterized types)
     // Ensure the column doesn't already exist
     if (columns_.find(name) != columns_.end()) {
       throw Exception("Unable to Add Column: Already Exists [" + name + "]");
@@ -105,15 +101,10 @@ class Row {
    *         otherwise
    */
   bool operator==(const Row& rhs) const {
-    return columns_.size() == rhs.columns_.size()
-      && std::equal(columns_.begin(),
-                    columns_.end(),
-                    rhs.columns_.begin(),
-                    ColumnsKeyEquality());
-  }
-  bool operator!=(const Row& rhs) const {
-    return !(*this == rhs);
+    return columns_.size() == rhs.columns_.size() &&
+           std::equal(columns_.begin(), columns_.end(), rhs.columns_.begin(), ColumnsKeyEquality());
   }
+  bool operator!=(const Row& rhs) const { return !(*this == rhs); }
 
   /**
    * Build the column types for the column used by the row
@@ -124,8 +115,7 @@ class Row {
     writer.Key("column_types");
     writer.StartObject();
 
-    for (Map::const_iterator iterator = columns_.begin(); iterator != columns_.end();
-      ++iterator) {
+    for (Map::const_iterator iterator = columns_.begin(); iterator != columns_.end(); ++iterator) {
       std::string name = iterator->first;
       std::string cql_type = iterator->second.first;
       writer.Key(name.c_str());
@@ -143,21 +133,19 @@ class Row {
   void build_row(rapidjson::PrettyWriter<rapidjson::StringBuffer>& writer) const {
     writer.StartObject();
 
-    for (Map::const_iterator iterator = columns_.begin(); iterator != columns_.end();
-      ++iterator) {
+    for (Map::const_iterator iterator = columns_.begin(); iterator != columns_.end(); ++iterator) {
       std::string name = iterator->first;
       std::string value = iterator->second.second;
 
       // Add the column|value pair
       writer.Key(name.c_str());
-      bool is_array = value.compare(0, 1, "[")  == 0 &&
-        value.compare(value.size() - 1, 1, "]") == 0;
+      bool is_array = value.compare(0, 1, "[") == 0 && value.compare(value.size() - 1, 1, "]") == 0;
       if (is_array) {
         value = value.substr(1, value.size() - 2);
         writer.StartArray();
         std::vector<std::string> values = test::Utils::explode(value, ',');
-        for (std::vector<std::string>::iterator iterator = values.begin();
-          iterator != values.end(); ++iterator) {
+        for (std::vector<std::string>::iterator iterator = values.begin(); iterator != values.end();
+             ++iterator) {
           writer.String((*iterator).c_str());
         }
         writer.EndArray();
@@ -204,10 +192,10 @@ class Rows {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
 
-  Rows() { }
+  Rows() {}
 
   /**
    * Add a row
@@ -218,8 +206,7 @@ class Rows {
    */
   Rows& add_row(const Row& columns) {
     if (!rows_.empty() && rows_.front() != columns) {
-      throw Exception(
-        "Unable to Add Row: Columns are incompatible with previous row(s)");
+      throw Exception("Unable to Add Row: Columns are incompatible with previous row(s)");
     }
     rows_.push_back(columns);
     return *this;
@@ -230,9 +217,7 @@ class Rows {
    *
    * @return True if rows are empty; false otherwise
    */
-  bool empty() const {
-    return rows_.empty();
-  }
+  bool empty() const { return rows_.empty(); }
 
   /**
    * Build the column types for the column used by the rows
@@ -251,8 +236,8 @@ class Rows {
   void build_rows(rapidjson::PrettyWriter<rapidjson::StringBuffer>& rows) const {
     rows.Key("rows");
     rows.StartArray();
-    for (std::vector<Row>::const_iterator iterator = rows_.begin();
-      iterator != rows_.end(); ++iterator) {
+    for (std::vector<Row>::const_iterator iterator = rows_.begin(); iterator != rows_.end();
+         ++iterator) {
       iterator->build_row(rows);
     }
     rows.EndArray();
@@ -271,7 +256,7 @@ class Rows {
 class Success : public Result {
 public:
   Success()
-    : Result("success") { }
+      : Result("success") {}
 
   /**
    * Fully construct the 'success' result
@@ -279,10 +264,9 @@ class Success : public Result {
    * @param delay_in_ms Delay in milliseconds before forwarding result
    * @param rows Rows to return when responding to the request
    */
-  Success(unsigned long delay_in_ms,
-          const Rows& rows)
-    : Result("success", delay_in_ms)
-    , rows_(rows) { }
+  Success(unsigned long delay_in_ms, const Rows& rows)
+      : Result("success", delay_in_ms)
+      , rows_(rows) {}
 
   /**
    * Set a fixed delay to the response time of a result
diff --git a/gtests/src/integration/simulacron/results/write_timeout.hpp b/gtests/src/integration/simulacron/results/write_timeout.hpp
index a899d2df1..4509aaec7 100644
--- a/gtests/src/integration/simulacron/results/write_timeout.hpp
+++ b/gtests/src/integration/simulacron/results/write_timeout.hpp
@@ -23,7 +23,6 @@
 
 #include "cassandra.h"
 
-
 namespace prime {
 
 /**
@@ -32,11 +31,11 @@ namespace prime {
 class WriteTimeout : public Result {
 public:
   WriteTimeout()
-    : Result("write_timeout")
-    , consistency_(CASS_CONSISTENCY_LOCAL_ONE)
-    , received_responses_(0)
-    , required_responses_(1)
-    , write_type_(CASS_WRITE_TYPE_SIMPLE) { }
+      : Result("write_timeout")
+      , consistency_(CASS_CONSISTENCY_LOCAL_ONE)
+      , received_responses_(0)
+      , required_responses_(1)
+      , write_type_(CASS_WRITE_TYPE_SIMPLE) {}
 
   /**
    * Fully construct the 'write_timeout' result
@@ -47,16 +46,14 @@ class WriteTimeout : public Result {
    * @param required_responses Number of responses required from replicas
    * @param write_type The type of write that resulted in write timeout
    */
-  WriteTimeout(unsigned long delay_in_ms,
-               CassConsistency consistency,
-               unsigned int received_responses,
-               unsigned int required_responses,
+  WriteTimeout(unsigned long delay_in_ms, CassConsistency consistency,
+               unsigned int received_responses, unsigned int required_responses,
                CassWriteType write_type)
-    : Result("write_timeout", delay_in_ms)
-    , consistency_(consistency)
-    , received_responses_(received_responses)
-    , required_responses_(required_responses)
-    , write_type_(write_type) { }
+      : Result("write_timeout", delay_in_ms)
+      , consistency_(consistency)
+      , received_responses_(received_responses)
+      , required_responses_(required_responses)
+      , write_type_(write_type) {}
 
   /**
    * Set a fixed delay to the response time of a result
diff --git a/gtests/src/integration/simulacron/simulacron_cluster.cpp b/gtests/src/integration/simulacron/simulacron_cluster.cpp
index 24c0dcbaa..31632dc52 100644
--- a/gtests/src/integration/simulacron/simulacron_cluster.cpp
+++ b/gtests/src/integration/simulacron/simulacron_cluster.cpp
@@ -19,10 +19,10 @@
 #include "test_utils.hpp"
 #include "tlog.hpp"
 
+#include "objects/uuid_gen.hpp"
 #include "scoped_lock.hpp"
 #include "tsocket.hpp"
 #include "values/uuid.hpp"
-#include "objects/uuid_gen.hpp"
 
 #include <algorithm>
 #include <sstream>
@@ -35,10 +35,12 @@
 #define OUTPUT_BUFFER_SIZE 10240ul
 #define SIMULACRON_NAP 100
 #define SIMULACRON_CONNECTION_RETRIES 600 // Up to 60 seconds for retry based on SIMULACRON_NAP
-#define SIMULACRON_PROCESS_RETRIS 100 // Up to 10 seconds for retry based on SIMULACRON_NAP
+#define SIMULACRON_PROCESS_RETRIS 100     // Up to 10 seconds for retry based on SIMULACRON_NAP
 #define MAX_TOKEN static_cast<uint64_t>(INT64_MAX) - 1
 #define DATA_CENTER_PREFIX "dc"
 
+using datastax::internal::ScopedMutex;
+
 // Initialize the mutex, running status, thread, and default data center nodes
 uv_mutex_t test::SimulacronCluster::mutex_;
 bool test::SimulacronCluster::is_ready_ = false;
@@ -46,21 +48,19 @@ bool test::SimulacronCluster::is_running_ = false;
 uv_thread_t test::SimulacronCluster::thread_;
 const unsigned int DEFAULT_NODE[] = { 1 };
 const std::vector<unsigned int> test::SimulacronCluster::DEFAULT_DATA_CENTER_NODES(
-  DEFAULT_NODE, DEFAULT_NODE + sizeof(DEFAULT_NODE) / sizeof(DEFAULT_NODE[0]));
+    DEFAULT_NODE, DEFAULT_NODE + sizeof(DEFAULT_NODE) / sizeof(DEFAULT_NODE[0]));
 
 test::SimulacronCluster::SimulacronCluster()
-  : dse_version_("")
-  , cassandra_version_("")
-  , current_cluster_id_(-1)
-{
+    : dse_version_("")
+    , cassandra_version_("")
+    , current_cluster_id_(-1) {
   // Initialize the mutex
   uv_mutex_init(&mutex_);
 
   // Determine if Simulacron file exists
   if (!test::Utils::file_exists(SIMULACRON_SERVER_JAR)) {
     std::stringstream message;
-    message << "Unable to find Simulacron JAR file ["
-      << SIMULACRON_SERVER_JAR << "]";
+    message << "Unable to find Simulacron JAR file [" << SIMULACRON_SERVER_JAR << "]";
     throw Exception(message.str());
   }
 
@@ -72,11 +72,9 @@ test::SimulacronCluster::SimulacronCluster()
     if (cassandra_version == "0.0.0") {
       throw Exception("Unable to determine Cassandra version from DSE version");
     }
-    dse_version_ = test::Utils::replace_all(dse_version.to_string(), "-",
-      ".");
+    dse_version_ = test::Utils::replace_all(dse_version.to_string(), "-", ".");
   }
-  cassandra_version_ = test::Utils::replace_all(cassandra_version.to_string(),
-    "-", ".");
+  cassandra_version_ = test::Utils::replace_all(cassandra_version.to_string(), "-", ".");
 
   // Create Simulacron process (threaded) and wait for completely availability
   uv_thread_create(&thread_, handle_thread_create, NULL);
@@ -91,17 +89,15 @@ test::SimulacronCluster::SimulacronCluster()
   test::Utils::wait_for_port(SIMULACRON_LISTEN_ADDRESS, SIMULACRON_ADMIN_PORT);
 }
 
-test::SimulacronCluster::~SimulacronCluster() {
-  remove_cluster();
-}
+test::SimulacronCluster::~SimulacronCluster() { remove_cluster(); }
 
 std::string test::SimulacronCluster::cluster_contact_points(bool is_all /*= true*/) {
   // Iterate over each node and collect the list of active contact points
   std::vector<Cluster::DataCenter::Node> cluster_nodes = nodes();
   size_t index = 1;
   std::stringstream contact_points;
-  for (std::vector<Cluster::DataCenter::Node>::iterator it =
-    cluster_nodes.begin(); it != cluster_nodes.end(); ++it) {
+  for (std::vector<Cluster::DataCenter::Node>::iterator it = cluster_nodes.begin();
+       it != cluster_nodes.end(); ++it) {
     if (is_all || is_node_up(index++)) {
       if (!contact_points.str().empty()) {
         contact_points << ",";
@@ -112,16 +108,16 @@ std::string test::SimulacronCluster::cluster_contact_points(bool is_all /*= true
   return contact_points.str();
 }
 
-void test::SimulacronCluster::create_cluster(const std::vector<unsigned int>& data_center_nodes /*= DEFAULT_DATA_CENTER_NODES*/,
-                                             bool with_vnodes /*= false */) {
+void test::SimulacronCluster::create_cluster(
+    const std::vector<unsigned int>& data_center_nodes /*= DEFAULT_DATA_CENTER_NODES*/,
+    bool with_vnodes /*= false */) {
   std::stringstream paramters;
   std::stringstream cluster_name;
   cluster_name << DEFAULT_CLUSTER_PREFIX << "_";
 
   // Add the data centers, Cassandra version, and token/vnodes parameters
-  paramters << "data_centers="
-    << test::Utils::implode<unsigned int>(data_center_nodes, ',')
-    << "&cassandra_version=" << cassandra_version_;
+  paramters << "data_centers=" << test::Utils::implode<unsigned int>(data_center_nodes, ',')
+            << "&cassandra_version=" << cassandra_version_;
   // Update the cluster configuration (set num_tokens)
   if (with_vnodes) {
     // Maximum number of tokens is 1536
@@ -139,8 +135,7 @@ void test::SimulacronCluster::create_cluster(const std::vector<unsigned int>& da
   }
 
   // Add the cluster name
-  cluster_name << "_"
-    << test::Utils::implode<unsigned int>(data_center_nodes, '-');
+  cluster_name << "_" << test::Utils::implode<unsigned int>(data_center_nodes, '-');
   if (with_vnodes) {
     cluster_name << "-vnodes";
   }
@@ -155,8 +150,8 @@ void test::SimulacronCluster::create_cluster(const std::vector<unsigned int>& da
 }
 
 void test::SimulacronCluster::create_cluster(unsigned int data_center_one_nodes,
-  unsigned int data_center_two_nodes /*= 0*/,
-  bool with_vnodes /*=false */) {
+                                             unsigned int data_center_two_nodes /*= 0*/,
+                                             bool with_vnodes /*=false */) {
   std::vector<unsigned int> data_center_nodes;
   if (data_center_one_nodes > 0) {
     data_center_nodes.push_back(data_center_one_nodes);
@@ -167,9 +162,7 @@ void test::SimulacronCluster::create_cluster(unsigned int data_center_one_nodes,
   create_cluster(data_center_nodes, with_vnodes);
 }
 
-void test::SimulacronCluster::remove_cluster() {
-  send_delete("cluster");
-}
+void test::SimulacronCluster::remove_cluster() { send_delete("cluster"); }
 
 std::string test::SimulacronCluster::get_ip_address(unsigned int node) {
   std::vector<Cluster::DataCenter::Node> current_nodes = nodes();
@@ -186,9 +179,8 @@ bool test::SimulacronCluster::is_node_down(unsigned int node) {
     if (!is_node_available(node)) {
       return true;
     } else {
-      TEST_LOG("Connected to Node " << node
-        << " in Cluster: Rechecking node down status ["
-        << number_of_retries << "]");
+      TEST_LOG("Connected to Node " << node << " in Cluster: Rechecking node down status ["
+                                    << number_of_retries << "]");
       test::Utils::msleep(SIMULACRON_NAP);
     }
   }
@@ -204,9 +196,8 @@ bool test::SimulacronCluster::is_node_up(unsigned int node) {
     if (is_node_available(node)) {
       return true;
     } else {
-      TEST_LOG("Unable to Connect to Node " << node
-        << " in Cluster: Rechecking node up status ["
-        << number_of_retries << "]");
+      TEST_LOG("Unable to Connect to Node " << node << " in Cluster: Rechecking node up status ["
+                                            << number_of_retries << "]");
       test::Utils::msleep(SIMULACRON_NAP);
     }
   }
@@ -233,14 +224,13 @@ std::vector<test::SimulacronCluster::Cluster::DataCenter> test::SimulacronCluste
   return current_cluster.data_centers;
 }
 
-std::vector<test::SimulacronCluster::Cluster::DataCenter::Node>
-test::SimulacronCluster::nodes() {
+std::vector<test::SimulacronCluster::Cluster::DataCenter::Node> test::SimulacronCluster::nodes() {
   // Get the cluster object and retrieve the nodes from the data center(s)
   Cluster current_cluster = cluster();
   std::vector<Cluster::DataCenter::Node> nodes;
   std::vector<Cluster::DataCenter> data_centers = current_cluster.data_centers;
-  for (std::vector<Cluster::DataCenter>::iterator it =
-    data_centers.begin(); it != data_centers.end(); ++it) {
+  for (std::vector<Cluster::DataCenter>::iterator it = data_centers.begin();
+       it != data_centers.end(); ++it) {
     std::vector<Cluster::DataCenter::Node> dc_nodes = it->nodes;
     nodes.insert(nodes.end(), dc_nodes.begin(), dc_nodes.end());
   }
@@ -255,12 +245,9 @@ unsigned int test::SimulacronCluster::active_connections(unsigned int node) {
   return 0;
 }
 
-unsigned int test::SimulacronCluster::active_connections() {
-  return cluster().active_connections;
-}
+unsigned int test::SimulacronCluster::active_connections() { return cluster().active_connections; }
 
-void test::SimulacronCluster::prime_query(prime::Request& request,
-                                          unsigned int node /*= 0*/) {
+void test::SimulacronCluster::prime_query(prime::Request& request, unsigned int node /*= 0*/) {
   std::stringstream endpoint;
   endpoint << "prime/" << current_cluster_id_ << generate_node_endpoint(node);
   send_post(endpoint.str(), request.json());
@@ -272,18 +259,16 @@ void test::SimulacronCluster::remove_primed_queries(unsigned int node /*= 0*/) {
   send_delete(endpoint.str());
 }
 
-void test::SimulacronCluster::handle_exit(uv_process_t* process,
-                                          int64_t error_code,
+void test::SimulacronCluster::handle_exit(uv_process_t* process, int64_t error_code,
                                           int term_signal) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   TEST_LOG("Process " << process->pid << " Terminated: " << error_code);
   uv_close(reinterpret_cast<uv_handle_t*>(process), NULL);
 }
 
-void test::SimulacronCluster::handle_allocation(uv_handle_t* handle,
-                                                size_t suggested_size,
+void test::SimulacronCluster::handle_allocation(uv_handle_t* handle, size_t suggested_size,
                                                 uv_buf_t* buffer) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   buffer->base = new char[OUTPUT_BUFFER_SIZE];
   buffer->len = OUTPUT_BUFFER_SIZE;
 }
@@ -291,9 +276,9 @@ void test::SimulacronCluster::handle_allocation(uv_handle_t* handle,
 void test::SimulacronCluster::handle_thread_create(void* arg) {
   // Initialize the loop and process arguments
   uv_loop_t loop;
-  if(uv_loop_init(&loop) != 0) {
-    throw Exception("Unable to Create Simulacron Process: libuv loop " \
-      "initialization failed");
+  if (uv_loop_init(&loop) != 0) {
+    throw Exception("Unable to Create Simulacron Process: libuv loop "
+                    "initialization failed");
   };
   uv_process_options_t options;
   memset(&options, 0, sizeof(uv_process_options_t));
@@ -308,9 +293,9 @@ void test::SimulacronCluster::handle_thread_create(void* arg) {
   options.stdio = stdio;
   options.stdio[0].flags = UV_IGNORE;
   options.stdio[1].flags = static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
-  options.stdio[1].data.stream = (uv_stream_t*) &standard_output;
+  options.stdio[1].data.stream = (uv_stream_t*)&standard_output;
   options.stdio[2].flags = static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
-  options.stdio[2].data.stream = (uv_stream_t*) &error_output;
+  options.stdio[2].data.stream = (uv_stream_t*)&error_output;
 
   // Generate the spawn command for use with uv_spawn
   const char* spawn_command[7];
@@ -331,14 +316,11 @@ void test::SimulacronCluster::handle_thread_create(void* arg) {
   uv_process_t process;
   int error_code = uv_spawn(&loop, &process, &options);
   if (error_code == 0) {
-    TEST_LOG("Launched " << spawn_command[0] << " with ID "
-      << process.pid);
+    TEST_LOG("Launched " << spawn_command[0] << " with ID " << process.pid);
 
     // Start the output thread loops
-    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_output),
-      handle_allocation, handle_read);
-    uv_read_start(reinterpret_cast<uv_stream_t*>(&error_output),
-      handle_allocation, handle_read);
+    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_output), handle_allocation, handle_read);
+    uv_read_start(reinterpret_cast<uv_stream_t*>(&error_output), handle_allocation, handle_read);
 
     // Start the process loop
     is_running_ = true;
@@ -350,9 +332,9 @@ void test::SimulacronCluster::handle_thread_create(void* arg) {
   }
 }
 
-void test::SimulacronCluster::handle_read(uv_stream_t* stream,
-  ssize_t buffer_length, const uv_buf_t* buffer) {
-  cass::ScopedMutex lock(&mutex_);
+void test::SimulacronCluster::handle_read(uv_stream_t* stream, ssize_t buffer_length,
+                                          const uv_buf_t* buffer) {
+  ScopedMutex lock(&mutex_);
   if (buffer_length > 0) {
     // Process the buffer and log it
     std::string message(buffer->base, buffer_length);
@@ -375,39 +357,36 @@ void test::SimulacronCluster::send_delete(const std::string& endpoint) {
   if (response.status_code != 202) {
     std::stringstream message;
     message << "DELETE Operation " << endpoint
-      << " did not Complete Successfully: " << response.status_code;
+            << " did not Complete Successfully: " << response.status_code;
     throw Exception(message.str());
   }
 }
 
-const std::string test::SimulacronCluster::send_get(
-  const std::string& endpoint) {
+const std::string test::SimulacronCluster::send_get(const std::string& endpoint) {
   Response response = send_request(Request::HTTP_METHOD_GET, endpoint);
   if (response.status_code != 200) {
     std::stringstream message;
     message << "GET Operation " << endpoint
-      << " did not Complete Successfully: " << response.status_code;
+            << " did not Complete Successfully: " << response.status_code;
     throw Exception(message.str());
   }
   return response.message;
 }
 
-const std::string test::SimulacronCluster::send_post(
-  const std::string& endpoint, const std::string& content /*= ""*/) {
-  Response response = send_request(Request::HTTP_METHOD_POST, endpoint,
-    content);
+const std::string test::SimulacronCluster::send_post(const std::string& endpoint,
+                                                     const std::string& content /*= ""*/) {
+  Response response = send_request(Request::HTTP_METHOD_POST, endpoint, content);
   if (response.status_code != 201) {
     std::stringstream message;
     message << "POST Operation " << endpoint
-      << " did not Complete Successfully: " << response.status_code;
+            << " did not Complete Successfully: " << response.status_code;
     throw Exception(message.str());
   }
   return response.message;
 }
 
-Response test::SimulacronCluster::send_request(Request::Method method,
-  const std::string& endpoint,
-  const std::string& content /*= ""*/) {
+Response test::SimulacronCluster::send_request(Request::Method method, const std::string& endpoint,
+                                               const std::string& content /*= ""*/) {
   // Create and send the request to the REST server
   Request request;
   request.method = method;
@@ -425,8 +404,7 @@ bool test::SimulacronCluster::is_node_available(unsigned int node) {
   std::vector<Cluster::DataCenter::Node> cluster_nodes = nodes();
   if (node > cluster_nodes.size()) {
     std::stringstream message;
-    message << "Unable to Check Availability of Node: Node " << node
-      << " is not a valid node";
+    message << "Unable to Check Availability of Node: Node " << node << " is not a valid node";
     throw test::Exception(message.str());
   }
 
@@ -438,7 +416,7 @@ bool test::SimulacronCluster::is_node_available(unsigned int node) {
 }
 
 bool test::SimulacronCluster::is_node_available(const std::string& ip_address,
-  unsigned short port) {
+                                                unsigned short port) {
   Socket socket;
   try {
     socket.establish_connection(ip_address, port);
@@ -457,12 +435,11 @@ const std::string test::SimulacronCluster::generate_node_endpoint(unsigned int n
     std::vector<Cluster::DataCenter::Node> current_nodes = nodes();
     if (node > current_nodes.size()) {
       std::stringstream message;
-      message << "Insufficient Nodes in Cluster: Cluster contains "
-        << current_nodes.size() << "; " << node << " is invalid";
+      message << "Insufficient Nodes in Cluster: Cluster contains " << current_nodes.size() << "; "
+              << node << " is invalid";
       throw Exception(message.str());
     }
-    endpoint << "/" << current_nodes[node - 1].data_center_id << "/"
-      << current_nodes[node - 1].id;
+    endpoint << "/" << current_nodes[node - 1].data_center_id << "/" << current_nodes[node - 1].id;
   }
   return endpoint.str();
 }
diff --git a/gtests/src/integration/simulacron/simulacron_cluster.hpp b/gtests/src/integration/simulacron/simulacron_cluster.hpp
index 9dd06904f..3a8ac4708 100644
--- a/gtests/src/integration/simulacron/simulacron_cluster.hpp
+++ b/gtests/src/integration/simulacron/simulacron_cluster.hpp
@@ -21,11 +21,11 @@
 #ifdef USE_SIMULACRON_SERVER
 #include "exception.hpp"
 #include "priming_requests.hpp"
-#include "shared_ptr.hpp"
 #include "rest_client.hpp"
+#include "shared_ptr.hpp"
 
 #ifdef _CRT_SECURE_NO_WARNINGS
-# undef _CRT_SECURE_NO_WARNINGS
+#undef _CRT_SECURE_NO_WARNINGS
 #endif
 #include <rapidjson/document.h>
 #include <uv.h>
@@ -33,8 +33,8 @@
 #include <algorithm>
 #include <cstdio>
 #include <map>
-#include <string>
 #include <string.h>
+#include <string>
 #include <vector>
 
 namespace test {
@@ -47,7 +47,7 @@ class SimulacronCluster {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) { }
+        : test::Exception(message) {}
   };
 
   /**
@@ -59,7 +59,7 @@ class SimulacronCluster {
         struct PeerInfo {
           std::vector<std::string> tokens;
 
-          PeerInfo() { };
+          PeerInfo(){};
           PeerInfo(const rapidjson::Value& peer_info) {
             if (peer_info.IsObject()) {
               if (peer_info.HasMember("tokens")) {
@@ -83,18 +83,17 @@ class SimulacronCluster {
         PeerInfo peer_info;
 
         Node(const rapidjson::Value& node, unsigned int dc_id)
-          : data_center_id(dc_id) {
+            : data_center_id(dc_id) {
           if (node.IsObject()) {
             if (node.HasMember("name") && node.HasMember("id") &&
-              node.HasMember("active_connections") &&
-              node.HasMember("address") && node.HasMember("peer_info")) {
+                node.HasMember("active_connections") && node.HasMember("address") &&
+                node.HasMember("peer_info")) {
               name = node["name"].GetString();
               id = node["id"].GetUint();
               active_connections = node["active_connections"].GetUint();
 
               const rapidjson::Value& address = node["address"];
-              std::vector<std::string> tokens = test::Utils::explode(
-                address.GetString(), ':');
+              std::vector<std::string> tokens = test::Utils::explode(address.GetString(), ':');
               if (tokens.size() == 2) {
                 ip_address = tokens[0];
                 std::stringstream valueStream(tokens[1]);
@@ -114,9 +113,7 @@ class SimulacronCluster {
           }
         }
 
-        bool operator< (const Node& rhs) const {
-          return id < rhs.id;
-        }
+        bool operator<(const Node& rhs) const { return id < rhs.id; }
       };
 
       std::string name;
@@ -127,7 +124,7 @@ class SimulacronCluster {
       DataCenter(const rapidjson::Value& data_center) {
         if (data_center.IsObject()) {
           if (data_center.HasMember("name") && data_center.HasMember("id") &&
-            data_center.HasMember("active_connections")) {
+              data_center.HasMember("active_connections")) {
             name = data_center["name"].GetString();
             id = data_center["id"].GetUint();
             active_connections = data_center["active_connections"].GetUint();
@@ -137,8 +134,7 @@ class SimulacronCluster {
               if (dc_nodes.IsArray()) {
                 for (rapidjson::SizeType i = 0; i < dc_nodes.Size(); ++i) {
                   Node node(dc_nodes[i], id);
-                  nodes.insert(std::lower_bound(nodes.begin(), nodes.end(),
-                    node), node);
+                  nodes.insert(std::lower_bound(nodes.begin(), nodes.end(), node), node);
                 }
               } else {
                 throw Exception("Nodes are not valid for the data center object");
@@ -152,9 +148,7 @@ class SimulacronCluster {
         }
       }
 
-      bool operator< (const DataCenter& rhs) const {
-        return id < rhs.id;
-      }
+      bool operator<(const DataCenter& rhs) const { return id < rhs.id; }
     };
 
     std::string name;
@@ -164,12 +158,11 @@ class SimulacronCluster {
     std::string dse_version;
     std::vector<DataCenter> data_centers;
 
-    Cluster(const rapidjson::Document *cluster) {
+    Cluster(const rapidjson::Document* cluster) {
       if (cluster) {
         if (cluster->IsObject()) {
           if (cluster->HasMember("name") && cluster->HasMember("id") &&
-            cluster->HasMember("active_connections") &&
-            cluster->HasMember("data_centers")) {
+              cluster->HasMember("active_connections") && cluster->HasMember("data_centers")) {
             name = (*cluster)["name"].GetString();
             id = (*cluster)["id"].GetUint();
             active_connections = (*cluster)["active_connections"].GetUint();
@@ -185,12 +178,12 @@ class SimulacronCluster {
             if (dcs.IsArray()) {
               for (rapidjson::SizeType i = 0; i < dcs.Size(); ++i) {
                 DataCenter dc(dcs[i]);
-                data_centers.insert(std::lower_bound(data_centers.begin(),
-                  data_centers.end(), dc), dc);
+                data_centers.insert(std::lower_bound(data_centers.begin(), data_centers.end(), dc),
+                                    dc);
               }
             } else {
-              throw Exception("Data centers are not valid for the cluster " \
-                "object");
+              throw Exception("Data centers are not valid for the cluster "
+                              "object");
             }
           } else {
             throw Exception("JSON object is not a cluster object");
@@ -241,8 +234,9 @@ class SimulacronCluster {
    * @param with_vnode True if vnodes should be enabled; false otherwise
    *                   (default: false)
    */
-  void create_cluster(const std::vector<unsigned int>& data_center_nodes = DEFAULT_DATA_CENTER_NODES,
-                      bool with_vnodes = false);
+  void
+  create_cluster(const std::vector<unsigned int>& data_center_nodes = DEFAULT_DATA_CENTER_NODES,
+                 bool with_vnodes = false);
 
   /**
    * Create the Simulacron cluster; number of nodes in data center 1 and 2
@@ -252,8 +246,7 @@ class SimulacronCluster {
    * @param with_vnode True if vnodes should be enabled; false otherwise
    *                   (default: false)
    */
-  void create_cluster(unsigned int data_center_one_nodes,
-                      unsigned int data_center_two_nodes = 0,
+  void create_cluster(unsigned int data_center_one_nodes, unsigned int data_center_two_nodes = 0,
                       bool with_vnodes = false);
 
   /**
@@ -383,9 +376,7 @@ class SimulacronCluster {
    * @param suggested_size Suggested size for the buffer
    * @param buffer Buffer to allocate bytes for
    */
-  static void handle_allocation(uv_handle_t* handle,
-                                size_t suggested_size,
-                                uv_buf_t* buffer);
+  static void handle_allocation(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buffer);
 
   /**
    * uv_spawn callback for handling the completion of the process
@@ -394,9 +385,7 @@ class SimulacronCluster {
    * @param error_code Error/Exit code
    * @param term_signal Terminating signal
    */
-  static void handle_exit(uv_process_t* process,
-                          int64_t error_code,
-                          int term_signal);
+  static void handle_exit(uv_process_t* process, int64_t error_code, int term_signal);
 
   /**
    * uv_read_start callback for processing the buffer in the pipe
@@ -405,9 +394,7 @@ class SimulacronCluster {
    * @param buffer_length Length of the buffer
    * @param buffer Buffer to process
    */
-  static void handle_read(uv_stream_t* stream,
-                          ssize_t buffer_length,
-                          const uv_buf_t* buffer);
+  static void handle_read(uv_stream_t* stream, ssize_t buffer_length, const uv_buf_t* buffer);
 
   /**
    * uv_thread_create callback for executing the Simulacron process
@@ -440,8 +427,7 @@ class SimulacronCluster {
    * @return REST server response
    * @throws SimulacronCluster::Exception If status code is not 201
    */
-  const std::string send_post(const std::string& endpoint,
-                              const std::string& content = "");
+  const std::string send_post(const std::string& endpoint, const std::string& content = "");
 
   /**
    * Send the request to the Simulacron REST server
@@ -452,8 +438,7 @@ class SimulacronCluster {
    * @return REST server response
    * @throws SimulacronCluster::Exception
    */
-  Response send_request(Request::Method method,
-                        const std::string& endpoint,
+  Response send_request(Request::Method method, const std::string& endpoint,
                         const std::string& content = "");
 
   /**
diff --git a/gtests/src/integration/simulacron/simulacron_integration.cpp b/gtests/src/integration/simulacron/simulacron_integration.cpp
index 3eec4ac56..cbb02bceb 100644
--- a/gtests/src/integration/simulacron/simulacron_integration.cpp
+++ b/gtests/src/integration/simulacron/simulacron_integration.cpp
@@ -24,12 +24,10 @@ SharedPtr<test::SimulacronCluster> SimulacronIntegration::sc_ = NULL;
 bool SimulacronIntegration::is_sc_started_ = false;
 
 SimulacronIntegration::SimulacronIntegration()
-  : is_sc_start_requested_(true)
-  , is_sc_for_test_case_(false) {
-}
+    : is_sc_start_requested_(true)
+    , is_sc_for_test_case_(false) {}
 
-SimulacronIntegration::~SimulacronIntegration() {
-}
+SimulacronIntegration::~SimulacronIntegration() {}
 
 void SimulacronIntegration::SetUpTestCase() {
   try {
@@ -74,8 +72,7 @@ void SimulacronIntegration::TearDown() {
 }
 
 test::driver::Cluster SimulacronIntegration::default_cluster() {
-  return Integration::default_cluster()
-    .with_connection_heartbeat_interval(0);
+  return Integration::default_cluster().with_connection_heartbeat_interval(0);
 }
 
 void SimulacronIntegration::default_start_sc() {
@@ -86,7 +83,9 @@ void SimulacronIntegration::default_start_sc() {
   start_sc(data_center_nodes);
 }
 
-void SimulacronIntegration::start_sc(const std::vector<unsigned int>& data_center_nodes /*= SimulacronCluster::DEFAULT_DATA_CENTER_NODES*/) {
+void SimulacronIntegration::start_sc(
+    const std::vector<unsigned int>&
+        data_center_nodes /*= SimulacronCluster::DEFAULT_DATA_CENTER_NODES*/) {
   // Ensure the SC is only started once (process handling)
   if (!is_sc_started_) {
     // Create and start the SC
@@ -97,26 +96,22 @@ void SimulacronIntegration::start_sc(const std::vector<unsigned int>& data_cente
   }
 }
 
-test::driver::Result SimulacronIntegration::execute_mock_query(
-  CassConsistency consistency /*= CASS_CONSISTENCY_ONE*/) {
+test::driver::Result
+SimulacronIntegration::execute_mock_query(CassConsistency consistency /*= CASS_CONSISTENCY_ONE*/) {
   return session_.execute("mock query", consistency, false, false);
 }
 
 void SimulacronIntegration::prime_mock_query(unsigned int node /*= 0*/) {
   prime::Success success = prime::Success();
-  success.with_rows(prime::Rows()
-    .add_row(prime::Row()
-      .add_column("SUCCESS", CASS_VALUE_TYPE_BOOLEAN, "TRUE")));
+  success.with_rows(
+      prime::Rows().add_row(prime::Row().add_column("SUCCESS", CASS_VALUE_TYPE_BOOLEAN, "TRUE")));
   prime_mock_query_with_result(&success, node);
 }
 
-
 void SimulacronIntegration::prime_mock_query_with_result(prime::Result* result,
                                                          unsigned int node /*= 0*/) {
   // Create the mock query
-  prime::Request mock_query = prime::Request()
-    .with_query("mock query")
-    .with_result(result);
+  prime::Request mock_query = prime::Request().with_query("mock query").with_result(result);
 
   // Prime the mock query with the given error
   sc_->prime_query(mock_query, node);
diff --git a/gtests/src/integration/simulacron/simulacron_integration.hpp b/gtests/src/integration/simulacron/simulacron_integration.hpp
index a48cc59a6..03b6c69ba 100644
--- a/gtests/src/integration/simulacron/simulacron_integration.hpp
+++ b/gtests/src/integration/simulacron/simulacron_integration.hpp
@@ -29,12 +29,12 @@
   INTEGRATION_TYPED_TEST_P(simulacron, test_case, test_name)
 
 #define CHECK_SIMULACRON_AVAILABLE \
-  if (!sc_) { \
-    return; \
+  if (!sc_) {                      \
+    return;                        \
   }
 
 #define SKIP_TEST_IF_SIMULACRON_UNAVAILABLE \
-  if (!sc_) { \
+  if (!sc_) {                               \
     SKIP_TEST("Simulacron is unavailable"); \
   }
 
@@ -89,7 +89,8 @@ class SimulacronIntegration : public Integration {
    * @param data_center_nodes Data center(s) to create in the Simulacron cluster
    *                          (default: 1 data center with 1 node)
    */
-  void start_sc(const std::vector<unsigned int>& data_center_nodes = SimulacronCluster::DEFAULT_DATA_CENTER_NODES);
+  void start_sc(const std::vector<unsigned int>& data_center_nodes =
+                    SimulacronCluster::DEFAULT_DATA_CENTER_NODES);
 
   /**
    * Execute a mock query at a given consistency level
@@ -102,7 +103,8 @@ class SimulacronIntegration : public Integration {
    *                                  remaining nodes with a successful mock
    *                                  query
    */
-  virtual test::driver::Result execute_mock_query(CassConsistency consistency = CASS_CONSISTENCY_ONE);
+  virtual test::driver::Result
+  execute_mock_query(CassConsistency consistency = CASS_CONSISTENCY_ONE);
 
   /**
    * Prime the successful mock query on the given node
@@ -123,8 +125,7 @@ class SimulacronIntegration : public Integration {
    *             result will be applied to all nodes in the Simulacron cluster
    *             (DEFAULT: 0 - Apply mock query with result to all nodes)
    */
-  void prime_mock_query_with_result(prime::Result* result,
-                                    unsigned int node = 0);
+  void prime_mock_query_with_result(prime::Result* result, unsigned int node = 0);
 
 private:
   /**
diff --git a/gtests/src/integration/strptime.cpp b/gtests/src/integration/strptime.cpp
index 6389979d3..a1d28ec8c 100644
--- a/gtests/src/integration/strptime.cpp
+++ b/gtests/src/integration/strptime.cpp
@@ -1,8 +1,8 @@
 #include "strptime.hpp"
 
-#include <stdlib.h>
 #include <ctype.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <string.h>
 
 #ifndef _WIN32
@@ -37,147 +37,155 @@
 namespace test {
 
 /* A restricted form of strptime() that doesn't support any locale based format options */
-char *strptime(const char * s, const char * f, struct tm * v)
-{
+char* strptime(const char* s, const char* f, struct tm* v) {
   int i, w, neg, adj, min, range, *dest, dummy;
   int want_century = 0, century = 0, relyear = 0;
   while (*f) {
     if (*f != '%') {
-      if (isspace(*f)) for (; *s && isspace(*s); s++);
-      else if (*s != *f) return 0;
-      else s++;
+      if (isspace(*f))
+        for (; *s && isspace(*s); s++)
+          ;
+      else if (*s != *f)
+        return 0;
+      else
+        s++;
       f++;
       continue;
     }
     f++;
     if (*f == '+') f++;
     if (isdigit(*f)) {
-      char *new_f;
-      w=strtoul(f, &new_f, 10);
+      char* new_f;
+      w = strtoul(f, &new_f, 10);
       f = new_f;
     } else {
-      w=-1;
+      w = -1;
     }
-    adj=0;
+    adj = 0;
     switch (*f++) {
-    case 'C':
-      dest = &century;
-      if (w<0) w=2;
-      want_century |= 2;
-      goto numeric_digits;
-    case 'd': case 'e':
-      dest = &v->tm_mday;
-      min = 1;
-      range = 31;
-      goto numeric_range;
-    case 'D':
-      s = test::strptime(s, "%m/%d/%y", v);
-      if (!s) return 0;
-      break;
-    case 'H':
-      dest = &v->tm_hour;
-      min = 0;
-      range = 24;
-      goto numeric_range;
-    case 'I':
-      dest = &v->tm_hour;
-      min = 1;
-      range = 12;
-      goto numeric_range;
-    case 'j':
-      dest = &v->tm_yday;
-      min = 1;
-      range = 366;
-      adj = 1;
-      goto numeric_range;
-    case 'm':
-      dest = &v->tm_mon;
-      min = 1;
-      range = 12;
-      adj = 1;
-      goto numeric_range;
-    case 'M':
-      dest = &v->tm_min;
-      min = 0;
-      range = 60;
-      goto numeric_range;
-    case 'n': case 't':
-      for (; *s && isspace(*s); s++);
-      break;
-    case 'R':
-      s = test::strptime(s, "%H:%M", v);
-      if (!s) return 0;
-      break;
-    case 'S':
-      dest = &v->tm_sec;
-      min = 0;
-      range = 61;
-      goto numeric_range;
-    case 'T':
-      s = test::strptime(s, "%H:%M:%S", v);
-      if (!s) return 0;
-      break;
-    case 'U':
-    case 'W':
-      /* Throw away result, for now. (FIXME?) */
-      dest = &dummy;
-      min = 0;
-      range = 54;
-      goto numeric_range;
-    case 'w':
-      dest = &v->tm_wday;
-      min = 0;
-      range = 7;
-      goto numeric_range;
-    case 'y':
-      dest = &relyear;
-      w = 2;
-      want_century |= 1;
-      goto numeric_digits;
-    case 'Y':
-      dest = &v->tm_year;
-      if (w<0) w=4;
-      adj = 1900;
-      want_century = 0;
-      goto numeric_digits;
-    case '%':
-      if (*s++ != '%') return 0;
-      break;
-    default:
-      return 0;
-    numeric_range:
-      if (!isdigit(*s)) return 0;
-      *dest = 0;
-      for (i=1; i<=min+range && isdigit(*s); i*=10)
-        *dest = *dest * 10 + *s++ - '0';
-      if (*dest - min >= (unsigned)range) return 0;
-      *dest -= adj;
-      switch((char *)dest - (char *)v) {
-      case offsetof(struct tm, tm_yday):
-        ;
-      }
-      goto update;
-    numeric_digits:
-      neg = 0;
-      if (*s == '+') s++;
-      else if (*s == '-') neg=1, s++;
-      if (!isdigit(*s)) return 0;
-      for (*dest=i=0; i<w && isdigit(*s); i++)
-        *dest = *dest * 10 + *s++ - '0';
-      if (neg) *dest = -*dest;
-      *dest -= adj;
-      goto update;
-    update:
-      //FIXME
-      ;
+      case 'C':
+        dest = &century;
+        if (w < 0) w = 2;
+        want_century |= 2;
+        goto numeric_digits;
+      case 'd':
+      case 'e':
+        dest = &v->tm_mday;
+        min = 1;
+        range = 31;
+        goto numeric_range;
+      case 'D':
+        s = test::strptime(s, "%m/%d/%y", v);
+        if (!s) return 0;
+        break;
+      case 'H':
+        dest = &v->tm_hour;
+        min = 0;
+        range = 24;
+        goto numeric_range;
+      case 'I':
+        dest = &v->tm_hour;
+        min = 1;
+        range = 12;
+        goto numeric_range;
+      case 'j':
+        dest = &v->tm_yday;
+        min = 1;
+        range = 366;
+        adj = 1;
+        goto numeric_range;
+      case 'm':
+        dest = &v->tm_mon;
+        min = 1;
+        range = 12;
+        adj = 1;
+        goto numeric_range;
+      case 'M':
+        dest = &v->tm_min;
+        min = 0;
+        range = 60;
+        goto numeric_range;
+      case 'n':
+      case 't':
+        for (; *s && isspace(*s); s++)
+          ;
+        break;
+      case 'R':
+        s = test::strptime(s, "%H:%M", v);
+        if (!s) return 0;
+        break;
+      case 'S':
+        dest = &v->tm_sec;
+        min = 0;
+        range = 61;
+        goto numeric_range;
+      case 'T':
+        s = test::strptime(s, "%H:%M:%S", v);
+        if (!s) return 0;
+        break;
+      case 'U':
+      case 'W':
+        /* Throw away result, for now. (FIXME?) */
+        dest = &dummy;
+        min = 0;
+        range = 54;
+        goto numeric_range;
+      case 'w':
+        dest = &v->tm_wday;
+        min = 0;
+        range = 7;
+        goto numeric_range;
+      case 'y':
+        dest = &relyear;
+        w = 2;
+        want_century |= 1;
+        goto numeric_digits;
+      case 'Y':
+        dest = &v->tm_year;
+        if (w < 0) w = 4;
+        adj = 1900;
+        want_century = 0;
+        goto numeric_digits;
+      case '%':
+        if (*s++ != '%') return 0;
+        break;
+      default:
+        return 0;
+      numeric_range:
+        if (!isdigit(*s)) return 0;
+        *dest = 0;
+        for (i = 1; i <= min + range && isdigit(*s); i *= 10)
+          *dest = *dest * 10 + *s++ - '0';
+        if (*dest - min >= (unsigned)range) return 0;
+        *dest -= adj;
+        switch ((char*)dest - (char*)v) { case offsetof(struct tm, tm_yday):; }
+        goto update;
+      numeric_digits:
+        neg = 0;
+        if (*s == '+')
+          s++;
+        else if (*s == '-')
+          neg = 1, s++;
+        if (!isdigit(*s)) return 0;
+        for (*dest = i = 0; i < w && isdigit(*s); i++)
+          *dest = *dest * 10 + *s++ - '0';
+        if (neg) *dest = -*dest;
+        *dest -= adj;
+        goto update;
+      update
+          :
+          // FIXME
+          ;
     }
   }
   if (want_century) {
     v->tm_year = relyear;
-    if (want_century & 2) v->tm_year += century * 100 - 1900;
-    else if (v->tm_year <= 68) v->tm_year += 100;
+    if (want_century & 2)
+      v->tm_year += century * 100 - 1900;
+    else if (v->tm_year <= 68)
+      v->tm_year += 100;
   }
-  return (char *)s;
+  return (char*)s;
 }
 
 } // namespace test
diff --git a/gtests/src/integration/strptime.hpp b/gtests/src/integration/strptime.hpp
index ffb9d1b2b..7b8330ab4 100644
--- a/gtests/src/integration/strptime.hpp
+++ b/gtests/src/integration/strptime.hpp
@@ -29,7 +29,7 @@ namespace test {
  * @param tm The resulting time struct
  * @return NULL if an error occurred
  */
-char *strptime(const char *s, const char *f, struct tm *tm);
+char* strptime(const char* s, const char* f, struct tm* tm);
 
 } // namespace test
 
diff --git a/gtests/src/integration/test_category.cpp b/gtests/src/integration/test_category.cpp
index a4de871d4..50990b1a0 100644
--- a/gtests/src/integration/test_category.cpp
+++ b/gtests/src/integration/test_category.cpp
@@ -22,7 +22,8 @@
 // Constant value definitions for test type
 const TestCategory TestCategory::CASSANDRA("CASSANDRA", 0, "Cassandra", "*_Cassandra_*");
 const TestCategory TestCategory::DSE("DSE", 1, "DataStax Enterprise", "*_DSE_*");
-const TestCategory TestCategory::SIMULACRON("SIMULACRON", SHRT_MAX, "Simulated DSE (and Cassandra)", "*_simulacron_*");
+const TestCategory TestCategory::SIMULACRON("SIMULACRON", SHRT_MAX, "Simulated DSE (and Cassandra)",
+                                            "*_simulacron_*");
 
 // Static declarations for test type
 std::set<TestCategory> TestCategory::constants_;
@@ -33,40 +34,28 @@ std::ostream& operator<<(std::ostream& os, const TestCategory& object) {
 }
 
 TestCategory::TestCategory()
-  : name_("INVALID")
-  , ordinal_(-1)
-  , display_name_("Invalid test category")
-  , filter_("*") {}
+    : name_("INVALID")
+    , ordinal_(-1)
+    , display_name_("Invalid test category")
+    , filter_("*") {}
 
-TestCategory::TestCategory(const std::string& name) {
-  *this = name;
-}
+TestCategory::TestCategory(const std::string& name) { *this = name; }
 
-const std::string& TestCategory::name() const {
-  return name_;
-}
+const std::string& TestCategory::name() const { return name_; }
 
-short TestCategory::ordinal() const {
-  return ordinal_;
-}
+short TestCategory::ordinal() const { return ordinal_; }
 
-const std::string& TestCategory::display_name() const {
-  return display_name_;
-}
+const std::string& TestCategory::display_name() const { return display_name_; }
 
-const std::string& TestCategory::filter() const {
-  return filter_;
-}
+const std::string& TestCategory::filter() const { return filter_; }
 
-void TestCategory::operator =(const TestCategory& object) {
+void TestCategory::operator=(const TestCategory& object) {
   name_ = object.name_;
   ordinal_ = object.ordinal_;
   display_name_ = object.display_name_;
 }
 
-void TestCategory::operator=(const std::string& name) {
-  *this = get_enumeration(name);
-}
+void TestCategory::operator=(const std::string& name) { *this = get_enumeration(name); }
 
 bool TestCategory::operator<(const TestCategory& object) const {
   return ordinal_ < object.ordinal_;
@@ -91,28 +80,20 @@ bool TestCategory::operator==(const std::string& object) const {
   return lhs.compare(rhs) == 0;
 }
 
-bool TestCategory::operator !=(const TestCategory& object) const {
-  return !(*this == object);
-}
+bool TestCategory::operator!=(const TestCategory& object) const { return !(*this == object); }
 
-bool TestCategory::operator !=(const std::string& object) const {
-  return !(*this == object);
-}
+bool TestCategory::operator!=(const std::string& object) const { return !(*this == object); }
 
-TestCategory::iterator TestCategory::begin() {
-    return get_constants().begin();
-  }
+TestCategory::iterator TestCategory::begin() { return get_constants().begin(); }
 
-TestCategory::iterator TestCategory::end() {
-  return get_constants().end();
-}
+TestCategory::iterator TestCategory::end() { return get_constants().end(); }
 
-TestCategory::TestCategory(const std::string& name, short ordinal,
-  const std::string& display_name, const std::string& filter)
-  : name_(name)
-  , ordinal_(ordinal)
-  , display_name_(display_name)
-  , filter_(filter) {}
+TestCategory::TestCategory(const std::string& name, short ordinal, const std::string& display_name,
+                           const std::string& filter)
+    : name_(name)
+    , ordinal_(ordinal)
+    , display_name_(display_name)
+    , filter_(filter) {}
 
 const std::set<TestCategory>& TestCategory::get_constants() {
   if (constants_.empty()) {
@@ -124,7 +105,7 @@ const std::set<TestCategory>& TestCategory::get_constants() {
   return constants_;
 }
 
-TestCategory TestCategory::get_enumeration(const std::string& name)  const{
+TestCategory TestCategory::get_enumeration(const std::string& name) const {
   // Iterator over the constants and find the corresponding enumeration
   if (!name.empty()) {
     for (iterator iterator = begin(); iterator != end(); ++iterator) {
diff --git a/gtests/src/integration/test_category.hpp b/gtests/src/integration/test_category.hpp
index d507a3923..95136a47b 100644
--- a/gtests/src/integration/test_category.hpp
+++ b/gtests/src/integration/test_category.hpp
@@ -30,7 +30,7 @@ class TestCategory {
   class Exception : public test::Exception {
   public:
     Exception(const std::string& message)
-      : test::Exception(message) {}
+        : test::Exception(message) {}
   };
   /**
    * Iterator
@@ -184,8 +184,8 @@ class TestCategory {
    * @param display_name Display name for enumeration
    * @param filter Filter for enumeration
    */
-  TestCategory(const std::string& name, short ordinal,
-    const std::string& display_name, const std::string& filter);
+  TestCategory(const std::string& name, short ordinal, const std::string& display_name,
+               const std::string& filter);
   /**
    * Get the enumeration constants
    *
diff --git a/gtests/src/integration/test_utils.cpp b/gtests/src/integration/test_utils.cpp
index ce088948a..b0ba3579d 100644
--- a/gtests/src/integration/test_utils.cpp
+++ b/gtests/src/integration/test_utils.cpp
@@ -26,13 +26,13 @@
 #include <iomanip>
 #include <sstream>
 #ifndef _WIN32
-# include <time.h>
+#include <time.h>
 #endif
 
 #ifdef _WIN32
-# define FILE_MODE 0
+#define FILE_MODE 0
 #else
-# define FILE_MODE S_IRWXU | S_IRWXG | S_IROTH
+#define FILE_MODE S_IRWXU | S_IRWXG | S_IROTH
 #endif
 #define FILE_PATH_SIZE 1024
 
@@ -45,7 +45,7 @@ const char test::Utils::PATH_SEPARATOR = '\\';
 const char test::Utils::PATH_SEPARATOR = '/';
 #endif
 
-template<typename T>
+template <typename T>
 T* test::Utils::addressof(T& value) {
   return reinterpret_cast<T*>(&const_cast<char&>(reinterpret_cast<const volatile char&>(value)));
 }
@@ -128,14 +128,13 @@ std::string test::Utils::scalar_cql_type(CassValueType value_type) {
       break;
     default:
       std::stringstream message;
-      message << "Unable to Retrieve CQL Type: CassValueType [" <<
-        value_type << "] is not valid";
+      message << "Unable to Retrieve CQL Type: CassValueType [" << value_type << "] is not valid";
       throw test::Exception(message.str());
   }
 }
 
 std::vector<std::string> test::Utils::explode(const std::string& input,
-  const char delimiter /*= ' '*/) {
+                                              const char delimiter /*= ' '*/) {
   // Iterate over the input line and parse the tokens
   std::vector<std::string> result;
   std::istringstream parser(input);
@@ -159,8 +158,8 @@ std::string test::Utils::indent(const std::string& input, unsigned int indent) {
 
   // Iterate over each line in the input string and indent
   std::vector<std::string> lines = explode(input, '\n');
-  for (std::vector<std::string>::iterator iterator = lines.begin();
-    iterator < lines.end(); ++iterator) {
+  for (std::vector<std::string>::iterator iterator = lines.begin(); iterator < lines.end();
+       ++iterator) {
     output << std::setw(indent) << "" << *iterator;
     if ((iterator + 1) != lines.end()) {
       output << std::endl;
@@ -194,12 +193,12 @@ void test::Utils::msleep(unsigned int milliseconds) {
 #ifdef _WIN32
   Sleep(milliseconds);
 #else
-  //Convert the milliseconds into a proper timespec structure
+  // Convert the milliseconds into a proper timespec structure
   struct timespec requested;
   time_t seconds = static_cast<int>(milliseconds / 1000);
   long int nanoseconds = static_cast<long int>((milliseconds - (seconds * 1000)) * 1000000);
 
-  //Assign the requested time and perform sleep
+  // Assign the requested time and perform sleep
   requested.tv_sec = seconds;
   requested.tv_nsec = nanoseconds;
   while (nanosleep(&requested, &requested) == -1) {
@@ -208,11 +207,11 @@ void test::Utils::msleep(unsigned int milliseconds) {
 #endif
 }
 
-std::string test::Utils::replace_all(const std::string& input,
-  const std::string& from, const std::string& to) {
+std::string test::Utils::replace_all(const std::string& input, const std::string& from,
+                                     const std::string& to) {
   size_t position = 0;
   std::string result = input;
-  while((position = result.find(from, position)) != std::string::npos) {
+  while ((position = result.find(from, position)) != std::string::npos) {
     result.replace(position, from.length(), to);
     // Handle the case where 'to' is a substring of 'from'
     position += to.length();
@@ -221,13 +220,13 @@ std::string test::Utils::replace_all(const std::string& input,
 }
 
 std::string test::Utils::shorten(const std::string& input,
-  bool add_space_after_newline /*= true*/) {
+                                 bool add_space_after_newline /*= true*/) {
   std::string result = input;
 
   // Iterate over each trim delimiter
   std::string delimiters = TRIM_DELIMETERS;
-  for (std::string::iterator iterator = delimiters.begin();
-    iterator < delimiters.end(); ++iterator) {
+  for (std::string::iterator iterator = delimiters.begin(); iterator < delimiters.end();
+       ++iterator) {
     // Replace the trim delimiter with empty string (space if EOL)
     std::string delimiter(1, *iterator);
     std::string newline_replacement = add_space_after_newline ? " " : "";
@@ -259,8 +258,8 @@ std::string test::Utils::trim(const std::string& input) {
 }
 
 bool test::Utils::wait_for_port(const std::string& ip_address, unsigned short port,
-  unsigned int number_of_retries /*= 100*/,
-  unsigned int retry_delay_ms /*= 100*/) {
+                                unsigned int number_of_retries /*= 100*/,
+                                unsigned int retry_delay_ms /*= 100*/) {
   // Attempt establish a connection to the IP address and port of the node
   for (unsigned int n = 0; n < number_of_retries; ++n) {
     Socket socket;
diff --git a/gtests/src/integration/test_utils.hpp b/gtests/src/integration/test_utils.hpp
index 305c5a8c4..fdf28e80e 100644
--- a/gtests/src/integration/test_utils.hpp
+++ b/gtests/src/integration/test_utils.hpp
@@ -77,8 +77,7 @@ class Utils {
    * @param delimiter Character to use split into elements (default: <space>)
    * @return An array/vector representation of the string
    */
-  static std::vector<std::string> explode(const std::string& input,
-    const char delimiter = ' ');
+  static std::vector<std::string> explode(const std::string& input, const char delimiter = ' ');
 
   /**
    * Check to see if a file exists
@@ -105,13 +104,12 @@ class Utils {
    * @return A string concatenating all the vector elements with delimiter
    *         separation
    */
-  template<typename T>
-  inline static std::string implode(const std::vector<T>& elements,
-                                    const char delimiter = ' ') {
+  template <typename T>
+  inline static std::string implode(const std::vector<T>& elements, const char delimiter = ' ') {
     // Iterate through each element in the vector and concatenate the string
     std::stringstream result;
     for (typename std::vector<T>::const_iterator iterator = elements.begin();
-      iterator < elements.end(); ++iterator) {
+         iterator < elements.end(); ++iterator) {
       result << *iterator;
       if ((iterator + 1) != elements.end()) {
         result << delimiter;
@@ -144,8 +142,8 @@ class Utils {
    * @param to String to replace with
    * @return Input string with replacement
    */
-  static std::string replace_all(const std::string& input,
-    const std::string& from, const std::string& to);
+  static std::string replace_all(const std::string& input, const std::string& from,
+                                 const std::string& to);
 
   /**
    * Reduce/Shorten a multi-line string into a single line string
@@ -156,8 +154,7 @@ class Utils {
    *                                otherwise
    * @return Single line string converted from multi-line string
    */
-  static std::string shorten(const std::string& input,
-    bool add_space_after_newline = true);
+  static std::string shorten(const std::string& input, bool add_space_after_newline = true);
 
   /**
    * Convert a string to lowercase
@@ -186,8 +183,8 @@ class Utils {
    * @return True if port on IP address is available; false otherwise
    */
   static bool wait_for_port(const std::string& ip_address, unsigned short port,
-    unsigned int number_of_retries = 100,
-    unsigned int retry_delay_ms = 100);
+                            unsigned int number_of_retries = 100,
+                            unsigned int retry_delay_ms = 100);
 };
 
 } // namespace test
diff --git a/gtests/src/integration/tests/simulacron/test_simulacron_connect.cpp b/gtests/src/integration/tests/simulacron/test_simulacron_connect.cpp
index f1484b6b5..59a6f19b3 100644
--- a/gtests/src/integration/tests/simulacron/test_simulacron_connect.cpp
+++ b/gtests/src/integration/tests/simulacron/test_simulacron_connect.cpp
@@ -22,7 +22,8 @@
  * Connection integration tests using Simulacron
  */
 class ConnectionTest : public SimulacronIntegration {
-using SimulacronIntegration::connect;
+  using SimulacronIntegration::connect;
+
 public:
   void SetUp() {
     is_sc_start_requested_ = false;
@@ -37,8 +38,7 @@ using SimulacronIntegration::connect;
    * @param is_across_dcs True if connections are going to be made on all DCs;
    *                      false otherwise.
    */
-  void assert_active_connections(int host_connections = 1,
-    bool is_across_dcs = true) {
+  void assert_active_connections(int host_connections = 1, bool is_across_dcs = true) {
     std::vector<SimulacronCluster::Cluster::DataCenter> data_centers = sc_->data_centers();
     for (std::vector<SimulacronCluster::Cluster::DataCenter>::iterator it = data_centers.begin();
          it != data_centers.end(); ++it) {
@@ -65,8 +65,7 @@ using SimulacronIntegration::connect;
    * @param cluster Cluster configuration to use when establishing the
    *                connection (default: NULL; uses default configuration)
    */
-  void connect(std::vector<unsigned int> data_center_nodes,
-    test::driver::Cluster cluster = NULL) {
+  void connect(std::vector<unsigned int> data_center_nodes, test::driver::Cluster cluster = NULL) {
     // Start the SC, prime the tables, and establish a connection
     start_sc(data_center_nodes);
     contact_points_ = sc_->get_ip_address(1);
@@ -88,7 +87,7 @@ using SimulacronIntegration::connect;
    *                connection (default: NULL; uses default configuration)
    */
   void connect(unsigned int number_dc1_nodes, unsigned int number_dc2_nodes,
-    test::driver::Cluster cluster = NULL) {
+               test::driver::Cluster cluster = NULL) {
     // Initialize the number of nodes in the standard data centers
     std::vector<unsigned int> data_center_nodes;
     number_dc1_nodes_ = number_dc1_nodes;
@@ -189,13 +188,11 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectOneNodeTwoDataCenters) {
  * @expected_result Successful connection and validation of active connections
  *                  across the data centers
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectOneNodeTwoDataCentersAcrossDCs) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectOneNodeTwoDataCentersAcrossDCs) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_load_balance_round_robin();
+  test::driver::Cluster cluster = default_cluster().with_load_balance_round_robin();
   connect(1, 1, cluster);
   assert_active_connections();
 }
@@ -231,13 +228,11 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectThreeNodesTwoDataCenters) {
  * @expected_result Successful connection and validation of active connections
  *                  across the data centers
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectThreeNodesTwoDataCentersAcrossDCs) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectThreeNodesTwoDataCentersAcrossDCs) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_load_balance_round_robin();
+  test::driver::Cluster cluster = default_cluster().with_load_balance_round_robin();
   connect(3, 3, cluster);
   assert_active_connections();
 }
@@ -253,8 +248,7 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
  * @since 1.0.0
  * @expected_result Successful connection and validation of active connections
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectFiveHundredNodesTwoDataCenters) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectFiveHundredNodesTwoDataCenters) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
@@ -274,13 +268,11 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
  * @expected_result Successful connection and validation of active connections
  *                  across the data centers
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectFiveHundredNodesTwoDataCentersAcrossDCs) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectFiveHundredNodesTwoDataCentersAcrossDCs) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_load_balance_round_robin();
+  test::driver::Cluster cluster = default_cluster().with_load_balance_round_robin();
   connect(500, 500, cluster);
   assert_active_connections();
 }
@@ -322,8 +314,7 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectOneNodeNineDataCenters) {
  * @expected_result Successful connection and validation of active connections
  *                  across the data centers
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectOneNodeNineDataCentersAcrossDCs) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectOneNodeNineDataCentersAcrossDCs) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Create the nine data centers
@@ -333,8 +324,7 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
   }
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_load_balance_round_robin();
+  test::driver::Cluster cluster = default_cluster().with_load_balance_round_robin();
   connect(data_center_nodes, cluster);
   assert_active_connections();
 }
@@ -350,13 +340,12 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
  * @since 1.0.0
  * @expected_result Successful connection and validation of active connections
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectOneNodeMultipleConnectionsPerHost) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectOneNodeMultipleConnectionsPerHost) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
+  test::driver::Cluster cluster =
+      default_cluster().with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
   connect(1, 0, cluster);
   assert_active_connections(CORE_CONNECTIONS_PER_HOST);
 }
@@ -372,13 +361,12 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
  * @since 1.0.0
  * @expected_result Successful connection and validation of active connections
  */
-SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
-                              ConnectThreeNodesMultipleConnectionsPerHost) {
+SIMULACRON_INTEGRATION_TEST_F(ConnectionTest, ConnectThreeNodesMultipleConnectionsPerHost) {
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
+  test::driver::Cluster cluster =
+      default_cluster().with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
   connect(3, 0, cluster);
   assert_active_connections(CORE_CONNECTIONS_PER_HOST);
 }
@@ -399,8 +387,8 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
+  test::driver::Cluster cluster =
+      default_cluster().with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
   connect(1, 1, cluster);
   assert_active_connections(CORE_CONNECTIONS_PER_HOST, false);
 }
@@ -421,8 +409,8 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
   SKIP_TEST_IF_SIMULACRON_UNAVAILABLE;
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
+  test::driver::Cluster cluster =
+      default_cluster().with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
   connect(3, 3, cluster);
   assert_active_connections(CORE_CONNECTIONS_PER_HOST, false);
 }
@@ -449,8 +437,8 @@ SIMULACRON_INTEGRATION_TEST_F(ConnectionTest,
   }
 
   // Ensure the control connection and normal node connection is established
-  test::driver::Cluster cluster = default_cluster()
-    .with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
+  test::driver::Cluster cluster =
+      default_cluster().with_core_connections_per_host(CORE_CONNECTIONS_PER_HOST);
   connect(data_center_nodes, cluster);
   assert_active_connections(CORE_CONNECTIONS_PER_HOST, false);
 }
diff --git a/gtests/src/integration/tests/simulacron/test_simulacron_idempotent.cpp b/gtests/src/integration/tests/simulacron/test_simulacron_idempotent.cpp
index b7e0bd296..8c02a78b4 100644
--- a/gtests/src/integration/tests/simulacron/test_simulacron_idempotent.cpp
+++ b/gtests/src/integration/tests/simulacron/test_simulacron_idempotent.cpp
@@ -22,7 +22,8 @@
  * Idempotent integration tests
  */
 class IdempotentTest : public SimulacronIntegration {
-using SimulacronIntegration::execute_mock_query;
+  using SimulacronIntegration::execute_mock_query;
+
 public:
   void SetUp() {
     number_dc1_nodes_ = 3;
@@ -44,8 +45,7 @@ using SimulacronIntegration::execute_mock_query;
    *                                  should be enabled; false otherwise
    * @return Result from the executed mock query; see Result::error_code()
    */
-  test::driver::Result execute_mock_query(bool is_idempotent,
-    bool apply_custom_retry_policy) {
+  test::driver::Result execute_mock_query(bool is_idempotent, bool apply_custom_retry_policy) {
     // Create the statement with the desired idempotence and custom retry policy
     test::driver::Statement statement("mock query");
     statement.set_consistency(CASS_CONSISTENCY_ONE);
@@ -54,8 +54,8 @@ using SimulacronIntegration::execute_mock_query;
 
     // Determine if the custom or default retry policy should be applied
     test::driver::RetryPolicy policy((apply_custom_retry_policy
-      ? NextHostRetryPolicy::policy()
-      : test::driver::DefaultRetryPolicy()));
+                                          ? NextHostRetryPolicy::policy()
+                                          : test::driver::DefaultRetryPolicy()));
     test::driver::LoggingRetryPolicy logging_policy(policy);
     statement.set_retry_policy(logging_policy);
 
@@ -92,7 +92,6 @@ SIMULACRON_INTEGRATION_TEST_F(IdempotentTest, WriteTimeoutNonIdempotentNoRetry)
   }
 }
 
-
 /**
  * Perform query using a idempotent statement; no errors should occur
  *
@@ -154,7 +153,6 @@ SIMULACRON_INTEGRATION_TEST_F(IdempotentTest, ClosedConnectionNonIdempotentNoRet
   }
 }
 
-
 /**
  * Perform query using a idempotent statement while a connection is closed
  *
diff --git a/gtests/src/integration/tests/test_async.cpp b/gtests/src/integration/tests/test_async.cpp
index 1e73d0229..1ccf51175 100644
--- a/gtests/src/integration/tests/test_async.cpp
+++ b/gtests/src/integration/tests/test_async.cpp
@@ -28,8 +28,8 @@ class AsyncTests : public Integration {
     Integration::SetUp();
 
     // Create the table
-    session_.execute("CREATE TABLE " + table_name_
-                     + " (key timeuuid PRIMARY KEY, value_number int, value_text text)");
+    session_.execute("CREATE TABLE " + table_name_ +
+                     " (key timeuuid PRIMARY KEY, value_number int, value_text text)");
   }
 
   /**
@@ -44,7 +44,8 @@ class AsyncTests : public Integration {
     for (size_t i = 0; i < NUMBER_OF_CONCURRENT_REQUESTS; ++i) {
       // Create the insert statement
       Statement insert("INSERT INTO " + table_name_ +
-                       " (key, value_number, value_text) VALUES (?, ?, ?) IF NOT EXISTS", 3);
+                           " (key, value_number, value_text) VALUES (?, ?, ?) IF NOT EXISTS",
+                       3);
 
       // Bind the values to the insert statement
       TimeUuid key = uuid_generator_.generate_timeuuid();
diff --git a/gtests/src/integration/tests/test_auth.cpp b/gtests/src/integration/tests/test_auth.cpp
index 8776914bf..f37b6d3ff 100644
--- a/gtests/src/integration/tests/test_auth.cpp
+++ b/gtests/src/integration/tests/test_auth.cpp
@@ -43,12 +43,10 @@ class AuthenticationTests : public Integration {
    * @param password Password credentials
    * @return Session instance
    */
-  Session connect_using_credentials(int protocol_version,
-                                   const char* username,
-                                   const char* password) {
+  Session connect_using_credentials(int protocol_version, const char* username,
+                                    const char* password) {
     // Establish a connection using the protocol version
-    cluster_.with_protocol_version(protocol_version)
-      .with_credentials(username, password);
+    cluster_.with_protocol_version(protocol_version).with_credentials(username, password);
     return cluster_.connect("", false);
   }
 
@@ -59,8 +57,7 @@ class AuthenticationTests : public Integration {
    * @param authenticator Driver authenticator
    * @oaram data Data associated with the callback
    */
-  static void handle_authenticator_initial(CassAuthenticator* authuenticator,
-                                    void* data) {
+  static void handle_authenticator_initial(CassAuthenticator* authuenticator, void* data) {
     cass_authenticator_set_error(authuenticator, NULL);
   }
 };
@@ -80,12 +77,11 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, ProtocolVersions) {
   CHECK_FAILURE;
 
   // Iterate over all known/supported protocol versions
-  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION;
-       i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION; ++i) {
+  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION; i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION;
+       ++i) {
     // Establish a connection using the protocol version
     Session session = connect_using_credentials(i, "cassandra", "cassandra");
-    ASSERT_EQ(CASS_OK, session.connect_error_code())
-      << session.connect_error_description();
+    ASSERT_EQ(CASS_OK, session.connect_error_code()) << session.connect_error_description();
 
     // Execute a query against the schema keyspaces table
     Result result = session.execute("SELECT * FROM " + system_schema_keyspaces_);
@@ -111,8 +107,8 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, InvalidEmptyCredentials) {
 
   // Iterate over all known/supported protocol versions
   logger_.add_critera("Key may not be empty");
-  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION;
-       i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION; ++i) {
+  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION; i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION;
+       ++i) {
     /*
      * This is a case that could be guarded in the API entry point, or error out
      * in connection. However, auth is subject to major changes and this is just
@@ -142,8 +138,8 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, InvalidNullUsernameCredentials
 
   // Iterate over all known/supported protocol versions
   logger_.add_critera("Key may not be empty");
-  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION;
-       i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION; ++i) {
+  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION; i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION;
+       ++i) {
     /*
      * This is a case that could be guarded in the API entry point, or error out
      * in connection. However, auth is subject to major changes and this is just
@@ -173,8 +169,8 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, InvalidNullPasswordCredentials
 
   // Iterate over all known/supported protocol versions
   logger_.add_critera("and/or password are incorrect");
-  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION;
-       i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION; ++i) {
+  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION; i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION;
+       ++i) {
     /*
      * This is a case that could be guarded in the API entry point, or error out
      * in connection. However, auth is subject to major changes and this is just
@@ -214,8 +210,8 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, BadCredentials) {
   }
 
   // Iterate over all known/supported protocol versions
-  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION;
-       i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION; ++i) {
+  for (int i = CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION; i <= CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION;
+       ++i) {
     /*
      * This is a case that could be guarded in the API entry point, or error out
      * in connection. However, auth is subject to major changes and this is just
@@ -257,14 +253,11 @@ CASSANDRA_INTEGRATION_TEST_F(AuthenticationTests, AuthenticatorSetErrorNull) {
 
   // Attempt to establish session connection using authentication callback
   CassAuthenticatorCallbacks authentication_callbacks = {
-    AuthenticationTests::handle_authenticator_initial,
-    NULL,
-    NULL,
-    NULL
+    AuthenticationTests::handle_authenticator_initial, NULL, NULL, NULL
   };
   cluster_.with_authenticator_callbacks(&authentication_callbacks, NULL, NULL);
-  Session session = connect_using_credentials(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION,
-                                              "invalid", "invalid");
+  Session session =
+      connect_using_credentials(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION, "invalid", "invalid");
   ASSERT_EQ(session.connect_error_code(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
   ASSERT_GE(logger_.count(), 1u);
 }
diff --git a/gtests/src/integration/tests/test_basics.cpp b/gtests/src/integration/tests/test_basics.cpp
index f71c2ca18..6145b4393 100644
--- a/gtests/src/integration/tests/test_basics.cpp
+++ b/gtests/src/integration/tests/test_basics.cpp
@@ -19,7 +19,7 @@
 /**
  * Basics integration tests; common operations
  */
-class BasicsTests : public Integration { };
+class BasicsTests : public Integration {};
 
 /**
  * Perform inserts and validate the timestamps from the server
@@ -36,12 +36,11 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, Timestamps) {
   CHECK_FAILURE;
 
   // Create the table, insert and select queries for the test
-  session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                   table_name_.c_str(), "int", "int"));
-  std::string insert_query = format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                                           table_name_.c_str(), "?", "?");
-  Statement select_query = Statement("SELECT WRITETIME (value) FROM "
-                                     + table_name_);
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
+  std::string insert_query =
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?");
+  Statement select_query = Statement("SELECT WRITETIME (value) FROM " + table_name_);
 
   // Insert a value and get the timestamp from the server
   Statement statement(insert_query, 2);
@@ -69,8 +68,7 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, Timestamps) {
 
   // Validate the timestamps
   ASSERT_NE(timestamp_1, timestamp_2);
-  ASSERT_LT(timestamp_2 - timestamp_1 - BigInteger(pause_duration * 1000),
-            BigInteger(100000));
+  ASSERT_LT(timestamp_2 - timestamp_1 - BigInteger(pause_duration * 1000), BigInteger(100000));
 }
 
 /**
@@ -87,15 +85,13 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, Counters) {
   CHECK_FAILURE;
 
   // Create the table and update/upsert queries for the test
-  session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                   table_name_.c_str(), "int", "counter"));
-  std::string update_query = "UPDATE " + table_name_
-    + " SET value=value %s ? WHERE key=0";
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "counter"));
+  std::string update_query = "UPDATE " + table_name_ + " SET value=value %s ? WHERE key=0";
 
   // Perform multiple upserts against the counter value
   for (int step = 0; step < 100; ++step) {
-    Statement statement(format_string(update_query.c_str(),
-      (step % 2 == 0 ? "-" : "+")), 1);
+    Statement statement(format_string(update_query.c_str(), (step % 2 == 0 ? "-" : "+")), 1);
     statement.bind<Counter>(0, Counter(step));
     session_.execute(statement);
   }
@@ -125,14 +121,15 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, RowsInRowsOut) {
   CHECK_FAILURE;
 
   // Create the table, insert, and select statements for the test
-  session_.execute("CREATE TABLE " + table_name_
-                   + " (key bigint PRIMARY KEY, " \
+  session_.execute("CREATE TABLE " + table_name_ +
+                   " (key bigint PRIMARY KEY, "
                    "value_1 bigint, value_2 bigint, value_3 bigint)");
-  Statement insert_statement("INSERT INTO " + table_name_
-                             + " (key, value_1, value_2, value_3) " \
-                             "VALUES (?, ?, ?, ?)", 4);
-  Statement select_statement("SELECT key, value_1, value_2, value_3 FROM "
-                             + table_name_ + " LIMIT 1000");
+  Statement insert_statement("INSERT INTO " + table_name_ +
+                                 " (key, value_1, value_2, value_3) "
+                                 "VALUES (?, ?, ?, ?)",
+                             4);
+  Statement select_statement("SELECT key, value_1, value_2, value_3 FROM " + table_name_ +
+                             " LIMIT 1000");
 
   // Create multiple rows with varying data
   for (int i = 0; i < 1000; ++i) {
@@ -177,8 +174,8 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, ColumnNames) {
   CHECK_FAILURE;
 
   // Create the table for the test
-  session_.execute("CREATE TABLE " + table_name_
-                   + " (key bigint PRIMARY KEY, " \
+  session_.execute("CREATE TABLE " + table_name_ +
+                   " (key bigint PRIMARY KEY, "
                    "value_1 text, value_2 int, value_3 bigint, value_4 float)");
 
   // Validate the column names
@@ -210,18 +207,17 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, EmptyResults) {
   CHECK_FAILURE;
 
   // Create the table
-  Result result = session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                                   table_name_.c_str(), "int", "int"));
+  Result result = session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
   ASSERT_TRUE(result.is_empty());
 
   // Insert data into the table
-  result = session_.execute(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                            table_name_.c_str(), "0", "0"));
+  result = session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "0", "0"));
   ASSERT_TRUE(result.is_empty());
 
   // Delete data from the table
-  result = session_.execute(format_string(CASSANDRA_DELETE_ROW_FORMAT,
-                            table_name_.c_str(), "0"));
+  result = session_.execute(format_string(CASSANDRA_DELETE_ROW_FORMAT, table_name_.c_str(), "0"));
   ASSERT_TRUE(result.is_empty());
 
   // Select data from the table (all rows have been deleted)
@@ -246,12 +242,11 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, UnsetParameters) {
   CHECK_FAILURE;
 
   // Create the table, insert a known value, and create insert statement for the test
-  session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                   table_name_.c_str(), "int", "int"));
-  session_.execute(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                   table_name_.c_str(), "0", "1"));
-  Prepared insert_prepared = session_.prepare(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                                              table_name_.c_str(), "?", "?"));
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
+  session_.execute(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "0", "1"));
+  Prepared insert_prepared = session_.prepare(
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?"));
 
   // Bind a single value and leave one unset
   Statement insert_statement = insert_prepared.bind();
@@ -287,17 +282,17 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, UnsetParameters) {
  * @test_category queries:basic
  * @since core:2.3.0
  * @expected_result String will be bound/inserted into blob  and values will be
-  *                 validated
+ *                 validated
  */
 CASSANDRA_INTEGRATION_TEST_F(BasicsTests, BindBlobAsString) {
   CHECK_FAILURE;
 
   // Create the table, prepared and  insert statement for the test
-  session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                   table_name_.c_str(), "int", "blob"));
+  session_.execute(
+      format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "blob"));
   // Prepared needed to validate bind type information
-  Prepared insert_prepared = session_.prepare(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                                              table_name_.c_str(), "?", "?"));
+  Prepared insert_prepared = session_.prepare(
+      format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?"));
   Statement insert_statement = insert_prepared.bind();
 
   // Bind and insert the data into the table
@@ -341,33 +336,32 @@ CASSANDRA_INTEGRATION_TEST_F(BasicsTests, NoCompactEnabledConnection) {
   CCM::CassVersion cass_version = server_version_;
   if (Options::is_dse()) {
     if (server_version_ >= "6.0.0") {
-      SKIP_TEST("Unsupported for DataStax Enterprise Version " << server_version_.to_string()
+      SKIP_TEST("Unsupported for DataStax Enterprise Version "
+                << server_version_.to_string()
                 << ": Apache Cassandra server version must be used and less than"
                 << " v4.0.0 and either 3.0.16+ or 3.11.2+ in order to execute");
     }
     cass_version = static_cast<CCM::DseVersion>(cass_version).get_cass_version();
   }
   if (cass_version >= "4.0.0") {
-    SKIP_TEST("Unsupported for Apache Cassandra Version " << cass_version.to_string()
+    SKIP_TEST("Unsupported for Apache Cassandra Version "
+              << cass_version.to_string()
               << ": Server version must be less than v4.0.0 and either 3.0.16+"
               << " or 3.11.2+ in order to execute");
   }
 
   // Create a session where the NO_COMPACT option is set
-  Session no_compact_session = default_cluster()
-    .with_no_compact()
-    .connect(default_keyspace());
+  Session no_compact_session = default_cluster().with_no_compact().connect(default_keyspace());
 
   // Create the table and insert data using the NO_COMPACT session
   no_compact_session.execute(format_string(
-                             "CREATE TABLE %s (k int PRIMARY KEY, v int) WITH COMPACT STORAGE",
-                             table_name_.c_str()));
-  no_compact_session.execute(format_string("INSERT INTO %s (k, v) VALUES(%s, %s)",
-                             table_name_.c_str(), "1", "1"));
-  no_compact_session.execute(format_string("INSERT INTO %s (k, v) VALUES(%s, %s)",
-                             table_name_.c_str(), "2", "2"));
-  no_compact_session.execute(format_string("INSERT INTO %s (k, v) VALUES(%s, %s)",
-                             table_name_.c_str(), "3", "3"));
+      "CREATE TABLE %s (k int PRIMARY KEY, v int) WITH COMPACT STORAGE", table_name_.c_str()));
+  no_compact_session.execute(
+      format_string("INSERT INTO %s (k, v) VALUES(%s, %s)", table_name_.c_str(), "1", "1"));
+  no_compact_session.execute(
+      format_string("INSERT INTO %s (k, v) VALUES(%s, %s)", table_name_.c_str(), "2", "2"));
+  no_compact_session.execute(
+      format_string("INSERT INTO %s (k, v) VALUES(%s, %s)", table_name_.c_str(), "3", "3"));
 
   // Validate the default session with compact storage enabled
   Result result = session_.execute(default_select_all());
diff --git a/gtests/src/integration/tests/test_batch.cpp b/gtests/src/integration/tests/test_batch.cpp
index c42b8258d..62cfce295 100644
--- a/gtests/src/integration/tests/test_batch.cpp
+++ b/gtests/src/integration/tests/test_batch.cpp
@@ -24,15 +24,15 @@
 class BatchSingleNodeClusterTests : public Integration {
 public:
   BatchSingleNodeClusterTests()
-    : value_cql_data_type_("text") { }
+      : value_cql_data_type_("text") {}
 
   virtual void SetUp() {
     // Call the parent setup function
     Integration::SetUp();
 
     // Create the table, insert and select statements for the test
-    session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                     table_name_.c_str(), "int", value_cql_data_type_.c_str()));
+    session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int",
+                                   value_cql_data_type_.c_str()));
     create_queries_select_statements();
   }
 
@@ -58,12 +58,11 @@ class BatchSingleNodeClusterTests : public Integration {
    * Create the queries and select statement for the test
    */
   virtual void create_queries_select_statements() {
-    insert_query_ = format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                                  table_name_.c_str(), "?", "?");
-    update_query_ = format_string(CASSANDRA_UPDATE_VALUE_FORMAT,
-                                  table_name_.c_str(), "value + ?", "?");
-    select_prepared_ = session_.prepare(format_string(CASSANDRA_SELECT_VALUE_FORMAT,
-                                        table_name_.c_str(), "?"));
+    insert_query_ = format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?");
+    update_query_ =
+        format_string(CASSANDRA_UPDATE_VALUE_FORMAT, table_name_.c_str(), "value + ?", "?");
+    select_prepared_ =
+        session_.prepare(format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), "?"));
   }
 
   /**
@@ -84,8 +83,7 @@ class BatchSingleNodeClusterTests : public Integration {
       Result result = session_.execute(statement);
 
       // Validate the result
-      ASSERT_EQ(Text(format_string("test data %d", i)),
-                result.first_row().next().as<Text>());
+      ASSERT_EQ(Text(format_string("test data %d", i)), result.first_row().next().as<Text>());
     }
   }
 
@@ -96,8 +94,7 @@ class BatchSingleNodeClusterTests : public Integration {
    * @param index The index/row being validated
    */
   virtual void validate_result(Result result, int index) {
-    ASSERT_EQ(Text(format_string("test data %d", index)),
-              result.first_row().next().as<Text>());
+    ASSERT_EQ(Text(format_string("test data %d", index)), result.first_row().next().as<Text>());
   }
 };
 
@@ -108,9 +105,7 @@ class BatchSingleNodeClusterTests : public Integration {
  */
 class BatchCounterSingleNodeClusterTests : public BatchSingleNodeClusterTests {
 public:
-  BatchCounterSingleNodeClusterTests() {
-    value_cql_data_type_ = "counter";
-  }
+  BatchCounterSingleNodeClusterTests() { value_cql_data_type_ = "counter"; }
 
   /**
    * Validate the result for the text data type
@@ -264,13 +259,15 @@ CASSANDRA_INTEGRATION_TEST_F(BatchCounterSingleNodeClusterTests, InvalidBatchTyp
 
   // Create and add the insert statement
   Statement statement(insert_query_, 2);
-  statement.bind<Integer>(0, Integer(37)); // Attempt to insert a counter value inside a batch statement
+  statement.bind<Integer>(
+      0, Integer(37)); // Attempt to insert a counter value inside a batch statement
   statement.bind<Counter>(1, Counter(37));
   batch.add(statement);
 
   // Execute the batch statement and verify the server response
   Result result = session_.execute(batch, false);
-  ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code()); // Cannot include a counter statement in a logged batch
+  ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
+            result.error_code()); // Cannot include a counter statement in a logged batch
 }
 
 /**
@@ -315,8 +312,7 @@ CASSANDRA_INTEGRATION_TEST_F(BatchCounterThreeNodeClusterTests, MixedPreparedAnd
   session_.execute(batch);
 
   // Validate the updates
-  Result result = session_.execute(default_select_all(),
-                                   CASS_CONSISTENCY_QUORUM);
+  Result result = session_.execute(default_select_all(), CASS_CONSISTENCY_QUORUM);
   ASSERT_EQ(number_of_rows, result.row_count());
   ASSERT_EQ(2u, result.column_count());
   Rows rows = result.rows();
diff --git a/gtests/src/integration/tests/test_by_name.cpp b/gtests/src/integration/tests/test_by_name.cpp
index 3025112df..17dc07b32 100644
--- a/gtests/src/integration/tests/test_by_name.cpp
+++ b/gtests/src/integration/tests/test_by_name.cpp
@@ -16,27 +16,31 @@
 
 #include "integration.hpp"
 
-#define TABLE_FORMAT "CREATE TABLE %s (" \
-                       "key timeuuid PRIMARY KEY, " \
-                       "a int, " \
-                       "b boolean, " \
-                       "c text, " \
-                       "abc float, " \
-                       "\"ABC\" float, " \
-                       "\"aBc\" float" \
-                     ")"
-#define TABLE_BYTES_FORMAT "CREATE TABLE %s (" \
-                             "key timeuuid PRIMARY KEY, " \
-                             "blobs blob, " \
-                             "varints varint" \
-                           ")"
+#define TABLE_FORMAT           \
+  "CREATE TABLE %s ("          \
+  "key timeuuid PRIMARY KEY, " \
+  "a int, "                    \
+  "b boolean, "                \
+  "c text, "                   \
+  "abc float, "                \
+  "\"ABC\" float, "            \
+  "\"aBc\" float"              \
+  ")"
+#define TABLE_BYTES_FORMAT     \
+  "CREATE TABLE %s ("          \
+  "key timeuuid PRIMARY KEY, " \
+  "blobs blob, "               \
+  "varints varint"             \
+  ")"
 #define INSERT_FORMAT "INSERT INTO %s (key, a, b, c) VALUES (?, ?, ?, ?)"
-#define INSERT_CASE_SENSITIVE_FORMAT "INSERT INTO %s " \
-                                     "(key, abc, \"ABC\", \"aBc\") " \
-                                     "VALUES (?, ?, ?, ?)"
-#define INSERT_ALL_FORMAT "INSERT INTO %s " \
-                          "(key, a, b, c, abc, \"ABC\", \"aBc\") " \
-                          "VALUES (?, ?, ?, ?, ?, ?, ?)"
+#define INSERT_CASE_SENSITIVE_FORMAT \
+  "INSERT INTO %s "                  \
+  "(key, abc, \"ABC\", \"aBc\") "    \
+  "VALUES (?, ?, ?, ?)"
+#define INSERT_ALL_FORMAT                  \
+  "INSERT INTO %s "                        \
+  "(key, a, b, c, abc, \"ABC\", \"aBc\") " \
+  "VALUES (?, ?, ?, ?, ?, ?, ?)"
 #define INSERT_BYTES_FORMAT "INSERT INTO %s (key, blobs, varints) VALUES (?, ?, ?)"
 
 /**
@@ -199,8 +203,7 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, Prepared) {
   CHECK_FAILURE;
 
   // Prepare, create, insert and validate
-  Prepared prepared = session_.prepare(format_string(INSERT_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared = session_.prepare(format_string(INSERT_FORMAT, table_name_.c_str()));
   insert_and_validate(prepared.bind());
 }
 
@@ -238,8 +241,8 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, PreparedCaseSensitive) {
   CHECK_FAILURE;
 
   // Prepare, create, insert and validate
-  Prepared prepared = session_.prepare(format_string(INSERT_CASE_SENSITIVE_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared =
+      session_.prepare(format_string(INSERT_CASE_SENSITIVE_FORMAT, table_name_.c_str()));
   insert_and_validate_case_sensitive(prepared.bind());
 }
 
@@ -261,8 +264,7 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, SimpleCaseSensitive) {
   CHECK_VERSION(2.1.0);
 
   // Prepare, create, insert and validate
-  Statement statement(format_string(INSERT_CASE_SENSITIVE_FORMAT,
-                      table_name_.c_str()), 4);
+  Statement statement(format_string(INSERT_CASE_SENSITIVE_FORMAT, table_name_.c_str()), 4);
   insert_and_validate_case_sensitive(statement);
 }
 
@@ -282,8 +284,8 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, MultipleBinds) {
   CHECK_FAILURE;
 
   // Prepare, bind, and insert the values into the table
-  Prepared prepared = session_.prepare(format_string(INSERT_CASE_SENSITIVE_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared =
+      session_.prepare(format_string(INSERT_CASE_SENSITIVE_FORMAT, table_name_.c_str()));
   Statement statement = prepared.bind();
   TimeUuid key = uuid_generator_.generate_timeuuid();
   statement.bind<TimeUuid>("key", key);
@@ -311,14 +313,13 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, MultipleBinds) {
  * @test_category queries:prepared
  * @since core:1.0.0
  * @expected_result Driver error will occur when binding value to invalid column
-  *                 name
+ *                 name
  */
 CASSANDRA_INTEGRATION_TEST_F(ByNameTests, BindUsingInvalidName) {
   CHECK_FAILURE;
 
   // Prepare and create the insert statement
-  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT, table_name_.c_str()));
   Statement statement = prepared.bind();
 
   // Bind values to invalid columns name and validate error
@@ -339,14 +340,13 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, BindUsingInvalidName) {
  * @test_category queries:basic
  * @since core:1.0.0
  * @expected_result Driver error will occur when retrieving value from invalid
-  *                 column name
+ *                 column name
  */
 CASSANDRA_INTEGRATION_TEST_F(ByNameTests, RetrieveInvalidName) {
   CHECK_FAILURE;
 
   // Prepare, create, insert and validate (all)
-  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT, table_name_.c_str()));
   Statement statement = prepared.bind();
   insert_and_validate_all(statement);
 
@@ -373,8 +373,7 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameTests, NullPrepared) {
   CHECK_FAILURE;
 
   // Prepare, create, insert and validate
-  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared = session_.prepare(format_string(INSERT_ALL_FORMAT, table_name_.c_str()));
   insert_and_validate_all_null(prepared.bind());
 }
 
@@ -423,8 +422,7 @@ CASSANDRA_INTEGRATION_TEST_F(ByNameBytesTests, Prepared) {
   Varint varints("1234567890123456789012345678901234567890");
 
   // Prepare, bind, and insert the values into the table
-  Prepared prepared = session_.prepare(format_string(INSERT_BYTES_FORMAT,
-                                       table_name_.c_str()));
+  Prepared prepared = session_.prepare(format_string(INSERT_BYTES_FORMAT, table_name_.c_str()));
   Statement statement = prepared.bind();
   statement.bind<TimeUuid>("key", key);
   statement.bind<Blob>("blobs", blobs);
diff --git a/gtests/src/integration/tests/test_cassandra_types.cpp b/gtests/src/integration/tests/test_cassandra_types.cpp
index e84f8c0a9..87f63cbb1 100644
--- a/gtests/src/integration/tests/test_cassandra_types.cpp
+++ b/gtests/src/integration/tests/test_cassandra_types.cpp
@@ -19,7 +19,7 @@
 /**
  * Cassandra type integration tests
  */
-template<class C>
+template <class C>
 class CassandraTypesTest : public Integration {
 public:
   /**
@@ -28,7 +28,7 @@ class CassandraTypesTest : public Integration {
   static const std::vector<C> values_;
 
   CassandraTypesTest()
-    : is_key_allowed_(true) { }
+      : is_key_allowed_(true) {}
 
   void SetUp() {
     // Enable schema metadata to easily create user type (when needed)
@@ -76,11 +76,11 @@ class CassandraTypesTest : public Integration {
    */
   void initialize(const std::string& cql_type) {
     if (is_key_allowed_) {
-      session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-        table_name_.c_str(), cql_type.c_str(), cql_type.c_str()));
+      session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(),
+                                     cql_type.c_str(), cql_type.c_str()));
     } else {
-      session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-        table_name_.c_str(), "int", cql_type.c_str()));
+      session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int",
+                                     cql_type.c_str()));
     }
     insert_query_ = format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?");
     select_query_ = format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), "?");
@@ -92,7 +92,7 @@ TYPED_TEST_CASE_P(CassandraTypesTest);
 /**
  * Specialized duration integration test extension
  */
-class CassandraTypesDurationTest : public CassandraTypesTest<Duration> { };
+class CassandraTypesDurationTest : public CassandraTypesTest<Duration> {};
 
 /**
  * Perform insert using a simple and prepared statement operation
@@ -114,16 +114,14 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Basic) {
   const std::vector<TypeParam>& values = CassandraTypesTest<TypeParam>::values_;
 
   // Iterate over all the Cassandra type values
-  for (typename std::vector<TypeParam>::const_iterator it = values.begin();
-    it != values.end(); ++it) {
+  for (typename std::vector<TypeParam>::const_iterator it = values.begin(); it != values.end();
+       ++it) {
     // Get the current value
     const TypeParam& value = *it;
 
     // Create both simple and prepared statements
-    Statement statements[] = {
-      Statement(this->insert_query_, 2),
-      this->prepared_statement_.bind()
-    };
+    Statement statements[] = { Statement(this->insert_query_, 2),
+                               this->prepared_statement_.bind() };
 
     // Iterate over all the statements
     for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -173,16 +171,14 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicByName) {
   const std::vector<TypeParam>& values = CassandraTypesTest<TypeParam>::values_;
 
   // Iterate over all the Cassandra type values
-  for (typename std::vector<TypeParam>::const_iterator it = values.begin();
-    it != values.end(); ++it) {
+  for (typename std::vector<TypeParam>::const_iterator it = values.begin(); it != values.end();
+       ++it) {
     // Get the current value
     const TypeParam& value = *it;
 
     // Create both simple and prepared statements
-    Statement statements[] = {
-      Statement(this->insert_query_, 2),
-      this->prepared_statement_.bind()
-    };
+    Statement statements[] = { Statement(this->insert_query_, 2),
+                               this->prepared_statement_.bind() };
 
     // Iterate over all the statements
     for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -230,10 +226,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullValues) {
   this->default_setup();
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -276,10 +269,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullList) {
   this->default_setup();
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -297,7 +287,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullList) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::List<TypeParam> select_value =
-      result.first_row().next().as<test::driver::List<TypeParam> >();
+        result.first_row().next().as<test::driver::List<TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -323,10 +313,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullMap) {
   this->default_setup();
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -344,7 +331,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullMap) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::Map<TypeParam, TypeParam> select_value =
-      result.first_row().next().as<test::driver::Map<TypeParam, TypeParam> >();
+        result.first_row().next().as<test::driver::Map<TypeParam, TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -370,10 +357,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullSet) {
   this->default_setup();
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -391,7 +375,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullSet) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::Set<TypeParam> select_value =
-      result.first_row().next().as<test::driver::Set<TypeParam> >();
+        result.first_row().next().as<test::driver::Set<TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -419,10 +403,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, List) {
   this->initialize("frozen<" + list.cql_type() + ">");
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -476,10 +457,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Set) {
   this->initialize("frozen<" + set.cql_type() + ">");
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate overall all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -530,18 +508,16 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Map) {
     // Initialize the table and assign the values for the map
     std::map<TypeParam, TypeParam> map_values;
     const std::vector<TypeParam>& values = CassandraTypesTest<TypeParam>::values_;
-    for (typename std::vector<TypeParam>::const_iterator it = values.begin();
-         it != values.end(); ++it) {
+    for (typename std::vector<TypeParam>::const_iterator it = values.begin(); it != values.end();
+         ++it) {
       map_values[*it] = *it;
     }
     Map<TypeParam, TypeParam> map(map_values);
     this->initialize("frozen<" + map.cql_type() + ">");
 
     // Create both simple and prepared statements
-    Statement statements[] = {
-      Statement(this->insert_query_, 2),
-      this->prepared_statement_.bind()
-    };
+    Statement statements[] = { Statement(this->insert_query_, 2),
+                               this->prepared_statement_.bind() };
 
     // Iterate over all the statements
     for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -566,18 +542,16 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Map) {
     std::map<Integer, TypeParam> map_values;
     const std::vector<TypeParam>& values = CassandraTypesTest<TypeParam>::values_;
     cass_int32_t count = 1;
-    for (typename std::vector<TypeParam>::const_iterator it = values.begin();
-         it != values.end(); ++it) {
+    for (typename std::vector<TypeParam>::const_iterator it = values.begin(); it != values.end();
+         ++it) {
       map_values[Integer(count++)] = *it;
     }
     Map<Integer, TypeParam> map(map_values);
     this->initialize("frozen<" + map.cql_type() + ">");
 
     // Create both simple and prepared statements
-    Statement statements[] = {
-      Statement(this->insert_query_, 2),
-      this->prepared_statement_.bind()
-    };
+    Statement statements[] = { Statement(this->insert_query_, 2),
+                               this->prepared_statement_.bind() };
 
     // Iterate over all the statements
     for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -632,10 +606,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Tuple) {
   this->initialize(cql_type);
 
   // Create both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   // Iterate over all the statements
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
@@ -703,7 +674,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, UDT) {
   this->session_.execute(create_type);
 
   // Initialize the table; NOTE: UDT must be frozen for older versions of Cassandra
-  this->initialize("frozen<" +  cql_type + ">");
+  this->initialize("frozen<" + cql_type + ">");
 
   // Build our UDT values and UDT type
   std::map<std::string, TypeParam> udt_values;
@@ -712,21 +683,17 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, UDT) {
     field << "field" << i;
     udt_values[field.str()] = values[i];
   }
-  UserType user_type(this->session_.schema()
-                     .keyspace(this->keyspace_name_)
-                     .user_type(cql_type).data_type());
+  UserType user_type(
+      this->session_.schema().keyspace(this->keyspace_name_).user_type(cql_type).data_type());
 
   // Assign/Set the values in the user type
   for (typename std::map<std::string, TypeParam>::const_iterator it = udt_values.begin();
-    it != udt_values.end(); ++it) {
+       it != udt_values.end(); ++it) {
     user_type.set<TypeParam>(it->second, it->first);
   }
 
   // Use both simple and prepared statements
-  Statement statements[] = {
-    Statement(this->insert_query_, 2),
-    this->prepared_statement_.bind()
-  };
+  Statement statements[] = { Statement(this->insert_query_, 2), this->prepared_statement_.bind() };
 
   for (size_t i = 0; i < ARRAY_LEN(statements); ++i) {
     Statement& statement = statements[i];
@@ -756,16 +723,11 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, UDT) {
 
 // Register all parameterized test cases for primitives (excludes duration)
 REGISTER_TYPED_TEST_CASE_P(CassandraTypesTest, Integration_Cassandra_Basic,
-                                               Integration_Cassandra_BasicByName,
-                                               Integration_Cassandra_BasicNullValues,
-                                               Integration_Cassandra_BasicNullList,
-                                               Integration_Cassandra_BasicNullMap,
-                                               Integration_Cassandra_BasicNullSet,
-                                               Integration_Cassandra_List,
-                                               Integration_Cassandra_Set,
-                                               Integration_Cassandra_Map,
-                                               Integration_Cassandra_Tuple,
-                                               Integration_Cassandra_UDT);
+                           Integration_Cassandra_BasicByName, Integration_Cassandra_BasicNullValues,
+                           Integration_Cassandra_BasicNullList, Integration_Cassandra_BasicNullMap,
+                           Integration_Cassandra_BasicNullSet, Integration_Cassandra_List,
+                           Integration_Cassandra_Set, Integration_Cassandra_Map,
+                           Integration_Cassandra_Tuple, Integration_Cassandra_UDT);
 
 /**
  * Attempt to utilize an invalid duration value on a statement
@@ -800,115 +762,84 @@ CASSANDRA_INTEGRATION_TEST_F(CassandraTypesDurationTest, MixedValues) {
 }
 
 // Instantiate the test case for all the Cassandra data types
-typedef testing::Types<Ascii,
-                       BigInteger,
-                       Blob,
-                       Boolean,
-                       Date,
-                       Decimal,
-                       Double,
-                       Duration,
-                       Float,
-                       Inet,
-                       Integer,
-                       SmallInteger,
-                       Text,
-                       Time,
-                       Timestamp,
-                       TimeUuid,
-                       TinyInteger,
-                       Uuid,
-                       Varchar,
-                       Varint> CassandraTypes;
+typedef testing::Types<Ascii, BigInteger, Blob, Boolean, Date, Decimal, Double, Duration, Float,
+                       Inet, Integer, SmallInteger, Text, Time, Timestamp, TimeUuid, TinyInteger,
+                       Uuid, Varchar, Varint>
+    CassandraTypes;
 INSTANTIATE_TYPED_TEST_CASE_P(CassandraTypes, CassandraTypesTest, CassandraTypes);
 
 /**
  * Values for ASCII tests
  */
-const Ascii ASCII_VALUES[] = {
-  Ascii("DataStax"),
-  Ascii("C/C++"),
-  Ascii("Driver"),
-  Ascii("Cassandra")
-};
-template<> const std::vector<Ascii> CassandraTypesTest<Ascii>::values_(
-  ASCII_VALUES,
-  ASCII_VALUES + ARRAY_LEN(ASCII_VALUES));
+const Ascii ASCII_VALUES[] = { Ascii("DataStax"), Ascii("C/C++"), Ascii("Driver"),
+                               Ascii("Cassandra") };
+template <>
+const std::vector<Ascii> CassandraTypesTest<Ascii>::values_(ASCII_VALUES,
+                                                            ASCII_VALUES + ARRAY_LEN(ASCII_VALUES));
 
 /**
  * Values for bigint tests
  */
-const BigInteger BIGINT_VALUES[] = {
-  BigInteger::max(),
-  BigInteger::min(),
-  BigInteger(static_cast<cass_int64_t>(0)),
-  BigInteger(37)
-};
-template<> const std::vector<BigInteger> CassandraTypesTest<BigInteger>::values_(
-  BIGINT_VALUES,
-  BIGINT_VALUES + ARRAY_LEN(BIGINT_VALUES));
+const BigInteger BIGINT_VALUES[] = { BigInteger::max(), BigInteger::min(),
+                                     BigInteger(static_cast<cass_int64_t>(0)), BigInteger(37) };
+template <>
+const std::vector<BigInteger> CassandraTypesTest<BigInteger>::values_(BIGINT_VALUES,
+                                                                      BIGINT_VALUES +
+                                                                          ARRAY_LEN(BIGINT_VALUES));
 
 /**
  * Values for blob tests
  */
-const Blob BLOB_VALUES[] = {
-  Blob("DataStax C/C++ Driver"),
-  Blob("Cassandra"),
-  Blob("DataStax Enterprise")
-};
-template<> const std::vector<Blob> CassandraTypesTest<Blob>::values_(
-  BLOB_VALUES,
-  BLOB_VALUES + ARRAY_LEN(BLOB_VALUES));
+const Blob BLOB_VALUES[] = { Blob("DataStax C/C++ Driver"), Blob("Cassandra"),
+                             Blob("DataStax Enterprise") };
+template <>
+const std::vector<Blob> CassandraTypesTest<Blob>::values_(BLOB_VALUES,
+                                                          BLOB_VALUES + ARRAY_LEN(BLOB_VALUES));
 
 /**
  * Values for boolean tests
  */
-const Boolean BOOLEAN_VALUES[] = {
-  Boolean(true),
-  Boolean(false)
-};
-template<> const std::vector<Boolean> CassandraTypesTest<Boolean>::values_(
-  BOOLEAN_VALUES,
-  BOOLEAN_VALUES + ARRAY_LEN(BOOLEAN_VALUES));
+const Boolean BOOLEAN_VALUES[] = { Boolean(true), Boolean(false) };
+template <>
+const std::vector<Boolean> CassandraTypesTest<Boolean>::values_(BOOLEAN_VALUES,
+                                                                BOOLEAN_VALUES +
+                                                                    ARRAY_LEN(BOOLEAN_VALUES));
 
 /**
  * Values for date tests
  */
-const Date DATE_VALUES[] = {
-  Date::max(), // maximum for strftime
-  Date::min(), // minimum for strftime
-  Date(static_cast<cass_uint32_t>(0)),
-  Date(12345u)
-};
-template<> const std::vector<Date> CassandraTypesTest<Date>::values_(
-  DATE_VALUES,
-  DATE_VALUES + ARRAY_LEN(DATE_VALUES));
+const Date DATE_VALUES[] = { Date::max(), // maximum for strftime
+                             Date::min(), // minimum for strftime
+                             Date(static_cast<cass_uint32_t>(0)), Date(12345u) };
+template <>
+const std::vector<Date> CassandraTypesTest<Date>::values_(DATE_VALUES,
+                                                          DATE_VALUES + ARRAY_LEN(DATE_VALUES));
 
 /**
  * Values for decimal tests
  */
-const Decimal DECIMAL_VALUES[] = {
-  Decimal("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"),
-  Decimal("2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274"),
-  Decimal("1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374")
-};
-template<> const std::vector<Decimal> CassandraTypesTest<Decimal>::values_(
-  DECIMAL_VALUES,
-  DECIMAL_VALUES + ARRAY_LEN(DECIMAL_VALUES));
+const Decimal DECIMAL_VALUES[] = { Decimal("3."
+                                           "1415926535897932384626433832795028841971693993751058209"
+                                           "749445923078164062862089986280348253421170679"),
+                                   Decimal("2."
+                                           "7182818284590452353602874713526624977572470936999595749"
+                                           "669676277240766303535475945713821785251664274"),
+                                   Decimal("1."
+                                           "6180339887498948482045868343656381177203091798057628621"
+                                           "354486227052604628189024497072072041893911374") };
+template <>
+const std::vector<Decimal> CassandraTypesTest<Decimal>::values_(DECIMAL_VALUES,
+                                                                DECIMAL_VALUES +
+                                                                    ARRAY_LEN(DECIMAL_VALUES));
 
 /**
  * Values for double tests
  */
-const Double DOUBLE_VALUES[] = {
-  Double::max(),
-  Double::min(),
-  Double(3.1415926535),
-  Double(2.7182818284),
-  Double(1.6180339887)
-};
-template<> const std::vector<Double> CassandraTypesTest<Double>::values_(
-  DOUBLE_VALUES,
-  DOUBLE_VALUES + ARRAY_LEN(DOUBLE_VALUES));
+const Double DOUBLE_VALUES[] = { Double::max(), Double::min(), Double(3.1415926535),
+                                 Double(2.7182818284), Double(1.6180339887) };
+template <>
+const std::vector<Double>
+    CassandraTypesTest<Double>::values_(DOUBLE_VALUES, DOUBLE_VALUES + ARRAY_LEN(DOUBLE_VALUES));
 
 /**
  * Values for duration tests
@@ -922,168 +853,127 @@ const Duration DURATION_VALUES[] = {
   Duration(CassDuration(0, std::numeric_limits<cass_int32_t>::max(), 1)),
   Duration(CassDuration(0, std::numeric_limits<cass_int32_t>::min(), -1))
 };
-template<> const std::vector<Duration> CassandraTypesTest<Duration>::values_(
-  DURATION_VALUES,
-  DURATION_VALUES + ARRAY_LEN(DURATION_VALUES));
+template <>
+const std::vector<Duration> CassandraTypesTest<Duration>::values_(DURATION_VALUES,
+                                                                  DURATION_VALUES +
+                                                                      ARRAY_LEN(DURATION_VALUES));
 
 /**
  * Values for float tests
  */
-const Float FLOAT_VALUES[] = {
-  Float::max(),
-  Float::min(),
-  Float(3.14159f),
-  Float(2.71828f),
-  Float(1.61803f)
-};
-template<> const std::vector<Float> CassandraTypesTest<Float>::values_(
-  FLOAT_VALUES,
-  FLOAT_VALUES + ARRAY_LEN(FLOAT_VALUES));
+const Float FLOAT_VALUES[] = { Float::max(), Float::min(), Float(3.14159f), Float(2.71828f),
+                               Float(1.61803f) };
+template <>
+const std::vector<Float> CassandraTypesTest<Float>::values_(FLOAT_VALUES,
+                                                            FLOAT_VALUES + ARRAY_LEN(FLOAT_VALUES));
 
 /**
  * Values for inet tests
  */
-const Inet INET_VALUES[] = {
-  Inet::max(),
-  Inet::min(),
-  Inet("127.0.0.1"),
-  Inet("0:0:0:0:0:0:0:1"),
-  Inet("2001:db8:85a3:0:0:8a2e:370:7334")
-};
-template<> const std::vector<Inet> CassandraTypesTest<Inet>::values_(
-  INET_VALUES,
-  INET_VALUES + ARRAY_LEN(INET_VALUES));
+const Inet INET_VALUES[] = { Inet::max(), Inet::min(), Inet("127.0.0.1"), Inet("0:0:0:0:0:0:0:1"),
+                             Inet("2001:db8:85a3:0:0:8a2e:370:7334") };
+template <>
+const std::vector<Inet> CassandraTypesTest<Inet>::values_(INET_VALUES,
+                                                          INET_VALUES + ARRAY_LEN(INET_VALUES));
 
 /**
  * Values for int tests
  */
-const Integer INT_VALUES[] = {
-  Integer::max(),
-  Integer::min(),
-  Integer(0),
-  Integer(148)
-};
-template<> const std::vector<Integer> CassandraTypesTest<Integer>::values_(
-  INT_VALUES,
-  INT_VALUES + ARRAY_LEN(INT_VALUES));
+const Integer INT_VALUES[] = { Integer::max(), Integer::min(), Integer(0), Integer(148) };
+template <>
+const std::vector<Integer> CassandraTypesTest<Integer>::values_(INT_VALUES,
+                                                                INT_VALUES + ARRAY_LEN(INT_VALUES));
 
 /**
  * Values for smallint tests
  */
-const SmallInteger SMALLINT_VALUES[] = {
-  SmallInteger::max(),
-  SmallInteger::min(),
-  SmallInteger(static_cast<int16_t>(0)),
-  SmallInteger(148)
-};
-template<> const std::vector<SmallInteger> CassandraTypesTest<SmallInteger>::values_(
-  SMALLINT_VALUES,
-  SMALLINT_VALUES + ARRAY_LEN(SMALLINT_VALUES));
+const SmallInteger SMALLINT_VALUES[] = { SmallInteger::max(), SmallInteger::min(),
+                                         SmallInteger(static_cast<int16_t>(0)), SmallInteger(148) };
+template <>
+const std::vector<SmallInteger>
+    CassandraTypesTest<SmallInteger>::values_(SMALLINT_VALUES,
+                                              SMALLINT_VALUES + ARRAY_LEN(SMALLINT_VALUES));
 
 /**
  * Values for text tests
  */
-const Text TEXT_VALUES[] = {
-  Text("The quick brown fox jumps over the lazy dog"),
-  Text("Hello World"),
-  Text("DataStax C/C++ Driver")
-};
-template<> const std::vector<Text> CassandraTypesTest<Text>::values_(
-  TEXT_VALUES,
-  TEXT_VALUES + ARRAY_LEN(TEXT_VALUES));
+const Text TEXT_VALUES[] = { Text("The quick brown fox jumps over the lazy dog"),
+                             Text("Hello World"), Text("DataStax C/C++ Driver") };
+template <>
+const std::vector<Text> CassandraTypesTest<Text>::values_(TEXT_VALUES,
+                                                          TEXT_VALUES + ARRAY_LEN(TEXT_VALUES));
 
 /**
  * Values for time tests
  */
-const Time TIME_VALUES[] = {
-  Time::max(),
-  Time::min(),
-  Time(static_cast<cass_int64_t>(0)),
-  Time(9876543210)
-};
-template<> const std::vector<Time> CassandraTypesTest<Time>::values_(
-  TIME_VALUES,
-  TIME_VALUES + ARRAY_LEN(TIME_VALUES));
+const Time TIME_VALUES[] = { Time::max(), Time::min(), Time(static_cast<cass_int64_t>(0)),
+                             Time(9876543210) };
+template <>
+const std::vector<Time> CassandraTypesTest<Time>::values_(TIME_VALUES,
+                                                          TIME_VALUES + ARRAY_LEN(TIME_VALUES));
 
 /**
  * Values for timestamp tests
  */
-const Timestamp TIMESTAMP_VALUES[] = {
-  Timestamp::max(),
-  Timestamp::min(),
-  Timestamp(123),
-  Timestamp(456),
-  Timestamp(789)
-};
-template<> const std::vector<Timestamp> CassandraTypesTest<Timestamp>::values_(
-  TIMESTAMP_VALUES,
-  TIMESTAMP_VALUES + ARRAY_LEN(TIMESTAMP_VALUES));
+const Timestamp TIMESTAMP_VALUES[] = { Timestamp::max(), Timestamp::min(), Timestamp(123),
+                                       Timestamp(456), Timestamp(789) };
+template <>
+const std::vector<Timestamp>
+    CassandraTypesTest<Timestamp>::values_(TIMESTAMP_VALUES,
+                                           TIMESTAMP_VALUES + ARRAY_LEN(TIMESTAMP_VALUES));
 
 /**
  * Values for timeuuid tests
  */
-const TimeUuid TIMEUUID_VALUES[] = {
-  TimeUuid::min(),
-  TimeUuid::max(),
-  TimeUuid(values::TimeUuid::min(0)),
-  TimeUuid(values::TimeUuid::max(0)),
-  TimeUuid(values::TimeUuid::min(CASS_UINT64_MAX)),
-  TimeUuid(values::TimeUuid::max(CASS_UINT64_MAX)),
-  TimeUuid(values::TimeUuid::min(uv_hrtime())),
-  TimeUuid(values::TimeUuid::max(uv_hrtime()))
-};
-template<> const std::vector<TimeUuid> CassandraTypesTest<TimeUuid>::values_(
-  TIMEUUID_VALUES,
-  TIMEUUID_VALUES + ARRAY_LEN(TIMEUUID_VALUES));
+const TimeUuid TIMEUUID_VALUES[] = { TimeUuid::min(),
+                                     TimeUuid::max(),
+                                     TimeUuid(values::TimeUuid::min(0)),
+                                     TimeUuid(values::TimeUuid::max(0)),
+                                     TimeUuid(values::TimeUuid::min(CASS_UINT64_MAX)),
+                                     TimeUuid(values::TimeUuid::max(CASS_UINT64_MAX)),
+                                     TimeUuid(values::TimeUuid::min(uv_hrtime())),
+                                     TimeUuid(values::TimeUuid::max(uv_hrtime())) };
+template <>
+const std::vector<TimeUuid> CassandraTypesTest<TimeUuid>::values_(TIMEUUID_VALUES,
+                                                                  TIMEUUID_VALUES +
+                                                                      ARRAY_LEN(TIMEUUID_VALUES));
 
 /**
  * Values for tinyint tests
  */
-const TinyInteger TINYINT_VALUES[] = {
-  TinyInteger::max(),
-  TinyInteger::min(),
-  TinyInteger(static_cast<int8_t>(0)),
-  TinyInteger(37)
-};
-template<> const std::vector<TinyInteger> CassandraTypesTest<TinyInteger>::values_(
-  TINYINT_VALUES,
-  TINYINT_VALUES + ARRAY_LEN(TINYINT_VALUES));
+const TinyInteger TINYINT_VALUES[] = { TinyInteger::max(), TinyInteger::min(),
+                                       TinyInteger(static_cast<int8_t>(0)), TinyInteger(37) };
+template <>
+const std::vector<TinyInteger>
+    CassandraTypesTest<TinyInteger>::values_(TINYINT_VALUES,
+                                             TINYINT_VALUES + ARRAY_LEN(TINYINT_VALUES));
 
 /**
  * Values for uuid tests
  */
-const Uuid UUID_VALUES[] = {
-  Uuid::max(),
-  Uuid::min(),
-  Uuid("03398c99-c635-4fad-b30a-3b2c49f785c2"),
-  Uuid("03398c99-c635-4fad-b30a-3b2c49f785c3"),
-  Uuid("03398c99-c635-4fad-b30a-3b2c49f785c4")
-};
-template<> const std::vector<Uuid> CassandraTypesTest<Uuid>::values_(
-  UUID_VALUES,
-  UUID_VALUES + ARRAY_LEN(UUID_VALUES));
+const Uuid UUID_VALUES[] = { Uuid::max(), Uuid::min(), Uuid("03398c99-c635-4fad-b30a-3b2c49f785c2"),
+                             Uuid("03398c99-c635-4fad-b30a-3b2c49f785c3"),
+                             Uuid("03398c99-c635-4fad-b30a-3b2c49f785c4") };
+template <>
+const std::vector<Uuid> CassandraTypesTest<Uuid>::values_(UUID_VALUES,
+                                                          UUID_VALUES + ARRAY_LEN(UUID_VALUES));
 
 /**
  * Values for varchar tests
  */
-const Varchar VARCHAR_VALUES[] = {
-  Varchar("The quick brown fox jumps over the lazy dog"),
-  Varchar("Hello World"),
-  Varchar("DataStax C/C++ Driver")
-};
-template<> const std::vector<Varchar> CassandraTypesTest<Varchar>::values_(
-  VARCHAR_VALUES,
-  VARCHAR_VALUES + ARRAY_LEN(VARCHAR_VALUES));
+const Varchar VARCHAR_VALUES[] = { Varchar("The quick brown fox jumps over the lazy dog"),
+                                   Varchar("Hello World"), Varchar("DataStax C/C++ Driver") };
+template <>
+const std::vector<Varchar> CassandraTypesTest<Varchar>::values_(VARCHAR_VALUES,
+                                                                VARCHAR_VALUES +
+                                                                    ARRAY_LEN(VARCHAR_VALUES));
 
 /**
  * Values for varint tests
  */
-const Varint VARINT_VALUES[] = {
-  Varint("123456789012345678901234567890"),
-  Varint("98765432109876543210987654321098765432109876543210"),
-  Varint("0"),
-  Varint("-296")
-};
-template<> const std::vector<Varint> CassandraTypesTest<Varint>::values_(
-  VARINT_VALUES,
-  VARINT_VALUES + ARRAY_LEN(VARINT_VALUES));
+const Varint VARINT_VALUES[] = { Varint("123456789012345678901234567890"),
+                                 Varint("98765432109876543210987654321098765432109876543210"),
+                                 Varint("0"), Varint("-296") };
+template <>
+const std::vector<Varint>
+    CassandraTypesTest<Varint>::values_(VARINT_VALUES, VARINT_VALUES + ARRAY_LEN(VARINT_VALUES));
diff --git a/gtests/src/integration/tests/test_cluster.cpp b/gtests/src/integration/tests/test_cluster.cpp
index 2fc6846d4..509d024bd 100644
--- a/gtests/src/integration/tests/test_cluster.cpp
+++ b/gtests/src/integration/tests/test_cluster.cpp
@@ -26,5 +26,23 @@
 TEST(ClusterTest, SetLoadBalanceDcAwareNullLocalDc) {
   test::driver::Cluster cluster;
   EXPECT_EQ(CASS_ERROR_LIB_BAD_PARAMS,
-    cass_cluster_set_load_balance_dc_aware(cluster.get(), NULL, 99, cass_false));
+            cass_cluster_set_load_balance_dc_aware(cluster.get(), NULL, 99, cass_false));
+}
+
+/**
+ * Set invalid parameters for exponential reconnection policy.
+ *
+ * @jira_ticket CPP-745
+ * @test_category configuration
+ * @expected_result CASS_ERROR_LIB_BAD_PARAMS.
+ */
+TEST(ClusterTest, ExponentialReconnectionPolicyBadParameters) {
+  test::driver::Cluster cluster;
+
+  // Base delay must be greater than 1
+  EXPECT_EQ(CASS_ERROR_LIB_BAD_PARAMS, cass_cluster_set_exponential_reconnect(cluster.get(), 0, 1));
+  // Max delay must be greater than 1
+  EXPECT_EQ(CASS_ERROR_LIB_BAD_PARAMS, cass_cluster_set_exponential_reconnect(cluster.get(), 1, 0));
+  // Base delay cannot be greater than max delay
+  EXPECT_EQ(CASS_ERROR_LIB_BAD_PARAMS, cass_cluster_set_exponential_reconnect(cluster.get(), 3, 2));
 }
diff --git a/gtests/src/integration/tests/test_config.cpp b/gtests/src/integration/tests/test_config.cpp
index 66a1af7c3..5df00665e 100644
--- a/gtests/src/integration/tests/test_config.cpp
+++ b/gtests/src/integration/tests/test_config.cpp
@@ -22,26 +22,24 @@
 #include "objects/cluster.hpp"
 
 TEST(ConfigTest, Options) {
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_connect_timeout(9999u)
-                                  .with_port(7000);
-  EXPECT_EQ(9999u,
-            test::driver::internals::Utils::connect_timeout(cluster.get()));
+  test::driver::Cluster cluster =
+      test::driver::Cluster::build().with_connect_timeout(9999u).with_port(7000);
+  EXPECT_EQ(9999u, test::driver::internals::Utils::connect_timeout(cluster.get()));
   EXPECT_EQ(7000, test::driver::internals::Utils::port(cluster.get()));
 }
 
 TEST(ConfigTest, ContactPointsSimple) {
   std::string contact_points = "127.0.0.1,127.0.0.2,127.0.0.3";
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_contact_points(contact_points);
+  test::driver::Cluster cluster =
+      test::driver::Cluster::build().with_contact_points(contact_points);
   EXPECT_STREQ(contact_points.c_str(),
                test::driver::internals::Utils::contact_points(cluster.get()).c_str());
 }
 
 TEST(ConfigTest, ContactPointsClear) {
   std::string contact_points = "127.0.0.1,127.0.0.2,127.0.0.3";
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_contact_points(contact_points);
+  test::driver::Cluster cluster =
+      test::driver::Cluster::build().with_contact_points(contact_points);
   EXPECT_STREQ(contact_points.c_str(),
                test::driver::internals::Utils::contact_points(cluster.get()).c_str());
   cluster.with_contact_points("");
@@ -50,25 +48,24 @@ TEST(ConfigTest, ContactPointsClear) {
 
 TEST(ConfigTest, ContactPointsExtraCommas) {
   std::string contact_points = ",,,,127.0.0.1,,,,127.0.0.2,127.0.0.3,,,,";
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_contact_points(contact_points);
+  test::driver::Cluster cluster =
+      test::driver::Cluster::build().with_contact_points(contact_points);
   EXPECT_STREQ("127.0.0.1,127.0.0.2,127.0.0.3",
                test::driver::internals::Utils::contact_points(cluster.get()).c_str());
 }
 
 TEST(ConfigTest, ContactPointsExtraWhitespace) {
-  std::string contact_points = "   ,\r\n,  ,   ,  127.0.0.1 ,,,  ,\t127.0.0.2,127.0.0.3,  \t\n, ,,   ";
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_contact_points(contact_points);
+  std::string contact_points =
+      "   ,\r\n,  ,   ,  127.0.0.1 ,,,  ,\t127.0.0.2,127.0.0.3,  \t\n, ,,   ";
+  test::driver::Cluster cluster =
+      test::driver::Cluster::build().with_contact_points(contact_points);
   EXPECT_STREQ("127.0.0.1,127.0.0.2,127.0.0.3",
                test::driver::internals::Utils::contact_points(cluster.get()).c_str());
 }
 
 TEST(ConfigTest, ContactPointsAppend) {
-  test::driver::Cluster cluster = test::driver::Cluster::build()
-                                  .with_contact_points("127.0.0.1");
-  EXPECT_STREQ("127.0.0.1",
-               test::driver::internals::Utils::contact_points(cluster.get()).c_str());
+  test::driver::Cluster cluster = test::driver::Cluster::build().with_contact_points("127.0.0.1");
+  EXPECT_STREQ("127.0.0.1", test::driver::internals::Utils::contact_points(cluster.get()).c_str());
   cluster.with_contact_points("127.0.0.2");
   EXPECT_STREQ("127.0.0.1,127.0.0.2",
                test::driver::internals::Utils::contact_points(cluster.get()).c_str());
diff --git a/gtests/src/integration/tests/test_consistency.cpp b/gtests/src/integration/tests/test_consistency.cpp
index 50477d9ee..dab704176 100644
--- a/gtests/src/integration/tests/test_consistency.cpp
+++ b/gtests/src/integration/tests/test_consistency.cpp
@@ -21,23 +21,20 @@
  */
 class ConsistencyTwoNodeClusterTests : public Integration {
 public:
-  ConsistencyTwoNodeClusterTests() {
-    number_dc1_nodes_ = 2;
-  }
+  ConsistencyTwoNodeClusterTests() { number_dc1_nodes_ = 2; }
 
   virtual void SetUp() {
     // Call the parent setup function
     Integration::SetUp();
 
     // Create the table, insert and select statements for the test (with values)
-    session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT,
-                     table_name_.c_str(), "int", "int"));
-    insert_ = Statement(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT,
-                        table_name_.c_str(), "?", "?"), 2);
+    session_.execute(
+        format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "int"));
+    insert_ = Statement(
+        format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "?", "?"), 2);
     insert_.bind<Integer>(0, Integer(0));
     insert_.bind<Integer>(1, Integer(1));
-    select_ = Statement(format_string(CASSANDRA_SELECT_VALUE_FORMAT,
-                        table_name_.c_str(), "?"), 1);
+    select_ = Statement(format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), "?"), 1);
     select_.bind<Integer>(0, Integer(0));
   }
 
@@ -103,10 +100,8 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleLocalTwo) {
   select_.set_consistency(CASS_CONSISTENCY_TWO);
 
   // Perform insert and select operations (should fail: N=2, RF=1)
-  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE,
-            session_.execute(insert_, false).error_code());
-  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE,
-            session_.execute(select_, false).error_code());
+  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE, session_.execute(insert_, false).error_code());
+  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE, session_.execute(select_, false).error_code());
 }
 
 /**
@@ -127,10 +122,8 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleLocalThree) {
   select_.set_consistency(CASS_CONSISTENCY_THREE);
 
   // Perform insert and select operations (should fail: N=2, RF=1)
-  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE,
-            session_.execute(insert_, false).error_code());
-  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE,
-            session_.execute(select_, false).error_code());
+  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE, session_.execute(insert_, false).error_code());
+  ASSERT_EQ(CASS_ERROR_SERVER_UNAVAILABLE, session_.execute(select_, false).error_code());
 }
 
 /**
@@ -153,8 +146,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleAny) {
 
   // Perform insert and select operations (NOTE: `ANY` is for writes only)
   session_.execute(insert_);
-  ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-            session_.execute(select_, false).error_code());
+  ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(select_, false).error_code());
 }
 
 /**
@@ -166,7 +158,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleAny) {
  * @test_category consistency
  * @since core:1.0.0
  * @expected_result Successful insert and select using consistency
-  *                 `LOCAL_QUORUM`
+ *                 `LOCAL_QUORUM`
  */
 CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleLocalQuorum) {
   CHECK_FAILURE;
@@ -192,7 +184,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleLocalQuorum)
  * @since core:1.0.0
  * @expected_result Successful insert and failed select using consistency
  *                  `EACH_QUORUM` (Successful select using Cassandra v3.0.0+;
-  *                 see CASSANDRA-9602)
+ *                 see CASSANDRA-9602)
  */
 CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleEachQuorum) {
   CHECK_FAILURE;
@@ -209,8 +201,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleEachQuorum) {
   if (server_version_ >= "3.0.0") {
     session_.execute(select_);
   } else {
-    ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-              session_.execute(select_, false).error_code());
+    ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(select_, false).error_code());
   }
 }
 
@@ -229,8 +220,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyTwoNodeClusterTests, SimpleEachQuorum) {
  *                  Failed insert and select using multiple consistencies:
  *                  `ALL` (after decommission) and `THREE`
  */
-CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests,
-                             OneNodeDecommissioned) {
+CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests, OneNodeDecommissioned) {
   CHECK_FAILURE;
 
   // Perform a sanity check against a full healthy cluster (N=3, RF=3)
@@ -288,8 +278,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests,
  *                  Failed insert and select using multiple consistencies:
  *                  `ALL` (after decommission), `QUORUM`, `TWO`, and `THREE`
  */
-CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests,
-                             TwoNodesDecommissioned) {
+CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests, TwoNodesDecommissioned) {
   CHECK_FAILURE;
 
   // Perform a sanity check against a full healthy cluster (N=3, RF=3)
@@ -347,8 +336,7 @@ CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests,
  * @expected_result Successful insert and select using multiple consistencies
  *                  with the downgrading retry policy applied
  */
-CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests,
-                             DowngradingRetryPolicy) {
+CASSANDRA_INTEGRATION_TEST_F(ConsistencyThreeNodeClusterTests, DowngradingRetryPolicy) {
   CHECK_FAILURE;
 
   // Create a new session to utilize the downgrading retry policy
diff --git a/gtests/src/integration/tests/test_control_connection.cpp b/gtests/src/integration/tests/test_control_connection.cpp
index e451e0ff9..f10934d63 100644
--- a/gtests/src/integration/tests/test_control_connection.cpp
+++ b/gtests/src/integration/tests/test_control_connection.cpp
@@ -37,8 +37,7 @@ class ControlConnectionTests : public Integration {
    * @param session Session to execute the requests with
    * @param expected_nodes The nodes that
    */
-  void check_hosts(Session session,
-                   const std::set<unsigned short>& expected_nodes) {
+  void check_hosts(Session session, const std::set<unsigned short>& expected_nodes) {
     // Execute multiple requests and store the hosts used
     std::set<std::string> hosts;
     for (size_t i = 0; i < (expected_nodes.size() + 2); ++i) {
@@ -48,8 +47,8 @@ class ControlConnectionTests : public Integration {
         std::string host = result.host();
         if (!host.empty()) hosts.insert(host);
       } else {
-        TEST_LOG_ERROR("Failed to query host:" << result.error_message()
-          << "[" << result.error_code() << "]");
+        TEST_LOG_ERROR("Failed to query host:" << result.error_message() << "["
+                                               << result.error_code() << "]");
       }
     }
 
@@ -71,12 +70,10 @@ class ControlConnectionTests : public Integration {
    * @param nodes List of nodes to listen for
    * @param suffix Message suffix for logger criteria (optional)
    */
-  void reset_logger_criteria(const std::string& prefix,
-                             const std::set<unsigned short>& nodes,
+  void reset_logger_criteria(const std::string& prefix, const std::set<unsigned short>& nodes,
                              const std::string& suffix = "") {
     logger_.reset();
-    for (std::set<unsigned short>::const_iterator it = nodes.begin();
-         it != nodes.end(); ++it) {
+    for (std::set<unsigned short>::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
       std::stringstream node_ip_address;
       node_ip_address << ccm_->get_ip_prefix() << *it;
       logger_.add_critera(prefix + node_ip_address.str() + suffix);
@@ -89,9 +86,7 @@ class ControlConnectionTests : public Integration {
  */
 class ControlConnectionTwoNodeClusterTests : public ControlConnectionTests {
 public:
-  ControlConnectionTwoNodeClusterTests() {
-    number_dc1_nodes_ = 2;
-  }
+  ControlConnectionTwoNodeClusterTests() { number_dc1_nodes_ = 2; }
 };
 
 /**
@@ -99,9 +94,7 @@ class ControlConnectionTwoNodeClusterTests : public ControlConnectionTests {
  */
 class ControlConnectionThreeNodeClusterTests : public ControlConnectionTests {
 public:
-  ControlConnectionThreeNodeClusterTests() {
-    number_dc1_nodes_ = 3;
-  }
+  ControlConnectionThreeNodeClusterTests() { number_dc1_nodes_ = 3; }
 };
 
 /**
@@ -109,17 +102,14 @@ class ControlConnectionThreeNodeClusterTests : public ControlConnectionTests {
  */
 class ControlConnectionFourNodeClusterTests : public ControlConnectionTests {
 public:
-  ControlConnectionFourNodeClusterTests() {
-    number_dc1_nodes_ = 4;
-  }
+  ControlConnectionFourNodeClusterTests() { number_dc1_nodes_ = 4; }
 };
 
 /**
  * Control connection integration tests; two data centers with a single node
  * each
  */
-class ControlConnectionSingleNodeDataCentersClusterTests
-    : public ControlConnectionTests {
+class ControlConnectionSingleNodeDataCentersClusterTests : public ControlConnectionTests {
 public:
   ControlConnectionSingleNodeDataCentersClusterTests() {
     number_dc1_nodes_ = 1;
@@ -138,13 +128,12 @@ class ControlConnectionSingleNodeDataCentersClusterTests
  * @since core:1.0.0
  * @expected_result Control connection will not be established
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
-                             ConnectUsingInvalidIpAddress) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, ConnectUsingInvalidIpAddress) {
   CHECK_FAILURE;
 
   // Attempt to connect to the server using an invalid IP address
-  logger_.add_critera("Unable to establish a control connection to host " \
-                      "1.1.1.1 because of the following error: Underlying " \
+  logger_.add_critera("Unable to establish a control connection to host "
+                      "1.1.1.1 because of the following error: Underlying "
                       "connection error: Connection timeout");
   Cluster cluster = Cluster::build().with_contact_points("1.1.1.1");
   try {
@@ -191,8 +180,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, ConnectUsingInvalidPort) {
  * @since core:1.0.0
  * @expected_result Control connection will not be established
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
-                             ConnectUsingUnresolvableLocalIpAddress) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, ConnectUsingUnresolvableLocalIpAddress) {
   CHECK_FAILURE;
 
   // Attempt to connect to the server using an unresolvable local IP address
@@ -212,8 +200,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
  * @since core:1.0.0
  * @expected_result Control connection will not be established
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
-                             ConnectUsingUnbindableLocalIpAddress) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, ConnectUsingUnbindableLocalIpAddress) {
   CHECK_FAILURE;
 
   // Attempt to connect to the server using an unbindable local IP address
@@ -247,10 +234,9 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
   // Attempt to connect to the server using an valid local IP address
   // but invalid remote address. The specified remote is not routable
   // from the specified local.
-  logger_.add_critera("Unable to establish a control connection to host " \
+  logger_.add_critera("Unable to establish a control connection to host "
                       "1.1.1.1 because of the following error:");
-  Cluster cluster = Cluster::build().with_contact_points("1.1.1.1")
-                    .with_local_address("127.0.0.1");
+  Cluster cluster = Cluster::build().with_contact_points("1.1.1.1").with_local_address("127.0.0.1");
   try {
     cluster.connect();
     FAIL() << "Connection was established using invalid IP address";
@@ -278,8 +264,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
  * @expected_result Control connection will reconnect to each node active in the
  *                  cluster
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
-                             Reconnection) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests, Reconnection) {
   CHECK_FAILURE;
   is_test_chaotic_ = true; // Destroy the cluster after the test completes
 
@@ -288,9 +273,8 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
    * and ensure only the first node is used as the contact point for automatic
    * node discovery of the second node
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin()
-                    .with_contact_points(generate_contact_points(ccm_->get_ip_prefix(), 1));
+  Cluster cluster = default_cluster().with_load_balance_round_robin().with_contact_points(
+      generate_contact_points(ccm_->get_ip_prefix(), 1));
   Session session = cluster.connect();
 
   // Stop the first node and bootstrap a third node into the cluster
@@ -330,8 +314,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, TopologyChange) {
    * Create a new session connection using the round robin load balancing policy
    * to ensure all nodes can be accessed during request execution
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin();
+  Cluster cluster = default_cluster().with_load_balance_round_robin();
   Session session = cluster.connect();
 
   // Bootstrap a second node and ensure all hosts are actively used
@@ -365,17 +348,15 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, TopologyChange) {
  * @expected_result Control connection will update status of stopped and started
  *                  node
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
-                             StatusChange) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests, StatusChange) {
   CHECK_FAILURE;
 
   /*
    * Create a new session connection using the round robin load balancing policy
    * to ensure all nodes can be accessed during request execution
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin()
-                    .with_reconnect_wait_time(10); // Ensure reconnect timeout is quick
+  Cluster cluster = default_cluster().with_load_balance_round_robin().with_constant_reconnect(
+      10); // Ensure reconnect timeout is quick
   Session session = cluster.connect();
 
   // Ensure all hosts are actively used
@@ -412,8 +393,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
  * @since core:1.0.0
  * @expected_result Control connection will automatically discover other nodes
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
-                             NodeDiscovery) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests, NodeDiscovery) {
   CHECK_FAILURE;
 
   /*
@@ -421,9 +401,8 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
    * and ensure only the first node is used as the contact point for automatic
    * node discovery
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin()
-                    .with_contact_points(generate_contact_points(ccm_->get_ip_prefix(), 1));
+  Cluster cluster = default_cluster().with_load_balance_round_robin().with_contact_points(
+      generate_contact_points(ccm_->get_ip_prefix(), 1));
   Session session = cluster.connect();
 
   // Ensure all hosts are actively used
@@ -461,10 +440,11 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
   logger_.add_critera("to host 192.0.2.2 closed");
   logger_.add_critera("to host 192.0.2.3 closed");
   Cluster cluster = default_cluster(false) // Do not add the default contact points
-                    .with_load_balance_round_robin()
-                    .with_contact_points(generate_contact_points("192.0.2.", 3)) // Invalid IPs
-                    .with_contact_points(generate_contact_points(ccm_->get_ip_prefix(), 1)) // Single valid contact point
-                    .with_connect_timeout(1000u); // Handle initial invalid IPs
+                        .with_load_balance_round_robin()
+                        .with_contact_points(generate_contact_points("192.0.2.", 3)) // Invalid IPs
+                        .with_contact_points(generate_contact_points(
+                            ccm_->get_ip_prefix(), 1)) // Single valid contact point
+                        .with_connect_timeout(1000u);  // Handle initial invalid IPs
   Session session = cluster.connect();
 
   // Ensure the invalid IPs were not reached
@@ -491,8 +471,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
  * @since core:1.0.0
  * @expected_result Control connection will automatically discover other nodes
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
-                             NodeDiscoveryNoLocalRows) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests, NodeDiscoveryNoLocalRows) {
   CHECK_FAILURE;
 
   /*
@@ -500,9 +479,8 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
    * and ensure only the first node is used as the contact point for automatic
    * node discovery
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin()
-                    .with_contact_points(generate_contact_points(ccm_->get_ip_prefix(), 1));
+  Cluster cluster = default_cluster().with_load_balance_round_robin().with_contact_points(
+      generate_contact_points(ccm_->get_ip_prefix(), 1));
   Session session = cluster.connect();
 
   // Delete the `local` row from the system table (control connection info)
@@ -529,17 +507,15 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
  * @since core:1.0.0
  * @expected_result Control connection will automatically discover other nodes
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
-                             NodeDiscoveryNoRpcAddress) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests, NodeDiscoveryNoRpcAddress) {
   CHECK_FAILURE;
   is_test_chaotic_ = true; // Destroy the cluster after the test completes
 
   // Remove the `rpc_address` from the third node in the system table
   connect(); // Create the default session
   std::stringstream update_system_table;
-  update_system_table
-      << "UPDATE system.peers SET rpc_address = null WHERE peer = '"
-      << ccm_->get_ip_prefix() << "3'";
+  update_system_table << "UPDATE system.peers SET rpc_address = null WHERE peer = '"
+                      << ccm_->get_ip_prefix() << "3'";
   for (int i = 0; i < 3; ++i) { // Ensure all the nodes in the cluster are updated
     session_.execute(update_system_table.str());
   }
@@ -549,9 +525,8 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
    * and ensure only the first node is used as the contact point for automatic
    * node discovery
    */
-  Cluster cluster = default_cluster(false)
-                    .with_load_balance_round_robin()
-                    .with_contact_points(generate_contact_points(ccm_->get_ip_prefix(), 1));
+  Cluster cluster = default_cluster(false).with_load_balance_round_robin().with_contact_points(
+      generate_contact_points(ccm_->get_ip_prefix(), 1));
   Session session = cluster.connect();
 
   // Ensure nodes one and two are actively used
@@ -577,15 +552,13 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionThreeNodeClusterTests,
  *                  fail during full cluster outage and request will succeed
  *                  after cluster is restarted
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
-                             FullOutage) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, FullOutage) {
   CHECK_FAILURE;
   connect(); // Create the default session
 
   // Stop the cluster and attempt to perform a request
   ccm_->stop_cluster();
-  Result result = session_.execute(SELECT_ALL_SYSTEM_LOCAL_CQL,
-                                   CASS_CONSISTENCY_ONE, false, false);
+  Result result = session_.execute(SELECT_ALL_SYSTEM_LOCAL_CQL, CASS_CONSISTENCY_ONE, false, false);
   ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, result.error_code());
 
   // Update logger criteria to wait for nodes to reconnect
@@ -599,7 +572,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
   // Restart the cluster and wait for the nodes to reconnect
   ccm_->start_cluster();
   ASSERT_TRUE(wait_for_logger(nodes.size()));
-  msleep(3000); //TODO: Remove static sleep and check driver logs for reduced wait
+  msleep(3000); // TODO: Remove static sleep and check driver logs for reduced wait
 
   // Ensure all nodes are actively used
   std::set<unsigned short> expected_nodes;
@@ -622,12 +595,11 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
  * @expected_result Driver will not attempt to reconnect to a decommissioned
  *                  node
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
-                             NodeDecommission) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests, NodeDecommission) {
   CHECK_FAILURE;
   connect(); // Create the default session
 
-  //Ensure all hosts are actively used
+  // Ensure all hosts are actively used
   std::set<unsigned short> expected_nodes;
   expected_nodes.insert(1);
   expected_nodes.insert(2);
@@ -638,11 +610,10 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
    * attempted by waiting a period of time
    */
   logger_.reset();
-  logger_.add_critera("Spawning new connection to host "
-                      + ccm_->get_ip_prefix() + "1");
+  logger_.add_critera("Spawning new connection to host " + ccm_->get_ip_prefix() + "1");
   force_decommission_node(1);
   TEST_LOG("Node Decommissioned [" << ccm_->get_ip_prefix() << "1]: Sleeping "
-           << "for 30 seconds");
+                                   << "for 30 seconds");
   msleep(30000u);
   ASSERT_EQ(0u, logger_.count());
 }
@@ -659,22 +630,20 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTwoNodeClusterTests,
  * @expected_result Driver will randomize contact points when establishing a
  *                  connection
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionFourNodeClusterTests,
-                             RandomizedContactPoints) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionFourNodeClusterTests, RandomizedContactPoints) {
   CHECK_FAILURE;
 
   // Create a cluster object using randomized contact points
-  Cluster cluster = default_cluster()
-                    .with_load_balance_round_robin()
-                    .with_randomized_contact_points(true);
+  Cluster cluster =
+      default_cluster().with_load_balance_round_robin().with_randomized_contact_points(true);
 
   // Establish a connect and ensure the first established host is not node 1
   Session session;
   std::string node_1_ip_address = ccm_->get_ip_prefix() + "1";
   std::string starting_host = node_1_ip_address;
   start_timer();
-  while(starting_host.compare(node_1_ip_address) == 0
-        && elapsed_time() < 5000u) { // Allow five seconds to ensure node 1 is not the starting host
+  while (starting_host.compare(node_1_ip_address) == 0 &&
+         elapsed_time() < 5000u) { // Allow five seconds to ensure node 1 is not the starting host
     // Connect to the cluster and determine the executing host
     session = cluster.connect();
     starting_host = session.execute(SELECT_ALL_SYSTEM_LOCAL_CQL).host();
@@ -690,14 +659,12 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionFourNodeClusterTests,
     expected_host << ccm_->get_ip_prefix() << current_node;
 
     // Ensure the next host is the expected host
-    std::string current_host =
-        session.execute(SELECT_ALL_SYSTEM_LOCAL_CQL).host();
+    std::string current_host = session.execute(SELECT_ALL_SYSTEM_LOCAL_CQL).host();
     ASSERT_STREQ(expected_host.str().c_str(), current_host.c_str());
   }
 
   // Ensure the next host is the starting host
-  ASSERT_STREQ(starting_host.c_str(),
-               session.execute(SELECT_ALL_SYSTEM_LOCAL_CQL).host().c_str());
+  ASSERT_STREQ(starting_host.c_str(), session.execute(SELECT_ALL_SYSTEM_LOCAL_CQL).host().c_str());
 }
 
 /**
@@ -722,15 +689,14 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionSingleNodeDataCentersClusterTests,
    * Create a new session connection using the data center aware load balancing
    * policy
    */
-  Cluster cluster = default_cluster()
-                    .with_load_balance_dc_aware("invalid_data_center", 0, false);
+  Cluster cluster = default_cluster().with_load_balance_dc_aware("invalid_data_center", 0, false);
   try {
     Session session = cluster.connect();
     FAIL() << "Connection was established using invalid data center";
   } catch (Session::Exception& se) {
     ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, se.error_code());
-    ASSERT_STREQ("No hosts available for the control connection using the " \
-                 "DC-aware load balancing policy. Check to see if the " \
+    ASSERT_STREQ("No hosts available for the control connection using the "
+                 "DC-aware load balancing policy. Check to see if the "
                  "configured local datacenter is valid",
                  se.error_message().c_str());
   }
@@ -753,8 +719,7 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionSingleNodeDataCentersClusterTests,
  * @expected_result Driver will not hang and session/control connection will
  *                  terminate with error
  */
-CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
-                             TerminatedUsingMultipleIoThreadsWithError) {
+CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests, TerminatedUsingMultipleIoThreadsWithError) {
   CHECK_FAILURE;
   std::string inavlid_keyspace_name = "invalid_keyspace";
 
@@ -774,7 +739,6 @@ CASSANDRA_INTEGRATION_TEST_F(ControlConnectionTests,
     expected_message << "Built token map";
     logger_.add_critera(expected_message.str());
 
-
     // Create a new session connection using increasing number of I/O threads
     Cluster cluster = default_cluster().with_num_threads_io(i);
     try {
diff --git a/gtests/src/integration/tests/test_custom_payload.cpp b/gtests/src/integration/tests/test_custom_payload.cpp
index a840e9780..ae72c24ce 100644
--- a/gtests/src/integration/tests/test_custom_payload.cpp
+++ b/gtests/src/integration/tests/test_custom_payload.cpp
@@ -33,7 +33,8 @@ class CustomPayloadTests : public Integration {
     }
 
     // Restart the cluster with the appropriate JVM arguments and establish connection
-    ccm_->start_cluster("-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler");
+    ccm_->start_cluster("-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3."
+                        "CustomPayloadMirroringQueryHandler");
     connect();
   }
 };
diff --git a/gtests/src/integration/tests/test_dc_aware_policy.cpp b/gtests/src/integration/tests/test_dc_aware_policy.cpp
index ec18da175..0281b1bb4 100644
--- a/gtests/src/integration/tests/test_dc_aware_policy.cpp
+++ b/gtests/src/integration/tests/test_dc_aware_policy.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include "integration.hpp"
 #include "cassandra.h"
+#include "integration.hpp"
 
 #include <algorithm>
 #include <iterator>
@@ -31,9 +31,12 @@ class DcAwarePolicyTest : public Integration {
   }
 
   void initialize() {
-    session_.execute(format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "text"));
-    session_.execute(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "1", "'one'"));
-    session_.execute(format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "2", "'two'"));
+    session_.execute(
+        format_string(CASSANDRA_KEY_VALUE_TABLE_FORMAT, table_name_.c_str(), "int", "text"));
+    session_.execute(
+        format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "1", "'one'"));
+    session_.execute(
+        format_string(CASSANDRA_KEY_VALUE_INSERT_FORMAT, table_name_.c_str(), "2", "'two'"));
   }
 
   std::vector<std::string> validate() {
@@ -54,7 +57,8 @@ class DcAwarePolicyTest : public Integration {
   }
 
   Statement select_statement(const std::string& key) {
-    Statement statement(format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), key.c_str()));
+    Statement statement(
+        format_string(CASSANDRA_SELECT_VALUE_FORMAT, table_name_.c_str(), key.c_str()));
     statement.set_consistency(CASS_CONSISTENCY_ONE);
     statement.set_record_attempted_hosts(true);
     return statement;
@@ -91,10 +95,12 @@ CASSANDRA_INTEGRATION_TEST_F(DcAwarePolicyTest, UsedHostsRemoteDc) {
     std::vector<std::string> attempted_hosts = validate();
 
     // Verify that local DC hosts were used
-    EXPECT_TRUE(contains(ccm_->get_ip_prefix() + "1", attempted_hosts) || contains(ccm_->get_ip_prefix() + "2", attempted_hosts));
+    EXPECT_TRUE(contains(ccm_->get_ip_prefix() + "1", attempted_hosts) ||
+                contains(ccm_->get_ip_prefix() + "2", attempted_hosts));
 
     // Verify that no remote DC hosts were used
-    EXPECT_TRUE(!contains(ccm_->get_ip_prefix() + "3", attempted_hosts) && !contains(ccm_->get_ip_prefix() + "4", attempted_hosts));
+    EXPECT_TRUE(!contains(ccm_->get_ip_prefix() + "3", attempted_hosts) &&
+                !contains(ccm_->get_ip_prefix() + "4", attempted_hosts));
   }
 
   // Stop the whole local DC
@@ -105,9 +111,11 @@ CASSANDRA_INTEGRATION_TEST_F(DcAwarePolicyTest, UsedHostsRemoteDc) {
     std::vector<std::string> attempted_hosts = validate();
 
     // Verify that remote DC hosts were used
-    EXPECT_TRUE(contains(ccm_->get_ip_prefix() + "3", attempted_hosts) || contains(ccm_->get_ip_prefix() + "4", attempted_hosts));
+    EXPECT_TRUE(contains(ccm_->get_ip_prefix() + "3", attempted_hosts) ||
+                contains(ccm_->get_ip_prefix() + "4", attempted_hosts));
 
     // Verify that no local DC hosts where used
-    EXPECT_TRUE(!contains(ccm_->get_ip_prefix() + "1", attempted_hosts) && !contains(ccm_->get_ip_prefix() + "2", attempted_hosts));
+    EXPECT_TRUE(!contains(ccm_->get_ip_prefix() + "1", attempted_hosts) &&
+                !contains(ccm_->get_ip_prefix() + "2", attempted_hosts));
   }
 }
diff --git a/gtests/src/integration/tests/test_exec_profile.cpp b/gtests/src/integration/tests/test_exec_profile.cpp
index d8c56a2ce..ec565f2c8 100644
--- a/gtests/src/integration/tests/test_exec_profile.cpp
+++ b/gtests/src/integration/tests/test_exec_profile.cpp
@@ -24,10 +24,10 @@
 class ExecutionProfileTest : public Integration {
 public:
   ExecutionProfileTest()
-    : insert_(NULL)
-    , child_retry_policy_(IgnoreRetryPolicy::policy()) // Used for counting retry
-    , logging_retry_policy_(child_retry_policy_)
-    , skip_base_execution_profile_(false) {
+      : insert_(NULL)
+      , child_retry_policy_(IgnoreRetryPolicy::policy()) // Used for counting retry
+      , logging_retry_policy_(child_retry_policy_)
+      , skip_base_execution_profile_(false) {
     replication_factor_ = 2;
     number_dc1_nodes_ = 2;
     is_beta_protocol_ = false; // Issue with beta protocol v5 and functions on Cassandra v3.10.0+
@@ -40,33 +40,40 @@ class ExecutionProfileTest : public Integration {
     // Create the execution profiles for the test cases
     if (!skip_base_execution_profile_) {
       profiles_["request_timeout"] = ExecutionProfile::build().with_request_timeout(1);
-      profiles_["consistency"] = ExecutionProfile::build().with_consistency(CASS_CONSISTENCY_SERIAL);
-      profiles_["serial_consistency"] = ExecutionProfile::build().with_serial_consistency(CASS_CONSISTENCY_ONE);
-      profiles_["round_robin"] = ExecutionProfile::build().with_load_balance_round_robin()
-                                                          .with_token_aware_routing(false);
-      profiles_["latency_aware"] = ExecutionProfile::build().with_latency_aware_routing()
-                                                            .with_load_balance_round_robin();
-      profiles_["token_aware"] = ExecutionProfile::build().with_token_aware_routing()
-                                                          .with_load_balance_round_robin();
-      profiles_["blacklist"] = ExecutionProfile::build().with_blacklist_filtering(Options::host_prefix() + "1")
-                                                        .with_load_balance_round_robin();
-      profiles_["whitelist"] = ExecutionProfile::build().with_whitelist_filtering(Options::host_prefix() + "1")
-                                                        .with_load_balance_round_robin();
-      profiles_["retry_policy"] = ExecutionProfile::build().with_retry_policy(logging_retry_policy_)
-                                                           .with_consistency(CASS_CONSISTENCY_THREE);
-      profiles_["speculative_execution"] = ExecutionProfile::build().with_constant_speculative_execution_policy(100, 20);
+      profiles_["consistency"] =
+          ExecutionProfile::build().with_consistency(CASS_CONSISTENCY_SERIAL);
+      profiles_["serial_consistency"] =
+          ExecutionProfile::build().with_serial_consistency(CASS_CONSISTENCY_ONE);
+      profiles_["round_robin"] =
+          ExecutionProfile::build().with_load_balance_round_robin().with_token_aware_routing(false);
+      profiles_["latency_aware"] =
+          ExecutionProfile::build().with_latency_aware_routing().with_load_balance_round_robin();
+      profiles_["token_aware"] =
+          ExecutionProfile::build().with_token_aware_routing().with_load_balance_round_robin();
+      profiles_["blacklist"] = ExecutionProfile::build()
+                                   .with_blacklist_filtering(Options::host_prefix() + "1")
+                                   .with_load_balance_round_robin();
+      profiles_["whitelist"] = ExecutionProfile::build()
+                                   .with_whitelist_filtering(Options::host_prefix() + "1")
+                                   .with_load_balance_round_robin();
+      profiles_["retry_policy"] = ExecutionProfile::build()
+                                      .with_retry_policy(logging_retry_policy_)
+                                      .with_consistency(CASS_CONSISTENCY_THREE);
+      profiles_["speculative_execution"] =
+          ExecutionProfile::build().with_constant_speculative_execution_policy(100, 20);
     }
 
     // Call the parent setup function
     Integration::SetUp();
 
     // Create the table
-    session_.execute(format_string("CREATE TABLE %s (key text PRIMARY KEY, value int)",
-                     table_name_.c_str()));
+    session_.execute(
+        format_string("CREATE TABLE %s (key text PRIMARY KEY, value int)", table_name_.c_str()));
 
     // Create the insert statement for later use
     insert_ = Statement(format_string("INSERT INTO %s (key, value) VALUES (?, ?) IF NOT EXISTS",
-                                      table_name_.c_str()), 2);
+                                      table_name_.c_str()),
+                        2);
     insert_.bind<Text>(0, Text(test_name_));
     insert_.bind<Integer>(1, Integer(1000));
 
@@ -159,8 +166,7 @@ class ExecutionProfileTest : public Integration {
       std::set<Text> tokens = row.next().as<Set<Text> >().value();
 
       // Iterate over the tokens and update the token/host mapping
-      for (std::set<Text>::const_iterator it = tokens.begin();
-           it != tokens.end(); ++it) {
+      for (std::set<Text>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {
         int64_t token = 0;
         std::stringstream token_value(it->value());
         if ((token_value >> token).fail()) {
@@ -177,20 +183,21 @@ class ExecutionProfileTest : public Integration {
  */
 class DCExecutionProfileTest : public ExecutionProfileTest {
 public:
-  DCExecutionProfileTest() {
-    number_dc2_nodes_ = 1;
-  }
+  DCExecutionProfileTest() { number_dc2_nodes_ = 1; }
 
   void SetUp() {
     // Create the execution profiles for the test cases
-    profiles_["dc_aware"] = ExecutionProfile::build().with_load_balance_dc_aware("dc1", 1, false)
-                                                     .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
-    profiles_["blacklist_dc"] = ExecutionProfile::build().with_blacklist_dc_filtering("dc1")
-                                                         .with_load_balance_dc_aware("dc1", 1, true)
-                                                         .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
-    profiles_["whitelist_dc"] = ExecutionProfile::build().with_whitelist_dc_filtering("dc2")
-                                                         .with_load_balance_dc_aware("dc1", 1, true)
-                                                         .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
+    profiles_["dc_aware"] = ExecutionProfile::build()
+                                .with_load_balance_dc_aware("dc1", 1, false)
+                                .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
+    profiles_["blacklist_dc"] = ExecutionProfile::build()
+                                    .with_blacklist_dc_filtering("dc1")
+                                    .with_load_balance_dc_aware("dc1", 1, true)
+                                    .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
+    profiles_["whitelist_dc"] = ExecutionProfile::build()
+                                    .with_whitelist_dc_filtering("dc2")
+                                    .with_load_balance_dc_aware("dc1", 1, true)
+                                    .with_consistency(CASS_CONSISTENCY_LOCAL_ONE);
 
     // Call the parent setup function
     skip_base_execution_profile_ = true;
@@ -296,14 +303,14 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, Consistency) {
   result = session_.execute(batch, false);
   ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code());
   ASSERT_TRUE(contains(result.error_message(),
-              "SERIAL is not supported as conditional update commit consistency"));
+                       "SERIAL is not supported as conditional update commit consistency"));
 
   // Execute a simple query with assigned profile (should fail)
   insert_.set_execution_profile("consistency");
   result = session_.execute(insert_, false);
   ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code());
   ASSERT_TRUE(contains(result.error_message(),
-              "SERIAL is not supported as conditional update commit consistency"));
+                       "SERIAL is not supported as conditional update commit consistency"));
 }
 
 /**
@@ -328,15 +335,17 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, SerialConsistency) {
   batch.set_execution_profile("serial_consistency");
   Result result = session_.execute(batch, false);
   ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code());
-  ASSERT_TRUE(contains(result.error_message(),
-              "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL"));
+  ASSERT_TRUE(contains(
+      result.error_message(),
+      "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL"));
 
   // Execute a simple query with assigned profile (should fail)
   insert_.set_execution_profile("serial_consistency");
   result = session_.execute(insert_, false);
   ASSERT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, result.error_code());
-  ASSERT_TRUE(contains(result.error_message(),
-              "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL"));
+  ASSERT_TRUE(contains(
+      result.error_message(),
+      "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL"));
 }
 
 /**
@@ -357,7 +366,7 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, RoundRobin) {
   CHECK_FAILURE;
 
   // Execute statements over all the nodes in the cluster twice
-  for (size_t i = 0; i < total_nodes_ * 2 ; ++i) {
+  for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
     insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
@@ -466,8 +475,7 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, TokenAwareRouting) {
     ASSERT_EQ(CASS_OK, result.error_code());
 
     // Validate the correct replica/token was used
-    ASSERT_STREQ(get_primary_replica(value.str()).c_str(),
-                 result.host().c_str());
+    ASSERT_STREQ(get_primary_replica(value.str()).c_str(), result.host().c_str());
   }
 
   // Assign the execution profile for token aware routing
@@ -485,8 +493,7 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, TokenAwareRouting) {
     ASSERT_EQ(CASS_OK, result.error_code());
 
     // Validate the correct replica/token was used
-    ASSERT_STREQ(get_primary_replica(value.str()).c_str(),
-                 result.host().c_str());
+    ASSERT_STREQ(get_primary_replica(value.str()).c_str(), result.host().c_str());
   }
 }
 
@@ -524,7 +531,7 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, BlacklistFiltering) {
   // Execute statements over all the nodes in the cluster twice
   for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
-    insert_.set_execution_profile("");  // Reset the insert statement
+    insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
     ASSERT_EQ(CASS_OK, result.error_code());
 
@@ -570,7 +577,7 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, WhitelistFiltering) {
   // Execute statements over all the nodes in the cluster twice
   for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
-    insert_.set_execution_profile("");  // Reset the insert statement
+    insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
     ASSERT_EQ(CASS_OK, result.error_code());
 
@@ -608,8 +615,8 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, RetryPolicy) {
   ASSERT_EQ(CASS_OK, result.error_code());
   ASSERT_EQ(0u, logger_.count());
 
-  //TODO(fero): Create a write timeout test for using Simulacron
-  //NOTE: Tested locally with batch to ensure profiles are set with correct
+  // TODO(fero): Create a write timeout test for using Simulacron
+  // NOTE: Tested locally with batch to ensure profiles are set with correct
   //      retry policy (if available)
 
   // Execute a simple query with assigned profile
@@ -643,16 +650,15 @@ CASSANDRA_INTEGRATION_TEST_F(ExecutionProfileTest, SpeculativeExecutionPolicy) {
   session_.execute("CREATE OR REPLACE FUNCTION timeout(arg int) "
                    "RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java "
                    "AS $$ long start = System.currentTimeMillis(); "
-                     "while(System.currentTimeMillis() - start < arg) {"
-                       ";;"
-                     "}"
-                     "return arg;"
+                   "while(System.currentTimeMillis() - start < arg) {"
+                   ";;"
+                   "}"
+                   "return arg;"
                    "$$;");
 
   // Execute a simple query without assigned profile using timeout UDF
   Statement statement(format_string("SELECT timeout(value) FROM %s WHERE key='%s'",
-                                    table_name_.c_str(),
-                                    test_name_.c_str()));
+                                    table_name_.c_str(), test_name_.c_str()));
   statement.set_idempotent(true);
   statement.set_record_attempted_hosts(true);
   Result result = session_.execute(statement);
@@ -687,9 +693,9 @@ CASSANDRA_INTEGRATION_TEST_F(DCExecutionProfileTest, DCAware) {
   CHECK_FAILURE;
 
   // Execute statements over all the nodes in the cluster twice
-  for (size_t i = 0; i < total_nodes_ * 2 ; ++i) {
+  for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
-    insert_.set_execution_profile("");  // Reset the insert statement
+    insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
     ASSERT_EQ(CASS_OK, result.error_code());
 
@@ -737,7 +743,7 @@ CASSANDRA_INTEGRATION_TEST_F(DCExecutionProfileTest, BlacklistDCFiltering) {
   // Execute statements over all the nodes in the cluster twice
   for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
-    insert_.set_execution_profile("");  // Reset the insert statement
+    insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
     ASSERT_EQ(CASS_OK, result.error_code());
 
@@ -779,7 +785,7 @@ CASSANDRA_INTEGRATION_TEST_F(DCExecutionProfileTest, WhitelistDCFiltering) {
   // Execute statements over all the nodes in the cluster twice
   for (size_t i = 0; i < total_nodes_ * 2; ++i) {
     // Execute the same query with the cluster default profile
-    insert_.set_execution_profile("");  // Reset the insert statement
+    insert_.set_execution_profile(""); // Reset the insert statement
     Result result = session_.execute(insert_);
     ASSERT_EQ(CASS_OK, result.error_code());
 
diff --git a/gtests/src/integration/tests/test_null_string_params.cpp b/gtests/src/integration/tests/test_null_string_params.cpp
index f02c1a243..7a618b376 100644
--- a/gtests/src/integration/tests/test_null_string_params.cpp
+++ b/gtests/src/integration/tests/test_null_string_params.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include "integration.hpp"
 #include "cassandra.h"
+#include "integration.hpp"
 #include "result_response.hpp"
 
 /****
@@ -27,14 +27,14 @@
 // Name of materialized view used in this test file.
 #define VIEW_NAME "my_view"
 
+using namespace datastax::internal::core;
+
 /**
  * Null string api args test, without initially creating a connection.
  */
 class DisconnectedNullStringApiArgsTest : public Integration {
 public:
-  DisconnectedNullStringApiArgsTest() {
-    is_session_requested_ = false;
-  }
+  DisconnectedNullStringApiArgsTest() { is_session_requested_ = false; }
 
   void SetUp() {
     Integration::SetUp();
@@ -48,9 +48,7 @@ class DisconnectedNullStringApiArgsTest : public Integration {
  */
 class NullStringApiArgsTest : public Integration {
 public:
-  NullStringApiArgsTest() {
-    is_schema_metadata_ = true;
-  }
+  NullStringApiArgsTest() { is_schema_metadata_ = true; }
 };
 
 /**
@@ -70,49 +68,44 @@ class SchemaNullStringApiArgsTest : public NullStringApiArgsTest {
 
   void populateSchema() {
     session_.execute(format_string("CREATE TABLE %s (key text, value bigint, "
-        "PRIMARY KEY (key))", table_name_.c_str()));
-
-    session_.execute(
-      "CREATE FUNCTION avg_state(state tuple<int, bigint>, val int) "
-        "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
-        "LANGUAGE java AS "
-        "  'if (val != null) { "
-        "    state.setInt(0, state.getInt(0) + 1); "
-        "    state.setLong(1, state.getLong(1) + val.intValue()); "
-        "  } ;"
-        "  return state;'"
-        ";");
-    session_.execute(
-      "CREATE FUNCTION avg_final (state tuple<int, bigint>) "
-        "CALLED ON NULL INPUT RETURNS double "
-        "LANGUAGE java AS "
-        "  'double r = 0; "
-        "  if (state.getInt(0) == 0) return null; "
-        "  r = state.getLong(1); "
-        "  r /= state.getInt(0); "
-        "  return Double.valueOf(r);' "
-        ";");
-
-    session_.execute(
-      "CREATE AGGREGATE average(int) "
-        "SFUNC avg_state STYPE tuple<int, bigint> FINALFUNC avg_final "
-        "INITCOND(0, 0);");
+                                   "PRIMARY KEY (key))",
+                                   table_name_.c_str()));
+
+    session_.execute("CREATE FUNCTION avg_state(state tuple<int, bigint>, val int) "
+                     "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
+                     "LANGUAGE java AS "
+                     "  'if (val != null) { "
+                     "    state.setInt(0, state.getInt(0) + 1); "
+                     "    state.setLong(1, state.getLong(1) + val.intValue()); "
+                     "  } ;"
+                     "  return state;'"
+                     ";");
+    session_.execute("CREATE FUNCTION avg_final (state tuple<int, bigint>) "
+                     "CALLED ON NULL INPUT RETURNS double "
+                     "LANGUAGE java AS "
+                     "  'double r = 0; "
+                     "  if (state.getInt(0) == 0) return null; "
+                     "  r = state.getLong(1); "
+                     "  r /= state.getInt(0); "
+                     "  return Double.valueOf(r);' "
+                     ";");
+
+    session_.execute("CREATE AGGREGATE average(int) "
+                     "SFUNC avg_state STYPE tuple<int, bigint> FINALFUNC avg_final "
+                     "INITCOND(0, 0);");
 
     if (server_version_ >= "3.0.0") {
       session_.execute(format_string("CREATE MATERIALIZED VIEW %s "
-          "AS SELECT value "
-          "   FROM %s"
-          "   WHERE value IS NOT NULL and key IS NOT NULL "
-          "PRIMARY KEY(value, key)", VIEW_NAME, table_name_.c_str()));
+                                     "AS SELECT value "
+                                     "   FROM %s"
+                                     "   WHERE value IS NOT NULL and key IS NOT NULL "
+                                     "PRIMARY KEY(value, key)",
+                                     VIEW_NAME, table_name_.c_str()));
     }
-    session_.execute(
-      "CREATE TYPE address (street text, city text)"
-    );
+    session_.execute("CREATE TYPE address (street text, city text)");
 
     session_.execute(
-      format_string("CREATE INDEX schema_meta_index ON %s (value)",
-                    table_name_.c_str())
-    );
+        format_string("CREATE INDEX schema_meta_index ON %s (value)", table_name_.c_str()));
   }
 
 protected:
@@ -130,8 +123,7 @@ class SchemaNullStringApiArgsTest : public NullStringApiArgsTest {
  */
 CASSANDRA_INTEGRATION_TEST_F(DisconnectedNullStringApiArgsTest, SetContactPoints) {
   EXPECT_EQ(CASS_OK, cass_cluster_set_contact_points(cluster_.get(), NULL));
-  ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
-    cluster_.connect("", false).connect_error_code());
+  ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, cluster_.connect("", false).connect_error_code());
 }
 
 /**
@@ -204,7 +196,8 @@ CASSANDRA_INTEGRATION_TEST_F(DisconnectedNullStringApiArgsTest, ConnectKeyspaceN
  */
 CASSANDRA_INTEGRATION_TEST_F(NullStringApiArgsTest, SchemaMetaKeyspaceByNameNullKeyspace) {
   Schema schema_meta = session_.schema();
-  const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta.get(), NULL);
+  const CassKeyspaceMeta* keyspace_meta =
+      cass_schema_meta_keyspace_by_name(schema_meta.get(), NULL);
   EXPECT_EQ(NULL, keyspace_meta);
 }
 
@@ -229,38 +222,33 @@ CASSANDRA_INTEGRATION_TEST_F(NullStringApiArgsTest, PrepareNullQuery) {
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, KeyspaceMetaFunctions) {
   CHECK_VERSION(2.2.0);
-  const CassTableMeta* table_meta =
-    cass_keyspace_meta_table_by_name(keyspace_meta_.get(), NULL);
+  const CassTableMeta* table_meta = cass_keyspace_meta_table_by_name(keyspace_meta_.get(), NULL);
   EXPECT_EQ(NULL, table_meta);
 
   if (schema_meta_.version().major_version >= 3) {
-    const CassMaterializedViewMeta *view_meta =
-      cass_keyspace_meta_materialized_view_by_name(keyspace_meta_.get(), NULL);
+    const CassMaterializedViewMeta* view_meta =
+        cass_keyspace_meta_materialized_view_by_name(keyspace_meta_.get(), NULL);
     EXPECT_EQ(NULL, view_meta);
   }
 
-  const CassDataType* type_meta =
-    cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), NULL);
+  const CassDataType* type_meta = cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), NULL);
   EXPECT_EQ(NULL, type_meta);
 
-  const CassValue* field_meta =
-    cass_keyspace_meta_field_by_name(keyspace_meta_.get(), NULL);
+  const CassValue* field_meta = cass_keyspace_meta_field_by_name(keyspace_meta_.get(), NULL);
   EXPECT_EQ(NULL, field_meta);
 
   const CassFunctionMeta* function_meta =
-    cass_keyspace_meta_function_by_name(keyspace_meta_.get(), NULL, "abc");
+      cass_keyspace_meta_function_by_name(keyspace_meta_.get(), NULL, "abc");
   EXPECT_EQ(NULL, function_meta);
 
-  function_meta =
-    cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final", NULL);
+  function_meta = cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final", NULL);
   EXPECT_EQ(NULL, function_meta);
 
   const CassAggregateMeta* aggregate_meta =
-    cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), NULL, "abc");
+      cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), NULL, "abc");
   EXPECT_EQ(NULL, aggregate_meta);
 
-  aggregate_meta =
-    cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), "average", NULL);
+  aggregate_meta = cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), "average", NULL);
   EXPECT_EQ(NULL, aggregate_meta);
 }
 
@@ -274,17 +262,15 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, KeyspaceMetaFunctions)
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, TableMetaFunctions) {
   CHECK_VERSION(2.2.0);
-  const CassColumnMeta* column_meta =
-    cass_table_meta_column_by_name(table_meta_.get(), NULL);
+  const CassColumnMeta* column_meta = cass_table_meta_column_by_name(table_meta_.get(), NULL);
   EXPECT_EQ(NULL, column_meta);
 
-  const CassIndexMeta* index_meta =
-    cass_table_meta_index_by_name(table_meta_.get(), NULL);
+  const CassIndexMeta* index_meta = cass_table_meta_index_by_name(table_meta_.get(), NULL);
   EXPECT_EQ(NULL, index_meta);
 
   if (schema_meta_.version().major_version >= 3) {
-    const CassMaterializedViewMeta *view_meta =
-      cass_table_meta_materialized_view_by_name(table_meta_.get(), NULL);
+    const CassMaterializedViewMeta* view_meta =
+        cass_table_meta_materialized_view_by_name(table_meta_.get(), NULL);
     EXPECT_EQ(NULL, view_meta);
   }
 
@@ -292,12 +278,12 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, TableMetaFunctions) {
   EXPECT_EQ(NULL, field_meta);
 
   column_meta = cass_table_meta_column_by_name(table_meta_.get(), "value");
-  EXPECT_NE(static_cast<CassColumnMeta *>(NULL), column_meta);
+  EXPECT_NE(static_cast<CassColumnMeta*>(NULL), column_meta);
   field_meta = cass_column_meta_field_by_name(column_meta, NULL);
   EXPECT_EQ(NULL, field_meta);
 
   index_meta = cass_table_meta_index_by_name(table_meta_.get(), "schema_meta_index");
-  EXPECT_NE(static_cast<CassIndexMeta *>(NULL), index_meta);
+  EXPECT_NE(static_cast<CassIndexMeta*>(NULL), index_meta);
   field_meta = cass_index_meta_field_by_name(index_meta, NULL);
   EXPECT_EQ(NULL, field_meta);
 }
@@ -312,16 +298,14 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, TableMetaFunctions) {
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, MaterializedViewMetaFunctions) {
   CHECK_VERSION(3.0.0);
 
-  const CassMaterializedViewMeta *view_meta =
-    cass_table_meta_materialized_view_by_name(table_meta_.get(), VIEW_NAME);
-  ASSERT_NE(static_cast<CassMaterializedViewMeta *>(NULL), view_meta);
+  const CassMaterializedViewMeta* view_meta =
+      cass_table_meta_materialized_view_by_name(table_meta_.get(), VIEW_NAME);
+  ASSERT_NE(static_cast<CassMaterializedViewMeta*>(NULL), view_meta);
 
-  const CassColumnMeta *column_meta =
-    cass_materialized_view_meta_column_by_name(view_meta, NULL);
+  const CassColumnMeta* column_meta = cass_materialized_view_meta_column_by_name(view_meta, NULL);
   EXPECT_EQ(NULL, column_meta);
 
-  const CassValue *field_meta = cass_materialized_view_meta_field_by_name(
-    view_meta, NULL);
+  const CassValue* field_meta = cass_materialized_view_meta_field_by_name(view_meta, NULL);
   EXPECT_EQ(NULL, field_meta);
 }
 
@@ -336,22 +320,22 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, MaterializedViewMetaFu
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, FunctionAndAggregateMetaFunctions) {
   CHECK_VERSION(2.2.0);
   // C* 3.x and later annotate collection columns as frozen.
-  const CassFunctionMeta* function_meta = (schema_meta_.version().major_version >= 3) ?
-    cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final",
-                                        "frozen<tuple<int,bigint>>") :
-    cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final",
-                                        "tuple<int,bigint>");
-  ASSERT_NE(static_cast<CassFunctionMeta *>(NULL), function_meta);
-
-  const CassDataType* data_type =
-    cass_function_meta_argument_type_by_name(function_meta, NULL);
+  const CassFunctionMeta* function_meta =
+      (schema_meta_.version().major_version >= 3)
+          ? cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final",
+                                                "frozen<tuple<int,bigint>>")
+          : cass_keyspace_meta_function_by_name(keyspace_meta_.get(), "avg_final",
+                                                "tuple<int,bigint>");
+  ASSERT_NE(static_cast<CassFunctionMeta*>(NULL), function_meta);
+
+  const CassDataType* data_type = cass_function_meta_argument_type_by_name(function_meta, NULL);
   EXPECT_EQ(NULL, data_type);
 
   const CassValue* field_meta = cass_function_meta_field_by_name(function_meta, NULL);
   EXPECT_EQ(NULL, field_meta);
 
   const CassAggregateMeta* aggregate_meta =
-    cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), "average", "int");
+      cass_keyspace_meta_aggregate_by_name(keyspace_meta_.get(), "average", "int");
   ASSERT_NE(static_cast<CassAggregateMeta*>(NULL), aggregate_meta);
   field_meta = cass_aggregate_meta_field_by_name(aggregate_meta, NULL);
   EXPECT_EQ(NULL, field_meta);
@@ -369,11 +353,9 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
   Statement statement(NULL);
 
   statement = cass_statement_new(NULL, 0);
-  EXPECT_EQ(CASS_ERROR_SERVER_SYNTAX_ERROR,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_ERROR_SERVER_SYNTAX_ERROR, session_.execute(statement, false).error_code());
 
-  statement = cass_statement_new(
-    format_string("SELECT * FROM %s", table_name_.c_str()).c_str(), 0);
+  statement = cass_statement_new(format_string("SELECT * FROM %s", table_name_.c_str()).c_str(), 0);
   EXPECT_EQ(CASS_OK, cass_statement_set_keyspace(statement.get(), NULL));
   EXPECT_EQ(CASS_OK, session_.execute(statement, false).error_code());
 
@@ -381,33 +363,29 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
   // the statement fails.
   Session session_without_keyspace = cluster_.connect();
   EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_without_keyspace.execute(statement, false).error_code());
+            session_without_keyspace.execute(statement, false).error_code());
 
   std::string query_string = format_string("INSERT INTO %s (key, value) "
-                                             "VALUES (42, :v)", table_name_.c_str());
+                                           "VALUES (42, :v)",
+                                           table_name_.c_str());
   const char* query = query_string.c_str();
 
   statement = cass_statement_new(query, 1);
   EXPECT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(), NULL));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
-
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
-#define BIND_BY_NAME_TEST(FUNC, NAME, VALUE) \
-  statement = cass_statement_new(query, 1); \
+#define BIND_BY_NAME_TEST(FUNC, NAME, VALUE)              \
+  statement = cass_statement_new(query, 1);               \
   EXPECT_EQ(CASS_OK, FUNC(statement.get(), NAME, VALUE)); \
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, \
-    session_.execute(statement, false).error_code());
-
-#define BIND_BY_NAME_TEST_WITH_VALUE_LEN(FUNC, NAME, VALUE, VALUE_LEN) \
-  statement = cass_statement_new(query, 1); \
-  EXPECT_EQ(CASS_OK, FUNC(statement.get(), NAME, VALUE, VALUE_LEN)); \
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, \
-    session_.execute(statement, false).error_code()); \
-  statement = cass_statement_new(query, 1); \
-  EXPECT_EQ(CASS_OK, FUNC(statement.get(), "v", NULL, 0)); \
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, \
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
+
+#define BIND_BY_NAME_TEST_WITH_VALUE_LEN(FUNC, NAME, VALUE, VALUE_LEN)                         \
+  statement = cass_statement_new(query, 1);                                                    \
+  EXPECT_EQ(CASS_OK, FUNC(statement.get(), NAME, VALUE, VALUE_LEN));                           \
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code()); \
+  statement = cass_statement_new(query, 1);                                                    \
+  EXPECT_EQ(CASS_OK, FUNC(statement.get(), "v", NULL, 0));                                     \
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   BIND_BY_NAME_TEST(cass_statement_bind_int8_by_name, NULL, 42);
   BIND_BY_NAME_TEST(cass_statement_bind_int16_by_name, NULL, 42);
@@ -420,47 +398,37 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
 
   statement = cass_statement_new(query, 1);
   EXPECT_EQ(CASS_OK, cass_statement_bind_string(statement.get(), 0, NULL));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   BIND_BY_NAME_TEST(cass_statement_bind_string_by_name, NULL, "val");
   BIND_BY_NAME_TEST(cass_statement_bind_string_by_name, "v", NULL);
 
   BIND_BY_NAME_TEST_WITH_VALUE_LEN(cass_statement_bind_bytes_by_name, NULL,
-                                   reinterpret_cast<const cass_byte_t *>("a"), 1);
+                                   reinterpret_cast<const cass_byte_t*>("a"), 1);
 
   statement = cass_statement_new(query, 1);
-  EXPECT_EQ(CASS_OK,
-    cass_statement_bind_custom(statement.get(), 0, "myclass", NULL, 0));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_OK, cass_statement_bind_custom(statement.get(), 0, "myclass", NULL, 0));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   statement = cass_statement_new(query, 1);
-  EXPECT_EQ(CASS_OK,
-    cass_statement_bind_custom(statement.get(), 0, NULL,
-      reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_OK, cass_statement_bind_custom(statement.get(), 0, NULL,
+                                                reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   statement = cass_statement_new(query, 1);
   EXPECT_EQ(CASS_OK,
-    cass_statement_bind_custom_by_name(statement.get(), NULL, "myclass",
-      reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+            cass_statement_bind_custom_by_name(statement.get(), NULL, "myclass",
+                                               reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   statement = cass_statement_new(query, 1);
-  EXPECT_EQ(CASS_OK,
-    cass_statement_bind_custom_by_name(statement.get(), "v", "myclass", NULL, 0));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_OK, cass_statement_bind_custom_by_name(statement.get(), "v", "myclass", NULL, 0));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   statement = cass_statement_new(query, 1);
-  EXPECT_EQ(CASS_OK,
-    cass_statement_bind_custom_by_name(statement.get(), "v", NULL,
-      reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_OK, cass_statement_bind_custom_by_name(
+                         statement.get(), "v", NULL, reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   UuidGen uuid_generator(11);
   BIND_BY_NAME_TEST(cass_statement_bind_uuid_by_name, NULL,
@@ -470,20 +438,17 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
   EXPECT_EQ(CASS_OK, cass_inet_from_string("127.1.2.3", &inet));
   BIND_BY_NAME_TEST(cass_statement_bind_inet_by_name, NULL, inet);
 
-  const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-                              112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-                              84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+  const cass_uint8_t pi[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,   25, 32,  135,
+                              129, 180, 112, 176, 158, 120, 246, 235, 29,  145, 238, 50, 108, 239,
+                              219, 100, 250, 84,  6,   186, 148, 76,  230, 46,  181, 89, 239, 247 };
   statement = cass_statement_new(query, 1);
   EXPECT_EQ(CASS_OK,
-    cass_statement_bind_decimal_by_name(statement.get(), NULL, pi, sizeof(pi), 100));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+            cass_statement_bind_decimal_by_name(statement.get(), NULL, pi, sizeof(pi), 100));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   statement = cass_statement_new(query, 1);
-  EXPECT_EQ(CASS_OK,
-    cass_statement_bind_duration_by_name(statement.get(), NULL, 1, 2, 3));
-  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY,
-    session_.execute(statement, false).error_code());
+  EXPECT_EQ(CASS_OK, cass_statement_bind_duration_by_name(statement.get(), NULL, 1, 2, 3));
+  EXPECT_EQ(CASS_ERROR_SERVER_INVALID_QUERY, session_.execute(statement, false).error_code());
 
   CassCollection* collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2);
   EXPECT_EQ(CASS_OK, cass_collection_append_string(collection, "a"));
@@ -498,14 +463,12 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
   cass_tuple_free(tuple);
 
   const CassDataType* udt_address =
-    cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), "address");
-  ASSERT_NE(static_cast<CassDataType *>(NULL), udt_address);
+      cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), "address");
+  ASSERT_NE(static_cast<CassDataType*>(NULL), udt_address);
 
   CassUserType* address = cass_user_type_new_from_data_type(udt_address);
-  EXPECT_EQ(CASS_OK,
-    cass_user_type_set_string_by_name(address, "street", "123 My Street"));
-  EXPECT_EQ(CASS_OK,
-    cass_user_type_set_string_by_name(address, "city", "Somewhere"));
+  EXPECT_EQ(CASS_OK, cass_user_type_set_string_by_name(address, "street", "123 My Street"));
+  EXPECT_EQ(CASS_OK, cass_user_type_set_string_by_name(address, "city", "Somewhere"));
   BIND_BY_NAME_TEST(cass_statement_bind_user_type_by_name, NULL, address);
   cass_user_type_free(address);
 
@@ -523,12 +486,10 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, StatementFunctions) {
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, PreparedFunctions) {
   CHECK_VERSION(2.2.0);
-  Prepared prepared =
-    session_.prepare(format_string("INSERT INTO %s (key, value) "
-                                     "VALUES ('42', :v)", table_name_.c_str()));
-  const CassDataType* data_type = cass_prepared_parameter_data_type_by_name(
-    prepared.get(), NULL
-  );
+  Prepared prepared = session_.prepare(format_string("INSERT INTO %s (key, value) "
+                                                     "VALUES ('42', :v)",
+                                                     table_name_.c_str()));
+  const CassDataType* data_type = cass_prepared_parameter_data_type_by_name(prepared.get(), NULL);
   EXPECT_EQ(NULL, data_type);
 }
 
@@ -552,8 +513,7 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, DataTypeFunctions) {
   EXPECT_EQ(CASS_OK, cass_data_type_set_class_name(custom_type, NULL));
 
   EXPECT_EQ(CASS_OK, cass_data_type_add_sub_type_by_name(udt, NULL, custom_type));
-  EXPECT_EQ(CASS_OK,
-    cass_data_type_add_sub_value_type_by_name(udt, NULL, CASS_VALUE_TYPE_BOOLEAN));
+  EXPECT_EQ(CASS_OK, cass_data_type_add_sub_value_type_by_name(udt, NULL, CASS_VALUE_TYPE_BOOLEAN));
 
   cass_data_type_free(udt);
   cass_data_type_free(custom_type);
@@ -571,13 +531,13 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, CollectionFunctions) {
   CassCollection* collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2);
   EXPECT_EQ(CASS_OK, cass_collection_append_string(collection, NULL));
   EXPECT_EQ(CASS_OK, cass_collection_append_custom(collection, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
+                                                   reinterpret_cast<const cass_byte_t*>("a"), 1));
   cass_collection_free(collection);
 
   CassTuple* tuple = cass_tuple_new(2);
   EXPECT_EQ(CASS_OK, cass_tuple_set_string(tuple, 0, NULL));
-  EXPECT_EQ(CASS_OK, cass_tuple_set_custom(tuple, 0, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
+  EXPECT_EQ(CASS_OK,
+            cass_tuple_set_custom(tuple, 0, NULL, reinterpret_cast<const cass_byte_t*>("a"), 1));
   cass_tuple_free(tuple);
 }
 
@@ -591,70 +551,85 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, CollectionFunctions) {
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, UserTypeFunctions) {
   CHECK_VERSION(2.2.0);
-  const CassDataType *udt_address =
-    cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), "address");
-  ASSERT_NE(static_cast<CassDataType *>(NULL), udt_address);
+  const CassDataType* udt_address =
+      cass_keyspace_meta_user_type_by_name(keyspace_meta_.get(), "address");
+  ASSERT_NE(static_cast<CassDataType*>(NULL), udt_address);
 
-  CassUserType *address = cass_user_type_new_from_data_type(udt_address);
+  CassUserType* address = cass_user_type_new_from_data_type(udt_address);
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_null_by_name(address, NULL));
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_int8_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_int16_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_int32_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_uint32_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_int64_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_float_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_double_by_name(address, NULL, 42));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_bool_by_name(address, NULL, cass_false));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_int16_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_int32_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_uint32_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_int64_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_float_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_double_by_name(address, NULL, 42));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_bool_by_name(address, NULL, cass_false));
   EXPECT_EQ(CASS_OK, cass_user_type_set_string(address, 0, NULL));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_string_by_name(address, NULL, "foo"));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_bytes_by_name(address, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_LIB_INVALID_VALUE_TYPE, cass_user_type_set_custom(address, 0, "org.foo", NULL, 0));
-  EXPECT_EQ(CASS_ERROR_LIB_INVALID_VALUE_TYPE, cass_user_type_set_custom(address, 0, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_custom_by_name(address, NULL, "org.foo", NULL, 0));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_custom_by_name(address, NULL, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_custom_by_name(address, "v", "org.foo", NULL, 0));
-  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST, cass_user_type_set_custom_by_name(address, "v", NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_string_by_name(address, NULL, "foo"));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_bytes_by_name(address, NULL,
+                                             reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_LIB_INVALID_VALUE_TYPE,
+            cass_user_type_set_custom(address, 0, "org.foo", NULL, 0));
+  EXPECT_EQ(
+      CASS_ERROR_LIB_INVALID_VALUE_TYPE,
+      cass_user_type_set_custom(address, 0, NULL, reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_custom_by_name(address, NULL, "org.foo", NULL, 0));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_custom_by_name(address, NULL, NULL,
+                                              reinterpret_cast<const cass_byte_t*>("a"), 1));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_custom_by_name(address, "v", "org.foo", NULL, 0));
+  EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
+            cass_user_type_set_custom_by_name(address, "v", NULL,
+                                              reinterpret_cast<const cass_byte_t*>("a"), 1));
 
   UuidGen uuid_generator(11);
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_uuid_by_name(address, NULL,
-                                    uuid_generator.generate_random_uuid().value()));
+            cass_user_type_set_uuid_by_name(address, NULL,
+                                            uuid_generator.generate_random_uuid().value()));
 
   CassInet inet;
   EXPECT_EQ(CASS_OK, cass_inet_from_string("127.1.2.3", &inet));
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_inet_by_name(address, NULL, inet));
+            cass_user_type_set_inet_by_name(address, NULL, inet));
 
-  const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-                              112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-                              84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+  const cass_uint8_t pi[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,   25, 32,  135,
+                              129, 180, 112, 176, 158, 120, 246, 235, 29,  145, 238, 50, 108, 239,
+                              219, 100, 250, 84,  6,   186, 148, 76,  230, 46,  181, 89, 239, 247 };
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_decimal_by_name(address, NULL, pi, sizeof(pi), 100));
+            cass_user_type_set_decimal_by_name(address, NULL, pi, sizeof(pi), 100));
 
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_duration_by_name(address, NULL, 1, 2, 3));
+            cass_user_type_set_duration_by_name(address, NULL, 1, 2, 3));
 
   CassCollection* collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2);
   EXPECT_EQ(CASS_OK, cass_collection_append_string(collection, "a"));
   EXPECT_EQ(CASS_OK, cass_collection_append_string(collection, "b"));
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_collection_by_name(address, NULL, collection));
+            cass_user_type_set_collection_by_name(address, NULL, collection));
   cass_collection_free(collection);
 
   CassTuple* tuple = cass_tuple_new(2);
   EXPECT_EQ(CASS_OK, cass_tuple_set_string(tuple, 0, "a"));
   EXPECT_EQ(CASS_OK, cass_tuple_set_string(tuple, 1, "b"));
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_tuple_by_name(address, NULL, tuple));
+            cass_user_type_set_tuple_by_name(address, NULL, tuple));
   cass_tuple_free(tuple);
 
-  CassUserType *address2 = cass_user_type_new_from_data_type(udt_address);
+  CassUserType* address2 = cass_user_type_new_from_data_type(udt_address);
   EXPECT_EQ(CASS_ERROR_LIB_NAME_DOES_NOT_EXIST,
-    cass_user_type_set_user_type_by_name(address, NULL, address2));
+            cass_user_type_set_user_type_by_name(address, NULL, address2));
   cass_user_type_free(address2);
 
   cass_user_type_free(address);
@@ -672,8 +647,8 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, UserTypeFunctions) {
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, MiscellaneousFunctions) {
   CHECK_VERSION(2.2.0);
-  cass::ResultResponse response;
-  cass::Row r(&response);
+  ResultResponse response;
+  datastax::internal::core::Row r(&response);
   CassRow* row = CassRow::to(&r);
   EXPECT_EQ(NULL, cass_row_get_column_by_name(row, NULL));
 
@@ -681,8 +656,7 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, MiscellaneousFunctions
   EXPECT_EQ(CASS_ERROR_LIB_BAD_PARAMS, cass_uuid_from_string(NULL, &uuid));
 
   CassCustomPayload* payload = cass_custom_payload_new();
-  cass_custom_payload_set(payload, NULL,
-    reinterpret_cast<const cass_byte_t *>("a"), 1);
+  cass_custom_payload_set(payload, NULL, reinterpret_cast<const cass_byte_t*>("a"), 1);
   cass_custom_payload_remove(payload, NULL);
   cass_custom_payload_free(payload);
 
diff --git a/gtests/src/integration/tests/test_schema_metadata.cpp b/gtests/src/integration/tests/test_schema_metadata.cpp
index 329802781..8adbc07f7 100644
--- a/gtests/src/integration/tests/test_schema_metadata.cpp
+++ b/gtests/src/integration/tests/test_schema_metadata.cpp
@@ -14,17 +14,15 @@
   limitations under the License.
 */
 
-#include "integration.hpp"
 #include "cassandra.h"
+#include "integration.hpp"
 
 // Name of materialized view used in this test file.
 #define VIEW_NAME "my_view"
 
 class SchemaMetadataTest : public Integration {
 public:
-  SchemaMetadataTest() {
-    is_schema_metadata_ = true;
-  }
+  SchemaMetadataTest() { is_schema_metadata_ = true; }
 
   void SetUp() {
     CHECK_VERSION(2.2.0);
@@ -35,49 +33,44 @@ class SchemaMetadataTest : public Integration {
 
   void populateSchema() {
     session_.execute(format_string("CREATE TABLE %s (key text, value bigint, "
-                                     "PRIMARY KEY (key))", table_name_.c_str()));
-
-    session_.execute(
-      "CREATE FUNCTION avg_state(state tuple<int, bigint>, val int) "
-        "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
-        "LANGUAGE java AS "
-        "  'if (val != null) { "
-        "    state.setInt(0, state.getInt(0) + 1); "
-        "    state.setLong(1, state.getLong(1) + val.intValue()); "
-        "  } ;"
-        "  return state;'"
-        ";");
-    session_.execute(
-      "CREATE FUNCTION avg_final (state tuple<int, bigint>) "
-        "CALLED ON NULL INPUT RETURNS double "
-        "LANGUAGE java AS "
-        "  'double r = 0; "
-        "  if (state.getInt(0) == 0) return null; "
-        "  r = state.getLong(1); "
-        "  r /= state.getInt(0); "
-        "  return Double.valueOf(r);' "
-        ";");
-
-    session_.execute(
-      "CREATE AGGREGATE average(int) "
-        "SFUNC avg_state STYPE tuple<int, bigint> FINALFUNC avg_final "
-        "INITCOND(0, 0);");
+                                   "PRIMARY KEY (key))",
+                                   table_name_.c_str()));
+
+    session_.execute("CREATE FUNCTION avg_state(state tuple<int, bigint>, val int) "
+                     "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
+                     "LANGUAGE java AS "
+                     "  'if (val != null) { "
+                     "    state.setInt(0, state.getInt(0) + 1); "
+                     "    state.setLong(1, state.getLong(1) + val.intValue()); "
+                     "  } ;"
+                     "  return state;'"
+                     ";");
+    session_.execute("CREATE FUNCTION avg_final (state tuple<int, bigint>) "
+                     "CALLED ON NULL INPUT RETURNS double "
+                     "LANGUAGE java AS "
+                     "  'double r = 0; "
+                     "  if (state.getInt(0) == 0) return null; "
+                     "  r = state.getLong(1); "
+                     "  r /= state.getInt(0); "
+                     "  return Double.valueOf(r);' "
+                     ";");
+
+    session_.execute("CREATE AGGREGATE average(int) "
+                     "SFUNC avg_state STYPE tuple<int, bigint> FINALFUNC avg_final "
+                     "INITCOND(0, 0);");
 
     if (server_version_ >= "3.0.0") {
       session_.execute(format_string("CREATE MATERIALIZED VIEW %s "
-                                       "AS SELECT value "
-                                       "   FROM %s"
-                                       "   WHERE value IS NOT NULL and key IS NOT NULL "
-                                       "PRIMARY KEY(value, key)", VIEW_NAME, table_name_.c_str()));
+                                     "AS SELECT value "
+                                     "   FROM %s"
+                                     "   WHERE value IS NOT NULL and key IS NOT NULL "
+                                     "PRIMARY KEY(value, key)",
+                                     VIEW_NAME, table_name_.c_str()));
     }
-    session_.execute(
-      "CREATE TYPE address (street text, city text)"
-    );
+    session_.execute("CREATE TYPE address (street text, city text)");
 
     session_.execute(
-      format_string("CREATE INDEX schema_meta_index ON %s (value)",
-                    table_name_.c_str())
-    );
+        format_string("CREATE INDEX schema_meta_index ON %s (value)", table_name_.c_str()));
   }
 
 protected:
@@ -90,30 +83,30 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaMetadataTest, Views) {
   Table table_meta = keyspace_meta.table(table_name_);
 
   // Verify that the view exists in the keyspace and table.
-  const CassMaterializedViewMeta *view_from_keyspace =
-    cass_keyspace_meta_materialized_view_by_name(keyspace_meta.get(), VIEW_NAME);
+  const CassMaterializedViewMeta* view_from_keyspace =
+      cass_keyspace_meta_materialized_view_by_name(keyspace_meta.get(), VIEW_NAME);
   EXPECT_TRUE(view_from_keyspace != NULL);
 
   // Now from the table, and it should be the same CassMaterializedViewMeta object.
-  const CassMaterializedViewMeta *view_from_table =
-    cass_table_meta_materialized_view_by_name(table_meta.get(), VIEW_NAME);
+  const CassMaterializedViewMeta* view_from_table =
+      cass_table_meta_materialized_view_by_name(table_meta.get(), VIEW_NAME);
   EXPECT_EQ(view_from_keyspace, view_from_table);
 
   // Verify that the view's back-pointer references this table object.
-  EXPECT_EQ(table_meta.get(),
-    cass_materialized_view_meta_base_table(view_from_keyspace));
+  EXPECT_EQ(table_meta.get(), cass_materialized_view_meta_base_table(view_from_keyspace));
 
   // Alter the view, which will cause a new event, and make sure the new
   // view object is available in our metadata (in a new schema snapshot).
 
   session_.execute(format_string("ALTER MATERIALIZED VIEW %s "
-                                  "WITH comment = 'my view rocks'", VIEW_NAME));
+                                 "WITH comment = 'my view rocks'",
+                                 VIEW_NAME));
 
   Schema new_schema = session_.schema();
   Keyspace new_keyspace_meta = new_schema.keyspace(keyspace_name_);
 
-  const CassMaterializedViewMeta *updated_view =
-    cass_keyspace_meta_materialized_view_by_name(new_keyspace_meta.get(), VIEW_NAME);
+  const CassMaterializedViewMeta* updated_view =
+      cass_keyspace_meta_materialized_view_by_name(new_keyspace_meta.get(), VIEW_NAME);
   EXPECT_NE(updated_view, view_from_keyspace);
 }
 
@@ -168,45 +161,36 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaMetadataTest, VirtualMetadata) {
   EXPECT_EQ(cass_table_meta_partition_key_count(table_meta.get()), 1u);
   EXPECT_EQ(cass_table_meta_clustering_key_count(table_meta.get()), 2u);
 
-  EXPECT_EQ(cass_table_meta_clustering_key_order(table_meta.get(), 0),
-            CASS_CLUSTERING_ORDER_ASC);
-  EXPECT_EQ(cass_table_meta_clustering_key_order(table_meta.get(), 1),
-            CASS_CLUSTERING_ORDER_ASC);
+  EXPECT_EQ(cass_table_meta_clustering_key_order(table_meta.get(), 0), CASS_CLUSTERING_ORDER_ASC);
+  EXPECT_EQ(cass_table_meta_clustering_key_order(table_meta.get(), 1), CASS_CLUSTERING_ORDER_ASC);
 
   const CassColumnMeta* column_meta;
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "keyspace_name");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_TEXT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_TEXT);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "table_name");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_TEXT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_TEXT);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "task_id");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_UUID);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_UUID);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "kind");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_TEXT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_TEXT);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "progress");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_BIGINT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_BIGINT);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "total");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_BIGINT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_BIGINT);
 
   column_meta = cass_table_meta_column_by_name(table_meta.get(), "unit");
   ASSERT_TRUE(column_meta);
-  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)),
-            CASS_VALUE_TYPE_TEXT);
+  EXPECT_EQ(cass_data_type_type(cass_column_meta_data_type(column_meta)), CASS_VALUE_TYPE_TEXT);
 }
diff --git a/gtests/src/integration/tests/test_session.cpp b/gtests/src/integration/tests/test_session.cpp
index 238775303..24234009c 100644
--- a/gtests/src/integration/tests/test_session.cpp
+++ b/gtests/src/integration/tests/test_session.cpp
@@ -24,17 +24,15 @@
 #define EVENT_MAXIMUM_WAIT_TIME_MS 5000
 #define EVENT_WAIT_FOR_NAP_MS 100
 
+using namespace datastax::internal;
+
 class SessionTest : public Integration {
 public:
   typedef std::pair<CassHostListenerEvent, std::string> Event;
   typedef std::queue<Event> Events;
 
-  SessionTest() {
-    uv_mutex_init(&mutex_);
-  }
-  ~SessionTest() {
-    uv_mutex_destroy(&mutex_);
-  }
+  SessionTest() { uv_mutex_init(&mutex_); }
+  ~SessionTest() { uv_mutex_destroy(&mutex_); }
 
   void SetUp() {
     is_session_requested_ = false;
@@ -42,7 +40,7 @@ class SessionTest : public Integration {
   }
 
   void check_event(CassHostListenerEvent expected_event, short expected_node) {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     std::stringstream expected_address;
     expected_address << ccm_->get_ip_prefix() << expected_node;
     Event event = events_.front();
@@ -52,8 +50,7 @@ class SessionTest : public Integration {
   }
   bool wait_for_event(size_t expected_count) {
     start_timer();
-    while (elapsed_time() < EVENT_MAXIMUM_WAIT_TIME_MS
-           && event_count() < expected_count) {
+    while (elapsed_time() < EVENT_MAXIMUM_WAIT_TIME_MS && event_count() < expected_count) {
       msleep(EVENT_WAIT_FOR_NAP_MS);
     }
     return event_count() >= expected_count;
@@ -61,11 +58,11 @@ class SessionTest : public Integration {
 
 protected:
   size_t event_count() {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     return events_.size();
   }
   void add_event(CassHostListenerEvent event, CassInet inet) {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     char address[CASS_INET_STRING_LENGTH];
 
     cass_inet_string(inet, address);
@@ -83,9 +80,7 @@ class SessionTest : public Integration {
 
     events_.push(Event(event, address));
   }
-  static void on_host_listener(CassHostListenerEvent event,
-                               CassInet inet,
-                               void* data) {
+  static void on_host_listener(CassHostListenerEvent event, CassInet inet, void* data) {
     SessionTest* instance = static_cast<SessionTest*>(data);
     instance->add_event(event, inet);
   }
@@ -110,7 +105,8 @@ CASSANDRA_INTEGRATION_TEST_F(SessionTest, MetricsWithoutConnecting) {
 
   CassSpeculativeExecutionMetrics spec_ex_metrics;
   logger_.reset();
-  logger_.add_critera("Attempted to get speculative execution metrics before connecting session object");
+  logger_.add_critera(
+      "Attempted to get speculative execution metrics before connecting session object");
   cass_session_get_speculative_execution_metrics(session.get(), &spec_ex_metrics);
   EXPECT_EQ(spec_ex_metrics.min, 0u);
   EXPECT_EQ(spec_ex_metrics.percentage, 0.0);
@@ -121,9 +117,8 @@ CASSANDRA_INTEGRATION_TEST_F(SessionTest, ExternalHostListener) {
   CHECK_FAILURE;
   is_test_chaotic_ = true; // Destroy the cluster after the test completes
 
-  Cluster cluster = default_cluster()
-    .with_load_balance_round_robin()
-    .with_host_listener_callback(on_host_listener, this);
+  Cluster cluster = default_cluster().with_load_balance_round_robin().with_host_listener_callback(
+      on_host_listener, this);
   Session session = cluster.connect();
 
   // Initial node 1 events (add and up)
diff --git a/gtests/src/integration/tests/test_startup_options.cpp b/gtests/src/integration/tests/test_startup_options.cpp
index 921aa0fb3..087252e98 100644
--- a/gtests/src/integration/tests/test_startup_options.cpp
+++ b/gtests/src/integration/tests/test_startup_options.cpp
@@ -19,7 +19,7 @@
 /**
  * Startup options integration tests
  */
-class StartupOptionssTests : public Integration { };
+class StartupOptionssTests : public Integration {};
 
 /**
  * Verify driver name and version are assigned in startup options.
@@ -38,17 +38,14 @@ CASSANDRA_INTEGRATION_TEST_F(StartupOptionssTests, DriverOptions) {
   CHECK_FAILURE;
   CHECK_VERSION(4.0.0);
   if (Options::is_dse()) {
-    SKIP_TEST("Unsupported for DataStax Enterprise Version " << server_version_.to_string()
-              << ": 'system_views.clients' is unavailable");
+    SKIP_TEST("Unsupported for DataStax Enterprise Version "
+              << server_version_.to_string() << ": 'system_views.clients' is unavailable");
   }
 
-  Result result = session_.execute(
-      "SELECT driver_name, driver_version from system_views.clients");
+  Result result = session_.execute("SELECT driver_name, driver_version from system_views.clients");
   ASSERT_EQ(2u, result.row_count()); // Control connection and request processor connection
   ASSERT_EQ(2u, result.column_count());
   Row row = result.first_row();
-  ASSERT_EQ(Varchar(driver::internals::Utils::driver_name()),
-            row.next().as<Varchar>());
-  ASSERT_EQ(Varchar(driver::internals::Utils::driver_version()),
-            row.next().as<Varchar>());
+  ASSERT_EQ(Varchar(driver::internals::Utils::driver_name()), row.next().as<Varchar>());
+  ASSERT_EQ(Varchar(driver::internals::Utils::driver_version()), row.next().as<Varchar>());
 }
diff --git a/gtests/src/integration/tests/test_statement.cpp b/gtests/src/integration/tests/test_statement.cpp
index e845a7bf8..20f1930ef 100644
--- a/gtests/src/integration/tests/test_statement.cpp
+++ b/gtests/src/integration/tests/test_statement.cpp
@@ -18,9 +18,7 @@
 
 class StatementTests : public Integration {
 public:
-  StatementTests() {
-    number_dc1_nodes_ = 2;
-  }
+  StatementTests() { number_dc1_nodes_ = 2; }
 };
 
 /**
@@ -115,12 +113,11 @@ CASSANDRA_INTEGRATION_TEST_F(StatementTests, SetHostWhereHostIsDown) {
  */
 TEST(StatementTest, SetHostWithValidHostString) {
   Statement statement("");
-  EXPECT_EQ(cass_statement_set_host(statement.get(), "127.0.0.1", 9042),
-            CASS_OK);
-  EXPECT_EQ(cass_statement_set_host(statement.get(), "::1", 9042),
-            CASS_OK);
-  EXPECT_EQ(cass_statement_set_host(statement.get(), "2001:0db8:85a3:0000:0000:8a2e:0370:7334", 9042),
-            CASS_OK);
+  EXPECT_EQ(cass_statement_set_host(statement.get(), "127.0.0.1", 9042), CASS_OK);
+  EXPECT_EQ(cass_statement_set_host(statement.get(), "::1", 9042), CASS_OK);
+  EXPECT_EQ(
+      cass_statement_set_host(statement.get(), "2001:0db8:85a3:0000:0000:8a2e:0370:7334", 9042),
+      CASS_OK);
 }
 
 /**
@@ -132,12 +129,9 @@ TEST(StatementTest, SetHostWithValidHostString) {
  */
 TEST(StatementTest, SetHostWithInvalidHostString) {
   Statement statement("");
-  EXPECT_EQ(cass_statement_set_host(statement.get(), "notvalid", 9042),
-            CASS_ERROR_LIB_BAD_PARAMS);
-  EXPECT_EQ(cass_statement_set_host(statement.get(), "", 9042),
-            CASS_ERROR_LIB_BAD_PARAMS);
-  EXPECT_EQ(cass_statement_set_host(statement.get(), NULL, 9042),
-            CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_statement_set_host(statement.get(), "notvalid", 9042), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_statement_set_host(statement.get(), "", 9042), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_statement_set_host(statement.get(), NULL, 9042), CASS_ERROR_LIB_BAD_PARAMS);
 }
 
 /**
@@ -152,16 +146,13 @@ TEST(StatementTest, SetHostWithValidHostInet) {
   CassInet valid;
   ASSERT_EQ(cass_inet_from_string("127.0.0.1", &valid), CASS_OK);
   EXPECT_EQ(valid.address_length, 4);
-  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042),
-            CASS_OK);
+  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042), CASS_OK);
   ASSERT_EQ(cass_inet_from_string("::1", &valid), CASS_OK);
   EXPECT_EQ(valid.address_length, 16);
-  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042),
-            CASS_OK);
+  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042), CASS_OK);
   ASSERT_EQ(cass_inet_from_string("2001:0db8:85a3:0000:0000:8a2e:0370:7334", &valid), CASS_OK);
   EXPECT_EQ(valid.address_length, 16);
-  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042),
-            CASS_OK);
+  EXPECT_EQ(cass_statement_set_host_inet(statement.get(), &valid, 9042), CASS_OK);
 }
 
 /**
diff --git a/gtests/src/integration/tests/test_tracing.cpp b/gtests/src/integration/tests/test_tracing.cpp
index 035e43202..13d324b4d 100644
--- a/gtests/src/integration/tests/test_tracing.cpp
+++ b/gtests/src/integration/tests/test_tracing.cpp
@@ -16,7 +16,7 @@
 
 #include "integration.hpp"
 
-class TracingTests : public Integration { };
+class TracingTests : public Integration {};
 
 CASSANDRA_INTEGRATION_TEST_F(TracingTests, Simple) {
   CHECK_FAILURE;
@@ -35,7 +35,7 @@ CASSANDRA_INTEGRATION_TEST_F(TracingTests, Simple) {
     Statement statement("SELECT * FROM system_traces.sessions WHERE session_id = ?", 1);
     statement.bind(0, tracing_id);
     Result result = session_.execute(statement);
-    ASSERT_GT(result.row_count(),  0u);
+    ASSERT_GT(result.row_count(), 0u);
     Uuid session_id = result.first_row().column_by_name<Uuid>("session_id");
     ASSERT_FALSE(session_id.is_null());
     EXPECT_EQ(tracing_id, session_id);
diff --git a/gtests/src/integration/tlog.hpp b/gtests/src/integration/tlog.hpp
index fc81b83f5..851583f4e 100644
--- a/gtests/src/integration/tlog.hpp
+++ b/gtests/src/integration/tlog.hpp
@@ -20,9 +20,10 @@
 #include "options.hpp"
 
 // Create simple console logging functions
-#define TEST_LOG_MESSAGE(message, is_output) if (is_output) { \
-  std::cerr << "test> " << message << std::endl; \
-}
+#define TEST_LOG_MESSAGE(message, is_output)       \
+  if (is_output) {                                 \
+    std::cerr << "test> " << message << std::endl; \
+  }
 #define TEST_LOG(message) TEST_LOG_MESSAGE(message, Options::is_verbose_integration())
 #define TEST_LOG_ERROR(message) TEST_LOG_MESSAGE(message, true)
 
diff --git a/gtests/src/integration/values.hpp b/gtests/src/integration/values.hpp
index 22f71dfde..a528bb801 100644
--- a/gtests/src/integration/values.hpp
+++ b/gtests/src/integration/values.hpp
@@ -36,8 +36,7 @@
 #include "values/varchar.hpp"
 #include "values/varint.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 typedef NullableValue<values::Ascii> Ascii;
 typedef NullableValue<values::BigInteger> BigInteger;
@@ -61,7 +60,6 @@ typedef NullableValue<values::Uuid> Uuid;
 typedef NullableValue<values::Varchar> Varchar;
 typedef NullableValue<values::Varint> Varint;
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif //__TEST_VALUES_HPP__
diff --git a/gtests/src/integration/values/ascii.hpp b/gtests/src/integration/values/ascii.hpp
index db6c32ddd..8f2b2d081 100644
--- a/gtests/src/integration/values/ascii.hpp
+++ b/gtests/src/integration/values/ascii.hpp
@@ -18,9 +18,7 @@
 #define __TEST_ASCII_HPP__
 #include "nullable_value.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * ASCII wrapped value
@@ -30,23 +28,18 @@ class Ascii {
   typedef std::string ConvenienceType;
   typedef std::string ValueType;
 
-  Ascii() { }
+  Ascii() {}
 
   Ascii(const ConvenienceType& ascii)
-    : ascii_(ascii) { }
+      : ascii_(ascii) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-              cass_collection_append_string(collection.get(), ascii_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_string(collection.get(), ascii_.c_str()));
   }
 
-  std::string cql_type() const {
-    return "ascii";
-  }
+  std::string cql_type() const { return "ascii"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver string
@@ -54,9 +47,7 @@ class Ascii {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const std::string& rhs) const {
-    return ascii_.compare(rhs);
-  }
+  int compare(const std::string& rhs) const { return ascii_.compare(rhs); }
 
   /**
    * Comparison operation for ASCII
@@ -64,57 +55,41 @@ class Ascii {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Ascii& rhs) const {
-    return compare(rhs.ascii_);
-  }
+  int compare(const Ascii& rhs) const { return compare(rhs.ascii_); }
 
   void initialize(const CassValue* value) {
     const char* string = NULL;
     size_t length;
     ASSERT_EQ(CASS_OK, cass_value_get_string(value, &string, &length))
-      << "Unable to Get ASCII: Invalid error code returned";
+        << "Unable to Get ASCII: Invalid error code returned";
     ascii_.assign(string, length);
   }
 
   void set(Tuple tuple, size_t index) {
-    ASSERT_EQ(CASS_OK,
-              cass_tuple_set_string(tuple.get(), index, ascii_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_tuple_set_string(tuple.get(), index, ascii_.c_str()));
   }
 
   void set(UserType user_type, const std::string& name) {
     ASSERT_EQ(CASS_OK,
-              cass_user_type_set_string_by_name(user_type.get(),
-                                                name.c_str(),
-                                                ascii_.c_str()));
+              cass_user_type_set_string_by_name(user_type.get(), name.c_str(), ascii_.c_str()));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_string(statement.get(),
-                                                  index,
-                                                  ascii_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_string(statement.get(), index, ascii_.c_str()));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_string_by_name(statement.get(),
-                                                          name.c_str(),
-                                                          ascii_.c_str()));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_string_by_name(statement.get(), name.c_str(), ascii_.c_str()));
   }
 
-  std::string str() const {
-    return ascii_;
-  }
+  std::string str() const { return ascii_; }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return ascii_;
-  }
+  ValueType value() const { return ascii_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_ASCII;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_ASCII; }
 
 protected:
   /**
@@ -123,14 +98,11 @@ class Ascii {
   std::string ascii_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Ascii& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Ascii& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_ASCII_HPP__
diff --git a/gtests/src/integration/values/blob.hpp b/gtests/src/integration/values/blob.hpp
index 5f64a1899..d1d8b88e1 100644
--- a/gtests/src/integration/values/blob.hpp
+++ b/gtests/src/integration/values/blob.hpp
@@ -21,9 +21,7 @@
 
 #include <cstring>
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Blob wrapped value
@@ -33,23 +31,18 @@ class Blob {
   typedef std::string ConvenienceType;
   typedef std::string ValueType;
 
-  Blob() { }
+  Blob() {}
 
   Blob(const ConvenienceType& blob)
-    : blob_(blob) { }
+      : blob_(blob) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-              cass_collection_append_bytes(collection.get(), data(), size()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_bytes(collection.get(), data(), size()));
   }
 
-  std::string cql_type() const {
-    return "blob";
-  }
+  std::string cql_type() const { return "blob"; }
 
-  std::string cql_value() const {
-    return "'0x" + str() + "'";
-  }
+  std::string cql_value() const { return "'0x" + str() + "'"; }
 
   /**
    * Comparison operation for driver bytes
@@ -74,39 +67,30 @@ class Blob {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Blob& rhs) const {
-    return compare(rhs.blob_);
-  }
+  int compare(const Blob& rhs) const { return compare(rhs.blob_); }
 
   /**
    * Helper method to return data for the blob type
    *
    * @return Blob data
    */
-  const cass_byte_t* data() const {
-    return reinterpret_cast<const cass_byte_t*>(blob_.data());
-  }
-
+  const cass_byte_t* data() const { return reinterpret_cast<const cass_byte_t*>(blob_.data()); }
 
   void initialize(const CassValue* value) {
     const cass_byte_t* bytes = NULL;
     size_t size;
     ASSERT_EQ(CASS_OK, cass_value_get_bytes(value, &bytes, &size))
-      << "Unable to Get Blob: Invalid error code returned";
-    blob_.assign(reinterpret_cast<const char*>(bytes),
-                 size * sizeof(cass_byte_t));
+        << "Unable to Get Blob: Invalid error code returned";
+    blob_.assign(reinterpret_cast<const char*>(bytes), size * sizeof(cass_byte_t));
   }
 
   void set(Tuple tuple, size_t index) {
-    ASSERT_EQ(CASS_OK,
-              cass_tuple_set_bytes(tuple.get(), index, data(), size()));
+    ASSERT_EQ(CASS_OK, cass_tuple_set_bytes(tuple.get(), index, data(), size()));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_bytes_by_name(user_type.get(),
-                                                        name.c_str(),
-                                                        data(),
-                                                        size()));
+    ASSERT_EQ(CASS_OK,
+              cass_user_type_set_bytes_by_name(user_type.get(), name.c_str(), data(), size()));
   }
 
   /**
@@ -114,23 +98,15 @@ class Blob {
    *
    * @return Blob size (e.g.length)
    */
-  size_t size() const {
-    return blob_.size() / sizeof(cass_byte_t);
-  }
-
+  size_t size() const { return blob_.size() / sizeof(cass_byte_t); }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes(statement.get(),
-                                                 index,
-                                                 data(),
-                                                 size()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes(statement.get(), index, data(), size()));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes_by_name(statement.get(),
-                                                         name.c_str(),
-                                                         data(),
-                                                         size()));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_bytes_by_name(statement.get(), name.c_str(), data(), size()));
   }
 
   std::string str() const {
@@ -147,17 +123,11 @@ class Blob {
     return value.str();
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return blob_;
-  }
+  ValueType value() const { return blob_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_BLOB;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_BLOB; }
 
 protected:
   /**
@@ -166,14 +136,11 @@ class Blob {
   std::string blob_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Blob& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Blob& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_BLOB_HPP__
diff --git a/gtests/src/integration/values/boolean.hpp b/gtests/src/integration/values/boolean.hpp
index 1b19dfb8b..5a4da0f34 100644
--- a/gtests/src/integration/values/boolean.hpp
+++ b/gtests/src/integration/values/boolean.hpp
@@ -19,9 +19,7 @@
 #include "nullable_value.hpp"
 #include "test_utils.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Boolean wrapped value
@@ -32,23 +30,18 @@ class Boolean {
   typedef cass_bool_t ValueType;
 
   Boolean()
-    : boolean_(cass_false) { }
+      : boolean_(cass_false) {}
 
   Boolean(const ConvenienceType boolean)
-    : boolean_(boolean ? cass_true : cass_false) { }
+      : boolean_(boolean ? cass_true : cass_false) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-      cass_collection_append_bool(collection.get(), boolean_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_bool(collection.get(), boolean_));
   }
 
-  std::string cql_type() const {
-    return "boolean";
-  }
+  std::string cql_type() const { return "boolean"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver booleans
@@ -69,13 +62,11 @@ class Boolean {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Boolean& rhs) const {
-    return compare(rhs.boolean_);
-  }
+  int compare(const Boolean& rhs) const { return compare(rhs.boolean_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_bool(value, &boolean_))
-      << "Unable to Get Boolean: Invalid error code returned";
+        << "Unable to Get Boolean: Invalid error code returned";
   }
 
   void set(Tuple tuple, size_t index) {
@@ -83,38 +74,24 @@ class Boolean {
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_bool_by_name(user_type.get(),
-                                                       name.c_str(),
-                                                       boolean_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_bool_by_name(user_type.get(), name.c_str(), boolean_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bool(statement.get(),
-                                                index,
-                                                boolean_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_bool(statement.get(), index, boolean_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bool_by_name(statement.get(),
-                                                        name.c_str(),
-                                                        boolean_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_bool_by_name(statement.get(), name.c_str(), boolean_));
   }
 
-  std::string str() const {
-    return (boolean_ == cass_true ? "true" : "false");
-  }
+  std::string str() const { return (boolean_ == cass_true ? "true" : "false"); }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return boolean_;
-  }
+  ValueType value() const { return boolean_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_BOOLEAN;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_BOOLEAN; }
 
 protected:
   /**
@@ -123,14 +100,11 @@ class Boolean {
   cass_bool_t boolean_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Boolean& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Boolean& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_BOOLEAN_HPP__
diff --git a/gtests/src/integration/values/date.hpp b/gtests/src/integration/values/date.hpp
index 50c5e49c5..0302229cb 100644
--- a/gtests/src/integration/values/date.hpp
+++ b/gtests/src/integration/values/date.hpp
@@ -25,9 +25,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Date wrapped value
@@ -38,23 +36,18 @@ class Date {
   typedef cass_uint32_t ValueType;
 
   Date()
-    : date_(0) { }
+      : date_(0) {}
 
   Date(const ConvenienceType date)
-    : date_(date) { }
+      : date_(date) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-      cass_collection_append_uint32(collection.get(), date_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_uint32(collection.get(), date_));
   }
 
-  std::string cql_type() const {
-    return "date";
-  }
+  std::string cql_type() const { return "date"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver unsigned integers (e.g. date)
@@ -75,13 +68,11 @@ class Date {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Date& rhs) const {
-    return compare(rhs.date_);
-  }
+  int compare(const Date& rhs) const { return compare(rhs.date_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_uint32(value, &date_))
-      << "Unable to Get Date: Invalid error code returned";
+        << "Unable to Get Date: Invalid error code returned";
   }
 
   static Date max() {
@@ -97,21 +88,15 @@ class Date {
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_uint32_by_name(user_type.get(),
-                                                         name.c_str(),
-                                                         date_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_uint32_by_name(user_type.get(), name.c_str(), date_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_uint32(statement.get(),
-                                                  index,
-                                                  date_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_uint32(statement.get(), index, date_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_uint32_by_name(statement.get(),
-                                                          name.c_str(),
-                                                          date_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_uint32_by_name(statement.get(), name.c_str(), date_));
   }
 
   std::string str() const {
@@ -122,17 +107,11 @@ class Date {
     return date_string;
   }
 
-  static std::string supported_server_version() {
-    return "2.2.3";
-  }
+  static std::string supported_server_version() { return "2.2.3"; }
 
-  cass_uint32_t value() const {
-    return date_;
-  }
+  cass_uint32_t value() const { return date_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_DATE;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_DATE; }
 
 protected:
   /**
@@ -141,15 +120,12 @@ class Date {
   cass_uint32_t date_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Date& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Date& value) {
   // Output both values
   output_stream << value.cql_value() << " [ = " << value.value() << "]";
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_DATE_HPP__
diff --git a/gtests/src/integration/values/decimal.hpp b/gtests/src/integration/values/decimal.hpp
index fbd1a0e97..61154fac4 100644
--- a/gtests/src/integration/values/decimal.hpp
+++ b/gtests/src/integration/values/decimal.hpp
@@ -18,9 +18,7 @@
 #define __TEST_DECIMAL_HPP__
 #include "varint.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Decimal wrapped value
@@ -29,23 +27,18 @@ class Decimal : public Varint {
 public:
   using Varint::compare;
 
-  Decimal() { }
+  Decimal() {}
 
   Decimal(const ConvenienceType& decimal)
-    : Varint(decimal) { }
+      : Varint(decimal) {}
 
   void append(Collection collection) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK,
-              cass_collection_append_decimal(collection.get(),
-              bytes.data(),
-              bytes.size(),
-              varint_.scale()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_decimal(collection.get(), bytes.data(), bytes.size(),
+                                                      varint_.scale()));
   }
 
-  std::string cql_type() const {
-    return "decimal";
-  }
+  std::string cql_type() const { return "decimal"; }
 
   /**
    * Comparison operation for varint
@@ -53,68 +46,51 @@ class Decimal : public Varint {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Decimal& rhs) const {
-    return Varint::compare(rhs.varint_);
-  }
+  int compare(const Decimal& rhs) const { return Varint::compare(rhs.varint_); }
 
   void initialize(const CassValue* value) {
     const cass_byte_t* bytes = NULL;
     size_t size;
     cass_int32_t scale;
     ASSERT_EQ(CASS_OK, cass_value_get_decimal(value, &bytes, &size, &scale))
-      << "Unable to Get Decimal: Invalid error code returned";
+        << "Unable to Get Decimal: Invalid error code returned";
     varint_ = BigNumber(bytes, size, scale);
   }
 
   void set(Tuple tuple, size_t index) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_tuple_set_decimal(tuple.get(),
-              index,
-              bytes.data(),
-              bytes.size(),
-              varint_.scale()));
+    ASSERT_EQ(CASS_OK, cass_tuple_set_decimal(tuple.get(), index, bytes.data(), bytes.size(),
+                                              varint_.scale()));
   }
 
   void set(UserType user_type, const std::string& name) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_user_type_set_decimal_by_name(user_type.get(),
-              name.c_str(),
-              bytes.data(),
-              bytes.size(),
-              varint_.scale()));
+    ASSERT_EQ(CASS_OK,
+              cass_user_type_set_decimal_by_name(user_type.get(), name.c_str(), bytes.data(),
+                                                 bytes.size(), varint_.scale()));
   }
 
   void statement_bind(Statement statement, size_t index) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_statement_bind_decimal(statement.get(),
-              index,
-              bytes.data(),
-              bytes.size(),
-              varint_.scale()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_decimal(statement.get(), index, bytes.data(),
+                                                   bytes.size(), varint_.scale()));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_statement_bind_decimal_by_name(statement.get(),
-              name.c_str(),
-              bytes.data(),
-              bytes.size(),
-              varint_.scale()));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_decimal_by_name(statement.get(), name.c_str(), bytes.data(),
+                                                  bytes.size(), varint_.scale()));
   }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_DECIMAL;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_DECIMAL; }
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Decimal& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Decimal& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_DECIMAL_HPP__
diff --git a/gtests/src/integration/values/double.hpp b/gtests/src/integration/values/double.hpp
index fd68ead58..d8f7f075c 100644
--- a/gtests/src/integration/values/double.hpp
+++ b/gtests/src/integration/values/double.hpp
@@ -29,9 +29,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Double wrapped value
@@ -42,23 +40,18 @@ class Double {
   typedef cass_double_t ValueType;
 
   Double()
-    : double_(0.0) { }
+      : double_(0.0) {}
 
   Double(const ConvenienceType double_value)
-    : double_(double_value) { }
+      : double_(double_value) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_double(collection.get(),
-                                                     double_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_double(collection.get(), double_));
   }
 
-  std::string cql_type() const {
-    return "double";
-  }
+  std::string cql_type() const { return "double"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver doubles
@@ -79,43 +72,31 @@ class Double {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Double& rhs) const {
-    return compare(rhs.double_);
-  }
+  int compare(const Double& rhs) const { return compare(rhs.double_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_double(value, &double_))
-      << "Unable to Get Double: Invalid error code returned";
+        << "Unable to Get Double: Invalid error code returned";
   }
 
-  static Double max() {
-    return Double(std::numeric_limits<cass_double_t>::max());
-  }
+  static Double max() { return Double(std::numeric_limits<cass_double_t>::max()); }
 
-  static Double min() {
-    return Double(std::numeric_limits<cass_double_t>::min());
-  }
+  static Double min() { return Double(std::numeric_limits<cass_double_t>::min()); }
 
   void set(Tuple tuple, size_t index) {
     ASSERT_EQ(CASS_OK, cass_tuple_set_double(tuple.get(), index, double_));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_double_by_name(user_type.get(),
-                                                         name.c_str(),
-                                                         double_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_double_by_name(user_type.get(), name.c_str(), double_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_double(statement.get(),
-                                                  index,
-                                                  double_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_double(statement.get(), index, double_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_double_by_name(statement.get(),
-                                                          name.c_str(),
-                                                          double_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_double_by_name(statement.get(), name.c_str(), double_));
   }
 
   std::string str() const {
@@ -124,17 +105,11 @@ class Double {
     return double_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  cass_double_t value() const {
-    return double_;
-  }
+  cass_double_t value() const { return double_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_DOUBLE;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_DOUBLE; }
 
 protected:
   /**
@@ -143,8 +118,6 @@ class Double {
   cass_double_t double_;
 };
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_DOUBLE_HPP__
diff --git a/gtests/src/integration/values/duration.hpp b/gtests/src/integration/values/duration.hpp
index aa83a4989..67e3cdc85 100644
--- a/gtests/src/integration/values/duration.hpp
+++ b/gtests/src/integration/values/duration.hpp
@@ -18,8 +18,7 @@
 #define __TEST_DURATION_HPP__
 #include "nullable_value.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Simple structure making up the months, days, and nanos for the duration
@@ -27,13 +26,13 @@ namespace driver {
  */
 struct CassDuration {
   CassDuration()
-    : months(0)
-    , days(0)
-    , nanos(0) { }
+      : months(0)
+      , days(0)
+      , nanos(0) {}
   CassDuration(cass_int32_t months, cass_int32_t days, cass_int64_t nanos)
-    : months(months)
-    , days(days)
-    , nanos(nanos) { }
+      : months(months)
+      , days(days)
+      , nanos(nanos) {}
   cass_int32_t months;
   cass_int32_t days;
   cass_int64_t nanos;
@@ -49,25 +48,19 @@ class Duration {
   typedef CassDuration ConvenienceType;
   typedef CassDuration ValueType;
 
-  Duration() { }
+  Duration() {}
 
   Duration(const ConvenienceType duration)
-    : duration_(duration) { }
+      : duration_(duration) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_duration(collection.get(),
-                                                       duration_.months,
-                                                       duration_.days,
-                                                       duration_.nanos));
+    ASSERT_EQ(CASS_OK, cass_collection_append_duration(collection.get(), duration_.months,
+                                                       duration_.days, duration_.nanos));
   }
 
-  std::string cql_type() const {
-    return "duration";
-  }
+  std::string cql_type() const { return "duration"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver duration integers
@@ -92,81 +85,56 @@ class Duration {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Duration& rhs) const {
-    return compare(rhs.duration_);
-  }
+  int compare(const Duration& rhs) const { return compare(rhs.duration_); }
 
   void initialize(const CassValue* value) {
-    ASSERT_EQ(CASS_OK, cass_value_get_duration(value,
-              &duration_.months,
-              &duration_.days,
-              &duration_.nanos))
-      << "Unable to Get Duration: Invalid error code returned";
+    ASSERT_EQ(CASS_OK,
+              cass_value_get_duration(value, &duration_.months, &duration_.days, &duration_.nanos))
+        << "Unable to Get Duration: Invalid error code returned";
   }
 
   void set(Tuple tuple, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_tuple_set_duration(tuple.get(),
-                                               index,
-                                               duration_.months,
-                                               duration_.days,
+    ASSERT_EQ(CASS_OK, cass_tuple_set_duration(tuple.get(), index, duration_.months, duration_.days,
                                                duration_.nanos));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_duration_by_name(user_type.get(),
-                                                           name.c_str(),
-                                                           duration_.months,
-                                                           duration_.days,
-                                                           duration_.nanos));
+    ASSERT_EQ(CASS_OK,
+              cass_user_type_set_duration_by_name(user_type.get(), name.c_str(), duration_.months,
+                                                  duration_.days, duration_.nanos));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_duration(statement.get(),
-                                                    index,
-                                                    duration_.months,
-                                                    duration_.days,
-                                                    duration_.nanos));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_duration(statement.get(), index, duration_.months,
+                                                    duration_.days, duration_.nanos));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_duration_by_name(statement.get(),
-                                                            name.c_str(),
-                                                            duration_.months,
-                                                            duration_.days,
-                                                            duration_.nanos));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_duration_by_name(statement.get(), name.c_str(), duration_.months,
+                                                   duration_.days, duration_.nanos));
   }
 
   std::string str() const {
     // Determine if any portion of the duration are negative
     bool is_negative = false;
-    is_negative = (duration_.months < 0 ||
-                   duration_.days < 0 ||
-                   duration_.nanos < 0);
+    is_negative = (duration_.months < 0 || duration_.days < 0 || duration_.nanos < 0);
 
     // Convert the duration to a human readable format
     cass_int32_t months = duration_.months < 0 ? -duration_.months : duration_.months;
     cass_int32_t days = duration_.days < 0 ? -duration_.days : duration_.days;
     cass_int64_t nanos = duration_.nanos < 0 ? -duration_.nanos : duration_.nanos;
     std::ostringstream duration_string;
-    duration_string << (is_negative ? "-1" : "")
-                    << months << "mo"
-                    << days << "d"
-                    << nanos << "ns";
+    duration_string << (is_negative ? "-1" : "") << months << "mo" << days << "d" << nanos << "ns";
 
     return duration_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "3.10";
-  }
+  static std::string supported_server_version() { return "3.10"; }
 
-  ValueType value() const {
-    return duration_;
-  }
+  ValueType value() const { return duration_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_DURATION;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_DURATION; }
 
 protected:
   /**
@@ -175,14 +143,12 @@ class Duration {
   CassDuration duration_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Duration& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Duration& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
 } // namespace values
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_DURATION_HPP__
diff --git a/gtests/src/integration/values/float.hpp b/gtests/src/integration/values/float.hpp
index 130254fa8..783e9b146 100644
--- a/gtests/src/integration/values/float.hpp
+++ b/gtests/src/integration/values/float.hpp
@@ -29,9 +29,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Float wrapped value
@@ -42,23 +40,18 @@ class Float {
   typedef cass_float_t ValueType;
 
   Float()
-    : float_(0.0f) { }
+      : float_(0.0f) {}
 
   Float(const ConvenienceType float_value)
-    : float_(float_value) { }
+      : float_(float_value) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_float(collection.get(),
-                                                    float_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_float(collection.get(), float_));
   }
 
-  std::string cql_type() const {
-    return "float";
-  }
+  std::string cql_type() const { return "float"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver floats
@@ -79,43 +72,31 @@ class Float {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Float& rhs) const {
-    return compare(rhs.float_);
-  }
+  int compare(const Float& rhs) const { return compare(rhs.float_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_float(value, &float_))
-      << "Unable to Get Float: Invalid error code returned";
+        << "Unable to Get Float: Invalid error code returned";
   }
 
-  static Float max() {
-    return Float(std::numeric_limits<cass_float_t>::max());
-  }
+  static Float max() { return Float(std::numeric_limits<cass_float_t>::max()); }
 
-  static Float min() {
-    return Float(std::numeric_limits<cass_float_t>::min());
-  }
+  static Float min() { return Float(std::numeric_limits<cass_float_t>::min()); }
 
   void set(Tuple tuple, size_t index) {
     ASSERT_EQ(CASS_OK, cass_tuple_set_float(tuple.get(), index, float_));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_float_by_name(user_type.get(),
-                                                        name.c_str(),
-                                                        float_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_float_by_name(user_type.get(), name.c_str(), float_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_float(statement.get(),
-                                                 index,
-                                                 float_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_float(statement.get(), index, float_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_float_by_name(statement.get(),
-                                                         name.c_str(),
-                                                         float_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_float_by_name(statement.get(), name.c_str(), float_));
   }
 
   std::string str() const {
@@ -124,17 +105,11 @@ class Float {
     return float_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return float_;
-  }
+  ValueType value() const { return float_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_FLOAT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_FLOAT; }
 
 protected:
   /**
@@ -143,8 +118,6 @@ class Float {
   cass_float_t float_;
 };
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_FLOAT_HPP__
diff --git a/gtests/src/integration/values/inet.hpp b/gtests/src/integration/values/inet.hpp
index ce64968dc..c3d4adab8 100644
--- a/gtests/src/integration/values/inet.hpp
+++ b/gtests/src/integration/values/inet.hpp
@@ -19,9 +19,7 @@
 #include "nullable_value.hpp"
 #include "test_utils.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Inet wrapped value
@@ -31,32 +29,25 @@ class Inet {
   typedef std::string ConvenienceType;
   typedef CassInet ValueType;
 
-  Inet() { }
+  Inet() {}
 
   Inet(const ConvenienceType& address) {
     std::string address_trim = Utils::trim(address);
 
     // Determine if the value is valid
-    CassError error_code = cass_inet_from_string(address_trim.c_str(),
-                                                 &inet_);
+    CassError error_code = cass_inet_from_string(address_trim.c_str(), &inet_);
     if (error_code != CASS_OK) {
-      EXPECT_TRUE(false) << "Invalid Inet " << address_trim
-        << ": Value will be NULL";
+      EXPECT_TRUE(false) << "Invalid Inet " << address_trim << ": Value will be NULL";
     }
   }
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_inet(collection.get(),
-                                                   inet_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_inet(collection.get(), inet_));
   }
 
-  std::string cql_type() const {
-    return "inet";
-  }
+  std::string cql_type() const { return "inet"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver addresses
@@ -77,13 +68,11 @@ class Inet {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Inet& rhs) const {
-    return compare(rhs.inet_);
-  }
+  int compare(const Inet& rhs) const { return compare(rhs.inet_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_inet(value, &inet_))
-      << "Unable to Get Inet: Invalid error code returned";
+        << "Unable to Get Inet: Invalid error code returned";
   }
 
   static Inet max() {
@@ -105,9 +94,7 @@ class Inet {
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_inet_by_name(user_type.get(),
-                                                       name.c_str(),
-                                                       inet_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_inet_by_name(user_type.get(), name.c_str(), inet_));
   }
 
   void statement_bind(Statement statement, size_t index) {
@@ -115,9 +102,7 @@ class Inet {
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_inet_by_name(statement.get(),
-                                                        name.c_str(),
-                                                        inet_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_inet_by_name(statement.get(), name.c_str(), inet_));
   }
 
   std::string str() const {
@@ -126,17 +111,11 @@ class Inet {
     return inet_string;
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return inet_;
-  }
+  ValueType value() const { return inet_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_INET;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_INET; }
 
 protected:
   /**
@@ -145,14 +124,11 @@ class Inet {
   CassInet inet_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Inet& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Inet& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_INET_HPP__
diff --git a/gtests/src/integration/values/integer.hpp b/gtests/src/integration/values/integer.hpp
index 899d2a4b7..f9a2fc331 100644
--- a/gtests/src/integration/values/integer.hpp
+++ b/gtests/src/integration/values/integer.hpp
@@ -29,9 +29,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * 8-bit integer wrapped value
@@ -42,22 +40,18 @@ class TinyInteger {
   typedef cass_int8_t ValueType;
 
   TinyInteger()
-    : integer_(0) { }
+      : integer_(0) {}
 
   TinyInteger(ConvenienceType integer)
-    : integer_(integer) { }
+      : integer_(integer) {}
 
   void append(Collection collection) {
     ASSERT_EQ(CASS_OK, cass_collection_append_int8(collection.get(), integer_));
   }
 
-  std::string cql_type() const {
-    return "tinyint";
-  }
+  std::string cql_type() const { return "tinyint"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver integers
@@ -78,43 +72,31 @@ class TinyInteger {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const TinyInteger& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const TinyInteger& rhs) const { return compare(rhs.integer_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_int8(value, &integer_))
-      << "Unable to Get 8-bit Integer: Invalid error code returned";
+        << "Unable to Get 8-bit Integer: Invalid error code returned";
   }
 
-  static TinyInteger max() {
-    return TinyInteger(std::numeric_limits<cass_int8_t>::max());
-  }
+  static TinyInteger max() { return TinyInteger(std::numeric_limits<cass_int8_t>::max()); }
 
-  static TinyInteger min() {
-    return TinyInteger(std::numeric_limits<cass_int8_t>::min());
-  }
+  static TinyInteger min() { return TinyInteger(std::numeric_limits<cass_int8_t>::min()); }
 
   void set(Tuple tuple, size_t index) {
     ASSERT_EQ(CASS_OK, cass_tuple_set_int8(tuple.get(), index, integer_));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_int8_by_name(user_type.get(),
-                                                       name.c_str(),
-                                                       integer_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_int8_by_name(user_type.get(), name.c_str(), integer_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int8(statement.get(),
-                                                index,
-                                                integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int8(statement.get(), index, integer_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int8_by_name(statement.get(),
-                                                        name.c_str(),
-                                                        integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int8_by_name(statement.get(), name.c_str(), integer_));
   }
 
   std::string str() const {
@@ -123,17 +105,11 @@ class TinyInteger {
     return integer_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "2.2.3";
-  }
+  static std::string supported_server_version() { return "2.2.3"; }
 
-  ValueType value() const {
-    return integer_;
-  }
+  ValueType value() const { return integer_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_TINY_INT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_TINY_INT; }
 
 protected:
   /**
@@ -151,23 +127,18 @@ class SmallInteger {
   typedef cass_int16_t ValueType;
 
   SmallInteger()
-    : integer_(0) { }
+      : integer_(0) {}
 
   SmallInteger(ConvenienceType integer)
-    : integer_(integer) { }
+      : integer_(integer) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_int16(collection.get(),
-                                                    integer_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_int16(collection.get(), integer_));
   }
 
-  std::string cql_type() const {
-    return "smallint";
-  }
+  std::string cql_type() const { return "smallint"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver integers
@@ -188,43 +159,31 @@ class SmallInteger {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const SmallInteger& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const SmallInteger& rhs) const { return compare(rhs.integer_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_int16(value, &integer_))
-      << "Unable to Get 16-bit Integer: Invalid error code returned";
+        << "Unable to Get 16-bit Integer: Invalid error code returned";
   }
 
-  static SmallInteger max() {
-    return SmallInteger(std::numeric_limits<cass_int16_t>::max());
-  }
+  static SmallInteger max() { return SmallInteger(std::numeric_limits<cass_int16_t>::max()); }
 
-  static SmallInteger min() {
-    return SmallInteger(std::numeric_limits<cass_int16_t>::min());
-  }
+  static SmallInteger min() { return SmallInteger(std::numeric_limits<cass_int16_t>::min()); }
 
   void set(Tuple tuple, size_t index) {
     ASSERT_EQ(CASS_OK, cass_tuple_set_int16(tuple.get(), index, integer_));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_int16_by_name(user_type.get(),
-                                                        name.c_str(),
-                                                        integer_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_int16_by_name(user_type.get(), name.c_str(), integer_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int16(statement.get(),
-                                                 index,
-                                                 integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int16(statement.get(), index, integer_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int16_by_name(statement.get(),
-                                                         name.c_str(),
-                                                         integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int16_by_name(statement.get(), name.c_str(), integer_));
   }
 
   std::string str() const {
@@ -233,17 +192,11 @@ class SmallInteger {
     return integer_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "2.2.3";
-  }
+  static std::string supported_server_version() { return "2.2.3"; }
 
-  ValueType value() const {
-    return integer_;
-  }
+  ValueType value() const { return integer_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_SMALL_INT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_SMALL_INT; }
 
 protected:
   /**
@@ -261,23 +214,18 @@ class Integer {
   typedef cass_int32_t ValueType;
 
   Integer()
-    : integer_(0) { }
+      : integer_(0) {}
 
   Integer(ConvenienceType integer)
-    : integer_(integer) { }
+      : integer_(integer) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_int32(collection.get(),
-                                                    integer_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_int32(collection.get(), integer_));
   }
 
-  std::string cql_type() const {
-    return "int";
-  }
+  std::string cql_type() const { return "int"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver integers
@@ -298,21 +246,15 @@ class Integer {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Integer& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const Integer& rhs) const { return compare(rhs.integer_); }
 
-  static Integer max() {
-    return Integer(std::numeric_limits<cass_int32_t>::max());
-  }
+  static Integer max() { return Integer(std::numeric_limits<cass_int32_t>::max()); }
 
-  static Integer min() {
-    return Integer(std::numeric_limits<cass_int32_t>::min());
-  }
+  static Integer min() { return Integer(std::numeric_limits<cass_int32_t>::min()); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_int32(value, &integer_))
-      << "Unable to Get 32-bit Integer: Invalid error code returned";
+        << "Unable to Get 32-bit Integer: Invalid error code returned";
   }
 
   void set(Tuple tuple, size_t index) {
@@ -320,21 +262,15 @@ class Integer {
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_int32_by_name(user_type.get(),
-                                                        name.c_str(),
-                                                        integer_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_int32_by_name(user_type.get(), name.c_str(), integer_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int32(statement.get(),
-                                                 index,
-                                                 integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int32(statement.get(), index, integer_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int32_by_name(statement.get(),
-                                                         name.c_str(),
-                                                         integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int32_by_name(statement.get(), name.c_str(), integer_));
   }
 
   std::string str() const {
@@ -343,17 +279,11 @@ class Integer {
     return integer_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return integer_;
-  }
+  ValueType value() const { return integer_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_INT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_INT; }
 
 protected:
   /**
@@ -371,23 +301,18 @@ class BigInteger {
   typedef cass_int64_t ValueType;
 
   BigInteger()
-    : integer_(0) { }
+      : integer_(0) {}
 
   BigInteger(ConvenienceType integer)
-    : integer_(integer) { }
+      : integer_(integer) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_int64(collection.get(),
-                                                    integer_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_int64(collection.get(), integer_));
   }
 
-  std::string cql_type() const {
-    return "bigint";
-  }
+  std::string cql_type() const { return "bigint"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver integers
@@ -408,43 +333,31 @@ class BigInteger {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const BigInteger& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const BigInteger& rhs) const { return compare(rhs.integer_); }
 
   void initialize(const CassValue* value) {
     ASSERT_EQ(CASS_OK, cass_value_get_int64(value, &integer_))
-      << "Unable to Get 64-bit Integer: Invalid error code returned";
+        << "Unable to Get 64-bit Integer: Invalid error code returned";
   }
 
-  static BigInteger max() {
-    return BigInteger(std::numeric_limits<cass_int64_t>::max());
-  }
+  static BigInteger max() { return BigInteger(std::numeric_limits<cass_int64_t>::max()); }
 
-  static BigInteger min() {
-    return BigInteger(std::numeric_limits<cass_int64_t>::min());
-  }
+  static BigInteger min() { return BigInteger(std::numeric_limits<cass_int64_t>::min()); }
 
   void set(Tuple tuple, size_t index) {
     ASSERT_EQ(CASS_OK, cass_tuple_set_int64(tuple.get(), index, integer_));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_int64_by_name(user_type.get(),
-                                                        name.c_str(),
-                                                        integer_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_int64_by_name(user_type.get(), name.c_str(), integer_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int64(statement.get(),
-                                                 index,
-                                                 integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int64(statement.get(), index, integer_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_int64_by_name(statement.get(),
-                                                         name.c_str(),
-                                                         integer_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_int64_by_name(statement.get(), name.c_str(), integer_));
   }
 
   std::string str() const {
@@ -453,25 +366,15 @@ class BigInteger {
     return integer_string.str();
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return integer_;
-  }
+  ValueType value() const { return integer_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_BIGINT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_BIGINT; }
 
-  BigInteger operator -(const BigInteger& rhs) {
-    return integer_ - rhs.integer_;
-  }
+  BigInteger operator-(const BigInteger& rhs) { return integer_ - rhs.integer_; }
 
-  BigInteger operator +(const BigInteger& rhs) {
-    return integer_ + rhs.integer_;
-  }
+  BigInteger operator+(const BigInteger& rhs) { return integer_ + rhs.integer_; }
 
 protected:
   /**
@@ -486,43 +389,34 @@ class BigInteger {
 class Counter : public BigInteger {
 public:
   Counter()
-    : BigInteger(0) { }
+      : BigInteger(0) {}
 
   Counter(ConvenienceType integer)
-    : BigInteger(integer) { }
+      : BigInteger(integer) {}
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_COUNTER;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_COUNTER; }
 };
 
-
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const TinyInteger& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const TinyInteger& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const SmallInteger& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const SmallInteger& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Integer& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Integer& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const BigInteger& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const BigInteger& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_INTEGER_HPP__
diff --git a/gtests/src/integration/values/list.hpp b/gtests/src/integration/values/list.hpp
index 82ab7bd3e..4dddebe21 100644
--- a/gtests/src/integration/values/list.hpp
+++ b/gtests/src/integration/values/list.hpp
@@ -21,24 +21,25 @@
 
 #include <algorithm>
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * List wrapped value
  */
-template<typename T>
-class List : public Collection, Comparable<List<T> > {
+template <typename T>
+class List
+    : public Collection
+    , Comparable<List<T> > {
 public:
   List()
-    : Collection(CASS_COLLECTION_TYPE_LIST) { }
+      : Collection(CASS_COLLECTION_TYPE_LIST) {}
 
   List(const std::vector<T>& list)
-    : Collection(CASS_COLLECTION_TYPE_LIST, list.size())
-    , list_(list) {
+      : Collection(CASS_COLLECTION_TYPE_LIST, list.size())
+      , list_(list) {
     // Create the collection
-    for (typename std::vector<T>::const_iterator iterator = list.begin();
-         iterator != list.end(); ++iterator) {
+    for (typename std::vector<T>::const_iterator iterator = list.begin(); iterator != list.end();
+         ++iterator) {
       T value = *iterator;
       Collection::append<T>(value);
       primary_sub_type_ = value.value_type();
@@ -47,22 +48,18 @@ class List : public Collection, Comparable<List<T> > {
   }
 
   List(const CassValue* value)
-    : Collection(CASS_COLLECTION_TYPE_LIST) {
+      : Collection(CASS_COLLECTION_TYPE_LIST) {
     initialize(value);
   }
 
-  void append(Collection collection) {
-    Collection::append(collection);
-  }
+  void append(Collection collection) { Collection::append(collection); }
 
   std::string cql_type() const {
     std::string cql_type = "list<" + list_[0].cql_type() + ">";
     return cql_type;
   }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver value list. This comparison is performed in
@@ -97,55 +94,42 @@ class List : public Collection, Comparable<List<T> > {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const List& rhs) const {
-    return compare(rhs.list_);
-  }
+  int compare(const List& rhs) const { return compare(rhs.list_); }
 
-  bool is_null() const {
-    return Collection::is_null_;
-  }
+  bool is_null() const { return Collection::is_null_; }
 
-  void set(Tuple tuple, size_t index) {
-    Collection::set(tuple, index);
-  }
+  void set(Tuple tuple, size_t index) { Collection::set(tuple, index); }
 
-  void set(UserType user_type, const std::string& name) {
-    Collection::set(user_type, name);
-  }
+  void set(UserType user_type, const std::string& name) { Collection::set(user_type, name); }
 
   /**
    * Get the size of the list
    *
    * @return The number of values in the list
    */
-  size_t size() const {
-    return list_.size();
-  }
+  size_t size() const { return list_.size(); }
 
   void statement_bind(Statement statement, size_t index) {
     if (is_null()) {
       ASSERT_EQ(CASS_OK, cass_statement_bind_null(statement.get(), index));
     } else {
-      ASSERT_EQ(CASS_OK,
-        cass_statement_bind_collection(statement.get(), index, get()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_collection(statement.get(), index, get()));
     }
   }
 
   void statement_bind(Statement statement, const std::string& name) {
     if (is_null()) {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(),
-                                                          name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(), name.c_str()));
     } else {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_collection_by_name(statement.get(),
-                                                                name.c_str(),
-                                                                get()));
+      ASSERT_EQ(CASS_OK,
+                cass_statement_bind_collection_by_name(statement.get(), name.c_str(), get()));
     }
   }
 
   std::string str() const {
     if (is_null()) {
       return "null";
-    } else if (list_.empty()){
+    } else if (list_.empty()) {
       return "[]";
     } else {
       std::stringstream list_string;
@@ -164,17 +148,11 @@ class List : public Collection, Comparable<List<T> > {
     }
   }
 
-  std::vector<T> value() const {
-    return list_;
-  }
+  std::vector<T> value() const { return list_; }
 
-  CassCollectionType collection_type() const {
-    return collection_type_;
-  }
+  CassCollectionType collection_type() const { return collection_type_; }
 
-  CassValueType value_type() const {
-    return primary_sub_type_;
-  }
+  CassValueType value_type() const { return primary_sub_type_; }
 
 private:
   /**
@@ -203,8 +181,6 @@ inline std::ostream& operator<<(std::ostream& os, const List<T>& list) {
   return os;
 }
 
-} // namespace driver
-} // namespace test
-
+}} // namespace test::driver
 
 #endif // __TEST_LIST_HPP__
diff --git a/gtests/src/integration/values/map.hpp b/gtests/src/integration/values/map.hpp
index 0e8aba723..74d0ca94a 100644
--- a/gtests/src/integration/values/map.hpp
+++ b/gtests/src/integration/values/map.hpp
@@ -19,24 +19,23 @@
 #include "nullable_value.hpp"
 #include "test_utils.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Map wrapped value
  */
-template<typename K, typename V>
+template <typename K, typename V>
 class Map : public Collection {
 public:
   Map()
-    : Collection(CASS_COLLECTION_TYPE_MAP) { }
+      : Collection(CASS_COLLECTION_TYPE_MAP) {}
 
   Map(const std::map<K, V>& map)
-    : Collection(CASS_COLLECTION_TYPE_MAP, map.size())
-    , map_(map) {
+      : Collection(CASS_COLLECTION_TYPE_MAP, map.size())
+      , map_(map) {
     // Create the collection
-    for (typename std::map<K, V>::const_iterator iterator = map.begin();
-      iterator != map.end(); ++iterator) {
+    for (typename std::map<K, V>::const_iterator iterator = map.begin(); iterator != map.end();
+         ++iterator) {
       K key = iterator->first;
       V value = iterator->second;
       Collection::append<K>(key);
@@ -47,82 +46,63 @@ class Map : public Collection {
   }
 
   Map(const CassValue* value)
-    : Collection(CASS_COLLECTION_TYPE_MAP) {
+      : Collection(CASS_COLLECTION_TYPE_MAP) {
     initialize(value);
   }
 
-  void append(Collection collection) {
-    Collection::append(collection);
-  }
+  void append(Collection collection) { Collection::append(collection); }
 
   std::string cql_type() const {
     typename std::map<K, V>::const_iterator iterator = map_.begin();
-    std::string cql_type = "map<" + iterator->first.cql_type() + ", "
-      + iterator->second.cql_type() + ">";
+    std::string cql_type =
+        "map<" + iterator->first.cql_type() + ", " + iterator->second.cql_type() + ">";
     return cql_type;
   }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
-  bool is_null() const {
-    return Collection::is_null_;
-  }
+  bool is_null() const { return Collection::is_null_; }
 
-  CassCollectionType collection_type() const {
-    return collection_type_;
-  }
+  CassCollectionType collection_type() const { return collection_type_; }
 
-  void set(Tuple tuple, size_t index) {
-    Collection::set(tuple, index);
-  }
+  void set(Tuple tuple, size_t index) { Collection::set(tuple, index); }
 
-  void set(UserType user_type, const std::string& name) {
-    Collection::set(user_type, name);
-  }
+  void set(UserType user_type, const std::string& name) { Collection::set(user_type, name); }
 
   /**
    * Get the size of the map
    *
    * @return The number of key/value in the map
    */
-  size_t size() const {
-    return map_.size();
-  }
+  size_t size() const { return map_.size(); }
 
   void statement_bind(Statement statement, size_t index) {
     if (is_null()) {
       ASSERT_EQ(CASS_OK, cass_statement_bind_null(statement.get(), index));
     } else {
-      ASSERT_EQ(CASS_OK,
-        cass_statement_bind_collection(statement.get(), index, get()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_collection(statement.get(), index, get()));
     }
   }
 
   void statement_bind(Statement statement, const std::string& name) {
     if (is_null()) {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(),
-                                                          name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(), name.c_str()));
     } else {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_collection_by_name(statement.get(),
-                                                                name.c_str(),
-                                                                get()));
+      ASSERT_EQ(CASS_OK,
+                cass_statement_bind_collection_by_name(statement.get(), name.c_str(), get()));
     }
   }
 
   std::vector<K> keys() const {
     std::vector<K> keys;
-    for (typename std::map<K, V>::const_iterator iterator = map_.begin();
-      iterator != map_.end(); ++iterator) {
+    for (typename std::map<K, V>::const_iterator iterator = map_.begin(); iterator != map_.end();
+         ++iterator) {
       keys.push_back(iterator->first);
     }
     return keys;
   }
 
-  CassValueType key_type() const {
-    return secondary_sub_type_;
-  }
+  CassValueType key_type() const { return secondary_sub_type_; }
 
   std::string str() const {
     if (is_null()) {
@@ -132,8 +112,8 @@ class Map : public Collection {
     } else {
       std::stringstream map_string;
       map_string << "{";
-      for (typename std::map<K, V>::const_iterator iterator = map_.begin();
-        iterator != map_.end(); ++iterator) {
+      for (typename std::map<K, V>::const_iterator iterator = map_.begin(); iterator != map_.end();
+           ++iterator) {
         K key = iterator->first;
         V value = iterator->second;
         map_string << key.cql_value() << ":" << value.cql_value();
@@ -148,22 +128,18 @@ class Map : public Collection {
     }
   }
 
-  std::map<K, V> value() const {
-    return map_;
-  }
+  std::map<K, V> value() const { return map_; }
 
   std::vector<V> values() const {
     std::vector<V> values;
-    for (typename std::map<K, V>::const_iterator iterator = map_.begin();
-      iterator != map_.end(); ++iterator) {
+    for (typename std::map<K, V>::const_iterator iterator = map_.begin(); iterator != map_.end();
+         ++iterator) {
       values.push_back(iterator->second);
     }
     return values;
   }
 
-  CassValueType value_type() const {
-    return primary_sub_type_;
-  }
+  CassValueType value_type() const { return primary_sub_type_; }
 
 private:
   /**
@@ -195,7 +171,6 @@ inline std::ostream& operator<<(std::ostream& os, const Map<K, V>& map) {
   return os;
 }
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_MAP_HPP__
diff --git a/gtests/src/integration/values/set.hpp b/gtests/src/integration/values/set.hpp
index 6f4f360d3..15d85300d 100644
--- a/gtests/src/integration/values/set.hpp
+++ b/gtests/src/integration/values/set.hpp
@@ -19,24 +19,25 @@
 #include "nullable_value.hpp"
 #include "test_utils.hpp"
 
-namespace test {
-namespace driver {
+namespace test { namespace driver {
 
 /**
  * Set wrapped value
  */
-template<typename T>
-class Set : public Collection, Comparable<Set<T> > {
+template <typename T>
+class Set
+    : public Collection
+    , Comparable<Set<T> > {
 public:
   Set()
-    : Collection(CASS_COLLECTION_TYPE_SET) { }
+      : Collection(CASS_COLLECTION_TYPE_SET) {}
 
   Set(const std::set<T>& set)
-    : Collection(CASS_COLLECTION_TYPE_SET, set.size())
-    , set_(set) {
+      : Collection(CASS_COLLECTION_TYPE_SET, set.size())
+      , set_(set) {
     // Create the collection
-    for (typename std::set<T>::const_iterator iterator = set.begin();
-      iterator != set.end(); ++iterator) {
+    for (typename std::set<T>::const_iterator iterator = set.begin(); iterator != set.end();
+         ++iterator) {
       T value = *iterator;
       Collection::append<T>(value);
       set_.insert(value);
@@ -46,10 +47,10 @@ class Set : public Collection, Comparable<Set<T> > {
   }
 
   Set(const std::vector<T>& set)
-    : Collection(CASS_COLLECTION_TYPE_SET, set.size()) {
+      : Collection(CASS_COLLECTION_TYPE_SET, set.size()) {
     // Create the collection
-    for (typename std::vector<T>::const_iterator iterator = set.begin();
-      iterator < set.end(); ++iterator) {
+    for (typename std::vector<T>::const_iterator iterator = set.begin(); iterator < set.end();
+         ++iterator) {
       T value = *iterator;
       Collection::append<T>(value);
       set_.insert(value);
@@ -59,26 +60,20 @@ class Set : public Collection, Comparable<Set<T> > {
   }
 
   Set(const CassValue* value)
-    : Collection(CASS_COLLECTION_TYPE_SET) {
+      : Collection(CASS_COLLECTION_TYPE_SET) {
     initialize(value);
   }
 
-  void append(Collection collection) {
-    Collection::append(collection);
-  }
+  void append(Collection collection) { Collection::append(collection); }
 
   std::string cql_type() const {
     std::string cql_type = "set<" + (*set_.begin()).cql_type() + ">";
     return cql_type;
   }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
-  bool is_null() const {
-    return Collection::is_null_;
-  }
+  bool is_null() const { return Collection::is_null_; }
 
   /**
    * Comparison operation for driver value set. This comparison is performed in
@@ -94,8 +89,8 @@ class Set : public Collection, Comparable<Set<T> > {
 
     // Iterate and compare (sets are already sorted)
     typename std::set<T>::const_iterator rhs_iterator = rhs.begin();
-    for (typename std::set<T>::const_iterator iterator = set_.begin();
-      iterator != set_.end(); ++iterator) {
+    for (typename std::set<T>::const_iterator iterator = set_.begin(); iterator != set_.end();
+         ++iterator) {
       int comparison = (*iterator).compare(*rhs_iterator);
       if (comparison != 0) return comparison;
       ++rhs_iterator;
@@ -110,44 +105,33 @@ class Set : public Collection, Comparable<Set<T> > {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Set& rhs) const {
-    return compare(rhs.set_);
-  }
+  int compare(const Set& rhs) const { return compare(rhs.set_); }
 
-  void set(Tuple tuple, size_t index) {
-    Collection::set(tuple, index);
-  }
+  void set(Tuple tuple, size_t index) { Collection::set(tuple, index); }
 
-  void set(UserType user_type, const std::string& name) {
-    Collection::set(user_type, name);
-  }
+  void set(UserType user_type, const std::string& name) { Collection::set(user_type, name); }
 
   /**
    * Get the size of the set
    *
    * @return The number of values in the set
    */
-  size_t size() const {
-    return set_.size();
-  }
+  size_t size() const { return set_.size(); }
 
   void statement_bind(Statement statement, size_t index) {
     if (is_null()) {
       ASSERT_EQ(CASS_OK, cass_statement_bind_null(statement.get(), index));
     } else {
-      ASSERT_EQ(CASS_OK,
-        cass_statement_bind_collection(statement.get(), index, get()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_collection(statement.get(), index, get()));
     }
   }
 
   void statement_bind(Statement statement, const std::string& name) {
     if (is_null()) {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(),
-                                                          name.c_str()));
+      ASSERT_EQ(CASS_OK, cass_statement_bind_null_by_name(statement.get(), name.c_str()));
     } else {
-      ASSERT_EQ(CASS_OK, cass_statement_bind_collection_by_name(statement.get(),
-                                                                name.c_str(),
-                                                                get()));
+      ASSERT_EQ(CASS_OK,
+                cass_statement_bind_collection_by_name(statement.get(), name.c_str(), get()));
     }
   }
 
@@ -159,8 +143,8 @@ class Set : public Collection, Comparable<Set<T> > {
     } else {
       std::stringstream set_string;
       set_string << "{";
-      for (typename std::set<T>::const_iterator iterator = set_.begin();
-        iterator != set_.end(); ++iterator) {
+      for (typename std::set<T>::const_iterator iterator = set_.begin(); iterator != set_.end();
+           ++iterator) {
         set_string << (*iterator).cql_value();
 
         // Add a comma separation to the set (unless the last element)
@@ -173,17 +157,11 @@ class Set : public Collection, Comparable<Set<T> > {
     }
   }
 
-  std::set<T> value() const {
-    return set_;
-  }
+  std::set<T> value() const { return set_; }
 
-  CassCollectionType collection_type() const {
-    return collection_type_;
-  }
+  CassCollectionType collection_type() const { return collection_type_; }
 
-  CassValueType value_type() const {
-    return primary_sub_type_;
-  }
+  CassValueType value_type() const { return primary_sub_type_; }
 
 private:
   /**
@@ -212,7 +190,6 @@ inline std::ostream& operator<<(std::ostream& os, const Set<T>& set) {
   return os;
 }
 
-} // namespace driver
-} // namespace test
+}} // namespace test::driver
 
 #endif // __TEST_SET_HPP__
diff --git a/gtests/src/integration/values/time.hpp b/gtests/src/integration/values/time.hpp
index 6ed73c079..b060e4b86 100644
--- a/gtests/src/integration/values/time.hpp
+++ b/gtests/src/integration/values/time.hpp
@@ -25,9 +25,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Time wrapped value
@@ -36,18 +34,14 @@ class Time : public BigInteger {
 public:
   using BigInteger::compare;
 
-  Time() { }
+  Time() {}
 
   Time(const ConvenienceType integer)
-    : BigInteger(integer) { }
+      : BigInteger(integer) {}
 
-  std::string cql_type() const {
-    return "time";
-  }
+  std::string cql_type() const { return "time"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver time
@@ -55,17 +49,11 @@ class Time : public BigInteger {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Time& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const Time& rhs) const { return compare(rhs.integer_); }
 
-  static Time max() {
-    return Time(86399999999999);
-  }
+  static Time max() { return Time(86399999999999); }
 
-  static Time min() {
-    return Time(static_cast<cass_int64_t>(0));
-  }
+  static Time min() { return Time(static_cast<cass_int64_t>(0)); }
 
   std::string str() const {
     // Convert the time to a human readable format
@@ -75,29 +63,22 @@ class Time : public BigInteger {
     strftime(temp, sizeof(temp), "%H:%M:%S", time);
     std::string time_string = temp;
     cass_int64_t diff = integer_ - epoch_secs * 1000000000;
-    sprintf(temp, "%09u", (unsigned int) diff);
+    sprintf(temp, "%09u", (unsigned int)diff);
     time_string.append(".");
     time_string.append(temp);
     return time_string;
   }
 
-  static std::string supported_server_version() {
-    return "2.2.3";
-  }
+  static std::string supported_server_version() { return "2.2.3"; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_TIME;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_TIME; }
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Time& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Time& value) {
   output_stream << value.cql_value() << " [ = " << value.value() << "]";
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_TIME_HPP__
diff --git a/gtests/src/integration/values/timestamp.hpp b/gtests/src/integration/values/timestamp.hpp
index a88e90493..3247195d4 100644
--- a/gtests/src/integration/values/timestamp.hpp
+++ b/gtests/src/integration/values/timestamp.hpp
@@ -25,9 +25,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Timestamp wrapped value
@@ -36,14 +34,12 @@ class Timestamp : public BigInteger {
 public:
   using BigInteger::compare;
 
-  Timestamp() { }
+  Timestamp() {}
 
   Timestamp(const ConvenienceType integer)
-    : BigInteger(integer) { }
+      : BigInteger(integer) {}
 
-  std::string cql_type() const {
-    return "timestamp";
-  }
+  std::string cql_type() const { return "timestamp"; }
 
   /**
    * Comparison operation for driver time
@@ -51,31 +47,20 @@ class Timestamp : public BigInteger {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Timestamp& rhs) const {
-    return compare(rhs.integer_);
-  }
+  int compare(const Timestamp& rhs) const { return compare(rhs.integer_); }
 
-  static Timestamp max() {
-    return Timestamp(std::numeric_limits<cass_int64_t>::max());
-  }
+  static Timestamp max() { return Timestamp(std::numeric_limits<cass_int64_t>::max()); }
 
-  static Timestamp min() {
-    return Timestamp(std::numeric_limits<cass_int64_t>::min());
-  }
+  static Timestamp min() { return Timestamp(std::numeric_limits<cass_int64_t>::min()); }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_TIMESTAMP;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_TIMESTAMP; }
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Timestamp& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Timestamp& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_TIMESTAMP_HPP__
diff --git a/gtests/src/integration/values/uuid.hpp b/gtests/src/integration/values/uuid.hpp
index 03e6c2b52..285863231 100644
--- a/gtests/src/integration/values/uuid.hpp
+++ b/gtests/src/integration/values/uuid.hpp
@@ -28,9 +28,7 @@
 #undef max
 #endif
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * UUID wrapped value
@@ -40,15 +38,14 @@ class Uuid {
   typedef std::string ConvenienceType;
   typedef CassUuid ValueType;
 
-  Uuid() { }
+  Uuid() {}
 
   Uuid(const ConvenienceType& value) {
     std::string value_trim = Utils::trim(value);
 
     // Determine if the value is valid (default is 0 otherwise)
     CassError error_code = cass_uuid_from_string(value_trim.c_str(), &uuid_);
-    EXPECT_EQ(CASS_OK, error_code) << "Invalid UUID " << value_trim
-      << ": Using default " << str();
+    EXPECT_EQ(CASS_OK, error_code) << "Invalid UUID " << value_trim << ": Using default " << str();
   }
 
   /**
@@ -57,20 +54,15 @@ class Uuid {
    * @param uuid Native driver value
    */
   Uuid(CassUuid uuid)
-    : uuid_(uuid) { }
+      : uuid_(uuid) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK,
-              cass_collection_append_uuid(collection.get(), uuid_));
+    ASSERT_EQ(CASS_OK, cass_collection_append_uuid(collection.get(), uuid_));
   }
 
-  static std::string cql_type() {
-    return "uuid";
-  }
+  static std::string cql_type() { return "uuid"; }
 
-  std::string cql_value() const {
-    return str();
-  }
+  std::string cql_value() const { return str(); }
 
   /**
    * Comparison operation for driver UUIDs
@@ -94,14 +86,12 @@ class Uuid {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Uuid& rhs) const {
-    return compare(rhs.uuid_);
-  }
+  int compare(const Uuid& rhs) const { return compare(rhs.uuid_); }
 
   void initialize(const CassValue* value) {
     // Get the UUID
     ASSERT_EQ(CASS_OK, cass_value_get_uuid(value, &uuid_))
-      << "Unable to Get Uuid: Invalid error code returned";
+        << "Unable to Get Uuid: Invalid error code returned";
   }
 
   static Uuid max() {
@@ -123,22 +113,15 @@ class Uuid {
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK,
-              cass_user_type_set_uuid_by_name(user_type.get(),
-                                              name.c_str(),
-                                              uuid_));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_uuid_by_name(user_type.get(), name.c_str(), uuid_));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_uuid(statement.get(),
-                                                index,
-                                                uuid_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_uuid(statement.get(), index, uuid_));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_uuid_by_name(statement.get(),
-                                                        name.c_str(),
-                                                        uuid_));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_uuid_by_name(statement.get(), name.c_str(), uuid_));
   }
 
   std::string str() const {
@@ -147,26 +130,18 @@ class Uuid {
     return buffer;
   }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  CassUuid value() const {
-    return uuid_;
-  }
+  CassUuid value() const { return uuid_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_UUID;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_UUID; }
 
   /**
    * Get the version of the UUID
    *
    * @return The version of the UUID (v1 or v4)
    */
-  cass_uint8_t version() {
-    return cass_uuid_version(uuid_);
-  }
+  cass_uint8_t version() { return cass_uuid_version(uuid_); }
 
 protected:
   /**
@@ -180,10 +155,10 @@ class Uuid {
  */
 class TimeUuid : public Uuid {
 public:
-  TimeUuid() { }
+  TimeUuid() {}
 
   TimeUuid(const ConvenienceType& value)
-    : Uuid(value) { }
+      : Uuid(value) {}
 
   /**
    * Constructor for native driver type
@@ -191,21 +166,17 @@ class TimeUuid : public Uuid {
    * @param uuid Native driver value
    */
   TimeUuid(CassUuid uuid)
-    : Uuid(uuid) { }
+      : Uuid(uuid) {}
 
-  std::string cql_type() const {
-    return "timeuuid";
-  }
+  std::string cql_type() const { return "timeuuid"; }
 
   void initialize(const CassValue* value) {
     // Get the time UUID
     ASSERT_EQ(CASS_OK, cass_value_get_uuid(value, &uuid_))
-      << "Unable to Get Uuid: Invalid error code returned";
+        << "Unable to Get Uuid: Invalid error code returned";
   }
 
-  static TimeUuid max() {
-    return TimeUuid::max(std::numeric_limits<uint64_t>::max());
-  }
+  static TimeUuid max() { return TimeUuid::max(std::numeric_limits<uint64_t>::max()); }
 
   /**
    * Gets a TimeUuid maximum value for the specified timestamp
@@ -219,9 +190,7 @@ class TimeUuid : public Uuid {
     return timeuuid;
   }
 
-  static TimeUuid min() {
-    return TimeUuid::min(std::numeric_limits<uint64_t>::min());
-  }
+  static TimeUuid min() { return TimeUuid::min(std::numeric_limits<uint64_t>::min()); }
 
   /**
    * Gets a TimeUuid minimum value for the specified timestamp
@@ -240,29 +209,21 @@ class TimeUuid : public Uuid {
    *
    * @return The timestamp in milliseconds since the epoch
    */
-  cass_uint64_t timestamp() {
-    return cass_uuid_timestamp(uuid_);
-  }
+  cass_uint64_t timestamp() { return cass_uuid_timestamp(uuid_); }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_TIMEUUID;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_TIMEUUID; }
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Uuid& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Uuid& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const TimeUuid& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const TimeUuid& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_UUID_HPP__
diff --git a/gtests/src/integration/values/varchar.hpp b/gtests/src/integration/values/varchar.hpp
index 377ca78c8..186d91d82 100644
--- a/gtests/src/integration/values/varchar.hpp
+++ b/gtests/src/integration/values/varchar.hpp
@@ -18,9 +18,7 @@
 #define __TEST_VARCHAR_HPP__
 #include "nullable_value.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Varchar wrapped value
@@ -30,23 +28,18 @@ class Varchar {
   typedef std::string ConvenienceType;
   typedef std::string ValueType;
 
-  Varchar() { }
+  Varchar() {}
 
   Varchar(const ConvenienceType& varchar)
-    : varchar_(varchar) { }
+      : varchar_(varchar) {}
 
   void append(Collection collection) {
-    ASSERT_EQ(CASS_OK, cass_collection_append_string(collection.get(),
-              varchar_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_string(collection.get(), varchar_.c_str()));
   }
 
-  std::string cql_type() const {
-    return "varchar";
-  }
+  std::string cql_type() const { return "varchar"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver string
@@ -54,9 +47,7 @@ class Varchar {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const std::string& rhs) const {
-    return varchar_.compare(rhs.c_str());
-  }
+  int compare(const std::string& rhs) const { return varchar_.compare(rhs.c_str()); }
 
   /**
    * Comparison operation for Varchar
@@ -64,57 +55,41 @@ class Varchar {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Varchar& rhs) const {
-    return compare(rhs.varchar_);
-  }
+  int compare(const Varchar& rhs) const { return compare(rhs.varchar_); }
 
   void initialize(const CassValue* value) {
     const char* string = NULL;
     size_t length;
     ASSERT_EQ(CASS_OK, cass_value_get_string(value, &string, &length))
-      << "Unable to Get Varchar: Invalid error code returned";
+        << "Unable to Get Varchar: Invalid error code returned";
     varchar_.assign(string, length);
   }
 
   void set(Tuple tuple, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_tuple_set_string(tuple.get(),
-              index,
-              varchar_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_tuple_set_string(tuple.get(), index, varchar_.c_str()));
   }
 
   void set(UserType user_type, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_user_type_set_string_by_name(user_type.get(),
-              name.c_str(),
-              varchar_.c_str()));
+    ASSERT_EQ(CASS_OK,
+              cass_user_type_set_string_by_name(user_type.get(), name.c_str(), varchar_.c_str()));
   }
 
   void statement_bind(Statement statement, size_t index) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_string(statement.get(),
-              index,
-              varchar_.c_str()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_string(statement.get(), index, varchar_.c_str()));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
-    ASSERT_EQ(CASS_OK, cass_statement_bind_string_by_name(statement.get(),
-              name.c_str(),
-              varchar_.c_str()));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_string_by_name(statement.get(), name.c_str(), varchar_.c_str()));
   }
 
-  std::string str() const {
-    return varchar_;
-  }
+  std::string str() const { return varchar_; }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return varchar_;
-  }
+  ValueType value() const { return varchar_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_VARCHAR;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_VARCHAR; }
 
 protected:
   /**
@@ -128,22 +103,18 @@ class Varchar {
  */
 class Text : public Varchar {
 public:
-  Text() { }
+  Text() {}
 
   Text(const ConvenienceType& text)
-    : Varchar(text) { }
+      : Varchar(text) {}
 
-  std::string cql_type() const {
-    return "text";
-  }
+  std::string cql_type() const { return "text"; }
 
   CassValueType value_type() const {
     return CASS_VALUE_TYPE_VARCHAR; // Text (alias is returned as varchar from server)
   }
 };
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_VARCHAR_HPP__
diff --git a/gtests/src/integration/values/varint.hpp b/gtests/src/integration/values/varint.hpp
index 9d9e17da9..98c195b9d 100644
--- a/gtests/src/integration/values/varint.hpp
+++ b/gtests/src/integration/values/varint.hpp
@@ -20,9 +20,7 @@
 
 #include "bignumber.hpp"
 
-namespace test {
-namespace driver {
-namespace values {
+namespace test { namespace driver { namespace values {
 
 /**
  * Varint wrapped value
@@ -32,24 +30,19 @@ class Varint {
   typedef std::string ConvenienceType;
   typedef BigNumber ValueType;
 
-  Varint() { }
+  Varint() {}
 
   Varint(const ConvenienceType& varint)
-    : varint_(varint) { }
+      : varint_(varint) {}
 
   void append(Collection collection) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK,
-              cass_collection_append_bytes(collection.get(), bytes.data(), bytes.size()));
+    ASSERT_EQ(CASS_OK, cass_collection_append_bytes(collection.get(), bytes.data(), bytes.size()));
   }
 
-  std::string cql_type() const {
-    return "varint";
-  }
+  std::string cql_type() const { return "varint"; }
 
-  std::string cql_value() const {
-    return "'" + str() + "'";
-  }
+  std::string cql_value() const { return "'" + str() + "'"; }
 
   /**
    * Comparison operation for driver bytes
@@ -57,9 +50,7 @@ class Varint {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const BigNumber& rhs) const {
-    return varint_.compare(rhs);
-  }
+  int compare(const BigNumber& rhs) const { return varint_.compare(rhs); }
 
   /**
    * Comparison operation for varint
@@ -67,64 +58,46 @@ class Varint {
    * @param rhs Right hand side to compare
    * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
    */
-  int compare(const Varint& rhs) const {
-    return compare(rhs.varint_);
-  }
+  int compare(const Varint& rhs) const { return compare(rhs.varint_); }
 
   void initialize(const CassValue* value) {
     const cass_byte_t* bytes = NULL;
     size_t size;
     ASSERT_EQ(CASS_OK, cass_value_get_bytes(value, &bytes, &size))
-      << "Unable to Get Varint: Invalid error code returned";
+        << "Unable to Get Varint: Invalid error code returned";
     varint_ = BigNumber(bytes, size, 0);
   }
 
   void set(Tuple tuple, size_t index) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK,
-              cass_tuple_set_bytes(tuple.get(), index, bytes.data(), bytes.size()));
+    ASSERT_EQ(CASS_OK, cass_tuple_set_bytes(tuple.get(), index, bytes.data(), bytes.size()));
   }
 
   void set(UserType user_type, const std::string& name) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK,
-              cass_user_type_set_bytes_by_name(user_type.get(),
-              name.c_str(),
-              bytes.data(),
-              bytes.size()));
+    ASSERT_EQ(CASS_OK, cass_user_type_set_bytes_by_name(user_type.get(), name.c_str(), bytes.data(),
+                                                        bytes.size()));
   }
 
   void statement_bind(Statement statement, size_t index) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes(statement.get(),
-              index,
-              bytes.data(),
-              bytes.size()));
+    ASSERT_EQ(CASS_OK,
+              cass_statement_bind_bytes(statement.get(), index, bytes.data(), bytes.size()));
   }
 
   void statement_bind(Statement statement, const std::string& name) {
     const std::vector<cass_byte_t>& bytes = varint_.encode_varint();
-    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes_by_name(statement.get(),
-              name.c_str(),
-              bytes.data(),
-              bytes.size()));
+    ASSERT_EQ(CASS_OK, cass_statement_bind_bytes_by_name(statement.get(), name.c_str(),
+                                                         bytes.data(), bytes.size()));
   }
 
-  std::string str() const {
-    return varint_.str();
-  }
+  std::string str() const { return varint_.str(); }
 
-  static std::string supported_server_version() {
-    return "1.2.0";
-  }
+  static std::string supported_server_version() { return "1.2.0"; }
 
-  ValueType value() const {
-    return varint_;
-  }
+  ValueType value() const { return varint_; }
 
-  CassValueType value_type() const {
-    return CASS_VALUE_TYPE_VARINT;
-  }
+  CassValueType value_type() const { return CASS_VALUE_TYPE_VARINT; }
 
 protected:
   /**
@@ -133,14 +106,11 @@ class Varint {
   BigNumber varint_;
 };
 
-inline std::ostream& operator<<(std::ostream& output_stream,
-                                const Varint& value) {
+inline std::ostream& operator<<(std::ostream& output_stream, const Varint& value) {
   output_stream << value.cql_value();
   return output_stream;
 }
 
-} // namespace values
-} // namespace driver
-} // namespace test
+}}} // namespace test::driver::values
 
 #endif // __TEST_VARINT_HPP__
diff --git a/gtests/src/integration/win_debug.cpp b/gtests/src/integration/win_debug.cpp
index adf9cff9f..d230c3716 100644
--- a/gtests/src/integration/win_debug.cpp
+++ b/gtests/src/integration/win_debug.cpp
@@ -15,19 +15,19 @@
 */
 
 #if defined(_WIN32) && defined(_DEBUG)
-# include "win_debug.hpp"
+#include "win_debug.hpp"
 
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
 // Enable memory leak detection
-# define _CRTDBG_MAP_ALLOC
-# include <stdlib.h>
-# include <crtdbg.h>
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#include <stdlib.h>
 
 // Enable memory leak detection for new operator
-# ifndef DBG_NEW
-#   define DBG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
-#   define new DBG_NEW
-# endif
+#ifndef DBG_NEW
+#define DBG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
+#define new DBG_NEW
+#endif
 
 /**
  * Output the memory leak results to the console
@@ -41,29 +41,29 @@ inline int __cdecl output_memory_leak_results(int report_type, char* message, in
   std::cerr << message;
   return 1;
 }
-# endif
+#endif
 
 void MemoryLeakListener::disable() {
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   VLDDisable();
-# else
+#else
   int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
   flags &= ~_CRTDBG_ALLOC_MEM_DF;
   _CrtSetDbgFlag(flags);
-# endif
+#endif
 }
 
 void MemoryLeakListener::enable() {
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   VLDEnable();
-# else
+#else
   int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
   flags |= _CRTDBG_ALLOC_MEM_DF;
   _CrtSetDbgFlag(flags);
-# endif
+#endif
 }
 
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
 void MemoryLeakListener::OnTestProgramStart(const testing::UnitTest& unit_test) {
   // Install the memory leak reporting
   _CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, &output_memory_leak_results);
@@ -73,16 +73,16 @@ void MemoryLeakListener::OnTestProgramEnd(const testing::UnitTest& unit_test) {
   // Uninstall/Remove the memory leak reporting
   _CrtSetReportHook2(_CRT_RPTHOOK_REMOVE, &output_memory_leak_results);
 }
-# endif
+#endif
 
 void MemoryLeakListener::OnTestStart(const testing::TestInfo& test_information) {
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   // Make all memory leaks (if any) as reported (clean slate)
   VLDMarkAllLeaksAsReported();
-# else
+#else
   // Get the starting memory state
   _CrtMemCheckpoint(&memory_start_state_);
-# endif
+#endif
 
   // Enable memory leak detection
   enable();
@@ -90,7 +90,7 @@ void MemoryLeakListener::OnTestStart(const testing::TestInfo& test_information)
 
 void MemoryLeakListener::OnTestEnd(const testing::TestInfo& test_information) {
   // Check for memory leaks if the test was successful
-  if(test_information.result()->Passed()) {
+  if (test_information.result()->Passed()) {
     check_leaks(test_information);
   }
 }
@@ -99,12 +99,12 @@ void MemoryLeakListener::check_leaks(const testing::TestInfo& test_information)
   // Disable memory leak checking
   disable();
 
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   // Determine if a difference exists (e.g. leak)
   if (VLDGetLeaksCount() > 0) {
     VLDReportLeaks();
     VLDMarkAllLeaksAsReported();
-# else
+#else
   // Get the ending memory state for the test
   _CrtMemState memory_end_state;
   _CrtMemCheckpoint(&memory_end_state);
@@ -114,10 +114,9 @@ void MemoryLeakListener::check_leaks(const testing::TestInfo& test_information)
   if (_CrtMemDifference(&memory_state_difference, &memory_start_state_, &memory_end_state)) {
     _CrtMemDumpAllObjectsSince(&memory_start_state_);
     _CrtMemDumpStatistics(&memory_state_difference);
-# endif
-    FAIL() << "Memory leaks detected in "
-      << test_information.test_case_name()
-      << "." << test_information.name();
+#endif
+    FAIL() << "Memory leaks detected in " << test_information.test_case_name() << "."
+           << test_information.name();
   }
 }
 
diff --git a/gtests/src/integration/win_debug.hpp b/gtests/src/integration/win_debug.hpp
index e05712656..c140fa22e 100644
--- a/gtests/src/integration/win_debug.hpp
+++ b/gtests/src/integration/win_debug.hpp
@@ -18,10 +18,10 @@
 #define __WIN_DEBUG_HPP__
 
 #if defined(_WIN32) && defined(_DEBUG)
-# ifdef USE_VISUAL_LEAK_DETECTOR
-#   include <vld.h>
-# endif
-# include <gtest/gtest.h>
+#ifdef USE_VISUAL_LEAK_DETECTOR
+#include <vld.h>
+#endif
+#include <gtest/gtest.h>
 #endif
 
 /**
@@ -30,10 +30,10 @@
 class MemoryLeakListener : public testing::EmptyTestEventListener {
 public:
 #if defined(_WIN32) && defined(_DEBUG)
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
   void OnTestProgramStart(const testing::UnitTest& unit_test);
   void OnTestProgramEnd(const testing::UnitTest& unit_test);
-# endif
+#endif
   void OnTestStart(const testing::TestInfo& test_information);
   void OnTestEnd(const testing::TestInfo& test_information);
 
@@ -47,12 +47,12 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
   static void enable();
 
 private:
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
   /**
    * Starting memory state (before start of test)
    */
   _CrtMemState memory_start_state_;
-# endif
+#endif
 
   /**
    * Check for memory leaks based on the starting memory state
@@ -61,8 +61,8 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
    */
   void check_leaks(const testing::TestInfo& test_information);
 #else
-  static void disable() {};
-  static void enable() {};
+  static void disable(){};
+  static void enable(){};
 #endif
 };
 
diff --git a/gtests/src/unit/event_loop_test.hpp b/gtests/src/unit/event_loop_test.hpp
index 19986222b..91e878e23 100644
--- a/gtests/src/unit/event_loop_test.hpp
+++ b/gtests/src/unit/event_loop_test.hpp
@@ -17,13 +17,16 @@
 #ifndef EVENT_LOOP_TEST_HPP
 #define EVENT_LOOP_TEST_HPP
 
-#include "unit.hpp"
 #include "event_loop.hpp"
+#include "unit.hpp"
+
+using datastax::internal::core::EventLoop;
+using datastax::internal::core::Future;
 
 class EventLoopTest : public Unit {
 public:
-  EventLoopTest(const cass::String& thread_name)
-    :thread_name_(thread_name) { }
+  EventLoopTest(const datastax::String& thread_name)
+      : thread_name_(thread_name) {}
 
   virtual void SetUp() {
     Unit::SetUp();
@@ -54,15 +57,15 @@ class EventLoopTest : public Unit {
    * @param outage_plan The outage plan to execute.
    * @return Generic future instance.
    */
-  cass::Future::Ptr execute_outage_plan(OutagePlan* outage_plan) {
-    cass::Future::Ptr future(new cass::Future(cass::Future::FUTURE_TYPE_GENERIC));
+  Future::Ptr execute_outage_plan(OutagePlan* outage_plan) {
+    Future::Ptr future(new Future(Future::FUTURE_TYPE_GENERIC));
     add_task(new ExecuteOutagePlan(outage_plan, future));
     return future;
   }
 
 private:
-  cass::EventLoop event_loop_;
-  cass::String thread_name_;
+  EventLoop event_loop_;
+  datastax::String thread_name_;
 };
 
 #endif // EVENT_LOOP_TEST_HPP
diff --git a/gtests/src/unit/loop_test.hpp b/gtests/src/unit/loop_test.hpp
index 6357e526c..f05a58ed4 100644
--- a/gtests/src/unit/loop_test.hpp
+++ b/gtests/src/unit/loop_test.hpp
@@ -17,8 +17,8 @@
 #ifndef LOOP_TEST_HPP
 #define LOOP_TEST_HPP
 
-#include "unit.hpp"
 #include "test_utils.hpp"
+#include "unit.hpp"
 
 #include <uv.h>
 
@@ -48,9 +48,7 @@ class LoopTest : public Unit {
     }
   }
 
-  int run_loop(uv_run_mode mode = UV_RUN_DEFAULT) {
-    return uv_run(loop(), mode);
-  }
+  int run_loop(uv_run_mode mode = UV_RUN_DEFAULT) { return uv_run(loop(), mode); }
 
   /**
    * Prevent the uv_work thread pool from completing any useful work for the
diff --git a/gtests/src/unit/main.cpp b/gtests/src/unit/main.cpp
index 679fa129b..2aac2abbf 100644
--- a/gtests/src/unit/main.cpp
+++ b/gtests/src/unit/main.cpp
@@ -17,23 +17,26 @@
 #include <gtest/gtest.h>
 
 #include "cassandra.h"
-#include "string.hpp"
 #include "ssl.hpp"
+#include "string.hpp"
+
+using datastax::String;
+using datastax::internal::core::SslContextFactory;
 
 #if defined(_WIN32) && defined(_DEBUG)
-# ifdef USE_VISUAL_LEAK_DETECTOR
-#   include <vld.h>
-# else
+#ifdef USE_VISUAL_LEAK_DETECTOR
+#include <vld.h>
+#else
 // Enable memory leak detection
-# define _CRTDBG_MAP_ALLOC
-# include <stdlib.h>
-# include <crtdbg.h>
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#include <stdlib.h>
 
 // Enable memory leak detection for new operator
-# ifndef DBG_NEW
-#   define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
-#   define new DBG_NEW
-# endif
+#ifndef DBG_NEW
+#define DBG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
+#define new DBG_NEW
+#endif
 
 /**
  * Output the memory leak results to the console
@@ -47,15 +50,14 @@ int __cdecl output_memory_leak_results(int report_type, char* message, int* erro
   std::cerr << message;
   return 1;
 }
-# endif
+#endif
 
 /**
  * Memory leak listener for detecting memory leaks on Windows more efficiently.
  */
 class MemoryLeakListener : public testing::EmptyTestEventListener {
 public:
-
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
   void OnTestProgramStart(const testing::UnitTest& unit_test) {
     // Install the memory leak reporting
     _CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, &output_memory_leak_results);
@@ -65,32 +67,32 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
     // Uninstall/Remove the memory leak reporting
     _CrtSetReportHook2(_CRT_RPTHOOK_REMOVE, &output_memory_leak_results);
   }
-# endif
+#endif
 
   void OnTestStart(const testing::TestInfo& test_information) {
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
     VLDMarkAllLeaksAsReported();
     VLDEnable();
-# else
+#else
     // Get the starting memory state
     _CrtMemCheckpoint(&memory_start_state_);
-# endif
+#endif
   }
 
   void OnTestEnd(const testing::TestInfo& test_information) {
     // Check for memory leaks if the test was successful
-    if(test_information.result()->Passed()) {
+    if (test_information.result()->Passed()) {
       check_leaks(test_information);
     }
-}
+  }
 
 private:
-# ifndef USE_VISUAL_LEAK_DETECTOR
+#ifndef USE_VISUAL_LEAK_DETECTOR
   /**
    * Starting memory state (before start of test)
    */
   _CrtMemState memory_start_state_;
-# endif
+#endif
 
   /**
    * Check for memory leaks based on the starting memory state
@@ -98,13 +100,13 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
    * @param test_information Information about the test
    */
   void check_leaks(const testing::TestInfo& test_information) {
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
     // Determine if a difference exists (e.g. leak)
     VLDDisable();
     if (VLDGetLeaksCount() > 0) {
       VLDReportLeaks();
       VLDMarkAllLeaksAsReported();
-# else
+#else
     // Get the ending memory state for the test
     _CrtMemState memory_end_state;
     _CrtMemCheckpoint(&memory_end_state);
@@ -113,10 +115,9 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
     // Determine if a difference exists (e.g. leak)
     if (_CrtMemDifference(&memory_state_difference, &memory_start_state_, &memory_end_state)) {
       _CrtMemDumpStatistics(&memory_state_difference);
-# endif
-      FAIL() << "Memory leaks detected in "
-             << test_information.test_case_name()
-             << "." << test_information.name();
+#endif
+      FAIL() << "Memory leaks detected in " << test_information.test_case_name() << "."
+             << test_information.name();
     }
   }
 };
@@ -128,11 +129,9 @@ class MemoryLeakListener : public testing::EmptyTestEventListener {
 class BootstrapListener : public testing::EmptyTestEventListener {
   void OnTestProgramStart(const testing::UnitTest& unit_test) {
     std::cout << "Starting DataStax C/C++ Driver Unit Test" << std::endl;
-    std::cout << "  Cassandra driver v"
-              << CASS_VERSION_MAJOR << "."
-              << CASS_VERSION_MINOR << "."
+    std::cout << "  Cassandra driver v" << CASS_VERSION_MAJOR << "." << CASS_VERSION_MINOR << "."
               << CASS_VERSION_PATCH;
-    if (!cass::String(CASS_VERSION_SUFFIX).empty()) {
+    if (!String(CASS_VERSION_SUFFIX).empty()) {
       std::cout << "-" << CASS_VERSION_SUFFIX;
     }
     std::cout << std::endl;
@@ -143,13 +142,9 @@ class BootstrapListener : public testing::EmptyTestEventListener {
     std::cout << "Finishing DataStax C/C++ Driver Unit Test" << std::endl;
   }
 
-  void OnTestStart(const testing::TestInfo& test_information) {
-    cass::SslContextFactory::init();
-  }
+  void OnTestStart(const testing::TestInfo& test_information) { SslContextFactory::init(); }
 
-  void OnTestEnd(const testing::TestInfo& test_information) {
-    cass::SslContextFactory::cleanup();
-  }
+  void OnTestEnd(const testing::TestInfo& test_information) { SslContextFactory::cleanup(); }
 };
 
 int main(int argc, char* argv[]) {
@@ -162,10 +157,10 @@ int main(int argc, char* argv[]) {
 #if defined(_WIN32) && defined(_DEBUG)
   // Add the memory leak checking to the listener callbacks
   listeners.Append(new MemoryLeakListener());
-# ifdef USE_VISUAL_LEAK_DETECTOR
+#ifdef USE_VISUAL_LEAK_DETECTOR
   // Google test statically initializes heap objects; mark all leaks as reported
   VLDMarkAllLeaksAsReported();
-# endif
+#endif
 #endif
 
   listeners.Append(new BootstrapListener());
diff --git a/gtests/src/unit/mockssandra.cpp b/gtests/src/unit/mockssandra.cpp
index e48375ec4..2620cece0 100644
--- a/gtests/src/unit/mockssandra.cpp
+++ b/gtests/src/unit/mockssandra.cpp
@@ -26,12 +26,14 @@
 #include "uuids.hpp"
 
 #ifdef WIN32
-#  include "winsock.h"
+#include "winsock.h"
 #endif
 
-using cass::Memory;
-using cass::ScopedMutex;
-using cass::OStringStream;
+using datastax::internal::bind_callback;
+using datastax::internal::Memory;
+using datastax::internal::OStringStream;
+using datastax::internal::ScopedMutex;
+using datastax::internal::core::UuidGen;
 
 #define SSL_BUF_SIZE 8192
 #define CASSANDRA_VERSION "3.11.4"
@@ -91,8 +93,10 @@ String Ssl::generate_cert(const String& key, String cn) {
   X509_set_pubkey(x509, pkey);
 
   X509_NAME* name = X509_get_subject_name(x509);
-  X509_NAME_add_entry_by_txt(name, "C", MBSTRING_ASC, reinterpret_cast<const unsigned char*>("US"), -1, -1, 0);
-  X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, reinterpret_cast<const unsigned char*>(cn.c_str()), -1, -1, 0);
+  X509_NAME_add_entry_by_txt(name, "C", MBSTRING_ASC, reinterpret_cast<const unsigned char*>("US"),
+                             -1, -1, 0);
+  X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
+                             reinterpret_cast<const unsigned char*>(cn.c_str()), -1, -1, 0);
   X509_set_issuer_name(x509, name);
   X509_sign(x509, pkey, EVP_md5());
 
@@ -123,8 +127,8 @@ static void print_ssl_error() {
 
 struct WriteReq {
   WriteReq(const char* data, size_t len, ClientConnection* connection)
-    : data(data, len)
-    , connection(connection) {
+      : data(data, len)
+      , connection(connection) {
     req.data = this;
   }
   const String data;
@@ -132,33 +136,23 @@ struct WriteReq {
   uv_write_t req;
 };
 
-Tcp::Tcp(void* data) {
-  tcp_.data = data;
-}
+Tcp::Tcp(void* data) { tcp_.data = data; }
 
-int Tcp::init(uv_loop_t* loop) {
-  return uv_tcp_init(loop, &tcp_);
-}
+int Tcp::init(uv_loop_t* loop) { return uv_tcp_init(loop, &tcp_); }
 
-int Tcp::bind(const struct sockaddr* addr) {
-  return uv_tcp_bind(&tcp_, addr, 0);
-}
+int Tcp::bind(const struct sockaddr* addr) { return uv_tcp_bind(&tcp_, addr, 0); }
 
-uv_handle_t* Tcp::as_handle() {
-  return reinterpret_cast<uv_handle_t*>(&tcp_);
-}
+uv_handle_t* Tcp::as_handle() { return reinterpret_cast<uv_handle_t*>(&tcp_); }
 
-uv_stream_t* Tcp::as_stream() {
-  return reinterpret_cast<uv_stream_t*>(&tcp_);
-}
+uv_stream_t* Tcp::as_stream() { return reinterpret_cast<uv_stream_t*>(&tcp_); }
 
 ClientConnection::ClientConnection(ServerConnection* server)
-  : tcp_(this)
-  , server_(server)
-  , ssl_(server->ssl_context() ? SSL_new(server->ssl_context()) : NULL)
-  , incoming_bio_(ssl_ ? BIO_new(BIO_s_mem()) : NULL)
-  , outgoing_bio_(ssl_ ? BIO_new(BIO_s_mem()) : NULL)
-  , handshake_state_(SSL_HANDSHAKE_INPROGRESS) {
+    : tcp_(this)
+    , server_(server)
+    , ssl_(server->ssl_context() ? SSL_new(server->ssl_context()) : NULL)
+    , incoming_bio_(ssl_ ? BIO_new(BIO_s_mem()) : NULL)
+    , outgoing_bio_(ssl_ ? BIO_new(BIO_s_mem()) : NULL)
+    , handshake_state_(SSL_HANDSHAKE_INPROGRESS) {
   tcp_.init(server->loop());
   if (ssl_) {
     SSL_set_bio(ssl_, incoming_bio_, outgoing_bio_);
@@ -169,9 +163,7 @@ ClientConnection::~ClientConnection() {
   if (ssl_) SSL_free(ssl_);
 }
 
-int ClientConnection::write(const String& data) {
-  return write(data.data(), data.length());
-}
+int ClientConnection::write(const String& data) { return write(data.data(), data.length()); }
 
 int ClientConnection::write(const char* data, size_t len) {
   if (ssl_) {
@@ -288,9 +280,7 @@ int ClientConnection::ssl_write(const char* data, size_t len) {
   return 0;
 }
 
-bool ClientConnection::is_handshake_done() {
-  return SSL_is_init_finished(ssl_) != 0;
-}
+bool ClientConnection::is_handshake_done() { return SSL_is_init_finished(ssl_) != 0; }
 
 bool ClientConnection::has_ssl_error(int rc) {
   if (rc > 0) return false;
@@ -353,15 +343,15 @@ void ClientConnection::on_ssl_read(const char* data, size_t len) {
   }
 }
 
-ServerConnection::ServerConnection(const Address& address,
-                                   const ClientConnectionFactory& factory)
-  : tcp_(this)
-  , event_loop_(NULL)
-  , state_(STATE_CLOSED)
-  , rc_(0)
-  , address_(address)
-  , factory_(factory)
-  , ssl_context_(NULL) {
+ServerConnection::ServerConnection(const Address& address, const ClientConnectionFactory& factory)
+    : tcp_(this)
+    , event_loop_(NULL)
+    , state_(STATE_CLOSED)
+    , rc_(0)
+    , address_(address)
+    , factory_(factory)
+    , ssl_context_(NULL)
+    , connection_attempts_(0) {
   uv_mutex_init(&mutex_);
   uv_cond_init(&cond_);
 }
@@ -374,14 +364,12 @@ ServerConnection::~ServerConnection() {
   }
 }
 
-uv_loop_t*ServerConnection::loop() {
+uv_loop_t* ServerConnection::loop() {
   ScopedMutex l(&mutex_);
   return event_loop_->loop();
 }
 
-bool ServerConnection::use_ssl(const String& key,
-                               const String& cert,
-                               const String& password) {
+bool ServerConnection::use_ssl(const String& key, const String& cert, const String& password) {
   if (ssl_context_) {
     SSL_CTX_free(ssl_context_);
   }
@@ -439,16 +427,14 @@ bool ServerConnection::use_ssl(const String& key,
   return true;
 }
 
-using cass::Task;
+using datastax::internal::core::Task;
 
 class RunListen : public Task {
 public:
   RunListen(ServerConnection* server)
-    : server_(server) { }
+      : server_(server) {}
 
-  virtual void run(EventLoop* event_loop) {
-    server_->internal_listen();
-  }
+  virtual void run(EventLoop* event_loop) { server_->internal_listen(); }
 
 private:
   ServerConnection* server_;
@@ -457,11 +443,9 @@ class RunListen : public Task {
 class RunClose : public Task {
 public:
   RunClose(ServerConnection* server)
-    : server_(server) { }
+      : server_(server) {}
 
-  virtual void run(EventLoop* event_loop) {
-    server_->internal_close();
-  }
+  virtual void run(EventLoop* event_loop) { server_->internal_close(); }
 
 private:
   ServerConnection* server_;
@@ -470,12 +454,10 @@ class RunClose : public Task {
 class RunTask : public Task {
 public:
   RunTask(const ServerConnectionTask::Ptr& task, const ServerConnection::Ptr& connection)
-    : task_(task)
-    , connection_(connection) { }
+      : task_(task)
+      , connection_(connection) {}
 
-  virtual void run(EventLoop* event_loop) {
-    task_->run(connection_.get());
-  }
+  virtual void run(EventLoop* event_loop) { task_->run(connection_.get()); }
 
 private:
   ServerConnectionTask::Ptr task_;
@@ -512,6 +494,7 @@ void ServerConnection::wait_close() {
   }
 }
 
+unsigned ServerConnection::connection_attempts() const { return connection_attempts_.load(); }
 void ServerConnection::run(const ServerConnectionTask::Ptr& task) {
   ScopedMutex l(&mutex_);
   if (state_ != STATE_LISTENING) return;
@@ -549,20 +532,15 @@ void ServerConnection::internal_listen() {
   signal_listen(rc);
 }
 
-int ServerConnection::accept(uv_stream_t* client) {
-  return uv_accept(tcp_.as_stream(), client);
-}
+int ServerConnection::accept(uv_stream_t* client) { return uv_accept(tcp_.as_stream(), client); }
 
 void ServerConnection::remove(ClientConnection* connection) {
-  clients_.erase(std::remove(clients_.begin(), clients_.end(), connection),
-                     clients_.end());
+  clients_.erase(std::remove(clients_.begin(), clients_.end(), connection), clients_.end());
   maybe_close();
 }
 
 void ServerConnection::internal_close() {
-  for (ClientConnections::iterator it = clients_.begin(),
-       end = clients_.end();
-       it != end; ++it) {
+  for (ClientConnections::iterator it = clients_.begin(), end = clients_.end(); it != end; ++it) {
     (*it)->close();
   }
   maybe_close();
@@ -570,9 +548,7 @@ void ServerConnection::internal_close() {
 
 void ServerConnection::maybe_close() {
   ScopedMutex l(&mutex_);
-  if (state_ == STATE_CLOSING &&
-      clients_.empty() &&
-      !uv_is_closing(tcp_.as_handle())) {
+  if (state_ == STATE_CLOSING && clients_.empty() && !uv_is_closing(tcp_.as_handle())) {
     uv_close(tcp_.as_handle(), on_close);
   }
 }
@@ -601,6 +577,8 @@ void ServerConnection::on_connection(uv_stream_t* server, int status) {
 }
 
 void ServerConnection::handle_connection(int status) {
+  connection_attempts_.fetch_add(1);
+
   if (status != 0) {
     fprintf(stderr, "Listen failure: %s\n", uv_strerror(status));
     return;
@@ -625,19 +603,20 @@ void ServerConnection::handle_close() {
 }
 
 int ServerConnection::on_password(char* buf, int size, int rwflag, void* password) {
-  strncpy(buf, (char *)(password), size);
+  strncpy(buf, (char*)(password), size);
   buf[size - 1] = '\0';
   return strlen(buf);
 }
 
 } // namespace internal
 
-#define CHECK(pos, error) do { \
-  if ((pos) > end) { \
-    fprintf(stderr, "Decoding error: %s\n", (error)); \
-    return end + 1; \
-   } \
-} while(0)
+#define CHECK(pos, error)                               \
+  do {                                                  \
+    if ((pos) > end) {                                  \
+      fprintf(stderr, "Decoding error: %s\n", (error)); \
+      return end + 1;                                   \
+    }                                                   \
+  } while (0)
 
 inline const char* decode_int8(const char* input, const char* end, int8_t* value) {
   CHECK(input + 1, "Unable to decode byte");
@@ -648,36 +627,36 @@ inline const char* decode_int8(const char* input, const char* end, int8_t* value
 inline const char* decode_int16(const char* input, const char* end, int16_t* value) {
   CHECK(input + 2, "Unable to decode signed short");
   *value = (static_cast<int16_t>(static_cast<uint8_t>(input[1])) << 0) |
-      (static_cast<int16_t>(static_cast<uint8_t>(input[0])) << 8);
+           (static_cast<int16_t>(static_cast<uint8_t>(input[0])) << 8);
   return input + sizeof(int16_t);
 }
 
 inline const char* decode_uint16(const char* input, const char* end, uint16_t* value) {
   CHECK(input + 2, "Unable to decode unsigned short");
   *value = (static_cast<uint16_t>(static_cast<uint8_t>(input[1])) << 0) |
-      (static_cast<uint16_t>(static_cast<uint8_t>(input[0])) << 8);
+           (static_cast<uint16_t>(static_cast<uint8_t>(input[0])) << 8);
   return input + sizeof(uint16_t);
 }
 
 inline const char* decode_int32(const char* input, const char* end, int32_t* value) {
   CHECK(input + 4, "Unable to decode integer");
   *value = (static_cast<int32_t>(static_cast<uint8_t>(input[3])) << 0) |
-      (static_cast<int32_t>(static_cast<uint8_t>(input[2])) << 8) |
-      (static_cast<int32_t>(static_cast<uint8_t>(input[1])) << 16) |
-      (static_cast<int32_t>(static_cast<uint8_t>(input[0])) << 24);
+           (static_cast<int32_t>(static_cast<uint8_t>(input[2])) << 8) |
+           (static_cast<int32_t>(static_cast<uint8_t>(input[1])) << 16) |
+           (static_cast<int32_t>(static_cast<uint8_t>(input[0])) << 24);
   return input + sizeof(int32_t);
 }
 
 inline const char* decode_int64(const char* input, const char* end, int64_t* value) {
   CHECK(input + 8, "Unable to decode long");
   *value = (static_cast<int64_t>(static_cast<uint8_t>(input[7])) << 0) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[6])) << 8) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[5])) << 16) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[4])) << 24) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[3])) << 32) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[2])) << 40) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[1])) << 48) |
-      (static_cast<int64_t>(static_cast<uint8_t>(input[0])) << 56);
+           (static_cast<int64_t>(static_cast<uint8_t>(input[6])) << 8) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[5])) << 16) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[4])) << 24) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[3])) << 32) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[2])) << 40) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[1])) << 48) |
+           (static_cast<int64_t>(static_cast<uint8_t>(input[0])) << 56);
   return input + sizeof(int64_t);
 }
 
@@ -709,7 +688,7 @@ inline const char* decode_bytes(const char* input, const char* end, String* outp
 }
 
 inline const char* decode_uuid(const char* input, CassUuid* output) {
-  output->time_and_version  = static_cast<uint64_t>(static_cast<uint8_t>(input[3]));
+  output->time_and_version = static_cast<uint64_t>(static_cast<uint8_t>(input[3]));
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[2])) << 8;
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[1])) << 16;
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[0])) << 24;
@@ -722,13 +701,13 @@ inline const char* decode_uuid(const char* input, CassUuid* output) {
 
   output->clock_seq_and_node = 0;
   for (size_t i = 0; i < 8; ++i) {
-    output->clock_seq_and_node |= static_cast<uint64_t>(static_cast<uint8_t>(input[15 - i])) << (8 * i);
+    output->clock_seq_and_node |= static_cast<uint64_t>(static_cast<uint8_t>(input[15 - i]))
+                                  << (8 * i);
   }
   return input + 16;
 }
 
-inline const char* decode_string_map(const char* input,
-                                     const char* end,
+inline const char* decode_string_map(const char* input, const char* end,
                                      Vector<std::pair<String, String> >* output) {
 
   uint16_t len = 0;
@@ -744,9 +723,7 @@ inline const char* decode_string_map(const char* input,
   return pos;
 }
 
-inline const char* decode_stringlist(const char* input,
-                                     const char* end,
-                                     Vector<String>* output) {
+inline const char* decode_stringlist(const char* input, const char* end, Vector<String>* output) {
   uint16_t len = 0;
   const char* pos = decode_uint16(input, end, &len);
   output->reserve(len);
@@ -758,9 +735,7 @@ inline const char* decode_stringlist(const char* input,
   return pos;
 }
 
-inline const char* decode_values(const char* input,
-                                 const char* end,
-                                 Vector<String>* output) {
+inline const char* decode_values(const char* input, const char* end, Vector<String>* output) {
   uint16_t len = 0;
   const char* pos = decode_uint16(input, end, &len);
   output->reserve(len);
@@ -772,10 +747,8 @@ inline const char* decode_values(const char* input,
   return pos;
 }
 
-inline const char* decode_values_with_names(const char* input,
-                                            const char* end,
-                                            Vector<String>* names,
-                                            Vector<String>* values) {
+inline const char* decode_values_with_names(const char* input, const char* end,
+                                            Vector<String>* names, Vector<String>* values) {
   uint16_t len = 0;
   const char* pos = decode_uint16(input, end, &len);
   names->reserve(len);
@@ -791,8 +764,8 @@ inline const char* decode_values_with_names(const char* input,
   return pos;
 }
 
-const char* decode_query_params_v1(const char* input, const char* end,
-                                   bool is_execute, QueryParameters* params) {
+const char* decode_query_params_v1(const char* input, const char* end, bool is_execute,
+                                   QueryParameters* params) {
   const char* pos = input;
   if (is_execute) {
     pos = decode_values(pos, end, &params->values);
@@ -803,8 +776,7 @@ const char* decode_query_params_v1(const char* input, const char* end,
   return pos;
 }
 
-const char* decode_query_params_v2(const char* input, const char*end,
-                                   QueryParameters* params) {
+const char* decode_query_params_v2(const char* input, const char* end, QueryParameters* params) {
   int8_t flags;
   const char* pos = input;
   pos = decode_uint16(pos, end, &params->consistency);
@@ -825,8 +797,7 @@ const char* decode_query_params_v2(const char* input, const char*end,
   return pos;
 }
 
-const char* decode_query_params_v3v4(const char* input, const char* end,
-                                     QueryParameters* params) {
+const char* decode_query_params_v3v4(const char* input, const char* end, QueryParameters* params) {
   int8_t flags;
   const char* pos = input;
   pos = decode_uint16(pos, end, &params->consistency);
@@ -852,8 +823,7 @@ const char* decode_query_params_v3v4(const char* input, const char* end,
   return pos;
 }
 
-const char* decode_query_params_v5(const char* input, const char* end,
-                                   QueryParameters* params) {
+const char* decode_query_params_v5(const char* input, const char* end, QueryParameters* params) {
   int32_t flags;
   const char* pos = input;
   pos = decode_uint16(pos, end, &params->consistency);
@@ -882,8 +852,8 @@ const char* decode_query_params_v5(const char* input, const char* end,
   return pos;
 }
 
-const char* decode_query_params(int version, const char* input, const char* end,
-                                bool is_execute, QueryParameters* params) {
+const char* decode_query_params(int version, const char* input, const char* end, bool is_execute,
+                                QueryParameters* params) {
   const char* pos = input;
   if (version == 1) {
     pos = decode_query_params_v1(pos, end, is_execute, params);
@@ -944,8 +914,7 @@ inline int32_t encode_string(const String& value, String* output) {
 
 inline int32_t encode_string_list(const Vector<String>& value, String* output) {
   int32_t size = encode_int16(value.size(), output);
-  for (Vector<String>::const_iterator it = value.begin(),
-       end = value.end(); it != end; ++it) {
+  for (Vector<String>::const_iterator it = value.begin(), end = value.end(); it != end; ++it) {
     size += encode_string(*it, output);
   }
   return size;
@@ -959,7 +928,7 @@ inline int32_t encode_bytes(const String& value, String* output) {
 
 inline int32_t encode_inet(const Address& value, String* output) {
   uint8_t buf[16];
-  uint8_t len =  value.to_inet(buf);
+  uint8_t len = value.to_inet(buf);
   encode_int8(len, output);
   for (uint8_t i = 0; i < len; ++i) {
     output->push_back(static_cast<char>(buf[i]));
@@ -998,7 +967,8 @@ inline int32_t encode_uuid(CassUuid uuid, String* output) {
   return 16;
 }
 
-static String encode_header(int8_t version, int8_t flags, int16_t stream, int8_t opcode, int32_t len) {
+static String encode_header(int8_t version, int8_t flags, int16_t stream, int8_t opcode,
+                            int32_t len) {
   String header;
   encode_int8(0x80 | version, &header);
   encode_int8(flags, &header);
@@ -1013,7 +983,7 @@ static String encode_header(int8_t version, int8_t flags, int16_t stream, int8_t
   }
   encode_int32(len, &header);
   if (flags & FLAG_TRACING) {
-    cass::UuidGen gen;
+    UuidGen gen;
     CassUuid tracing_id;
     gen.generate_random(&tracing_id);
     encode_uuid(tracing_id, &header);
@@ -1021,17 +991,11 @@ static String encode_header(int8_t version, int8_t flags, int16_t stream, int8_t
   return header;
 }
 
-Type Type::text() {
-  return Type(TYPE_VARCHAR);
-}
+Type Type::text() { return Type(TYPE_VARCHAR); }
 
-Type Type::inet() {
-  return Type(TYPE_INET);
-}
+Type Type::inet() { return Type(TYPE_INET); }
 
-Type Type::uuid() {
-  return Type(TYPE_UUID);
-}
+Type Type::uuid() { return Type(TYPE_UUID); }
 
 Type Type::list(const Type& sub_type) {
   Type type(TYPE_LIST);
@@ -1063,25 +1027,24 @@ void Column::encode(int protocol_version, String* output) const {
 
 void Collection::encode(int protocol_version, String* output) const {
   encode_int32(values_.size(), output);
-  for (Vector<Value>::const_iterator it = values_.begin(),
-       end = values_.end(); it != end; ++it) {
+  for (Vector<Value>::const_iterator it = values_.begin(), end = values_.end(); it != end; ++it) {
     it->encode(protocol_version, output);
   }
 }
 
 Value::Value()
-  : type_(NUL) { }
+    : type_(NUL) {}
 
-Value::Value(const cass::String& value)
-  : type_(VALUE)
-  , value_(new String(value)) { }
+Value::Value(const String& value)
+    : type_(VALUE)
+    , value_(new String(value)) {}
 
 Value::Value(const Collection& collection)
-  : type_(COLLECTION)
-  , collection_(new Collection(collection)){ }
+    : type_(COLLECTION)
+    , collection_(new Collection(collection)) {}
 
 Value::Value(const Value& other)
-  : type_(other.type_) {
+    : type_(other.type_) {
   if (type_ == VALUE) {
     value_ = new String(*other.value_);
   } else if (type_ == COLLECTION) {
@@ -1100,21 +1063,21 @@ Value::~Value() {
 void Value::encode(int protocol_version, String* output) const {
   if (type_ == NUL) {
     encode_int32(-1, output);
-  } else if(type_ == VALUE) {
+  } else if (type_ == VALUE) {
     encode_bytes(*value_, output);
-  } else if(type_ == COLLECTION) {
+  } else if (type_ == COLLECTION) {
     String buf;
     collection_->encode(protocol_version, &buf);
     encode_bytes(buf, output);
   }
 }
 
-Row::Builder& Row::Builder::text(const cass::String& text) {
+Row::Builder& Row::Builder::text(const String& text) {
   values_.push_back(Value(text));
   return *this;
 }
 
-Row::Builder& Row::Builder::inet(const cass::Address& inet) {
+Row::Builder& Row::Builder::inet(const Address& inet) {
   String value;
   uint8_t buf[16];
   uint8_t len = inet.to_inet(buf);
@@ -1137,9 +1100,8 @@ Row::Builder& Row::Builder::collection(const Collection& collection) {
   return *this;
 }
 
-void Row::encode(int protocol_version, cass::String* output) const {
-  for (Vector<Value>::const_iterator it = values_.begin(),
-       end = values_.end(); it != end; ++it) {
+void Row::encode(int protocol_version, String* output) const {
+  for (Vector<Value>::const_iterator it = values_.begin(), end = values_.end(); it != end; ++it) {
     it->encode(protocol_version, output);
   }
 }
@@ -1150,21 +1112,20 @@ String ResultSet::encode(int protocol_version) const {
   encode_int32(RESULT_ROWS, &body); // Result type
 
   encode_int32(RESULT_FLAG_GLOBAL_TABLESPEC, &body); // Flags
-  encode_int32(columns_.size(), &body); // Column count
-  encode_string(keyspace_name_, &body); // Global spec keyspace name
-  encode_string(table_name_, &body); // Global spec table name
+  encode_int32(columns_.size(), &body);              // Column count
+  encode_string(keyspace_name_, &body);              // Global spec keyspace name
+  encode_string(table_name_, &body);                 // Global spec table name
 
   // Columns
-  for (Vector<Column>::const_iterator it = columns_.begin(),
-       end = columns_.end(); it != end; ++it) {
+  for (Vector<Column>::const_iterator it = columns_.begin(), end = columns_.end(); it != end;
+       ++it) {
     it->encode(protocol_version, &body);
   }
 
   encode_int32(rows_.size(), &body); // Row count
 
   // Rows
-  for (Vector<Row>::const_iterator it = rows_.begin(),
-       end = rows_.end(); it != end; ++it) {
+  for (Vector<Row>::const_iterator it = rows_.begin(), end = rows_.end(); it != end; ++it) {
     it->encode(protocol_version, &body);
   }
 
@@ -1195,33 +1156,25 @@ Action::Builder& Action::Builder::execute_if(Action* action) {
   return *this;
 }
 
-Action::Builder& Action::Builder::nop() {
-  return execute(new Nop());
-}
+Action::Builder& Action::Builder::nop() { return execute(new Nop()); }
 
-Action::Builder& Action::Builder::wait(uint64_t timeout) {
-  return execute(new Wait(timeout));
-}
+Action::Builder& Action::Builder::wait(uint64_t timeout) { return execute(new Wait(timeout)); }
 
-Action::Builder& Action::Builder::close() {
-  return execute(new Close());
-}
+Action::Builder& Action::Builder::close() { return execute(new Close()); }
 
 Action::Builder& Action::Builder::error(int32_t code, const String& message) {
   return execute(new SendError(code, message));
 }
 
-Action::Builder&Action::Builder::invalid_protocol() {
+Action::Builder& Action::Builder::invalid_protocol() {
   return error(ERROR_PROTOCOL_ERROR, "Invalid or unsupported protocol version");
 }
 
-Action::Builder&Action::Builder::invalid_opcode() {
+Action::Builder& Action::Builder::invalid_opcode() {
   return error(ERROR_PROTOCOL_ERROR, "Invalid opcode (or not implemented)");
 }
 
-Action::Builder& Action::Builder::ready() {
-  return execute(new SendReady());
-}
+Action::Builder& Action::Builder::ready() { return execute(new SendReady()); }
 
 Action::Builder& Action::Builder::authenticate(const String& class_name) {
   return execute(new SendAuthenticate(class_name));
@@ -1235,66 +1188,45 @@ Action::Builder& Action::Builder::auth_success(const String& token) {
   return execute(new SendAuthSuccess(token));
 }
 
-Action::Builder& Action::Builder::supported() {
-  return execute(new SendSupported());
-}
+Action::Builder& Action::Builder::supported() { return execute(new SendSupported()); }
 
 Action::Builder& Action::Builder::up_event(const Address& address) {
   return execute(new SendUpEvent(address));
 }
 
-Action::Builder& Action::Builder::void_result() {
-  return execute(new VoidResult());
-}
+Action::Builder& Action::Builder::void_result() { return execute(new VoidResult()); }
 
 Action::Builder& Action::Builder::empty_rows_result(int32_t row_count) {
   return execute(new EmptyRowsResult(row_count));
 }
 
-Action::Builder& Action::Builder::no_result() {
-  return execute(new NoResult());
-}
+Action::Builder& Action::Builder::no_result() { return execute(new NoResult()); }
 
 Action::Builder& Action::Builder::match_query(const Matches& matches) {
   return execute(new MatchQuery(matches));
 }
 
-Action::Builder& Action::Builder::client_options() {
-  return execute(new ClientOptions());
-}
+Action::Builder& Action::Builder::client_options() { return execute(new ClientOptions()); }
 
-Action::Builder& Action::Builder::system_local() {
-  return execute(new SystemLocal());
-}
+Action::Builder& Action::Builder::system_local() { return execute(new SystemLocal()); }
 
-Action::Builder& Action::Builder::system_local_dse() {
-  return execute(new SystemLocalDse());
-}
+Action::Builder& Action::Builder::system_local_dse() { return execute(new SystemLocalDse()); }
 
-Action::Builder& Action::Builder::system_peers() {
-  return execute(new SystemPeers());
-}
+Action::Builder& Action::Builder::system_peers() { return execute(new SystemPeers()); }
 
-Action::Builder& Action::Builder::system_peers_dse() {
-  return execute(new SystemPeersDse());
-}
+Action::Builder& Action::Builder::system_peers_dse() { return execute(new SystemPeersDse()); }
 
-Action::Builder& Action::Builder::system_traces() {
-  return execute(new SystemTraces());
-}
+Action::Builder& Action::Builder::system_traces() { return execute(new SystemTraces()); }
 
-Action::Builder& Action::Builder::use_keyspace(const cass::String& keyspace) {
+Action::Builder& Action::Builder::use_keyspace(const String& keyspace) {
   return execute((new UseKeyspace(keyspace)));
 }
 
-Action::Builder& Action::Builder::plaintext_auth(const cass::String& username,
-                                                 const cass::String& password) {
+Action::Builder& Action::Builder::plaintext_auth(const String& username, const String& password) {
   return execute((new PlaintextAuth(username, password)));
 }
 
-Action::Builder& Action::Builder::validate_startup() {
-  return execute(new ValidateStartup());
-}
+Action::Builder& Action::Builder::validate_startup() { return execute(new ValidateStartup()); }
 
 Action::Builder& Action::Builder::validate_credentials() {
   return execute(new ValidateCredentials());
@@ -1304,13 +1236,9 @@ Action::Builder& Action::Builder::validate_auth_response() {
   return execute(new ValidateAuthResponse());
 }
 
-Action::Builder& Action::Builder::validate_register() {
-  return execute(new ValidateRegister());
-}
+Action::Builder& Action::Builder::validate_register() { return execute(new ValidateRegister()); }
 
-Action::Builder& Action::Builder::validate_query() {
-  return execute(new ValidateQuery());
-}
+Action::Builder& Action::Builder::validate_query() { return execute(new ValidateQuery()); }
 
 Action::Builder& Action::Builder::set_registered_for_events() {
   return execute(new SetRegisteredForEvents());
@@ -1320,25 +1248,21 @@ Action::Builder& Action::Builder::set_protocol_version() {
   return execute(new SetProtocolVersion());
 }
 
-Action* Action::Builder::build() {
-  return first_.release();
-}
+Action* Action::Builder::build() { return first_.release(); }
 
-Action::PredicateBuilder Action::Builder::is_address(const cass::Address& address) {
+Action::PredicateBuilder Action::Builder::is_address(const Address& address) {
   return PredicateBuilder(execute(new IsAddress(address)));
 }
 
-Action::PredicateBuilder Action::Builder::is_address(const cass::String& address, int port) {
+Action::PredicateBuilder Action::Builder::is_address(const String& address, int port) {
   return PredicateBuilder(execute(new IsAddress(Address(address, port))));
 }
 
-Action::PredicateBuilder Action::Builder::is_query(const cass::String& query) {
+Action::PredicateBuilder Action::Builder::is_query(const String& query) {
   return PredicateBuilder(execute(new IsQuery(query)));
 }
 
-void Action::run(Request* request) const {
-  on_run(request);
-}
+void Action::run(Request* request) const { on_run(request); }
 
 void Action::run_next(Request* request) const {
   if (next) {
@@ -1346,23 +1270,21 @@ void Action::run_next(Request* request) const {
   }
 }
 
-Request::Request(int8_t version, int8_t flags, int16_t stream, int8_t opcode,
-                 const String& body, ClientConnection* client)
-  : version_(version)
-  , flags_(flags)
-  , stream_(stream)
-  , opcode_(opcode)
-  , body_(body)
-  , client_(client)
-  , timer_action_(NULL) {
+Request::Request(int8_t version, int8_t flags, int16_t stream, int8_t opcode, const String& body,
+                 ClientConnection* client)
+    : version_(version)
+    , flags_(flags)
+    , stream_(stream)
+    , opcode_(opcode)
+    , body_(body)
+    , client_(client)
+    , timer_action_(NULL) {
   (void)flags_; // TODO: Implement custom payload etc.
 }
 
-void Request::write(int8_t opcode, const String& body) {
-  write(stream_, opcode, body);
-}
+void Request::write(int8_t opcode, const String& body) { write(stream_, opcode, body); }
 
-void Request::write(int16_t stream, int8_t opcode, const cass::String& body) {
+void Request::write(int16_t stream, int8_t opcode, const String& body) {
   client_->write(encode_header(version_, flags_, stream, opcode, body.size()) + body);
 }
 
@@ -1376,13 +1298,10 @@ void Request::error(int32_t code, const String& message) {
 void Request::wait(uint64_t timeout, const Action* action) {
   inc_ref();
   timer_action_ = action;
-  timer_.start(client_->server()->loop(), timeout,
-               cass::bind_callback(&Request::on_timeout, this));
+  timer_.start(client_->server()->loop(), timeout, bind_callback(&Request::on_timeout, this));
 }
 
-void Request::close() {
-  client_->close();
-}
+void Request::close() { client_->close(); }
 
 bool Request::decode_startup(Options* options) {
   return decode_string_map(start(), end(), options) == end();
@@ -1401,41 +1320,36 @@ bool Request::decode_register(EventTypes* types) {
 }
 
 bool Request::decode_query(String* query, QueryParameters* params) {
-  return decode_query_params(version_, decode_long_string(start(), end(), query), end(), false, params) == end();
+  return decode_query_params(version_, decode_long_string(start(), end(), query), end(), false,
+                             params) == end();
 }
 
 bool Request::decode_execute(String* id, QueryParameters* params) {
-  return decode_query_params(version_, decode_string(start(), end(), id), end(), true, params) == end();
+  return decode_query_params(version_, decode_string(start(), end(), id), end(), true, params) ==
+         end();
 }
 
 bool Request::decode_prepare(String* query, PrepareParameters* params) {
-  return decode_prepare_params(version_, decode_long_string(start(), end(), query), end(), params) == end();
+  return decode_prepare_params(version_, decode_long_string(start(), end(), query), end(),
+                               params) == end();
 }
 
-const Address& Request::address() const {
-  return client_->server()->address();
-}
+const Address& Request::address() const { return client_->server()->address(); }
 
 const Host& Request::host(const Address& address) const {
   return client_->cluster()->host(address);
 }
 
-Hosts Request::hosts() const {
-  return client_->cluster()->hosts();
-}
+Hosts Request::hosts() const { return client_->cluster()->hosts(); }
 
 void Request::on_timeout(Timer* timer) {
   timer_action_->run_next(this);
   dec_ref();
 }
 
-void SendError::on_run(Request* request) const {
-  request->error(code, message);
-}
+void SendError::on_run(Request* request) const { request->error(code, message); }
 
-void SendReady::on_run(Request* request) const {
-  request->write(OPCODE_READY, String());
-}
+void SendReady::on_run(Request* request) const { request->write(OPCODE_READY, String()); }
 
 void SendAuthenticate::on_run(Request* request) const {
   String body;
@@ -1480,14 +1394,14 @@ void EmptyRowsResult::on_run(Request* request) const {
   } else {
     String body;
     encode_int32(RESULT_ROWS, &body);
-    encode_int32(0, &body); // Flags
-    encode_int32(0, &body); // Column count
+    encode_int32(0, &body);         // Flags
+    encode_int32(0, &body);         // Column count
     encode_int32(row_count, &body); // Row count
     request->write(OPCODE_RESULT, body);
   }
 }
 
-void NoResult::on_run(Request* request) const { }
+void NoResult::on_run(Request* request) const {}
 
 void MatchQuery::on_run(Request* request) const {
   String query;
@@ -1496,8 +1410,7 @@ void MatchQuery::on_run(Request* request) const {
     request->error(ERROR_PROTOCOL_ERROR, "Invalid query message");
     return;
   } else {
-    for (Matches::const_iterator it = matches.begin(),
-         end = matches.end(); it != end; ++it) {
+    for (Matches::const_iterator it = matches.begin(), end = matches.end(); it != end; ++it) {
       if (it->first == query) {
         request->write(OPCODE_RESULT, it->second.encode(request->version()));
         return;
@@ -1516,9 +1429,10 @@ void ClientOptions::on_run(Request* request) const {
     ResultSet::Builder builder("client", "options");
     Row::Builder row_builder;
     for (Options::const_iterator it = request->client()->options().begin(),
-      end = request->client()->options().end(); it != end; ++it) {
-        builder.column((*it).first, Type::text());
-        row_builder.text((*it).second);
+                                 end = request->client()->options().end();
+         it != end; ++it) {
+      builder.column((*it).first, Type::text());
+      row_builder.text((*it).second);
     }
     ResultSet client_options = builder.row(row_builder.build()).build();
 
@@ -1536,25 +1450,24 @@ void SystemLocal::on_run(Request* request) const {
   } else if (query.find(SELECT_LOCAL) != String::npos) {
     const Host& host(request->host(request->address()));
 
-    ResultSet local_rs
-        = ResultSet::Builder("system", "local")
-          .column("key", Type::text())
-          .column("data_center", Type::text())
-          .column("rack", Type::text())
-          .column("release_version", Type::text())
-          .column("rpc_address", Type::inet())
-          .column("partitioner", Type::text())
-          .column("tokens", Type::list(Type::text()))
-          .row(Row::Builder()
-               .text(request->client()->server()->address().to_string())
-               .text(host.dc)
-               .text(host.rack)
-               .text(CASSANDRA_VERSION)
-               .inet(request->client()->server()->address())
-               .text(host.partitioner)
-               .collection(Collection::text(host.tokens))
-               .build())
-          .build();
+    ResultSet local_rs = ResultSet::Builder("system", "local")
+                             .column("key", Type::text())
+                             .column("data_center", Type::text())
+                             .column("rack", Type::text())
+                             .column("release_version", Type::text())
+                             .column("rpc_address", Type::inet())
+                             .column("partitioner", Type::text())
+                             .column("tokens", Type::list(Type::text()))
+                             .row(Row::Builder()
+                                      .text(request->client()->server()->address().to_string())
+                                      .text(host.dc)
+                                      .text(host.rack)
+                                      .text(CASSANDRA_VERSION)
+                                      .inet(request->client()->server()->address())
+                                      .text(host.partitioner)
+                                      .collection(Collection::text(host.tokens))
+                                      .build())
+                             .build();
 
     request->write(OPCODE_RESULT, local_rs.encode(request->version()));
   } else {
@@ -1570,27 +1483,26 @@ void SystemLocalDse::on_run(Request* request) const {
   } else if (query.find(SELECT_LOCAL) != String::npos) {
     const Host& host(request->host(request->address()));
 
-    ResultSet local_rs
-        = ResultSet::Builder("system", "local")
-          .column("key", Type::text())
-          .column("data_center", Type::text())
-          .column("rack", Type::text())
-          .column("dse_version", Type::text())
-          .column("release_version", Type::text())
-          .column("rpc_address", Type::inet())
-          .column("partitioner", Type::text())
-          .column("tokens", Type::list(Type::text()))
-          .row(Row::Builder()
-               .text(request->client()->server()->address().to_string())
-               .text(host.dc)
-               .text(host.rack)
-               .text(DSE_VERSION)
-               .text(DSE_CASSANDRA_VERSION)
-               .inet(request->client()->server()->address())
-               .text(host.partitioner)
-               .collection(Collection::text(host.tokens))
-               .build())
-          .build();
+    ResultSet local_rs = ResultSet::Builder("system", "local")
+                             .column("key", Type::text())
+                             .column("data_center", Type::text())
+                             .column("rack", Type::text())
+                             .column("dse_version", Type::text())
+                             .column("release_version", Type::text())
+                             .column("rpc_address", Type::inet())
+                             .column("partitioner", Type::text())
+                             .column("tokens", Type::list(Type::text()))
+                             .row(Row::Builder()
+                                      .text(request->client()->server()->address().to_string())
+                                      .text(host.dc)
+                                      .text(host.rack)
+                                      .text(DSE_VERSION)
+                                      .text(DSE_CASSANDRA_VERSION)
+                                      .inet(request->client()->server()->address())
+                                      .text(host.partitioner)
+                                      .collection(Collection::text(host.tokens))
+                                      .build())
+                             .build();
 
     request->write(OPCODE_RESULT, local_rs.encode(request->version()));
   } else {
@@ -1605,33 +1517,30 @@ void SystemPeers::on_run(Request* request) const {
     request->error(ERROR_PROTOCOL_ERROR, "Invalid query message");
   } else if (query.find(SELECT_PEERS) != String::npos) {
     const String where_clause(" WHERE peer = '");
-    ResultSet::Builder peers_builder
-        = ResultSet::Builder("system", "peers")
-          .column("peer", Type::inet())
-          .column("data_center", Type::text())
-          .column("rack", Type::text())
-          .column("release_version", Type::text())
-          .column("rpc_address", Type::inet())
-          .column("tokens", Type::list(Type::text()));
+    ResultSet::Builder peers_builder = ResultSet::Builder("system", "peers")
+                                           .column("peer", Type::inet())
+                                           .column("data_center", Type::text())
+                                           .column("rack", Type::text())
+                                           .column("release_version", Type::text())
+                                           .column("rpc_address", Type::inet())
+                                           .column("tokens", Type::list(Type::text()));
 
     size_t pos = query.find(where_clause);
     if (pos == String::npos) {
       Hosts hosts(request->hosts());
-      for (Hosts::const_iterator it = hosts.begin(),
-           end = hosts.end(); it != end; ++it) {
+      for (Hosts::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
         const Host& host(*it);
         if (host.address == request->address()) {
           continue;
         }
-        peers_builder
-            .row(Row::Builder()
-                 .inet(host.address)
-                 .text(host.dc)
-                 .text(host.rack)
-                 .text(CASSANDRA_VERSION)
-                 .inet(host.address)
-                 .collection(Collection::text(host.tokens))
-                 .build());
+        peers_builder.row(Row::Builder()
+                              .inet(host.address)
+                              .text(host.dc)
+                              .text(host.rack)
+                              .text(CASSANDRA_VERSION)
+                              .inet(host.address)
+                              .collection(Collection::text(host.tokens))
+                              .build());
       }
       ResultSet peers_rs = peers_builder.build();
       request->write(OPCODE_RESULT, peers_rs.encode(request->version()));
@@ -1651,17 +1560,16 @@ void SystemPeers::on_run(Request* request) const {
       }
 
       const Host& host(request->host(address));
-      ResultSet peers_rs
-          = peers_builder
-            .row(Row::Builder()
-                 .inet(host.address)
-                 .text(host.dc)
-                 .text(host.rack)
-                 .text(CASSANDRA_VERSION)
-                 .inet(host.address)
-                 .collection(Collection::text(host.tokens))
-                 .build())
-            .build();
+      ResultSet peers_rs = peers_builder
+                               .row(Row::Builder()
+                                        .inet(host.address)
+                                        .text(host.dc)
+                                        .text(host.rack)
+                                        .text(CASSANDRA_VERSION)
+                                        .inet(host.address)
+                                        .collection(Collection::text(host.tokens))
+                                        .build())
+                               .build();
       request->write(OPCODE_RESULT, peers_rs.encode(request->version()));
     }
   } else {
@@ -1676,35 +1584,32 @@ void SystemPeersDse::on_run(Request* request) const {
     request->error(ERROR_PROTOCOL_ERROR, "Invalid query message");
   } else if (query.find(SELECT_PEERS) != String::npos) {
     const String where_clause(" WHERE peer = '");
-    ResultSet::Builder peers_builder
-        = ResultSet::Builder("system", "peers")
-          .column("peer", Type::inet())
-          .column("data_center", Type::text())
-          .column("rack", Type::text())
-          .column("dse_version", Type::text())
-          .column("release_version", Type::text())
-          .column("rpc_address", Type::inet())
-          .column("tokens", Type::list(Type::text()));
+    ResultSet::Builder peers_builder = ResultSet::Builder("system", "peers")
+                                           .column("peer", Type::inet())
+                                           .column("data_center", Type::text())
+                                           .column("rack", Type::text())
+                                           .column("dse_version", Type::text())
+                                           .column("release_version", Type::text())
+                                           .column("rpc_address", Type::inet())
+                                           .column("tokens", Type::list(Type::text()));
 
     size_t pos = query.find(where_clause);
     if (pos == String::npos) {
       Hosts hosts(request->hosts());
-      for (Hosts::const_iterator it = hosts.begin(),
-           end = hosts.end(); it != end; ++it) {
+      for (Hosts::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
         const Host& host(*it);
         if (host.address == request->address()) {
           continue;
         }
-        peers_builder
-            .row(Row::Builder()
-                 .inet(host.address)
-                 .text(host.dc)
-                 .text(host.rack)
-                 .text(DSE_VERSION)
-                 .text(DSE_CASSANDRA_VERSION)
-                 .inet(host.address)
-                 .collection(Collection::text(host.tokens))
-                 .build());
+        peers_builder.row(Row::Builder()
+                              .inet(host.address)
+                              .text(host.dc)
+                              .text(host.rack)
+                              .text(DSE_VERSION)
+                              .text(DSE_CASSANDRA_VERSION)
+                              .inet(host.address)
+                              .collection(Collection::text(host.tokens))
+                              .build());
       }
       ResultSet peers_rs = peers_builder.build();
       request->write(OPCODE_RESULT, peers_rs.encode(request->version()));
@@ -1724,17 +1629,16 @@ void SystemPeersDse::on_run(Request* request) const {
       }
 
       const Host& host(request->host(address));
-      ResultSet peers_rs
-          = peers_builder
-            .row(Row::Builder()
-                 .inet(host.address)
-                 .text(host.dc)
-                 .text(host.rack)
-                 .text(CASSANDRA_VERSION)
-                 .inet(host.address)
-                 .collection(Collection::text(host.tokens))
-                 .build())
-            .build();
+      ResultSet peers_rs = peers_builder
+                               .row(Row::Builder()
+                                        .inet(host.address)
+                                        .text(host.dc)
+                                        .text(host.rack)
+                                        .text(CASSANDRA_VERSION)
+                                        .inet(host.address)
+                                        .collection(Collection::text(host.tokens))
+                                        .build())
+                               .build();
       request->write(OPCODE_RESULT, peers_rs.encode(request->version()));
     }
   } else {
@@ -1754,13 +1658,10 @@ void SystemTraces::on_run(Request* request) const {
     }
     CassUuid tracing_id;
     decode_uuid(params.values.front().data(), &tracing_id);
-    ResultSet session_rs
-        = ResultSet::Builder("system_traces", "session")
-          .column("session_id", Type::uuid())
-          .row(Row::Builder()
-               .uuid(tracing_id)
-               .build())
-          .build();
+    ResultSet session_rs = ResultSet::Builder("system_traces", "session")
+                               .column("session_id", Type::uuid())
+                               .row(Row::Builder().uuid(tracing_id).build())
+                               .build();
     request->write(OPCODE_RESULT, session_rs.encode(request->version()));
   } else {
     run_next(request);
@@ -1797,8 +1698,7 @@ void PlaintextAuth::on_run(Request* request) const {
     String username, password;
     String::const_reverse_iterator last = token.rbegin();
     enum { PASSWORD, USERNAME } state = PASSWORD;
-    for (String::const_reverse_iterator it = token.rbegin(),
-         end = token.rend(); it != end; ++it) {
+    for (String::const_reverse_iterator it = token.rbegin(), end = token.rend(); it != end; ++it) {
       if (*it == '\0') {
         if (state == PASSWORD) {
           password.assign(it.base(), last.base());
@@ -1891,16 +1791,15 @@ bool IsQuery::is_true(Request* request) const {
 }
 
 RequestHandler::RequestHandler(RequestHandler::Builder* builder,
-                 int lowest_supported_protocol_version,
-                 int highest_supported_protocol_version)
-  : invalid_protocol_(builder->on_invalid_protocol().build())
-  , invalid_opcode_(builder->on_invalid_opcode().build())
-  , lowest_supported_protocol_version_(lowest_supported_protocol_version)
-  , highest_supported_protocol_version_(highest_supported_protocol_version) { }
+                               int lowest_supported_protocol_version,
+                               int highest_supported_protocol_version)
+    : invalid_protocol_(builder->on_invalid_protocol().build())
+    , invalid_opcode_(builder->on_invalid_opcode().build())
+    , lowest_supported_protocol_version_(lowest_supported_protocol_version)
+    , highest_supported_protocol_version_(highest_supported_protocol_version) {}
 
 const RequestHandler* RequestHandler::Builder::build() {
-  RequestHandler* handler(new RequestHandler(this,
-                                             lowest_supported_protocol_version_,
+  RequestHandler* handler(new RequestHandler(this, lowest_supported_protocol_version_,
                                              highest_supported_protocol_version_));
 
   handler->actions_[OPCODE_STARTUP].reset(actions_[OPCODE_STARTUP].build());
@@ -1924,7 +1823,7 @@ void ProtocolHandler::decode(ClientConnection* client, const char* data, int32_t
     } else {
       // Not efficient, but concise. Copy the consumed part of the buffer
       // forward then resize the buffer to what's left over.
-      std::copy(buffer_.begin(), buffer_.begin() + result, buffer_.begin());
+      std::copy(buffer_.begin() + result, buffer_.end(), buffer_.begin());
       buffer_.resize(buffer_.size() - result);
     }
   }
@@ -1943,12 +1842,17 @@ int32_t ProtocolHandler::decode_frame(ClientConnection* client, const char* fram
         remaining--;
         if (version_ < request_handler_->lowest_supported_protocol_version() ||
             version_ > request_handler_->highest_supported_protocol_version()) {
-          // Respond using the highest supported protocol that the server
-          // supports (don't use the request's version because it's not supported)
-          Request::Ptr request(new Request(request_handler_->highest_supported_protocol_version(),
-                                           flags_, stream_, opcode_, String(), client));
+          // Use the highest supported protocol version unless it's less than the lowest supported
+          // then use the original request's protocol version.
+          int8_t response_version = request_handler_->highest_supported_protocol_version();
+          if (version_ < request_handler_->lowest_supported_protocol_version()) {
+            response_version = version_;
+          }
+          Request::Ptr request(
+              new Request(response_version, flags_, stream_, opcode_, String(), client));
           request_handler_->invalid_protocol(request.get());
-          return len - remaining;
+          client->close();
+          return -1;
         }
         state_ = HEADER;
         break;
@@ -1959,7 +1863,7 @@ int32_t ProtocolHandler::decode_frame(ClientConnection* client, const char* fram
           opcode_ = *pos++;
           pos = decode_int32(pos, end, &length_);
           remaining -= 7;
-        } else if (version_ >= 3 && version_ <= 5 && remaining >= 8) {
+        } else if (version_ >= 3 && remaining >= 8) {
           flags_ = *pos++;
           pos = decode_int16(pos, end, &stream_);
           opcode_ = *pos++;
@@ -1995,19 +1899,20 @@ void ProtocolHandler::decode_body(ClientConnection* client, const char* body, in
   request_handler_->run(request.get());
 }
 
-void ClientConnection::on_read(const char* data, size_t len) {
-  handler_.decode(this, data, len);
-}
+void ClientConnection::on_read(const char* data, size_t len) { handler_.decode(this, data, len); }
 
-Event::Event(const cass::String& event_body)
-  : event_body_(event_body) { }
+Event::Event(const String& event_body)
+    : event_body_(event_body) {}
 
 void Event::run(internal::ServerConnection* server_connection) {
   for (internal::ClientConnections::const_iterator it = server_connection->clients().begin(),
-       end = server_connection->clients().end(); it != end; ++it) {
+                                                   end = server_connection->clients().end();
+       it != end; ++it) {
     ClientConnection* client = static_cast<ClientConnection*>(*it);
     if (client->is_registered_for_events() && client->protocol_version() > 0) {
-      client->write(encode_header(client->protocol_version(), 0, -1, OPCODE_EVENT, event_body_.size()) + event_body_);
+      client->write(
+          encode_header(client->protocol_version(), 0, -1, OPCODE_EVENT, event_body_.size()) +
+          event_body_);
     }
   }
 }
@@ -2024,10 +1929,10 @@ Event::Ptr TopologyChangeEvent::removed_node(const Address& address) {
   return Ptr(new TopologyChangeEvent(REMOVED_NODE, address));
 }
 
-cass::String TopologyChangeEvent::encode(TopologyChangeEvent::Type type, const cass::Address& address) {
+String TopologyChangeEvent::encode(TopologyChangeEvent::Type type, const Address& address) {
   String body;
   encode_string("TOPOLOGY_CHANGE", &body);
-  switch(type) {
+  switch (type) {
     case NEW_NODE:
       encode_string("NEW_NODE", &body);
       break;
@@ -2046,14 +1951,14 @@ Event::Ptr StatusChangeEvent::up(const Address& address) {
   return Ptr(new StatusChangeEvent(UP, address));
 }
 
-Event::Ptr StatusChangeEvent::down(const cass::Address& address) {
+Event::Ptr StatusChangeEvent::down(const Address& address) {
   return Ptr(new StatusChangeEvent(DOWN, address));
 }
 
 String StatusChangeEvent::encode(Type type, const Address& address) {
   String body;
   encode_string("STATUS_CHANGE", &body);
-  switch(type) {
+  switch (type) {
     case UP:
       encode_string("UP", &body);
       break;
@@ -2065,48 +1970,35 @@ String StatusChangeEvent::encode(Type type, const Address& address) {
   return body;
 }
 
-Event::Ptr SchemaChangeEvent::keyspace(SchemaChangeEvent::Type type,
-                                       const String& keyspace_name) {
-  return Ptr(new SchemaChangeEvent(KEYSPACE,
-                                   type,
-                                   keyspace_name));
+Event::Ptr SchemaChangeEvent::keyspace(SchemaChangeEvent::Type type, const String& keyspace_name) {
+  return Ptr(new SchemaChangeEvent(KEYSPACE, type, keyspace_name));
 }
 
-Event::Ptr SchemaChangeEvent::table(SchemaChangeEvent::Type type,
-                                    const String& keyspace_name,
+Event::Ptr SchemaChangeEvent::table(SchemaChangeEvent::Type type, const String& keyspace_name,
                                     const String& table_name) {
-  return Ptr(new SchemaChangeEvent(TABLE, type,
-                                   keyspace_name, table_name));
+  return Ptr(new SchemaChangeEvent(TABLE, type, keyspace_name, table_name));
 }
 
-Event::Ptr SchemaChangeEvent::user_type(SchemaChangeEvent::Type type,
-                                        const String& keyspace_name,
+Event::Ptr SchemaChangeEvent::user_type(SchemaChangeEvent::Type type, const String& keyspace_name,
                                         const String& user_type_name) {
-  return Ptr(new SchemaChangeEvent(USER_TYPE, type,
-                                                 keyspace_name, user_type_name));
+  return Ptr(new SchemaChangeEvent(USER_TYPE, type, keyspace_name, user_type_name));
 }
 
-Event::Ptr SchemaChangeEvent::function(SchemaChangeEvent::Type type,
-                                       const String& keyspace_name,
+Event::Ptr SchemaChangeEvent::function(SchemaChangeEvent::Type type, const String& keyspace_name,
                                        const String& function_name,
                                        const Vector<String>& args_types) {
-  return Ptr(new SchemaChangeEvent(FUNCTION, type,
-                                                 keyspace_name, function_name,
-                                                 args_types));
+  return Ptr(new SchemaChangeEvent(FUNCTION, type, keyspace_name, function_name, args_types));
 }
 
-Event::Ptr SchemaChangeEvent::aggregate(SchemaChangeEvent::Type type,
-                                        const String& keyspace_name,
+Event::Ptr SchemaChangeEvent::aggregate(SchemaChangeEvent::Type type, const String& keyspace_name,
                                         const String& aggregate_name,
                                         const Vector<String>& args_types) {
-  return Ptr(new SchemaChangeEvent(AGGREGATE, type,
-                                                 keyspace_name, aggregate_name,
-                                                 args_types));
+  return Ptr(new SchemaChangeEvent(AGGREGATE, type, keyspace_name, aggregate_name, args_types));
 }
 
-cass::String SchemaChangeEvent::encode(SchemaChangeEvent::Target target, SchemaChangeEvent::Type type,
-                                       const cass::String& keyspace_name, const cass::String& target_name,
-                                       const Vector<cass::String>& arg_types) {
+String SchemaChangeEvent::encode(SchemaChangeEvent::Target target, SchemaChangeEvent::Type type,
+                                 const String& keyspace_name, const String& target_name,
+                                 const Vector<String>& arg_types) {
   String body;
   encode_string("SCHEMA_CHANGE", &body);
   switch (type) {
@@ -2129,7 +2021,8 @@ cass::String SchemaChangeEvent::encode(SchemaChangeEvent::Target target, SchemaC
       encode_string("TABLE", &body);
       encode_string(keyspace_name, &body);
       encode_string(target_name, &body);
-      break;;
+      break;
+      ;
     case USER_TYPE:
       encode_string("TYPE", &body);
       encode_string(keyspace_name, &body);
@@ -2151,10 +2044,8 @@ cass::String SchemaChangeEvent::encode(SchemaChangeEvent::Target target, SchemaC
   return body;
 }
 
-void Cluster::init(AddressGenerator& generator,
-                   ClientConnectionFactory& factory,
-                   size_t num_nodes_dc1,
-                   size_t num_nodes_dc2) {
+void Cluster::init(AddressGenerator& generator, ClientConnectionFactory& factory,
+                   size_t num_nodes_dc1, size_t num_nodes_dc2) {
   for (size_t i = 0; i < num_nodes_dc1; ++i) {
     create_and_add_server(generator, factory, "dc1");
   }
@@ -2163,9 +2054,7 @@ void Cluster::init(AddressGenerator& generator,
   }
 }
 
-Cluster::~Cluster() {
-  stop_all();
-}
+Cluster::~Cluster() { stop_all(); }
 
 String Cluster::use_ssl(const String& cn /*= ""*/) {
   String key(Ssl::generate_key());
@@ -2189,7 +2078,7 @@ int Cluster::start_all(EventLoopGroup* event_loop_group) {
   return 0;
 }
 
-void Cluster::start_all_async(cass::EventLoopGroup* event_loop_group) {
+void Cluster::start_all_async(EventLoopGroup* event_loop_group) {
   for (size_t i = 0; i < servers_.size(); ++i) {
     Server& server = servers_[i];
     server.connection->listen(event_loop_group);
@@ -2220,7 +2109,7 @@ int Cluster::start(EventLoopGroup* event_loop_group, size_t node) {
   return server.connection->wait_listen();
 }
 
-void Cluster::start_async(cass::EventLoopGroup* event_loop_group, size_t node) {
+void Cluster::start_async(EventLoopGroup* event_loop_group, size_t node) {
   if (node < 1 || node > servers_.size()) {
     return;
   }
@@ -2245,7 +2134,7 @@ void Cluster::stop_async(size_t node) {
   server.connection->close();
 }
 
-int Cluster::add(cass::EventLoopGroup* event_loop_group, size_t node) {
+int Cluster::add(EventLoopGroup* event_loop_group, size_t node) {
   if (node < 1 || node > servers_.size()) {
     return -1;
   }
@@ -2279,22 +2168,19 @@ void Cluster::remove(size_t node) {
 }
 
 const Host& Cluster::host(const Address& address) const {
-  for (Servers::const_iterator it = servers_.begin(),
-       end = servers_.end(); it != end; ++it) {
+  for (Servers::const_iterator it = servers_.begin(), end = servers_.end(); it != end; ++it) {
     if (it->host.address == address) {
       return it->host;
     }
   }
 
-  throw Exception(ERROR_PROTOCOL_ERROR,
-                  "Unable to find host " + address.to_string());
+  throw Exception(ERROR_PROTOCOL_ERROR, "Unable to find host " + address.to_string());
 }
 
 Hosts Cluster::hosts() const {
   Hosts hosts;
   hosts.reserve(servers_.size());
-  for (Servers::const_iterator it = servers_.begin(),
-       end = servers_.end(); it != end; ++it) {
+  for (Servers::const_iterator it = servers_.begin(), end = servers_.end(); it != end; ++it) {
     if (!it->is_removed.load()) {
       hosts.push_back(it->host);
     }
@@ -2302,41 +2188,44 @@ Hosts Cluster::hosts() const {
   return hosts;
 }
 
-int Cluster::create_and_add_server(AddressGenerator& generator,
-                                   ClientConnectionFactory& factory,
+unsigned Cluster::connection_attempts(size_t node) const {
+  if (node < 1 || node > servers_.size()) {
+    return 0;
+  }
+  const Server& server = servers_[node - 1];
+  return server.connection->connection_attempts();
+}
+
+int Cluster::create_and_add_server(AddressGenerator& generator, ClientConnectionFactory& factory,
                                    const String& dc) {
   Address address(generator.next());
   Server server(Host(address, dc, "rack1", token_rng_),
-                internal::ServerConnection::Ptr(
-                new internal::ServerConnection(address, factory)));
+                internal::ServerConnection::Ptr(new internal::ServerConnection(address, factory)));
 
   servers_.push_back(server);
   return static_cast<int>(servers_.size());
 }
 
 void Cluster::event(const Event::Ptr& event) {
-  for (Servers::const_iterator it = servers_.begin(),
-       end = servers_.end(); it != end; ++it) {
+  for (Servers::const_iterator it = servers_.begin(), end = servers_.end(); it != end; ++it) {
     it->connection->run(internal::ServerConnectionTask::Ptr(event));
   }
 }
 
 Address Ipv4AddressGenerator::next() {
   char buf[32];
-  sprintf(buf, "%d.%d.%d.%d", (ip_ >> 24) & 0xff, (ip_ >> 16) & 0xff, (ip_ >> 8) & 0xff, ip_ & 0xff);
+  sprintf(buf, "%d.%d.%d.%d", (ip_ >> 24) & 0xff, (ip_ >> 16) & 0xff, (ip_ >> 8) & 0xff,
+          ip_ & 0xff);
   ip_++;
   return Address(buf, port_);
 }
 
-Host::Host(const cass::Address& address,
-           const cass::String& dc,
-           const cass::String& rack,
-           MT19937_64& token_rng,
+Host::Host(const Address& address, const String& dc, const String& rack, MT19937_64& token_rng,
            int num_tokens)
-  : address(address)
-  , dc(dc)
-  , rack(rack)
-  , partitioner("org.apache.cassandra.dht.Murmur3Partitioner") {
+    : address(address)
+    , dc(dc)
+    , rack(rack)
+    , partitioner("org.apache.cassandra.dht.Murmur3Partitioner") {
   // Only murmur tokens currently supported
   for (int i = 0; i < num_tokens; ++i) {
     OStringStream ss;
@@ -2346,7 +2235,7 @@ Host::Host(const cass::Address& address,
 }
 
 SimpleEventLoopGroup::SimpleEventLoopGroup(size_t num_threads)
-  : cass::RoundRobinEventLoopGroup(num_threads) {
+    : RoundRobinEventLoopGroup(num_threads) {
   int rc = init("mockssandra");
   UNUSED_(rc);
   assert(rc == 0 && "Unable to initialize simple event loop");
@@ -2359,24 +2248,23 @@ SimpleEventLoopGroup::~SimpleEventLoopGroup() {
 }
 
 SimpleRequestHandlerBuilder::SimpleRequestHandlerBuilder()
-  : RequestHandler::Builder() {
+    : RequestHandler::Builder() {
   on(OPCODE_STARTUP).validate_startup().ready();
   on(OPCODE_OPTIONS).supported();
   on(OPCODE_CREDENTIALS).validate_credentials().ready();
   on(OPCODE_AUTH_RESPONSE).validate_auth_response().auth_success("");
-  on(OPCODE_REGISTER).validate_register().set_protocol_version().set_registered_for_events().ready();
+  on(OPCODE_REGISTER)
+      .validate_register()
+      .set_protocol_version()
+      .set_registered_for_events()
+      .ready();
   on(OPCODE_QUERY).system_local().system_peers().empty_rows_result(1);
 }
 
-AuthRequestHandlerBuilder::AuthRequestHandlerBuilder(const cass::String& username,
-                                                     const String& password)
-  : SimpleRequestHandlerBuilder() {
-  on(mockssandra::OPCODE_STARTUP)
-      .validate_startup()
-      .authenticate("com.datastax.SomeAuthenticator");
-  on(mockssandra::OPCODE_AUTH_RESPONSE)
-      .validate_auth_response()
-      .plaintext_auth(username, password);
+AuthRequestHandlerBuilder::AuthRequestHandlerBuilder(const String& username, const String& password)
+    : SimpleRequestHandlerBuilder() {
+  on(mockssandra::OPCODE_STARTUP).validate_startup().authenticate("com.datastax.SomeAuthenticator");
+  on(mockssandra::OPCODE_AUTH_RESPONSE).validate_auth_response().plaintext_auth(username, password);
 }
 
 } // namespace mockssandra
diff --git a/gtests/src/unit/mockssandra.hpp b/gtests/src/unit/mockssandra.hpp
index 913f2b87e..2e4d27e80 100644
--- a/gtests/src/unit/mockssandra.hpp
+++ b/gtests/src/unit/mockssandra.hpp
@@ -19,21 +19,21 @@
 
 #include <uv.h>
 
-#include <openssl/ssl.h>
 #include <openssl/bio.h>
 #include <openssl/err.h>
+#include <openssl/ssl.h>
 
 #include <stdint.h>
 
 #include "address.hpp"
 #include "event_loop.hpp"
-#include "string.hpp"
-#include "vector.hpp"
-#include "timer.hpp"
-#include "ref_counted.hpp"
 #include "list.hpp"
+#include "ref_counted.hpp"
 #include "scoped_ptr.hpp"
+#include "string.hpp"
 #include "third_party/mt19937_64/mt19937_64.hpp"
+#include "timer.hpp"
+#include "vector.hpp"
 
 #if defined(WIN32) || defined(_WIN32)
 #undef ERROR_ALREADY_EXISTS
@@ -43,17 +43,19 @@
 
 #define CLIENT_OPTIONS_QUERY "client.options"
 
-using cass::Address;
-using cass::EventLoop;
-using cass::EventLoopGroup;
-using cass::List;
-using cass::String;
-using cass::Task;
-using cass::Timer;
-using cass::Vector;
-using cass::RefCounted;
-using cass::SharedRefPtr;
-using cass::ScopedPtr;
+using datastax::String;
+using datastax::internal::Atomic;
+using datastax::internal::List;
+using datastax::internal::RefCounted;
+using datastax::internal::ScopedPtr;
+using datastax::internal::SharedRefPtr;
+using datastax::internal::Vector;
+using datastax::internal::core::Address;
+using datastax::internal::core::EventLoop;
+using datastax::internal::core::EventLoopGroup;
+using datastax::internal::core::RoundRobinEventLoopGroup;
+using datastax::internal::core::Task;
+using datastax::internal::core::Timer;
 
 namespace mockssandra {
 
@@ -89,10 +91,10 @@ class ClientConnection {
   ServerConnection* server() { return server_; }
 
   virtual int on_accept() { return accept(); }
-  virtual void on_close() { }
+  virtual void on_close() {}
 
-  virtual void on_read(const char* data, size_t len) { }
-  virtual void on_write() { }
+  virtual void on_read(const char* data, size_t len) {}
+  virtual void on_write() {}
 
   int write(const String& data);
   int write(const char* data, size_t len);
@@ -148,7 +150,7 @@ class ServerConnectionTask : public RefCounted<ServerConnectionTask> {
 public:
   typedef SharedRefPtr<ServerConnectionTask> Ptr;
 
-  virtual ~ServerConnectionTask() { }
+  virtual ~ServerConnectionTask() {}
   virtual void run(ServerConnection* server_connection) = 0;
 };
 
@@ -158,68 +160,63 @@ class ServerConnection : public RefCounted<ServerConnection> {
 public:
   typedef SharedRefPtr<ServerConnection> Ptr;
 
-   ServerConnection(const Address& address, const ClientConnectionFactory& factory);
-   ~ServerConnection();
+  ServerConnection(const Address& address, const ClientConnectionFactory& factory);
+  ~ServerConnection();
 
-   const Address& address() const { return address_; }
-   uv_loop_t* loop();
-   SSL_CTX* ssl_context() { return ssl_context_; }
-   const ClientConnections& clients() const { return clients_; }
+  const Address& address() const { return address_; }
+  uv_loop_t* loop();
+  SSL_CTX* ssl_context() { return ssl_context_; }
+  const ClientConnections& clients() const { return clients_; }
 
-   bool use_ssl(const String& key,
-                const String& cert,
-                const String& password = "");
+  bool use_ssl(const String& key, const String& cert, const String& password = "");
 
-   void listen(EventLoopGroup* event_loop_group);
-   int wait_listen();
+  void listen(EventLoopGroup* event_loop_group);
+  int wait_listen();
 
-   void close();
-   void wait_close();
+  void close();
+  void wait_close();
 
-   void run(const ServerConnectionTask::Ptr& task);
+  unsigned connection_attempts() const;
+  void run(const ServerConnectionTask::Ptr& task);
 
 private:
-   friend class ClientConnection;
-   int accept(uv_stream_t* client);
-   void remove(ClientConnection* connection);
+  friend class ClientConnection;
+  int accept(uv_stream_t* client);
+  void remove(ClientConnection* connection);
 
 private:
-   friend class RunListen;
-   friend class RunClose;
+  friend class RunListen;
+  friend class RunClose;
 
-   void internal_listen();
-   void internal_close();
-   void maybe_close();
+  void internal_listen();
+  void internal_close();
+  void maybe_close();
 
-   void signal_listen(int rc);
-   void signal_close();
+  void signal_listen(int rc);
+  void signal_close();
 
-   static void on_connection(uv_stream_t* stream, int status);
-   void handle_connection(int status);
+  static void on_connection(uv_stream_t* stream, int status);
+  void handle_connection(int status);
 
-   static void on_close(uv_handle_t* handle);
-   void handle_close();
+  static void on_close(uv_handle_t* handle);
+  void handle_close();
 
-   static int on_password(char *buf, int size, int rwflag, void *password);
+  static int on_password(char* buf, int size, int rwflag, void* password);
 
 private:
-   enum State {
-     STATE_CLOSED,
-     STATE_CLOSING,
-     STATE_PENDING,
-     STATE_LISTENING
-   };
-
-   Tcp tcp_;
-   EventLoop* event_loop_;
-   State state_;
-   int rc_;
-   uv_mutex_t mutex_;
-   uv_cond_t cond_;
-   ClientConnections clients_;
-   const Address address_;
-   const ClientConnectionFactory& factory_;
-   SSL_CTX* ssl_context_;
+  enum State { STATE_CLOSED, STATE_CLOSING, STATE_PENDING, STATE_LISTENING };
+
+  Tcp tcp_;
+  EventLoop* event_loop_;
+  State state_;
+  int rc_;
+  uv_mutex_t mutex_;
+  uv_cond_t cond_;
+  ClientConnections clients_;
+  const Address address_;
+  const ClientConnectionFactory& factory_;
+  SSL_CTX* ssl_context_;
+  Atomic<unsigned> connection_attempts_;
 };
 
 } // namespace internal
@@ -227,7 +224,7 @@ class ServerConnection : public RefCounted<ServerConnection> {
 enum {
   FLAG_COMPRESSION = 0x01,
   FLAG_TRACING = 0x02,
-  FLAG_CUSTOM_PAYLOAD  = 0x04,
+  FLAG_CUSTOM_PAYLOAD = 0x04,
   FLAG_WARNING = 0x08,
   FLAG_BETA = 0x10
 };
@@ -264,9 +261,7 @@ enum {
   QUERY_FLAG_KEYSPACE = 0x80
 };
 
-enum {
-  PREPARE_FLAGS_KEYSPACE = 0x01
-};
+enum { PREPARE_FLAGS_KEYSPACE = 0x01 };
 
 enum {
   ERROR_SERVER_ERROR = 0x0000,
@@ -371,10 +366,10 @@ class Type {
 
 private:
   Type()
-    : type_(-1) { }
+      : type_(-1) {}
 
   Type(int type)
-    : type_(type) { }
+      : type_(type) {}
 
   friend class Vector<Type>;
 
@@ -388,8 +383,8 @@ class Type {
 class Column {
 public:
   Column(const String& name, const Type type)
-    : name_(name)
-    , type_(type) { }
+      : name_(name)
+      , type_(type) {}
 
   void encode(int protocol_version, String* output) const;
 
@@ -403,11 +398,7 @@ class Collection;
 
 class Value {
 private:
-  enum Type {
-    NUL,
-    VALUE,
-    COLLECTION
-  };
+  enum Type { NUL, VALUE, COLLECTION };
 
 public:
   Value();
@@ -431,16 +422,14 @@ class Collection {
   class Builder {
   public:
     Builder(const Type& sub_type)
-      : sub_type_(sub_type) { }
+        : sub_type_(sub_type) {}
 
     Builder& text(const String& text) {
       values_.push_back(Value(text));
       return *this;
     }
 
-    Collection build() {
-      return Collection(sub_type_, values_);
-    }
+    Collection build() { return Collection(sub_type_, values_); }
 
   private:
     Type sub_type_;
@@ -451,18 +440,16 @@ class Collection {
 
   static Collection text(const Vector<String>& values) {
     Collection::Builder builder(Type::text());
-    for (Vector<String>::const_iterator it = values.begin(),
-         end = values.end(); it != end; ++it) {
+    for (Vector<String>::const_iterator it = values.begin(), end = values.end(); it != end; ++it) {
       builder.text(*it);
     }
     return builder.build();
   }
 
 private:
-  Collection(const Type& sub_type,
-             const Vector<Value> values)
-    : sub_type_(sub_type)
-    , values_(values) { }
+  Collection(const Type& sub_type, const Vector<Value> values)
+      : sub_type_(sub_type)
+      , values_(values) {}
 
 private:
   const Type sub_type_;
@@ -481,9 +468,7 @@ class Row {
 
     Builder& collection(const Collection& collection);
 
-    Row build() const {
-      return Row(values_);
-    }
+    Row build() const { return Row(values_); }
 
   private:
     Vector<Value> values_;
@@ -493,7 +478,7 @@ class Row {
 
 private:
   Row(const Vector<Value>& values)
-    : values_(values) { }
+      : values_(values) {}
 
 private:
   Vector<Value> values_;
@@ -504,8 +489,8 @@ class ResultSet {
   class Builder {
   public:
     Builder(const String& keyspace_name, const String& table_name)
-      : keyspace_name_(keyspace_name)
-      , table_name_(table_name) { }
+        : keyspace_name_(keyspace_name)
+        , table_name_(table_name) {}
 
     Builder& column(const String& name, const Type& type) {
       columns_.push_back(Column(name, type));
@@ -517,9 +502,7 @@ class ResultSet {
       return *this;
     }
 
-    ResultSet build() const {
-      return ResultSet(keyspace_name_, table_name_, columns_, rows_);
-    }
+    ResultSet build() const { return ResultSet(keyspace_name_, table_name_, columns_, rows_); }
 
   private:
     const String keyspace_name_;
@@ -533,14 +516,12 @@ class ResultSet {
   size_t column_count() const { return columns_.size(); }
 
 private:
-  ResultSet(const String& keyspace_name,
-            const String& table_name,
-            const Vector<Column>& columns,
+  ResultSet(const String& keyspace_name, const String& table_name, const Vector<Column>& columns,
             const Vector<Row>& rows)
-    : keyspace_name_(keyspace_name)
-    , table_name_(table_name)
-    , columns_(columns)
-    , rows_(rows) { }
+      : keyspace_name_(keyspace_name)
+      , table_name_(table_name)
+      , columns_(columns)
+      , rows_(rows) {}
 
 private:
   const String keyspace_name_;
@@ -551,19 +532,16 @@ class ResultSet {
 
 struct Exception : public std::exception {
   Exception(int code, const String& message)
-    : code(code)
-    , message(message) { }
-  virtual ~Exception() throw() { }
+      : code(code)
+      , message(message) {}
+  virtual ~Exception() throw() {}
   const int code;
   const String message;
 };
 
 struct Host {
-  Host() { }
-  Host(const Address& address,
-       const String& dc,
-       const String& rack,
-       MT19937_64& token_rng,
+  Host() {}
+  Host(const Address& address, const String& dc, const String& rack, MT19937_64& token_rng,
        int num_tokens = 2);
   Address address;
   String dc;
@@ -589,7 +567,7 @@ struct Action {
   class Builder {
   public:
     Builder()
-      : last_(NULL) { }
+        : last_(NULL) {}
 
     Builder& reset();
 
@@ -641,7 +619,7 @@ struct Action {
 
     PredicateBuilder is_query(const String& query);
 
-     Action* build();
+    Action* build();
 
   private:
     ScopedPtr<Action> first_;
@@ -651,21 +629,18 @@ struct Action {
   class PredicateBuilder {
   public:
     PredicateBuilder(Builder& builder)
-      : builder_(builder) { }
+        : builder_(builder) {}
 
-    Builder& then(Builder& builder) {
-      return then(builder.build());
-    }
+    Builder& then(Builder& builder) { return then(builder.build()); }
 
-    Builder& then(Action* action) {
-      return builder_.execute_if(action);
-    }
+    Builder& then(Action* action) { return builder_.execute_if(action); }
 
   private:
     Builder& builder_;
   };
 
-  Action() : next(NULL) { }
+  Action()
+      : next(NULL) {}
   virtual ~Action() { delete next; }
 
   void run(Request* request) const;
@@ -678,7 +653,8 @@ struct Action {
 };
 
 struct Predicate : public Action {
-  Predicate() : then(NULL) { }
+  Predicate()
+      : then(NULL) {}
   virtual ~Predicate() { delete then; }
 
   virtual bool is_predicate() const { return true; }
@@ -697,14 +673,14 @@ struct Predicate : public Action {
   const Action* then;
 };
 
-
-class Request : public List<Request>::Node
-              , public RefCounted<Request> {
+class Request
+    : public List<Request>::Node
+    , public RefCounted<Request> {
 public:
   typedef SharedRefPtr<Request> Ptr;
 
-  Request(int8_t version, int8_t flags, int16_t stream, int8_t opcode,
-          const String& body, ClientConnection* client);
+  Request(int8_t version, int8_t flags, int16_t stream, int8_t opcode, const String& body,
+          ClientConnection* client);
 
   int8_t version() const { return version_; }
   int16_t stream() const { return stream_; }
@@ -748,30 +724,26 @@ class Request : public List<Request>::Node
 };
 
 struct Nop : public Action {
-  virtual void on_run(Request* request) const { }
+  virtual void on_run(Request* request) const {}
 };
 
 struct Wait : public Action {
   Wait(uint64_t timeout)
-    : timeout(timeout) { }
+      : timeout(timeout) {}
 
-  virtual void on_run(Request* request) const {
-    request->wait(timeout, this);
-  }
+  virtual void on_run(Request* request) const { request->wait(timeout, this); }
 
   const uint64_t timeout;
 };
 
 struct Close : public Action {
-  virtual void on_run(Request* request) const {
-    request->close();
-  }
+  virtual void on_run(Request* request) const { request->close(); }
 };
 
 struct SendError : public Action {
   SendError(int32_t code, const String& message)
-    : code(code)
-    , message(message) { }
+      : code(code)
+      , message(message) {}
 
   virtual void on_run(Request* request) const;
 
@@ -785,21 +757,21 @@ struct SendReady : public Action {
 
 struct SendAuthenticate : public Action {
   SendAuthenticate(const String& class_name)
-    : class_name(class_name) { }
+      : class_name(class_name) {}
   virtual void on_run(Request* request) const;
   String class_name;
 };
 
 struct SendAuthChallenge : public Action {
   SendAuthChallenge(const String& token)
-    : token(token) { }
+      : token(token) {}
   virtual void on_run(Request* request) const;
   String token;
 };
 
 struct SendAuthSuccess : public Action {
   SendAuthSuccess(const String& token)
-    : token(token) { }
+      : token(token) {}
   virtual void on_run(Request* request) const;
   String token;
 };
@@ -810,7 +782,7 @@ struct SendSupported : public Action {
 
 struct SendUpEvent : public Action {
   SendUpEvent(const Address& address)
-    : address(address) { }
+      : address(address) {}
   virtual void on_run(Request* request) const;
   Address address;
 };
@@ -821,7 +793,7 @@ struct VoidResult : public Action {
 
 struct EmptyRowsResult : public Action {
   EmptyRowsResult(int row_count)
-    : row_count(row_count) { }
+      : row_count(row_count) {}
   virtual void on_run(Request* request) const;
   int32_t row_count;
 };
@@ -832,7 +804,7 @@ struct NoResult : public Action {
 
 struct MatchQuery : public Action {
   MatchQuery(const Matches& matches)
-    : matches(matches) { }
+      : matches(matches) {}
   virtual void on_run(Request* request) const;
   Matches matches;
 };
@@ -863,15 +835,15 @@ struct SystemTraces : public Action {
 
 struct UseKeyspace : public Action {
   UseKeyspace(const String& keyspace)
-    : keyspace(keyspace) { }
+      : keyspace(keyspace) {}
   virtual void on_run(Request* request) const;
   String keyspace;
 };
 
 struct PlaintextAuth : public Action {
-  PlaintextAuth (const String& username, const String& password)
-    : username(username)
-    , password(password) { }
+  PlaintextAuth(const String& username, const String& password)
+      : username(username)
+      , password(password) {}
   virtual void on_run(Request* request) const;
   String username;
   String password;
@@ -907,14 +879,14 @@ struct SetProtocolVersion : public Action {
 
 struct IsAddress : public Predicate {
   IsAddress(const Address& address)
-    : address(address) { }
+      : address(address) {}
   virtual bool is_true(Request* request) const;
   const Address address;
 };
 
 struct IsQuery : public Predicate {
   IsQuery(const String& query)
-    : query(query) { }
+      : query(query) {}
   virtual bool is_true(Request* request) const;
   const String query;
 };
@@ -924,8 +896,8 @@ class RequestHandler {
   class Builder {
   public:
     Builder()
-      : lowest_supported_protocol_version_(1)
-      , highest_supported_protocol_version_(5) {
+        : lowest_supported_protocol_version_(1)
+        , highest_supported_protocol_version_(5) {
       invalid_protocol_.invalid_protocol();
       invalid_opcode_.invalid_opcode();
     }
@@ -958,21 +930,14 @@ class RequestHandler {
     int highest_supported_protocol_version_;
   };
 
-  RequestHandler(Builder* builder,
-                 int lowest_supported_protocol_version,
+  RequestHandler(Builder* builder, int lowest_supported_protocol_version,
                  int highest_supported_protocol_version);
 
-  int lowest_supported_protocol_version() const {
-    return lowest_supported_protocol_version_;
-  }
+  int lowest_supported_protocol_version() const { return lowest_supported_protocol_version_; }
 
-  int highest_supported_protocol_version() const {
-    return highest_supported_protocol_version_;
-  }
+  int highest_supported_protocol_version() const { return highest_supported_protocol_version_; }
 
-  void invalid_protocol(Request* request) const {
-    invalid_protocol_->run(request);
-  }
+  void invalid_protocol(Request* request) const { invalid_protocol_->run(request); }
 
   void run(Request* request) const {
     const ScopedPtr<const Action>& action = actions_[request->opcode()];
@@ -991,17 +956,16 @@ class RequestHandler {
   const int highest_supported_protocol_version_;
 };
 
-
 class ProtocolHandler {
 public:
   ProtocolHandler(const RequestHandler* request_handler)
-    : request_handler_(request_handler)
-    , state_(PROTOCOL_VERSION)
-    , version_(0)
-    , flags_(0)
-    , stream_(0)
-    , opcode_(0)
-    , length_(0) { }
+      : request_handler_(request_handler)
+      , state_(PROTOCOL_VERSION)
+      , version_(0)
+      , flags_(0)
+      , stream_(0)
+      , opcode_(0)
+      , length_(0) {}
 
   void decode(ClientConnection* client, const char* data, int32_t len);
 
@@ -1009,11 +973,7 @@ class ProtocolHandler {
   int32_t decode_frame(ClientConnection* client, const char* frame, int32_t len);
   void decode_body(ClientConnection* client, const char* body, int32_t len);
 
-  enum State {
-    PROTOCOL_VERSION,
-    HEADER,
-    BODY
-  };
+  enum State { PROTOCOL_VERSION, HEADER, BODY };
 
 private:
   String buffer_;
@@ -1028,19 +988,20 @@ class ProtocolHandler {
 
 class ClientConnection : public internal::ClientConnection {
 public:
-  ClientConnection(internal::ServerConnection* server, const RequestHandler* request_handler, const Cluster* cluster)
-    : internal::ClientConnection(server)
-    , handler_(request_handler)
-    , cluster_(cluster)
-    , protocol_version_(-1)
-    , is_registered_for_events_(false) { }
+  ClientConnection(internal::ServerConnection* server, const RequestHandler* request_handler,
+                   const Cluster* cluster)
+      : internal::ClientConnection(server)
+      , handler_(request_handler)
+      , cluster_(cluster)
+      , protocol_version_(-1)
+      , is_registered_for_events_(false) {}
 
   virtual void on_read(const char* data, size_t len);
 
   const Cluster* cluster() const { return cluster_; }
 
   int protocol_version() const { return protocol_version_; }
-  void set_protocol_version(int protocol_version) { protocol_version_  = protocol_version; }
+  void set_protocol_version(int protocol_version) { protocol_version_ = protocol_version; }
 
   bool is_registered_for_events() const { return is_registered_for_events_; }
   void set_registered_for_events() { is_registered_for_events_ = true; }
@@ -1057,8 +1018,9 @@ class ClientConnection : public internal::ClientConnection {
 
 class CloseConnection : public ClientConnection {
 public:
-  CloseConnection(internal::ServerConnection* server, const RequestHandler* request_handler, const Cluster* cluster)
-    : ClientConnection(server, request_handler, cluster) { }
+  CloseConnection(internal::ServerConnection* server, const RequestHandler* request_handler,
+                  const Cluster* cluster)
+      : ClientConnection(server, request_handler, cluster) {}
 
   int on_accept() {
     int rc = accept();
@@ -1073,13 +1035,11 @@ class CloseConnection : public ClientConnection {
 class ClientConnectionFactory : public internal::ClientConnectionFactory {
 public:
   ClientConnectionFactory(const RequestHandler* request_handler, const Cluster* cluster)
-    : request_handler_(request_handler)
-    , cluster_(cluster)
-    , close_immediately_(false) { }
+      : request_handler_(request_handler)
+      , cluster_(cluster)
+      , close_immediately_(false) {}
 
-  void use_close_immediately() {
-    close_immediately_ = true;
-  }
+  void use_close_immediately() { close_immediately_ = true; }
 
   virtual internal::ClientConnection* create(internal::ServerConnection* server) const {
     if (close_immediately_) {
@@ -1102,9 +1062,10 @@ class AddressGenerator {
 
 class Ipv4AddressGenerator : public AddressGenerator {
 public:
-  Ipv4AddressGenerator(uint8_t a = 127, uint8_t b = 0, uint8_t c = 0, uint8_t d = 1, int port = 9042)
-    : ip_((a << 24) | (b << 16) | (c << 8) | (d & 0xff))
-    , port_(port) { }
+  Ipv4AddressGenerator(uint8_t a = 127, uint8_t b = 0, uint8_t c = 0, uint8_t d = 1,
+                       int port = 9042)
+      : ip_((a << 24) | (b << 16) | (c << 8) | (d & 0xff))
+      , port_(port) {}
 
   virtual Address next();
 
@@ -1127,14 +1088,10 @@ class Event : public internal::ServerConnectionTask {
 
 class TopologyChangeEvent : public Event {
 public:
-  enum Type {
-    NEW_NODE,
-    MOVED_NODE,
-    REMOVED_NODE
-  };
+  enum Type { NEW_NODE, MOVED_NODE, REMOVED_NODE };
 
   TopologyChangeEvent(Type type, const Address& address)
-    : Event(encode(type, address)) { }
+      : Event(encode(type, address)) {}
 
   static Ptr new_node(const Address& address);
   static Ptr moved_node(const Address& address);
@@ -1145,13 +1102,10 @@ class TopologyChangeEvent : public Event {
 
 class StatusChangeEvent : public Event {
 public:
-  enum Type {
-    UP,
-    DOWN
-  };
+  enum Type { UP, DOWN };
 
   StatusChangeEvent(Type type, const Address& address)
-    : Event(encode(type, address)) { }
+      : Event(encode(type, address)) {}
 
   static Ptr up(const Address& address);
   static Ptr down(const Address& address);
@@ -1161,48 +1115,30 @@ class StatusChangeEvent : public Event {
 
 class SchemaChangeEvent : public Event {
 public:
-  enum Type {
-    CREATED,
-    UPDATED,
-    DROPPED
-  };
+  enum Type { CREATED, UPDATED, DROPPED };
 
-  enum Target {
-    KEYSPACE,
-    TABLE,
-    USER_TYPE,
-    FUNCTION,
-    AGGREGATE
-  };
+  enum Target { KEYSPACE, TABLE, USER_TYPE, FUNCTION, AGGREGATE };
 
-  SchemaChangeEvent(Target target, Type type,
-                    const String& keyspace_name, const String& target_name = "",
+  SchemaChangeEvent(Target target, Type type, const String& keyspace_name,
+                    const String& target_name = "",
                     const Vector<String>& args_types = Vector<String>())
-    : Event(encode(target, type, keyspace_name, target_name, args_types)) { }
-
-  static Ptr keyspace(Type type,
-                      const String& keyspace_name);
-  static Ptr table(Type type,
-                   const String& keyspace_name, const String& table_name);
-  static Ptr user_type(Type type,
-                       const String& keyspace_name, const String& user_type_name);
-  static Ptr function(Type type,
-                      const String& keyspace_name, const String& function_name,
+      : Event(encode(target, type, keyspace_name, target_name, args_types)) {}
+
+  static Ptr keyspace(Type type, const String& keyspace_name);
+  static Ptr table(Type type, const String& keyspace_name, const String& table_name);
+  static Ptr user_type(Type type, const String& keyspace_name, const String& user_type_name);
+  static Ptr function(Type type, const String& keyspace_name, const String& function_name,
                       const Vector<String>& args_types);
-  static Ptr aggregate(Type type,
-                       const String& keyspace_name, const String& aggregate_name,
+  static Ptr aggregate(Type type, const String& keyspace_name, const String& aggregate_name,
                        const Vector<String>& args_types);
 
-  static String encode(Target target, Type type,
-                       const String& keyspace_name, const String& target_name,
-                       const Vector<String>& arg_types);
+  static String encode(Target target, Type type, const String& keyspace_name,
+                       const String& target_name, const Vector<String>& arg_types);
 };
 
 class Cluster {
 protected:
-  void init(AddressGenerator& generator,
-            ClientConnectionFactory& factory,
-            size_t num_nodes_dc1,
+  void init(AddressGenerator& generator, ClientConnectionFactory& factory, size_t num_nodes_dc1,
             size_t num_nodes_dc2);
 
 public:
@@ -1222,25 +1158,27 @@ class Cluster {
   void stop(size_t node);
   void stop_async(size_t node);
 
-  int add(cass::EventLoopGroup* event_loop_group, size_t node);
+  int add(EventLoopGroup* event_loop_group, size_t node);
   void remove(size_t node);
 
   const Host& host(const Address& address) const;
   Hosts hosts() const;
 
+  unsigned connection_attempts(size_t node) const;
+
   void event(const Event::Ptr& event);
 
 private:
   struct Server {
     Server(const Host& host, const internal::ServerConnection::Ptr& connection)
-      : host(host)
-      , connection(connection)
-      , is_removed(false) { }
+        : host(host)
+        , connection(connection)
+        , is_removed(false) {}
 
     Server(const Server& server)
-      : host(server.host)
-      , connection(server.connection)
-      , is_removed(server.is_removed.load()) { }
+        : host(server.host)
+        , connection(server.connection)
+        , is_removed(server.is_removed.load()) {}
 
     Server& operator=(const Server& server) {
       host = server.host;
@@ -1251,13 +1189,12 @@ class Cluster {
 
     Host host;
     internal::ServerConnection::Ptr connection;
-    cass::Atomic<bool> is_removed;
+    Atomic<bool> is_removed;
   };
 
   typedef Vector<Server> Servers;
 
-  int create_and_add_server(AddressGenerator& generator,
-                            ClientConnectionFactory& factory,
+  int create_and_add_server(AddressGenerator& generator, ClientConnectionFactory& factory,
                             const String& dc);
 
 private:
@@ -1265,7 +1202,7 @@ class Cluster {
   MT19937_64 token_rng_;
 };
 
-class SimpleEventLoopGroup : public cass::RoundRobinEventLoopGroup {
+class SimpleEventLoopGroup : public RoundRobinEventLoopGroup {
 public:
   SimpleEventLoopGroup(size_t num_threads = 1);
   ~SimpleEventLoopGroup();
@@ -1284,33 +1221,22 @@ class AuthRequestHandlerBuilder : public SimpleRequestHandlerBuilder {
 
 class SimpleCluster : public Cluster {
 public:
-  SimpleCluster(const RequestHandler* request_handler,
-                size_t num_nodes_dc1 = 1,
+  SimpleCluster(const RequestHandler* request_handler, size_t num_nodes_dc1 = 1,
                 size_t num_nodes_dc2 = 0)
-    : factory_(request_handler, this)
-    , event_loop_group_(1) {
+      : factory_(request_handler, this)
+      , event_loop_group_(1) {
     init(generator_, factory_, num_nodes_dc1, num_nodes_dc2);
   }
 
-  ~SimpleCluster() {
-    stop_all();
-  }
+  ~SimpleCluster() { stop_all(); }
 
-  void use_close_immediately() {
-    factory_.use_close_immediately();
-  }
+  void use_close_immediately() { factory_.use_close_immediately(); }
 
-  int start_all() {
-    return Cluster::start_all(&event_loop_group_);
-  }
+  int start_all() { return Cluster::start_all(&event_loop_group_); }
 
-  int start(size_t node) {
-    return Cluster::start(&event_loop_group_, node);
-  }
+  int start(size_t node) { return Cluster::start(&event_loop_group_, node); }
 
-  int add(size_t node) {
-    return Cluster::add(&event_loop_group_, node);
-  }
+  int add(size_t node) { return Cluster::add(&event_loop_group_, node); }
 
 private:
   Ipv4AddressGenerator generator_;
@@ -1321,12 +1247,10 @@ class SimpleCluster : public Cluster {
 class SimpleEchoServer {
 public:
   SimpleEchoServer(const Address& address = Address("127.0.0.1", 8888))
-   : event_loop_group_(1)
-   , server_(new internal::ServerConnection(address, factory_)) { }
+      : event_loop_group_(1)
+      , server_(new internal::ServerConnection(address, factory_)) {}
 
-  ~SimpleEchoServer() {
-    close();
-  }
+  ~SimpleEchoServer() { close(); }
 
   void close() {
     server_->close();
@@ -1342,9 +1266,7 @@ class SimpleEchoServer {
     return cert;
   }
 
-  void use_close_immediately() {
-    factory_.use_close_immediately();
-  }
+  void use_close_immediately() { factory_.use_close_immediately(); }
 
   int listen() {
     server_->listen(&event_loop_group_);
@@ -1359,7 +1281,7 @@ class SimpleEchoServer {
   class CloseConnection : public internal::ClientConnection {
   public:
     CloseConnection(internal::ServerConnection* server)
-      : internal::ClientConnection(server) { }
+        : internal::ClientConnection(server) {}
 
     virtual int on_accept() {
       int rc = accept();
@@ -1374,21 +1296,17 @@ class SimpleEchoServer {
   class EchoConnection : public internal::ClientConnection {
   public:
     EchoConnection(internal::ServerConnection* server)
-      : internal::ClientConnection(server) { }
+        : internal::ClientConnection(server) {}
 
-    virtual void on_read(const char* data, size_t len)  {
-      write(data, len);
-    }
+    virtual void on_read(const char* data, size_t len) { write(data, len); }
   };
 
   class ClientConnectionFactory : public internal::ClientConnectionFactory {
   public:
     ClientConnectionFactory()
-      : close_immediately_(false) { }
+        : close_immediately_(false) {}
 
-    void use_close_immediately() {
-      close_immediately_ = true;
-    }
+    void use_close_immediately() { close_immediately_ = true; }
 
     virtual internal::ClientConnection* create(internal::ServerConnection* server) const {
       if (close_immediately_) {
diff --git a/gtests/src/unit/test_token_map_utils.hpp b/gtests/src/unit/test_token_map_utils.hpp
index 9b46ee83e..9a492f0a0 100644
--- a/gtests/src/unit/test_token_map_utils.hpp
+++ b/gtests/src/unit/test_token_map_utils.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TEST_TOKEN_MAP_UTILS_HPP_INCLUDED__
-#define __CASS_TEST_TOKEN_MAP_UTILS_HPP_INCLUDED__
+#ifndef DATASTAX_TEST_TOKEN_MAP_UTILS_HPP
+#define DATASTAX_TEST_TOKEN_MAP_UTILS_HPP
 
 #include "constants.hpp"
 #include "decoder.hpp"
@@ -26,103 +26,97 @@
 
 #define CASS_PROTOCOL_VERSION 3
 
+using datastax::String;
+using datastax::internal::OStringStream;
+using datastax::internal::core::Address;
+using datastax::internal::core::ByteOrderedPartitioner;
+using datastax::internal::core::CollectionType;
+using datastax::internal::core::DataType;
+using datastax::internal::core::Decoder;
+using datastax::internal::core::Host;
+using datastax::internal::core::Murmur3Partitioner;
+using datastax::internal::core::RandomPartitioner;
+using datastax::internal::core::ResultResponse;
+using datastax::internal::core::TokenMap;
+using datastax::internal::core::VersionNumber;
+
 class BufferBuilder {
 public:
-  char* data() const {
-    return const_cast<char*>(buffer_.data());
-  }
+  char* data() const { return const_cast<char*>(buffer_.data()); }
 
-  size_t size() const {
-    return buffer_.size();
-  }
+  size_t size() const { return buffer_.size(); }
 
-  template<class T>
+  template <class T>
   void append(T value) {
-    cass::String buffer(size_of(value), 0);
+    String buffer(size_of(value), 0);
     encode(&buffer[0], value);
     buffer_.append(buffer);
   }
 
-  template<class T>
+  template <class T>
   void append_value(T value) {
     append<int32_t>(size_of(value));
     append<T>(value);
   }
 
-  void append_string(const cass::String& str) {
+  void append_string(const String& str) {
     append<uint16_t>(str.size());
     append(str);
   }
 
-  template<class T>
+  template <class T>
   void encode_at(size_t index, T value) {
     assert(index < buffer_.size() && index + size_of(value) < buffer_.size());
     encode(&buffer_[index], value);
   }
 
 private:
-  static size_t size_of(uint16_t value) {
-    return sizeof(int16_t);
-  }
+  static size_t size_of(uint16_t value) { return sizeof(int16_t); }
 
-  static size_t size_of(int32_t value) {
-    return sizeof(int32_t);
-  }
+  static size_t size_of(int32_t value) { return sizeof(int32_t); }
 
-  static size_t size_of(int64_t value) {
-    return sizeof(int64_t);
-  }
+  static size_t size_of(int64_t value) { return sizeof(int64_t); }
 
-  static size_t size_of(const cass::String& value) {
-    return value.size();
-  }
+  static size_t size_of(const String& value) { return value.size(); }
 
-  static void encode(char* buf, uint16_t value) {
-    cass::encode_uint16(buf, value);
-  }
+  static void encode(char* buf, uint16_t value) { datastax::internal::encode_uint16(buf, value); }
 
-  static void encode(char* buf, int32_t value) {
-    cass::encode_int32(buf, value);
-  }
+  static void encode(char* buf, int32_t value) { datastax::internal::encode_int32(buf, value); }
 
-  static void encode(char* buf, int64_t value) {
-    cass::encode_int64(buf, value);
-  }
+  static void encode(char* buf, int64_t value) { datastax::internal::encode_int64(buf, value); }
 
-  static void encode(char* buf, const cass::String& value) {
-    memcpy(buf, value.data(), value.size());
-  }
+  static void encode(char* buf, const String& value) { memcpy(buf, value.data(), value.size()); }
 
 private:
-  cass::String buffer_;
+  String buffer_;
 };
 
-typedef cass::Map<cass::String, cass::String> ReplicationMap;
+typedef datastax::internal::Map<String, String> ReplicationMap;
 
 struct ColumnMetadata {
-  ColumnMetadata(const cass::String& name, const cass::DataType::ConstPtr& data_type)
-    : name(name)
-    , data_type(data_type) { }
-  cass::String name;
-  cass::DataType::ConstPtr data_type;
+  ColumnMetadata(const String& name, const DataType::ConstPtr& data_type)
+      : name(name)
+      , data_type(data_type) {}
+  String name;
+  DataType::ConstPtr data_type;
 };
 
-typedef cass::Vector<ColumnMetadata> ColumnMetadataVec;
-typedef cass::Vector<cass::String> TokenVec;
-typedef cass::Vector<cass::Murmur3Partitioner::Token> Murmur3TokenVec;
+typedef datastax::internal::Vector<ColumnMetadata> ColumnMetadataVec;
+typedef datastax::internal::Vector<String> TokenVec;
+typedef datastax::internal::Vector<Murmur3Partitioner::Token> Murmur3TokenVec;
 
 class RowResultResponseBuilder : protected BufferBuilder {
 public:
   RowResultResponseBuilder(const ColumnMetadataVec& column_metadata)
-    : row_count_(0) {
-    append<cass_int32_t>(CASS_RESULT_KIND_ROWS); // Kind
+      : row_count_(0) {
+    append<cass_int32_t>(CASS_RESULT_KIND_ROWS);             // Kind
     append<cass_int32_t>(CASS_RESULT_FLAG_GLOBAL_TABLESPEC); // Flags
-    append<cass_int32_t>(column_metadata.size()); // Column count
+    append<cass_int32_t>(column_metadata.size());            // Column count
     append_string("keyspace");
     append_string("table");
 
-    for (ColumnMetadataVec::const_iterator i = column_metadata.begin(),
-          end = column_metadata.end(); i != end; ++i) {
+    for (ColumnMetadataVec::const_iterator i = column_metadata.begin(), end = column_metadata.end();
+         i != end; ++i) {
       append_column_metadata(*i);
     }
 
@@ -130,61 +124,55 @@ class RowResultResponseBuilder : protected BufferBuilder {
     append<cass_int32_t>(0); // Row count (updated later)
   }
 
-  void append_keyspace_row_v3(const cass::String& keyspace_name,
-                              const ReplicationMap& replication) {
-    append_value<cass::String>(keyspace_name);
+  void append_keyspace_row_v3(const String& keyspace_name, const ReplicationMap& replication) {
+    append_value<String>(keyspace_name);
 
     size_t size = sizeof(int32_t);
-    for (ReplicationMap::const_iterator i = replication.begin(),
-         end = replication.end(); i != end; ++i) {
+    for (ReplicationMap::const_iterator i = replication.begin(), end = replication.end(); i != end;
+         ++i) {
       size += sizeof(int32_t) + i->first.size();
       size += sizeof(int32_t) + i->second.size();
     }
 
     append<cass_int32_t>(size);
     append<cass_int32_t>(replication.size()); // Element count
-    for (ReplicationMap::const_iterator i = replication.begin(),
-         end = replication.end(); i != end; ++i) {
-      append_value<cass::String>(i->first);
-      append_value<cass::String>(i->second);
+    for (ReplicationMap::const_iterator i = replication.begin(), end = replication.end(); i != end;
+         ++i) {
+      append_value<String>(i->first);
+      append_value<String>(i->second);
     }
 
     ++row_count_;
   }
 
-  void append_keyspace_row_v3(const cass::String& keyspace_name,
-                              const cass::String& strategy_class,
-                              const cass::String& strategy_options) {
-    append_value<cass::String>(keyspace_name);
-    append_value<cass::String>(strategy_class);
-    append_value<cass::String>(strategy_options);
+  void append_keyspace_row_v3(const String& keyspace_name, const String& strategy_class,
+                              const String& strategy_options) {
+    append_value<String>(keyspace_name);
+    append_value<String>(strategy_class);
+    append_value<String>(strategy_options);
 
     ++row_count_;
   }
 
-  void append_local_peers_row_v3(const TokenVec& tokens,
-                                 const cass::String& partitioner,
-                                 const cass::String& dc,
-                                 const cass::String& rack,
-                                 const cass::String& release_version) {
-    append_value<cass::String>(rack);
-    append_value<cass::String>(dc);
-    append_value<cass::String>(release_version);
+  void append_local_peers_row_v3(const TokenVec& tokens, const String& partitioner,
+                                 const String& dc, const String& rack,
+                                 const String& release_version) {
+    append_value<String>(rack);
+    append_value<String>(dc);
+    append_value<String>(release_version);
     if (!partitioner.empty()) {
-      append_value<cass::String>(partitioner);
+      append_value<String>(partitioner);
     }
 
     size_t size = sizeof(int32_t);
-    for (TokenVec::const_iterator i = tokens.begin(),
-         end = tokens.end(); i != end; ++i) {
+    for (TokenVec::const_iterator i = tokens.begin(), end = tokens.end(); i != end; ++i) {
       size += sizeof(int32_t) + i->size();
     }
 
     append<cass_int32_t>(size);
     append<cass_int32_t>(tokens.size()); // Element count
-    for (TokenVec::const_iterator i = tokens.begin(),
-         end = tokens.end(); i != end; ++i) {
-      append_value<cass::String>(*i);
+    for (TokenVec::const_iterator i = tokens.begin(), end = tokens.end(); i != end; ++i) {
+      append_value<String>(*i);
     }
 
     ++row_count_;
@@ -195,17 +183,17 @@ class RowResultResponseBuilder : protected BufferBuilder {
     append_data_type(metadata.data_type);
   }
 
-  void append_data_type(const cass::DataType::ConstPtr& data_type) {
+  void append_data_type(const DataType::ConstPtr& data_type) {
     append<uint16_t>(data_type->value_type());
 
     switch (data_type->value_type()) {
       case CASS_VALUE_TYPE_LIST:
       case CASS_VALUE_TYPE_SET:
-        append_data_type(cass::CollectionType::ConstPtr(data_type)->types()[0]);
+        append_data_type(CollectionType::ConstPtr(data_type)->types()[0]);
         break;
       case CASS_VALUE_TYPE_MAP:
-        append_data_type(cass::CollectionType::ConstPtr(data_type)->types()[0]);
-        append_data_type(cass::CollectionType::ConstPtr(data_type)->types()[1]);
+        append_data_type(CollectionType::ConstPtr(data_type)->types()[0]);
+        append_data_type(CollectionType::ConstPtr(data_type)->types()[1]);
         break;
       case CASS_VALUE_TYPE_TUPLE:
       case CASS_VALUE_TYPE_UDT:
@@ -216,35 +204,35 @@ class RowResultResponseBuilder : protected BufferBuilder {
     }
   }
 
-  cass::ResultResponse* finish() {
+  ResultResponse* finish() {
     encode_at(row_count_index_, row_count_);
-    cass::Decoder decoder(data(), size(), CASS_PROTOCOL_VERSION);
+    Decoder decoder(data(), size(), CASS_PROTOCOL_VERSION);
     result_response_.decode(decoder);
     return &result_response_;
   }
 
 private:
-  cass::ResultResponse result_response_;
+  ResultResponse result_response_;
   size_t row_count_index_;
   int32_t row_count_;
 };
 
-inline cass::String to_string(const cass::Murmur3Partitioner::Token& token) {
-  cass::OStringStream ss;
+inline String to_string(const Murmur3Partitioner::Token& token) {
+  OStringStream ss;
   ss << token;
   return ss.str();
 }
 
-inline cass::String to_string(const cass::RandomPartitioner::Token& token) {
+inline String to_string(const RandomPartitioner::Token& token) {
   numeric::uint128_t r(token.lo);
   r |= (numeric::uint128_t(token.hi) << 64);
   return r.to_string();
 }
 
-inline cass::String to_string(const cass::ByteOrderedPartitioner::Token& token) {
-  cass::String s;
-  for (cass::ByteOrderedPartitioner::Token::const_iterator it = token.begin(),
-       end = token.end(); it != end; ++it) {
+inline String to_string(const ByteOrderedPartitioner::Token& token) {
+  String s;
+  for (ByteOrderedPartitioner::Token::const_iterator it = token.begin(), end = token.end();
+       it != end; ++it) {
     s.push_back(static_cast<char>(*it));
   }
   return s;
@@ -265,62 +253,59 @@ inline TokenVec random_murmur3_tokens(MT19937_64& rng, size_t num_tokens) {
 
 inline TokenVec murmur3_tokens(const Murmur3TokenVec& murmur3_tokens) {
   TokenVec tokens;
-  for (Murmur3TokenVec::const_iterator it = murmur3_tokens.begin(),
-       end = murmur3_tokens.end(); it != end; ++it) {
+  for (Murmur3TokenVec::const_iterator it = murmur3_tokens.begin(), end = murmur3_tokens.end();
+       it != end; ++it) {
     tokens.push_back(to_string(*it));
   }
   return tokens;
 }
 
-inline void add_keyspace_simple(const cass::String& keyspace_name,
-                                size_t replication_factor,
-                                cass::TokenMap* token_map) {
+inline void add_keyspace_simple(const String& keyspace_name, size_t replication_factor,
+                                TokenMap* token_map) {
 
-  cass::DataType::ConstPtr varchar_data_type(new cass::DataType(CASS_VALUE_TYPE_VARCHAR));
+  DataType::ConstPtr varchar_data_type(new DataType(CASS_VALUE_TYPE_VARCHAR));
 
   ColumnMetadataVec column_metadata;
   column_metadata.push_back(ColumnMetadata("keyspace_name", varchar_data_type));
-  column_metadata.push_back(ColumnMetadata("replication", cass::CollectionType::map(varchar_data_type, varchar_data_type, true)));
+  column_metadata.push_back(ColumnMetadata(
+      "replication", CollectionType::map(varchar_data_type, varchar_data_type, true)));
   RowResultResponseBuilder builder(column_metadata);
 
   ReplicationMap replication;
   replication["class"] = CASS_SIMPLE_STRATEGY;
-  cass::OStringStream ss;
+  OStringStream ss;
   ss << replication_factor;
   replication["replication_factor"] = ss.str();
   builder.append_keyspace_row_v3(keyspace_name, replication);
   builder.finish();
 
-  token_map->add_keyspaces(cass::VersionNumber(3, 0, 0), builder.finish());
+  token_map->add_keyspaces(VersionNumber(3, 0, 0), builder.finish());
 }
 
-inline void add_keyspace_network_topology(const cass::String& keyspace_name,
-                                          ReplicationMap& replication,
-                                          cass::TokenMap* token_map) {
+inline void add_keyspace_network_topology(const String& keyspace_name, ReplicationMap& replication,
+                                          TokenMap* token_map) {
 
-  cass::DataType::ConstPtr varchar_data_type(new cass::DataType(CASS_VALUE_TYPE_VARCHAR));
+  DataType::ConstPtr varchar_data_type(new DataType(CASS_VALUE_TYPE_VARCHAR));
 
   ColumnMetadataVec column_metadata;
   column_metadata.push_back(ColumnMetadata("keyspace_name", varchar_data_type));
-  column_metadata.push_back(ColumnMetadata("replication", cass::CollectionType::map(varchar_data_type, varchar_data_type, true)));
+  column_metadata.push_back(ColumnMetadata(
+      "replication", CollectionType::map(varchar_data_type, varchar_data_type, true)));
   RowResultResponseBuilder builder(column_metadata);
 
   replication["class"] = CASS_NETWORK_TOPOLOGY_STRATEGY;
   builder.append_keyspace_row_v3(keyspace_name, replication);
   builder.finish();
 
-  token_map->add_keyspaces(cass::VersionNumber(3, 0, 0), builder.finish());
+  token_map->add_keyspaces(VersionNumber(3, 0, 0), builder.finish());
 }
 
-inline cass::Host::Ptr create_host(const cass::Address& address,
-                                   const TokenVec& tokens,
-                                   const cass::String& partitioner = "",
-                                   const cass::String& dc = "dc",
-                                   const cass::String& rack = "rack",
-                                   const cass::String& release_version = "3.11") {
-  cass::Host::Ptr host(new cass::Host(address));
+inline Host::Ptr create_host(const Address& address, const TokenVec& tokens,
+                             const String& partitioner = "", const String& dc = "dc",
+                             const String& rack = "rack", const String& release_version = "3.11") {
+  Host::Ptr host(new Host(address));
 
-  cass::DataType::ConstPtr varchar_data_type(new cass::DataType(CASS_VALUE_TYPE_VARCHAR));
+  DataType::ConstPtr varchar_data_type(new DataType(CASS_VALUE_TYPE_VARCHAR));
 
   ColumnMetadataVec column_metadata;
   column_metadata.push_back(ColumnMetadata("data_center", varchar_data_type));
@@ -329,7 +314,8 @@ inline cass::Host::Ptr create_host(const cass::Address& address,
   if (!partitioner.empty()) {
     column_metadata.push_back(ColumnMetadata("partitioner", varchar_data_type));
   }
-  column_metadata.push_back(ColumnMetadata("tokens", cass::CollectionType::list(varchar_data_type, true)));
+  column_metadata.push_back(
+      ColumnMetadata("tokens", CollectionType::list(varchar_data_type, true)));
 
   RowResultResponseBuilder builder(column_metadata);
   builder.append_local_peers_row_v3(tokens, partitioner, dc, rack, release_version);
@@ -339,28 +325,23 @@ inline cass::Host::Ptr create_host(const cass::Address& address,
   return host;
 }
 
-inline cass::Host::Ptr create_host(const cass::String& address,
-                                   const TokenVec& tokens,
-                                   const cass::String& partitioner = "",
-                                   const cass::String& dc = "dc",
-                                   const cass::String& rack = "rack",
-                                   const cass::String& release_version = "3.11") {
-  return create_host(cass::Address(address, 9042), tokens, partitioner, dc, rack, release_version);
+inline Host::Ptr create_host(const String& address, const TokenVec& tokens,
+                             const String& partitioner = "", const String& dc = "dc",
+                             const String& rack = "rack", const String& release_version = "3.11") {
+  return create_host(Address(address, 9042), tokens, partitioner, dc, rack, release_version);
 }
 
-
-inline cass::RandomPartitioner::Token create_random_token(const cass::String& s) {
-  cass::RandomPartitioner::Token token;
+inline RandomPartitioner::Token create_random_token(const String& s) {
+  RandomPartitioner::Token token;
   numeric::uint128_t i(s);
   token.lo = (i & numeric::uint128_t("0xFFFFFFFFFFFFFFFF")).to_base_type();
   token.hi = (i >> 64).to_base_type();
   return token;
 }
 
-inline cass::ByteOrderedPartitioner::Token create_byte_ordered_token(const cass::String& s) {
-  cass::ByteOrderedPartitioner::Token token;
-  for (cass::String::const_iterator i = s.begin(),
-       end = s.end(); i != end; ++i) {
+inline ByteOrderedPartitioner::Token create_byte_ordered_token(const String& s) {
+  ByteOrderedPartitioner::Token token;
+  for (String::const_iterator i = s.begin(), end = s.end(); i != end; ++i) {
     token.push_back(static_cast<uint8_t>(*i));
   }
   return token;
diff --git a/gtests/src/unit/tests/test_address.cpp b/gtests/src/unit/tests/test_address.cpp
index 2be844338..c318445c5 100644
--- a/gtests/src/unit/tests/test_address.cpp
+++ b/gtests/src/unit/tests/test_address.cpp
@@ -18,14 +18,16 @@
 
 #include "address.hpp"
 
+using datastax::internal::core::Address;
+
 TEST(AddressUnitTest, CompareIPv4) {
-  EXPECT_GT(cass::Address("255.255.255.255", 9042).compare(cass::Address("0.0.0.0", 9042)), 0);
-  EXPECT_LT(cass::Address("0.0.0.0", 9042).compare(cass::Address("255.255.255.255", 9042)), 0);
-  EXPECT_EQ(cass::Address("1.2.3.4", 9042).compare(cass::Address("1.2.3.4", 9042)), 0);
+  EXPECT_GT(Address("255.255.255.255", 9042).compare(Address("0.0.0.0", 9042)), 0);
+  EXPECT_LT(Address("0.0.0.0", 9042).compare(Address("255.255.255.255", 9042)), 0);
+  EXPECT_EQ(Address("1.2.3.4", 9042).compare(Address("1.2.3.4", 9042)), 0);
 }
 
 TEST(AddressUnitTest, CompareIPv6) {
-  EXPECT_GT(cass::Address("0.0.0.0", 1).compare(cass::Address("0.0.0.0", 0), true), 0);
-  EXPECT_LT(cass::Address("0.0.0.0", 0).compare(cass::Address("0.0.0.0", 1), true), 0);
-  EXPECT_EQ(cass::Address("0.0.0.0", 0).compare(cass::Address("0.0.0.0", 1), false), 0);
+  EXPECT_GT(Address("0.0.0.0", 1).compare(Address("0.0.0.0", 0), true), 0);
+  EXPECT_LT(Address("0.0.0.0", 0).compare(Address("0.0.0.0", 1), true), 0);
+  EXPECT_EQ(Address("0.0.0.0", 0).compare(Address("0.0.0.0", 1), false), 0);
 }
diff --git a/gtests/src/unit/tests/test_async.cpp b/gtests/src/unit/tests/test_async.cpp
index a21d482dd..aa76781e2 100644
--- a/gtests/src/unit/tests/test_async.cpp
+++ b/gtests/src/unit/tests/test_async.cpp
@@ -19,22 +19,23 @@
 #include "async.hpp"
 #include "callback.hpp"
 
+using datastax::internal::bind_callback;
+using datastax::internal::core::Async;
+
 class AsyncUnitTest : public LoopTest {
 public:
   AsyncUnitTest()
-    : is_callback_called_(false) { }
+      : is_callback_called_(false) {}
 
   bool is_callback_called() { return is_callback_called_; }
 
 protected:
-  void start(cass::Async* async) {
-    ASSERT_EQ(0, async->start(loop(),
-                              cass::bind_callback(&AsyncUnitTest::on_async,
-                                                  this)));
+  void start(Async* async) {
+    ASSERT_EQ(0, async->start(loop(), bind_callback(&AsyncUnitTest::on_async, this)));
   }
 
 private:
-  void on_async(cass::Async* async) {
+  void on_async(Async* async) {
     is_callback_called_ = true;
     async->close_handle();
   }
@@ -44,7 +45,7 @@ class AsyncUnitTest : public LoopTest {
 };
 
 TEST_F(AsyncUnitTest, Simple) {
-  cass::Async async;
+  Async async;
   ASSERT_FALSE(async.is_running());
 
   start(&async);
@@ -62,7 +63,7 @@ TEST_F(AsyncUnitTest, Simple) {
 }
 
 TEST_F(AsyncUnitTest, NotStarted) {
-  cass::Async async;
+  Async async;
   ASSERT_FALSE(async.is_running());
   ASSERT_FALSE(is_callback_called());
 
diff --git a/gtests/src/unit/tests/test_atomic.cpp b/gtests/src/unit/tests/test_atomic.cpp
index 50910ddde..81a430e22 100644
--- a/gtests/src/unit/tests/test_atomic.cpp
+++ b/gtests/src/unit/tests/test_atomic.cpp
@@ -21,9 +21,9 @@
 #include <limits>
 #include <stdint.h>
 
-enum Enum {
-  ONE, TWO, THREE
-};
+using datastax::internal::Atomic;
+
+enum Enum { ONE, TWO, THREE };
 
 struct Object {};
 
@@ -35,7 +35,7 @@ void test_atomic_integer() {
   const T zero = static_cast<T>(0);
   const T one = static_cast<T>(1);
 
-  cass::Atomic<T> i(zero);
+  Atomic<T> i(zero);
 
   EXPECT_EQ(i.load(), zero);
 
@@ -86,7 +86,7 @@ TEST(AtomicUnitTest, Integers) {
 }
 
 TEST(AtomicUnitTest, Enumeration) {
-  cass::Atomic<Enum> e(ONE);
+  Atomic<Enum> e(ONE);
 
   EXPECT_EQ(e.load(), ONE);
 
@@ -116,7 +116,7 @@ TEST(AtomicUnitTest, Enumeration) {
 
 TEST(AtomicUnitTest, Pointer) {
   Object one, two;
-  cass::Atomic<Object*> p(&one);
+  Atomic<Object*> p(&one);
 
   EXPECT_EQ(p.load(), &one);
 
@@ -145,7 +145,7 @@ TEST(AtomicUnitTest, Pointer) {
 }
 
 TEST(AtomicUnitTest, Boolean) {
-  cass::Atomic<bool> b(false);
+  Atomic<bool> b(false);
 
   EXPECT_EQ(b.load(), false);
 
diff --git a/gtests/src/unit/tests/test_class_type_parser.cpp b/gtests/src/unit/tests/test_class_type_parser.cpp
index 3627721ea..5f8dc4d7b 100644
--- a/gtests/src/unit/tests/test_class_type_parser.cpp
+++ b/gtests/src/unit/tests/test_class_type_parser.cpp
@@ -18,22 +18,28 @@
 
 #include "data_type_parser.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 TEST(ClassTypeParserUnitTest, Simple) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  data_type = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.InetAddressType", cache);
+  data_type =
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.InetAddressType", cache);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_INET);
 
-  data_type = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.ReversedType(org.apache.cassandra.db.marshal.UTF8Type)", cache);
+  data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.ReversedType(org.apache.cassandra.db.marshal.UTF8Type)",
+      cache);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TEXT);
 
-  data_type = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UTF8Type)", cache);
+  data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UTF8Type)", cache);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
 
-  cass::CollectionType::ConstPtr collection
-      = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr collection = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(collection->types().size(), 1u);
   EXPECT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_TEXT);
 }
@@ -41,58 +47,74 @@ TEST(ClassTypeParserUnitTest, Simple) {
 TEST(ClassTypeParserUnitTest, Invalid) {
   cass_log_set_level(CASS_LOG_DISABLED);
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
   // Premature end of string
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(blah", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(blah,", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(blah", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(blah,", cache));
 
   // Empty
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType()", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType()", cache));
 
   // Invalid hex
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType(blah,ZZZZ", cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.UserType(blah,ZZZZ", cache));
 
   // Missing ':'
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType("
-                                                        "foo,61646472657373,"
-                                                        "737472656574org.apache.cassandra.db.marshal.UTF8Type)", cache));
+  EXPECT_FALSE(
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType("
+                                         "foo,61646472657373,"
+                                         "737472656574org.apache.cassandra.db.marshal.UTF8Type)",
+                                         cache));
 
   // Premature end of string
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType(", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UTF8Type", cache));
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UTF8Type,", cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType", cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType(", cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UTF8Type",
+      cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UTF8Type,",
+      cache));
 
   // Empty
-  EXPECT_FALSE(cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType()", cache));
+  EXPECT_FALSE(DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType()", cache));
 }
 
 TEST(ClassTypeParserUnitTest, UserDefinedType) {
-  cass::SimpleDataTypeCache cache;
-
-  cass::DataType::ConstPtr data_type
-      = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.UserType("
-                                                 "foo,61646472657373,"
-                                                 "737472656574:org.apache.cassandra.db.marshal.UTF8Type,"
-                                                 "7a6970636f6465:org.apache.cassandra.db.marshal.Int32Type,"
-                                                 "70686f6e6573:org.apache.cassandra.db.marshal.SetType("
-                                                 "org.apache.cassandra.db.marshal.UserType(foo,70686f6e65,6e616d65:org.apache.cassandra.db.marshal.UTF8Type,6e756d626572:org.apache.cassandra.db.marshal.UTF8Type)))",
-                                                 cache);
+  SimpleDataTypeCache cache;
+
+  DataType::ConstPtr data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.UserType("
+      "foo,61646472657373,"
+      "737472656574:org.apache.cassandra.db.marshal.UTF8Type,"
+      "7a6970636f6465:org.apache.cassandra.db.marshal.Int32Type,"
+      "70686f6e6573:org.apache.cassandra.db.marshal.SetType("
+      "org.apache.cassandra.db.marshal.UserType(foo,70686f6e65,6e616d65:org.apache.cassandra.db."
+      "marshal.UTF8Type,6e756d626572:org.apache.cassandra.db.marshal.UTF8Type)))",
+      cache);
 
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_UDT);
 
   // Check external UDT
 
-  cass::UserType::ConstPtr udt(data_type);
+  UserType::ConstPtr udt(data_type);
 
   EXPECT_EQ(udt->keyspace(), "foo");
   EXPECT_EQ(udt->type_name(), "address");
   ASSERT_EQ(udt->fields().size(), 3u);
 
-  cass::UserType::FieldVec::const_iterator i;
+  UserType::FieldVec::const_iterator i;
 
   i = udt->fields().begin();
 
@@ -109,15 +131,14 @@ TEST(ClassTypeParserUnitTest, UserDefinedType) {
   EXPECT_EQ(i->name, "phones");
   ASSERT_EQ(i->type->value_type(), CASS_VALUE_TYPE_SET);
 
-  cass::CollectionType::ConstPtr collection
-      = static_cast<cass::CollectionType::ConstPtr>(i->type);
+  CollectionType::ConstPtr collection = static_cast<CollectionType::ConstPtr>(i->type);
 
   ASSERT_EQ(collection->types().size(), 1u);
   ASSERT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_UDT);
 
   // Check internal UDT
 
-  udt = static_cast<cass::UserType::ConstPtr>(collection->types()[0]);
+  udt = static_cast<UserType::ConstPtr>(collection->types()[0]);
 
   EXPECT_EQ(udt->keyspace(), "foo");
   EXPECT_EQ(udt->type_name(), "phone");
@@ -135,17 +156,18 @@ TEST(ClassTypeParserUnitTest, UserDefinedType) {
 }
 
 TEST(ClassTypeParserUnitTest, Tuple) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::DataType::ConstPtr data_type
-      = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.TupleType("
-                                                 "org.apache.cassandra.db.marshal.Int32Type,"
-                                                 "org.apache.cassandra.db.marshal.UTF8Type,"
-                                                 "org.apache.cassandra.db.marshal.FloatType)", cache);
+  DataType::ConstPtr data_type =
+      DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.TupleType("
+                                         "org.apache.cassandra.db.marshal.Int32Type,"
+                                         "org.apache.cassandra.db.marshal.UTF8Type,"
+                                         "org.apache.cassandra.db.marshal.FloatType)",
+                                         cache);
 
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TUPLE);
 
-  cass::TupleType::ConstPtr tuple = static_cast<cass::TupleType::ConstPtr>(data_type);
+  TupleType::ConstPtr tuple = static_cast<TupleType::ConstPtr>(data_type);
 
   ASSERT_EQ(tuple->types().size(), 3u);
 
@@ -155,19 +177,19 @@ TEST(ClassTypeParserUnitTest, Tuple) {
 }
 
 TEST(ClassTypeParserUnitTest, NestedCollections) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::DataType::ConstPtr data_type
-      = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.MapType("
-                                                 "org.apache.cassandra.db.marshal.UTF8Type,"
-                                                 "org.apache.cassandra.db.marshal.FrozenType("
-                                                 "org.apache.cassandra.db.marshal.MapType("
-                                                 "org.apache.cassandra.db.marshal.Int32Type,org.apache.cassandra.db.marshal.Int32Type)))", cache);
+  DataType::ConstPtr data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.MapType("
+      "org.apache.cassandra.db.marshal.UTF8Type,"
+      "org.apache.cassandra.db.marshal.FrozenType("
+      "org.apache.cassandra.db.marshal.MapType("
+      "org.apache.cassandra.db.marshal.Int32Type,org.apache.cassandra.db.marshal.Int32Type)))",
+      cache);
 
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_MAP);
 
-  cass::CollectionType::ConstPtr collection
-      = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr collection = static_cast<CollectionType::ConstPtr>(data_type);
 
   ASSERT_EQ(collection->types().size(), 2u);
 
@@ -175,8 +197,8 @@ TEST(ClassTypeParserUnitTest, NestedCollections) {
 
   ASSERT_EQ(collection->types()[1]->value_type(), CASS_VALUE_TYPE_MAP);
 
-  cass::CollectionType::ConstPtr nested_collection
-      = static_cast<cass::CollectionType::ConstPtr>(collection->types()[1]);
+  CollectionType::ConstPtr nested_collection =
+      static_cast<CollectionType::ConstPtr>(collection->types()[1]);
 
   ASSERT_EQ(nested_collection->types().size(), 2u);
   EXPECT_EQ(nested_collection->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
@@ -184,12 +206,13 @@ TEST(ClassTypeParserUnitTest, NestedCollections) {
 }
 
 TEST(ClassTypeParserUnitTest, Composite) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::SharedRefPtr<cass::ParseResult> result
-      = cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType("
-                                                            "org.apache.cassandra.db.marshal.AsciiType,"
-                                                            "org.apache.cassandra.db.marshal.Int32Type)", cache);
+  SharedRefPtr<ParseResult> result =
+      DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType("
+                                                    "org.apache.cassandra.db.marshal.AsciiType,"
+                                                    "org.apache.cassandra.db.marshal.Int32Type)",
+                                                    cache);
 
   EXPECT_TRUE(result->is_composite());
 
@@ -205,10 +228,10 @@ TEST(ClassTypeParserUnitTest, Composite) {
 }
 
 TEST(ClassTypeParserUnitTest, NotComposite) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::SharedRefPtr<cass::ParseResult> result
-      = cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.InetAddressType", cache);
+  SharedRefPtr<ParseResult> result = DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.InetAddressType", cache);
 
   ASSERT_EQ(result->types().size(), 1u);
   EXPECT_EQ(result->types()[0]->value_type(), CASS_VALUE_TYPE_INET);
@@ -218,12 +241,13 @@ TEST(ClassTypeParserUnitTest, NotComposite) {
 }
 
 TEST(ClassTypeParserUnitTest, CompositeWithReversedType) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::SharedRefPtr<cass::ParseResult> result
-      = cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType("
-                                                            "org.apache.cassandra.db.marshal.ReversedType(org.apache.cassandra.db.marshal.AsciiType),"
-                                                            "org.apache.cassandra.db.marshal.Int32Type)", cache);
+  SharedRefPtr<ParseResult> result = DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType("
+      "org.apache.cassandra.db.marshal.ReversedType(org.apache.cassandra.db.marshal.AsciiType),"
+      "org.apache.cassandra.db.marshal.Int32Type)",
+      cache);
 
   EXPECT_TRUE(result->is_composite());
 
@@ -239,17 +263,20 @@ TEST(ClassTypeParserUnitTest, CompositeWithReversedType) {
 }
 
 TEST(ClassTypeParserUnitTest, CompositeWithCollections) {
-  cass::SimpleDataTypeCache cache;
-
-  cass::SharedRefPtr<cass::ParseResult> result
-      = cass::DataTypeClassNameParser::parse_with_composite("org.apache.cassandra.db.marshal.CompositeType("
-                                                            "org.apache.cassandra.db.marshal.Int32Type, "
-                                                            "org.apache.cassandra.db.marshal.UTF8Type,"
-                                                            "org.apache.cassandra.db.marshal.ColumnToCollectionType("
-                                                            "6162:org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.Int32Type),"
-                                                            "4A4b4C4D4e4F:org.apache.cassandra.db.marshal.SetType(org.apache.cassandra.db.marshal.UTF8Type),"
-                                                            "6A6b6C6D6e6F:org.apache.cassandra.db.marshal.MapType(org.apache.cassandra.db.marshal.UTF8Type, org.apache.cassandra.db.marshal.LongType)"
-                                                            "))", cache);
+  SimpleDataTypeCache cache;
+
+  SharedRefPtr<ParseResult> result = DataTypeClassNameParser::parse_with_composite(
+      "org.apache.cassandra.db.marshal.CompositeType("
+      "org.apache.cassandra.db.marshal.Int32Type, "
+      "org.apache.cassandra.db.marshal.UTF8Type,"
+      "org.apache.cassandra.db.marshal.ColumnToCollectionType("
+      "6162:org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.Int32Type),"
+      "4A4b4C4D4e4F:org.apache.cassandra.db.marshal.SetType(org.apache.cassandra.db.marshal."
+      "UTF8Type),"
+      "6A6b6C6D6e6F:org.apache.cassandra.db.marshal.MapType(org.apache.cassandra.db.marshal."
+      "UTF8Type, org.apache.cassandra.db.marshal.LongType)"
+      "))",
+      cache);
 
   EXPECT_TRUE(result->is_composite());
 
@@ -263,47 +290,52 @@ TEST(ClassTypeParserUnitTest, CompositeWithCollections) {
 
   ASSERT_EQ(result->collections().size(), 3u);
 
-  cass::ParseResult::CollectionMap::const_iterator i;
+  ParseResult::CollectionMap::const_iterator i;
 
   i = result->collections().find("ab");
-  cass::CollectionType::ConstPtr collection;
+  CollectionType::ConstPtr collection;
   ASSERT_NE(i, result->collections().end());
   ASSERT_EQ(i->second->value_type(), CASS_VALUE_TYPE_LIST);
-  collection = static_cast<cass::CollectionType::ConstPtr>(i->second);
+  collection = static_cast<CollectionType::ConstPtr>(i->second);
   ASSERT_EQ(collection->types().size(), 1u);
   EXPECT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
 
   i = result->collections().find("JKLMNO");
   ASSERT_NE(i, result->collections().end());
   EXPECT_EQ(i->second->value_type(), CASS_VALUE_TYPE_SET);
-  collection = static_cast<cass::CollectionType::ConstPtr>(i->second);
+  collection = static_cast<CollectionType::ConstPtr>(i->second);
   ASSERT_EQ(collection->types().size(), 1u);
   EXPECT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_TEXT);
 
   i = result->collections().find("jklmno");
   ASSERT_NE(i, result->collections().end());
   EXPECT_EQ(i->second->value_type(), CASS_VALUE_TYPE_MAP);
-  collection = static_cast<cass::CollectionType::ConstPtr>(i->second);
+  collection = static_cast<CollectionType::ConstPtr>(i->second);
   ASSERT_EQ(collection->types().size(), 2u);
   EXPECT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_TEXT);
   EXPECT_EQ(collection->types()[1]->value_type(), CASS_VALUE_TYPE_BIGINT);
 }
 
 TEST(ClassTypeParserUnitTest, Frozen) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  data_type = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.FrozenType(org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UTF8Type))", cache);
+  data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.FrozenType(org.apache.cassandra.db.marshal.ListType(org."
+      "apache.cassandra.db.marshal.UTF8Type))",
+      cache);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
   EXPECT_TRUE(data_type->is_frozen());
 
-  data_type = cass::DataTypeClassNameParser::parse_one("org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.FrozenType(org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UTF8Type)))", cache);
+  data_type = DataTypeClassNameParser::parse_one(
+      "org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.FrozenType(org."
+      "apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UTF8Type)))",
+      cache);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
   EXPECT_FALSE(data_type->is_frozen());
 
-  cass::CollectionType::ConstPtr collection
-      = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr collection = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(collection->types().size(), 1u);
   EXPECT_EQ(collection->types()[0]->value_type(), CASS_VALUE_TYPE_LIST);
   EXPECT_TRUE(collection->types()[0]->is_frozen());
diff --git a/gtests/src/unit/tests/test_cluster.cpp b/gtests/src/unit/tests/test_cluster.cpp
index 8338d6876..8e9f91357 100644
--- a/gtests/src/unit/tests/test_cluster.cpp
+++ b/gtests/src/unit/tests/test_cluster.cpp
@@ -20,19 +20,22 @@
 #include "cluster_connector.hpp"
 #include "ref_counted.hpp"
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+#define FIFTEEN_PERCENT(value) static_cast<double>((value * 115) / 100)
 
 class ClusterUnitTest : public EventLoopTest {
 public:
   ClusterUnitTest()
-    : EventLoopTest("ClusterUnitTest") { }
+      : EventLoopTest("ClusterUnitTest") {}
 
-  class Future : public cass::Future {
+  class Future : public core::Future {
   public:
     typedef SharedRefPtr<Future> Ptr;
 
     Future()
-      : cass::Future(FUTURE_TYPE_GENERIC) { }
+        : core::Future(FUTURE_TYPE_GENERIC) {}
 
     ~Future() {
       if (cluster_) {
@@ -59,21 +62,21 @@ class ClusterUnitTest : public EventLoopTest {
     typedef SharedRefPtr<Listener> Ptr;
 
     Listener(const Future::Ptr& close_future = Future::Ptr())
-      : close_future_(close_future) {
+        : close_future_(close_future) {
       inc_ref(); // Might leak during an error, but won't allow a stale pointer
     }
 
-    virtual ~Listener() { }
+    virtual ~Listener() {}
 
-    virtual void on_host_up(const Host::Ptr& host) { }
-    virtual void on_host_down(const Host::Ptr& host) { }
+    virtual void on_host_up(const Host::Ptr& host) {}
+    virtual void on_host_down(const Host::Ptr& host) {}
 
-    virtual void on_host_added(const Host::Ptr& host) { }
-    virtual void on_host_removed(const Host::Ptr& host) { }
+    virtual void on_host_added(const Host::Ptr& host) {}
+    virtual void on_host_removed(const Host::Ptr& host) {}
 
-    virtual void on_token_map_updated(const TokenMap::Ptr& token_map) { }
+    virtual void on_token_map_updated(const TokenMap::Ptr& token_map) {}
 
-    virtual void on_close(Cluster* cluster)  {
+    virtual void on_close(Cluster* cluster) {
       if (close_future_) {
         close_future_->set();
       }
@@ -88,18 +91,15 @@ class ClusterUnitTest : public EventLoopTest {
   public:
     typedef SharedRefPtr<UpDownListener> Ptr;
 
-    UpDownListener(const Future::Ptr& close_future,
-                   const Future::Ptr& up_future,
+    UpDownListener(const Future::Ptr& close_future, const Future::Ptr& up_future,
                    const Future::Ptr& down_future)
-      : Listener(close_future)
-      , up_future_(up_future)
-      , down_future_(down_future) {
+        : Listener(close_future)
+        , up_future_(up_future)
+        , down_future_(down_future) {
       uv_mutex_init(&mutex_);
     }
 
-    ~UpDownListener() {
-      uv_mutex_destroy(&mutex_);
-    }
+    ~UpDownListener() { uv_mutex_destroy(&mutex_); }
 
     Address address() {
       ScopedMutex l(&mutex_);
@@ -134,30 +134,23 @@ class ClusterUnitTest : public EventLoopTest {
     typedef SharedRefPtr<ReconnectClusterListener> Ptr;
 
     struct Event {
-      enum Type {
-        NODE_ADD,
-        NODE_REMOVE
-      };
+      enum Type { NODE_ADD, NODE_REMOVE };
       Event(Type type, const Address& address)
-        : type(type)
-        , address(address) { }
+          : type(type)
+          , address(address) {}
       Type type;
       Address address;
     };
     typedef Vector<Event> Events;
 
     ReconnectClusterListener(const Future::Ptr& close_future, OutagePlan* outage_plan)
-      : Listener(close_future)
-      , outage_plan_(outage_plan)
-      , cluster_(NULL) { }
+        : Listener(close_future)
+        , outage_plan_(outage_plan)
+        , cluster_(NULL) {}
 
-    const HostVec& connected_hosts() const {
-      return connected_hosts_;
-    }
+    const HostVec& connected_hosts() const { return connected_hosts_; }
 
-    const Events& events() const {
-      return events_;
-    }
+    const Events& events() const { return events_; }
 
     virtual void on_reconnect(Cluster* cluster) {
       cluster_ = cluster;
@@ -166,14 +159,15 @@ class ClusterUnitTest : public EventLoopTest {
         outage_plan_->run();
       } else {
         if (outage_plan_->is_done()) {
-          outage_plan_->stop(); // Stop and clean up outage plan timer handle on the original event loop thread.
+          outage_plan_->stop(); // Stop and clean up outage plan timer handle on the original event
+                                // loop thread.
           cluster->close();
         }
       }
     }
 
-    virtual void on_host_up(const Host::Ptr& host) { }
-    virtual void on_host_down(const Host::Ptr& host) { }
+    virtual void on_host_up(const Host::Ptr& host) {}
+    virtual void on_host_down(const Host::Ptr& host) {}
 
     virtual void on_host_added(const Host::Ptr& host) {
       events_.push_back(Event(Event::NODE_ADD, host->address()));
@@ -188,7 +182,7 @@ class ClusterUnitTest : public EventLoopTest {
       events_.push_back(Event(Event::NODE_REMOVE, host->address()));
     }
 
-    virtual void on_token_map_updated(const TokenMap::Ptr& token_map) { }
+    virtual void on_token_map_updated(const TokenMap::Ptr& token_map) {}
 
   private:
     HostVec connected_hosts_;
@@ -201,15 +195,12 @@ class ClusterUnitTest : public EventLoopTest {
   public:
     typedef SharedRefPtr<RecoverClusterListener> Ptr;
 
-    RecoverClusterListener(const Future::Ptr& close_future,
-                           const Future::Ptr& up_future,
+    RecoverClusterListener(const Future::Ptr& close_future, const Future::Ptr& up_future,
                            const Future::Ptr& recover_future)
-      : UpDownListener(close_future, up_future, Future::Ptr())
-      , recover_future_(recover_future) { }
+        : UpDownListener(close_future, up_future, Future::Ptr())
+        , recover_future_(recover_future) {}
 
-    const HostVec& connected_hosts() const {
-      return connected_hosts_;
-    }
+    const HostVec& connected_hosts() const { return connected_hosts_; }
 
     virtual void on_reconnect(Cluster* cluster) {
       connected_hosts_.push_back(cluster->connected_host());
@@ -228,16 +219,15 @@ class ClusterUnitTest : public EventLoopTest {
     typedef SharedRefPtr<DisableEventsListener> Ptr;
 
     DisableEventsListener(const Future::Ptr& close_future, mockssandra::Cluster& simple_cluster)
-      : Listener(close_future)
-      , event_future_(new Future())
-      , simple_cluster_(simple_cluster) { }
+        : Listener(close_future)
+        , event_future_(new Future())
+        , simple_cluster_(simple_cluster) {}
 
     Future::Ptr& event_future() { return event_future_; }
 
     virtual void on_reconnect(Cluster* cluster) {
       // Trigger an ADD event right after cluster connection.
-      simple_cluster_.event(
-            mockssandra::TopologyChangeEvent::new_node(cass::Address("127.0.0.2", 9042)));
+      simple_cluster_.event(mockssandra::TopologyChangeEvent::new_node(Address("127.0.0.2", 9042)));
     }
 
     virtual void on_host_up(const Host::Ptr& host) { event_future_->set(); }
@@ -251,6 +241,53 @@ class ClusterUnitTest : public EventLoopTest {
     mockssandra::Cluster& simple_cluster_;
   };
 
+  class ClusterUnitTestReconnectionPolicy : public ReconnectionPolicy {
+  public:
+    typedef SharedRefPtr<ClusterUnitTestReconnectionPolicy> Ptr;
+
+    ClusterUnitTestReconnectionPolicy()
+        : ReconnectionPolicy(ReconnectionPolicy::CONSTANT)
+        , reconnection_schedule_count_(0)
+        , destroyed_reconnection_schedule_count_(0)
+        , scheduled_delay_count_(0) {}
+
+    virtual const char* name() const { return "blah"; }
+    virtual ReconnectionSchedule* new_reconnection_schedule() {
+      ++reconnection_schedule_count_;
+      return new ClusterUnitTestReconnectionSchedule(&scheduled_delay_count_,
+                                                     &destroyed_reconnection_schedule_count_);
+    }
+
+    unsigned reconnection_schedule_count() const { return reconnection_schedule_count_; }
+    unsigned destroyed_reconnection_schedule_count() const {
+      return destroyed_reconnection_schedule_count_;
+    }
+    unsigned scheduled_delay_count() const { return scheduled_delay_count_; }
+
+  private:
+    unsigned reconnection_schedule_count_;
+    unsigned destroyed_reconnection_schedule_count_;
+    unsigned scheduled_delay_count_;
+
+    class ClusterUnitTestReconnectionSchedule : public ReconnectionSchedule {
+    public:
+      ClusterUnitTestReconnectionSchedule(unsigned* delay_count, unsigned* destroyed_count)
+          : delay_count_(delay_count)
+          , destroyed_count_(destroyed_count) {}
+
+      ~ClusterUnitTestReconnectionSchedule() { ++*destroyed_count_; }
+
+      virtual uint64_t next_delay_ms() {
+        ++*delay_count_;
+        return 1;
+      }
+
+    private:
+      unsigned* delay_count_;
+      unsigned* destroyed_count_;
+    };
+  };
+
   static void on_connection_connected(ClusterConnector* connector, Future* future) {
     if (connector->is_ok()) {
       future->set();
@@ -261,24 +298,19 @@ class ClusterUnitTest : public EventLoopTest {
                             connector->error_message());
           break;
         case ClusterConnector::CLUSTER_ERROR_SSL_ERROR:
-          future->set_error(connector->ssl_error_code(),
-                            connector->error_message());
+          future->set_error(connector->ssl_error_code(), connector->error_message());
           break;
         case ClusterConnector::CLUSTER_ERROR_AUTH_ERROR:
-          future->set_error(CASS_ERROR_SERVER_BAD_CREDENTIALS,
-                            connector->error_message());
+          future->set_error(CASS_ERROR_SERVER_BAD_CREDENTIALS, connector->error_message());
           break;
         case ClusterConnector::CLUSTER_ERROR_NO_HOSTS_AVAILABLE:
-          future->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
-                            connector->error_message());
+          future->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connector->error_message());
           break;
         case ClusterConnector::CLUSTER_CANCELED:
-          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT,
-                            "Canceled");
+          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT, "Canceled");
           break;
         default:
-          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT,
-                            connector->error_message());
+          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT, connector->error_message());
           break;
       }
     }
@@ -288,8 +320,7 @@ class ClusterUnitTest : public EventLoopTest {
     if (connector->is_ok()) {
       future->set_cluster(connector->release_cluster()); // Keep the cluster alive
     } else {
-      future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT,
-                        connector->error_message());
+      future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT, connector->error_message());
     }
   }
 };
@@ -304,9 +335,9 @@ TEST_F(ClusterUnitTest, Simple) {
   contact_points.push_back("127.0.0.3");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   connector->connect(event_loop());
 
@@ -320,13 +351,16 @@ TEST_F(ClusterUnitTest, SimpleWithCriticalFailures) {
   mockssandra::SimpleRequestHandlerBuilder builder;
   builder.on(mockssandra::OPCODE_STARTUP)
       .validate_startup()
-      .is_address("127.0.0.2").then(mockssandra::Action::Builder().authenticate("com.dataxtax.SomeAuthenticator"))
-      .is_address("127.0.0.3").then(mockssandra::Action::Builder().invalid_protocol())
+      .is_address("127.0.0.2")
+      .then(mockssandra::Action::Builder().authenticate("com.dataxtax.SomeAuthenticator"))
+      .is_address("127.0.0.3")
+      .then(mockssandra::Action::Builder().invalid_protocol())
       .ready();
 
   builder.on(mockssandra::OPCODE_AUTH_RESPONSE)
       .validate_auth_response()
-      .is_address("127.0.0.2").then(mockssandra::Action::Builder().plaintext_auth())
+      .is_address("127.0.0.2")
+      .then(mockssandra::Action::Builder().plaintext_auth())
       .auth_success();
 
   ContactPointList contact_points;
@@ -344,21 +378,21 @@ TEST_F(ClusterUnitTest, SimpleWithCriticalFailures) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   ClusterSettings settings;
   settings.control_connection_settings.connection_settings.auth_provider.reset(
-        new PlainTextAuthProvider("invalid", "invalid"));
+      new PlainTextAuthProvider("invalid", "invalid"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
-  EXPECT_GE(logging_criteria_count(), 2); // Invalid or unsupported protocol may retry with different protocol before connection
+  EXPECT_GE(
+      logging_criteria_count(),
+      2); // Invalid or unsupported protocol may retry with different protocol before connection
 }
 
 TEST_F(ClusterUnitTest, Resolve) {
@@ -369,9 +403,9 @@ TEST_F(ClusterUnitTest, Resolve) {
   contact_points.push_back("localhost");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
   connector->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
@@ -386,17 +420,15 @@ TEST_F(ClusterUnitTest, Auth) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   ClusterSettings settings;
   settings.control_connection_settings.connection_settings.auth_provider.reset(
-        new PlainTextAuthProvider("cassandra", "cassandra"));
+      new PlainTextAuthProvider("cassandra", "cassandra"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -412,13 +444,11 @@ TEST_F(ClusterUnitTest, Ssl) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -438,25 +468,25 @@ TEST_F(ClusterUnitTest, Cancel) {
 
   for (size_t i = 0; i < 10; ++i) {
     Future::Ptr connect_future(new Future());
-    ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                         PROTOCOL_VERSION,
-                                                         bind_callback(on_connection_connected, connect_future.get())));
+    ClusterConnector::Ptr connector(
+        new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                             bind_callback(on_connection_connected, connect_future.get())));
     connector->connect(event_loop());
     connectors.push_back(connector);
     connect_futures.push_back(connect_future);
   }
 
-  for (Vector<ClusterConnector::Ptr>::iterator it = connectors.begin(),
-       end = connectors.end(); it != end; ++it) {
+  for (Vector<ClusterConnector::Ptr>::iterator it = connectors.begin(), end = connectors.end();
+       it != end; ++it) {
     (*it)->cancel();
   }
 
   bool is_canceled = false;
   for (Vector<Future::Ptr>::const_iterator it = connect_futures.begin(),
-       end = connect_futures.end(); it != end; ++it) {
+                                           end = connect_futures.end();
+       it != end; ++it) {
     ASSERT_TRUE((*it)->wait_for(WAIT_FOR_TIME));
-    if ((*it)->error() &&
-        (*it)->error()->code == CASS_ERROR_LIB_UNABLE_TO_CONNECT &&
+    if ((*it)->error() && (*it)->error()->code == CASS_ERROR_LIB_UNABLE_TO_CONNECT &&
         (*it)->error()->message == "Canceled") {
       is_canceled = true;
     }
@@ -482,20 +512,17 @@ TEST_F(ClusterUnitTest, ReconnectToDiscoveredHosts) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
-  ReconnectClusterListener::Ptr listener(
-        new ReconnectClusterListener(close_future, &outage_plan));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
+  ReconnectClusterListener::Ptr listener(new ReconnectClusterListener(close_future, &outage_plan));
 
   ClusterSettings settings;
-  settings.reconnect_timeout_ms = 1; // Reconnect immediately
-  settings.control_connection_settings.connection_settings.connect_timeout_ms = 200; // Give enough time for the connection to complete
+  settings.reconnection_policy.reset(new ConstantReconnectionPolicy(1)); // Reconnect immediately
+  settings.control_connection_settings.connection_settings.connect_timeout_ms =
+      200; // Give enough time for the connection to complete
 
-  connector
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->connect(event_loop());
+  connector->with_settings(settings)->with_listener(listener.get())->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -528,20 +555,17 @@ TEST_F(ClusterUnitTest, ReconnectUpdateHosts) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
-  ReconnectClusterListener::Ptr listener(
-        new ReconnectClusterListener(close_future, &outage_plan));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
+  ReconnectClusterListener::Ptr listener(new ReconnectClusterListener(close_future, &outage_plan));
 
   ClusterSettings settings;
-  settings.reconnect_timeout_ms = 1; // Reconnect immediately
-  settings.control_connection_settings.connection_settings.connect_timeout_ms = 200; // Give enough time for the connection to complete
+  settings.reconnection_policy.reset(new ConstantReconnectionPolicy(1)); // Reconnect immediately
+  settings.control_connection_settings.connection_settings.connect_timeout_ms =
+      200; // Give enough time for the connection to complete
 
-  connector
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->connect(event_loop());
+  connector->with_settings(settings)->with_listener(listener.get())->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -571,19 +595,17 @@ TEST_F(ClusterUnitTest, CloseDuringReconnect) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
 
   Listener::Ptr listener(new Listener(close_future));
 
   ClusterSettings settings;
-  settings.reconnect_timeout_ms = 100000; // Make sure we're reconnecting when we close.
+  settings.reconnection_policy.reset(
+      new ConstantReconnectionPolicy(100000)); // Make sure we're reconnecting when we close.
 
-  connector
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->connect(event_loop());
+  connector->with_settings(settings)->with_listener(listener.get())->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -608,15 +630,13 @@ TEST_F(ClusterUnitTest, NotifyDownUp) {
   Future::Ptr connect_future(new Future());
   Future::Ptr up_future(new Future());
   Future::Ptr down_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
 
   UpDownListener::Ptr listener(new UpDownListener(close_future, up_future, down_future));
 
-  connector
-      ->with_listener(listener.get())
-      ->connect(event_loop());
+  connector->with_listener(listener.get())->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -641,7 +661,8 @@ TEST_F(ClusterUnitTest, NotifyDownUp) {
 
 TEST_F(ClusterUnitTest, ProtocolNegotiation) {
   mockssandra::SimpleRequestHandlerBuilder builder;
-  builder.with_supported_protocol_versions(1, PROTOCOL_VERSION - 1); // Support one less than our current version
+  builder.with_supported_protocol_versions(1, PROTOCOL_VERSION -
+                                                  1); // Support one less than our current version
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
@@ -649,9 +670,9 @@ TEST_F(ClusterUnitTest, ProtocolNegotiation) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   connector->connect(event_loop());
 
@@ -671,9 +692,9 @@ TEST_F(ClusterUnitTest, NoSupportedProtocols) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   connector->connect(event_loop());
 
@@ -692,16 +713,14 @@ TEST_F(ClusterUnitTest, FindValidHost) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   ClusterSettings settings;
   settings.control_connection_settings.connection_settings.connect_timeout_ms = 100;
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -717,9 +736,9 @@ TEST_F(ClusterUnitTest, NoHostsAvailable) {
   contact_points.push_back("127.0.0.3");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   connector->connect(event_loop());
 
@@ -736,17 +755,15 @@ TEST_F(ClusterUnitTest, InvalidAuth) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   ClusterSettings settings;
   settings.control_connection_settings.connection_settings.auth_provider.reset(
-        new PlainTextAuthProvider("invalid", "invalid"));
+      new PlainTextAuthProvider("invalid", "invalid"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(connect_future->error());
@@ -762,18 +779,17 @@ TEST_F(ClusterUnitTest, InvalidSsl) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   SslContext::Ptr ssl_context(SslContextFactory::create()); // No trusted cert
 
   ClusterSettings settings;
-  settings.control_connection_settings.connection_settings.socket_settings.ssl_context = ssl_context;
+  settings.control_connection_settings.connection_settings.socket_settings.ssl_context =
+      ssl_context;
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(connect_future->error());
@@ -792,26 +808,25 @@ TEST_F(ClusterUnitTest, DCAwareRecoverOnRemoteHost) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
 
   Future::Ptr up_future(new Future());
   Future::Ptr recover_future(new Future());
   RecoverClusterListener::Ptr listener(
-        new RecoverClusterListener(close_future, up_future, recover_future));
+      new RecoverClusterListener(close_future, up_future, recover_future));
 
   ClusterSettings settings;
-  settings.load_balancing_policy.reset(new DCAwarePolicy("dc1", 1, false)); // Allow connection to a single remote host
+  settings.load_balancing_policy.reset(
+      new DCAwarePolicy("dc1", 1, false)); // Allow connection to a single remote host
   settings.load_balancing_policies.clear();
   settings.load_balancing_policies.push_back(settings.load_balancing_policy);
-  settings.reconnect_timeout_ms = 1; // Reconnect immediately
-  settings.control_connection_settings.connection_settings.connect_timeout_ms = 200; // Give enough time for the connection to complete
+  settings.reconnection_policy.reset(new ConstantReconnectionPolicy(1)); // Reconnect immediately
+  settings.control_connection_settings.connection_settings.connect_timeout_ms =
+      200; // Give enough time for the connection to complete
 
-  connector
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->connect(event_loop());
+  connector->with_settings(settings)->with_listener(listener.get())->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -835,7 +850,8 @@ TEST_F(ClusterUnitTest, DCAwareRecoverOnRemoteHost) {
 
   ASSERT_EQ(listener->connected_hosts().size(), 2u);
   EXPECT_EQ(listener->connected_hosts()[0]->address(), Address("127.0.0.1", PORT));
-  EXPECT_EQ(listener->connected_hosts()[1]->address(), Address("127.0.0.2", PORT)); // Connected to remote host.
+  EXPECT_EQ(listener->connected_hosts()[1]->address(),
+            Address("127.0.0.2", PORT)); // Connected to remote host.
 }
 
 TEST_F(ClusterUnitTest, InvalidDC) {
@@ -846,23 +862,23 @@ TEST_F(ClusterUnitTest, InvalidDC) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, connect_future.get())));
 
   ClusterSettings settings;
-  settings.load_balancing_policy.reset(new DCAwarePolicy("invalid_dc", 0, false)); // Invalid DC and not using remote hosts
+  settings.load_balancing_policy.reset(
+      new DCAwarePolicy("invalid_dc", 0, false)); // Invalid DC and not using remote hosts
   settings.load_balancing_policies.clear();
   settings.load_balancing_policies.push_back(settings.load_balancing_policy);
 
-  connector
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(connect_future->error());
   EXPECT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connect_future->error()->code);
-  EXPECT_TRUE(connect_future->error()->message.find("Check to see if the configured local datacenter is valid") != String::npos);
+  EXPECT_TRUE(connect_future->error()->message.find(
+                  "Check to see if the configured local datacenter is valid") != String::npos);
 }
 
 TEST_F(ClusterUnitTest, DisableEventsOnStartup) {
@@ -874,21 +890,17 @@ TEST_F(ClusterUnitTest, DisableEventsOnStartup) {
   contact_points.push_back("127.0.0.1");
 
   Future::Ptr connect_future(new Future());
-  ClusterConnector::Ptr connector(new ClusterConnector(contact_points,
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_reconnect, connect_future.get())));
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
 
   ClusterSettings settings;
   settings.disable_events_on_startup = true; // Disable events to start
 
   Future::Ptr close_future(new Future());
-  DisableEventsListener::Ptr listener(
-        new DisableEventsListener(close_future, cluster));
+  DisableEventsListener::Ptr listener(new DisableEventsListener(close_future, cluster));
 
-  connector
-      ->with_listener(listener.get())
-      ->with_settings(settings)
-      ->connect(event_loop());
+  connector->with_listener(listener.get())->with_settings(settings)->connect(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_FALSE(connect_future->error());
@@ -906,3 +918,42 @@ TEST_F(ClusterUnitTest, DisableEventsOnStartup) {
   connect_future->cluster()->close();
   ASSERT_TRUE(close_future->wait_for(WAIT_FOR_TIME));
 }
+
+TEST_F(ClusterUnitTest, ReconnectionPolicy) {
+  mockssandra::SimpleCluster mock_cluster(simple());
+  ASSERT_EQ(mock_cluster.start_all(), 0);
+
+  OutagePlan outage_plan(loop(), &mock_cluster);
+  outage_plan.stop_node(1);
+  outage_plan.start_node(1);
+  outage_plan.stop_node(1);
+  outage_plan.start_node(1);
+
+  ContactPointList contact_points;
+  contact_points.push_back("127.0.0.1");
+
+  Future::Ptr close_future(new Future());
+  Future::Ptr connect_future(new Future());
+  ClusterConnector::Ptr connector(
+      new ClusterConnector(contact_points, PROTOCOL_VERSION,
+                           bind_callback(on_connection_reconnect, connect_future.get())));
+  ReconnectClusterListener::Ptr listener(new ReconnectClusterListener(close_future, &outage_plan));
+
+  ClusterSettings settings;
+  settings.reconnection_policy.reset(new ClusterUnitTestReconnectionPolicy());
+  settings.control_connection_settings.connection_settings.connect_timeout_ms =
+      200; // Give enough time for the connection to complete
+  connector->with_settings(settings)->with_listener(listener.get())->connect(event_loop());
+
+  ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
+  EXPECT_FALSE(connect_future->error());
+
+  ASSERT_TRUE(close_future->wait_for(WAIT_FOR_TIME));
+
+  ClusterUnitTestReconnectionPolicy::Ptr policy(
+      static_cast<ClusterUnitTestReconnectionPolicy::Ptr>(settings.reconnection_policy));
+  EXPECT_EQ(2u, policy->reconnection_schedule_count());
+  EXPECT_EQ(2u, policy->destroyed_reconnection_schedule_count());
+  EXPECT_GE(policy->scheduled_delay_count(), 2u);
+  EXPECT_EQ(3u, mock_cluster.connection_attempts(1)); // Includes initial connection attempt
+}
diff --git a/gtests/src/unit/tests/test_connection.cpp b/gtests/src/unit/tests/test_connection.cpp
index 22e5db413..6f3d8b823 100644
--- a/gtests/src/unit/tests/test_connection.cpp
+++ b/gtests/src/unit/tests/test_connection.cpp
@@ -27,7 +27,8 @@
 #undef STATUS_TIMEOUT
 #endif
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class ConnectionUnitTest : public LoopTest {
 public:
@@ -42,7 +43,7 @@ class ConnectionUnitTest : public LoopTest {
 
   struct State {
     State()
-      : status(STATUS_NEW) { }
+        : status(STATUS_NEW) {}
 
     Connection::Ptr connection;
     Status status;
@@ -51,9 +52,9 @@ class ConnectionUnitTest : public LoopTest {
   class RequestCallback : public SimpleRequestCallback {
   public:
     RequestCallback(Connection* connection, ConnectionUnitTest::State* state)
-      : SimpleRequestCallback("SELECT * FROM blah")
-      , state_(state)
-      , connection_(connection) { }
+        : SimpleRequestCallback("SELECT * FROM blah")
+        , state_(state)
+        , connection_(connection) {}
 
     virtual void on_internal_set(ResponseMessage* response) {
       connection_->close();
@@ -84,10 +85,12 @@ class ConnectionUnitTest : public LoopTest {
     state->status = STATUS_CONNECTED;
     state->connection = connector->release_connection();
     state->connection->start_heartbeats();
-    state->connection->write_and_flush(RequestCallback::Ptr(new RequestCallback(state->connection.get(), state)));
+    state->connection->write_and_flush(
+        RequestCallback::Ptr(new RequestCallback(state->connection.get(), state)));
   }
 
-  static void on_connection_error_code(Connector* connector, Connector::ConnectionError* error_code) {
+  static void on_connection_error_code(Connector* connector,
+                                       Connector::ConnectionError* error_code) {
     if (!connector->is_ok()) {
       *error_code = connector->error_code();
     }
@@ -104,17 +107,18 @@ class ConnectionUnitTest : public LoopTest {
     state->status = STATUS_CONNECTED;
     state->connection = connector->release_connection();
     state->connection->start_heartbeats();
-    state->connection->write_and_flush(RequestCallback::Ptr(new RequestCallback(state->connection.get(), state)));
+    state->connection->write_and_flush(
+        RequestCallback::Ptr(new RequestCallback(state->connection.get(), state)));
   }
 
-  static void on_delayed_error_code(DelayedConnector* connector, Connector::ConnectionError* error_code) {
+  static void on_delayed_error_code(DelayedConnector* connector,
+                                    Connector::ConnectionError* error_code) {
     if (!connector->is_ok()) {
       *error_code = connector->error_code();
     }
   }
 };
 
-
 TEST_F(ConnectionUnitTest, Simple) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
@@ -133,10 +137,7 @@ TEST_F(ConnectionUnitTest, Simple) {
 
 TEST_F(ConnectionUnitTest, Keyspace) {
   mockssandra::SimpleRequestHandlerBuilder builder;
-  builder
-      .on(mockssandra::OPCODE_QUERY)
-      .use_keyspace("foo")
-      .validate_query().void_result();
+  builder.on(mockssandra::OPCODE_QUERY).use_keyspace("foo").validate_query().void_result();
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
@@ -145,9 +146,7 @@ TEST_F(ConnectionUnitTest, Keyspace) {
                                          PROTOCOL_VERSION,
                                          bind_callback(on_connection_connected, &state)));
 
-  connector
-      ->with_keyspace("foo")
-      ->connect(loop());
+  connector->with_keyspace("foo")->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -168,9 +167,7 @@ TEST_F(ConnectionUnitTest, Auth) {
   ConnectionSettings settings;
   settings.auth_provider.reset(new PlainTextAuthProvider("cassandra", "cassandra"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -186,9 +183,7 @@ TEST_F(ConnectionUnitTest, Ssl) {
   Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                          PROTOCOL_VERSION,
                                          bind_callback(on_connection_connected, &state)));
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -243,9 +238,7 @@ TEST_F(ConnectionUnitTest, SslClose) {
     Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                            PROTOCOL_VERSION,
                                            bind_callback(on_connection_close, &is_closed)));
-    connector
-        ->with_settings(settings)
-        ->connect(loop());
+    connector->with_settings(settings)->connect(loop());
     connectors.push_back(connector);
   }
 
@@ -293,9 +286,7 @@ TEST_F(ConnectionUnitTest, SslCancel) {
     Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                            PROTOCOL_VERSION,
                                            bind_callback(on_connection_error_code, &error_code)));
-    connector
-        ->with_settings(settings)
-        ->connect(loop());
+    connector->with_settings(settings)->connect(loop());
     connectors.push_back(connector);
   }
 
@@ -325,9 +316,7 @@ TEST_F(ConnectionUnitTest, Timeout) {
   ConnectionSettings settings;
   settings.connect_timeout_ms = 200;
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -336,10 +325,7 @@ TEST_F(ConnectionUnitTest, Timeout) {
 
 TEST_F(ConnectionUnitTest, InvalidKeyspace) {
   mockssandra::SimpleRequestHandlerBuilder builder;
-  builder
-      .on(mockssandra::OPCODE_QUERY)
-      .use_keyspace("foo")
-      .validate_query().void_result();
+  builder.on(mockssandra::OPCODE_QUERY).use_keyspace("foo").validate_query().void_result();
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
@@ -347,9 +333,7 @@ TEST_F(ConnectionUnitTest, InvalidKeyspace) {
   Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                          PROTOCOL_VERSION,
                                          bind_callback(on_connection_error_code, &error_code)));
-  connector
-      ->with_keyspace("invalid")
-      ->connect(loop());
+  connector->with_keyspace("invalid")->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -364,8 +348,7 @@ TEST_F(ConnectionUnitTest, InvalidProtocol) {
   Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                          0x7F, // Invalid protocol version
                                          bind_callback(on_connection_error_code, &error_code)));
-  connector
-      ->connect(loop());
+  connector->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -373,17 +356,15 @@ TEST_F(ConnectionUnitTest, InvalidProtocol) {
 }
 
 TEST_F(ConnectionUnitTest, DeprecatedProtocol) {
-  mockssandra::SimpleCluster cluster(mockssandra::SimpleRequestHandlerBuilder()
-                                     .with_supported_protocol_versions(1, 2)
-                                     .build());
+  mockssandra::SimpleCluster cluster(
+      mockssandra::SimpleRequestHandlerBuilder().with_supported_protocol_versions(1, 2).build());
   cluster.start_all();
 
   Connector::ConnectionError error_code(Connector::CONNECTION_OK);
   Connector::Ptr connector(new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
                                          PROTOCOL_VERSION,
                                          bind_callback(on_connection_error_code, &error_code)));
-  connector
-      ->connect(loop());
+  connector->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -402,9 +383,7 @@ TEST_F(ConnectionUnitTest, InvalidAuth) {
   ConnectionSettings settings;
   settings.auth_provider.reset(new PlainTextAuthProvider("invalid", "invalid"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -426,9 +405,7 @@ TEST_F(ConnectionUnitTest, InvalidNoSsl) {
   settings.socket_settings.ssl_context = ssl_context;
   settings.socket_settings.hostname_resolution_enabled = true;
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -451,9 +428,7 @@ TEST_F(ConnectionUnitTest, InvalidSsl) {
   settings.socket_settings.ssl_context = ssl_context;
   settings.socket_settings.hostname_resolution_enabled = true;
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -465,9 +440,9 @@ TEST_F(ConnectionUnitTest, Delayed) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   State state;
-  DelayedConnector::Ptr connector(new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_delayed_connected, &state)));
+  DelayedConnector::Ptr connector(
+      new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_delayed_connected, &state)));
 
   connector->delayed_connect(loop(), 500);
 
@@ -481,9 +456,9 @@ TEST_F(ConnectionUnitTest, DelayedCancel) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   State state;
-  DelayedConnector::Ptr connector(new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_delayed_connected, &state)));
+  DelayedConnector::Ptr connector(
+      new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_delayed_connected, &state)));
 
   connector->delayed_connect(loop(), 500);
 
@@ -497,9 +472,9 @@ TEST_F(ConnectionUnitTest, DelayedCancel) {
 
   Connector::ConnectionError error_code(Connector::CONNECTION_OK);
   for (size_t i = 0; i < 10; ++i) {
-    DelayedConnector::Ptr connector(new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                         PROTOCOL_VERSION,
-                                                         bind_callback(on_delayed_error_code, &error_code)));
+    DelayedConnector::Ptr connector(
+        new DelayedConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                             bind_callback(on_delayed_error_code, &error_code)));
     connector->delayed_connect(loop(), 500);
     connectors.push_back(connector);
   }
diff --git a/gtests/src/unit/tests/test_control_connection.cpp b/gtests/src/unit/tests/test_control_connection.cpp
index 50c214e3d..224189f07 100644
--- a/gtests/src/unit/tests/test_control_connection.cpp
+++ b/gtests/src/unit/tests/test_control_connection.cpp
@@ -16,14 +16,16 @@
 
 #include "loop_test.hpp"
 
-#include "control_connector.hpp"
 #include "constants.hpp"
+#include "control_connector.hpp"
 
 #ifdef WIN32
 #undef STATUS_TIMEOUT
 #endif
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 using mockssandra::SchemaChangeEvent;
 using mockssandra::StatusChangeEvent;
 using mockssandra::TopologyChangeEvent;
@@ -53,8 +55,10 @@ struct RecordedEvent {
     NODE_REMOVED
   };
 
-  RecordedEvent() : type(INVALID) { }
-  RecordedEvent(Type type) : type(type) { }
+  RecordedEvent()
+      : type(INVALID) {}
+  RecordedEvent(Type type)
+      : type(type) {}
 
   Type type;
   ResultResponse::Ptr result;
@@ -67,14 +71,13 @@ static RecordedEvent invalid_event__;
 
 typedef Vector<RecordedEvent> RecordedEventVec;
 
-class RecordingControlConnectionListener
-    : public ControlConnectionListener {
+class RecordingControlConnectionListener : public ControlConnectionListener {
 public:
   const RecordedEventVec& events() const { return events_; }
 
   const RecordedEvent& find_event(RecordedEvent::Type type) {
-    for (RecordedEventVec::const_iterator it = events().begin(),
-         end = events().end(); it != end; ++it) {
+    for (RecordedEventVec::const_iterator it = events().begin(), end = events().end(); it != end;
+         ++it) {
       if (it->type == type) {
         return *it;
       }
@@ -83,20 +86,34 @@ class RecordingControlConnectionListener
   }
 
 protected:
-  virtual void on_update_schema(SchemaType type,
-                                const ResultResponse::Ptr& result,
-                                const String& keyspace_name,
-                                const String& target_name) {
+  virtual void on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                                const String& keyspace_name, const String& target_name) {
     RecordedEvent event;
     switch (type) {
-      case KEYSPACE: event.type = RecordedEvent::KEYSPACE_UPDATED; break;
-      case TABLE: event.type = RecordedEvent::TABLE_UPDATED; break;
-      case VIEW: event.type = RecordedEvent::VIEW_UPDATED; break;
-      case COLUMN: event.type = RecordedEvent::COLUMN_UPDATED; break;
-      case INDEX: event.type = RecordedEvent::INDEX_UPDATED; break;
-      case USER_TYPE: event.type = RecordedEvent::USER_TYPE_UPDATED; break;
-      case FUNCTION: event.type = RecordedEvent::FUNCTION_UPDATED; break;
-      case AGGREGATE: event.type = RecordedEvent::AGGREGATE_UPDATED; break;
+      case KEYSPACE:
+        event.type = RecordedEvent::KEYSPACE_UPDATED;
+        break;
+      case TABLE:
+        event.type = RecordedEvent::TABLE_UPDATED;
+        break;
+      case VIEW:
+        event.type = RecordedEvent::VIEW_UPDATED;
+        break;
+      case COLUMN:
+        event.type = RecordedEvent::COLUMN_UPDATED;
+        break;
+      case INDEX:
+        event.type = RecordedEvent::INDEX_UPDATED;
+        break;
+      case USER_TYPE:
+        event.type = RecordedEvent::USER_TYPE_UPDATED;
+        break;
+      case FUNCTION:
+        event.type = RecordedEvent::FUNCTION_UPDATED;
+        break;
+      case AGGREGATE:
+        event.type = RecordedEvent::AGGREGATE_UPDATED;
+        break;
     }
     event.result = result;
     event.keyspace_name = keyspace_name;
@@ -104,19 +121,34 @@ class RecordingControlConnectionListener
     events_.push_back(event);
   }
 
-  virtual void on_drop_schema(SchemaType type,
-                              const String& keyspace_name,
+  virtual void on_drop_schema(SchemaType type, const String& keyspace_name,
                               const String& target_name) {
     RecordedEvent event;
     switch (type) {
-      case KEYSPACE: event.type = RecordedEvent::KEYSPACE_DROPPED; break;
-      case TABLE: event.type = RecordedEvent::TABLE_DROPPED; break;
-      case VIEW: event.type = RecordedEvent::VIEW_DROPPED; break;
-      case COLUMN: event.type = RecordedEvent::COLUMN_DROPPED; break;
-      case INDEX: event.type = RecordedEvent::INDEX_DROPPED; break;
-      case USER_TYPE: event.type = RecordedEvent::USER_TYPE_DROPPED; break;
-      case FUNCTION: event.type = RecordedEvent::FUNCTION_DROPPED; break;
-      case AGGREGATE: event.type = RecordedEvent::AGGREGATE_DROPPED; break;
+      case KEYSPACE:
+        event.type = RecordedEvent::KEYSPACE_DROPPED;
+        break;
+      case TABLE:
+        event.type = RecordedEvent::TABLE_DROPPED;
+        break;
+      case VIEW:
+        event.type = RecordedEvent::VIEW_DROPPED;
+        break;
+      case COLUMN:
+        event.type = RecordedEvent::COLUMN_DROPPED;
+        break;
+      case INDEX:
+        event.type = RecordedEvent::INDEX_DROPPED;
+        break;
+      case USER_TYPE:
+        event.type = RecordedEvent::USER_TYPE_DROPPED;
+        break;
+      case FUNCTION:
+        event.type = RecordedEvent::FUNCTION_DROPPED;
+        break;
+      case AGGREGATE:
+        event.type = RecordedEvent::AGGREGATE_DROPPED;
+        break;
     }
     event.keyspace_name = keyspace_name;
     event.target_name = target_name;
@@ -147,7 +179,7 @@ class RecordingControlConnectionListener
     events_.push_back(event);
   }
 
-  virtual void on_close(ControlConnection* connection) { }
+  virtual void on_close(ControlConnection* connection) {}
 
 private:
   RecordedEventVec events_;
@@ -177,34 +209,30 @@ class ControlConnectionUnitTest : public LoopTest {
   struct EventListener : public RecordingControlConnectionListener {
   public:
     EventListener(mockssandra::SimpleCluster* cluster)
-      : remaining_(0)
-      , cluster_(cluster) { }
+        : remaining_(0)
+        , cluster_(cluster) {}
 
-    void add_event(const mockssandra::Event::Ptr& event) {
-      events_.push_back(event);
-    }
+    void add_event(const mockssandra::Event::Ptr& event) { events_.push_back(event); }
 
     void trigger_events(const ControlConnection::Ptr& connection) {
       connection_ = connection;
       remaining_ = events_.size();
       for (Vector<mockssandra::Event::Ptr>::const_iterator it = events_.begin(),
-           end = events_.end(); it != end; ++it) {
+                                                           end = events_.end();
+           it != end; ++it) {
         cluster_->event(*it);
       }
     }
 
-    virtual void on_update_schema(SchemaType type,
-                                  const ResultResponse::Ptr& result,
-                                  const String& keyspace_name,
-                                  const String& target_name) {
-      RecordingControlConnectionListener::on_update_schema(type, result,
-                                                           keyspace_name, target_name);
+    virtual void on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                                  const String& keyspace_name, const String& target_name) {
+      RecordingControlConnectionListener::on_update_schema(type, result, keyspace_name,
+                                                           target_name);
       if (type == COLUMN || type == INDEX) return;
       if (--remaining_ <= 0) connection_->close();
     }
 
-    virtual void on_drop_schema(SchemaType type,
-                                const String& keyspace_name,
+    virtual void on_drop_schema(SchemaType type, const String& keyspace_name,
                                 const String& target_name = "") {
       RecordingControlConnectionListener::on_drop_schema(type, keyspace_name, target_name);
       if (--remaining_ <= 0) connection_->close();
@@ -215,12 +243,12 @@ class ControlConnectionUnitTest : public LoopTest {
       if (--remaining_ <= 0) connection_->close();
     }
 
-    virtual void on_down(const Address& address)  {
+    virtual void on_down(const Address& address) {
       RecordingControlConnectionListener::on_down(address);
       if (--remaining_ <= 0) connection_->close();
     }
 
-    virtual void on_add(const Host::Ptr& host)  {
+    virtual void on_add(const Host::Ptr& host) {
       RecordingControlConnectionListener::on_add(host);
       if (--remaining_ <= 0) connection_->close();
     }
@@ -247,9 +275,9 @@ TEST_F(ControlConnectionUnitTest, Simple) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   bool is_connected = false;
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, &is_connected)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, &is_connected)));
   connector->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
@@ -262,15 +290,14 @@ TEST_F(ControlConnectionUnitTest, Auth) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   bool is_connected = false;
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, &is_connected)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, &is_connected)));
   ControlConnectionSettings settings;
-  settings.connection_settings.auth_provider.reset(new PlainTextAuthProvider("cassandra", "cassandra"));
+  settings.connection_settings.auth_provider.reset(
+      new PlainTextAuthProvider("cassandra", "cassandra"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -284,12 +311,10 @@ TEST_F(ControlConnectionUnitTest, Ssl) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   bool is_connected = false;
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, &is_connected)));
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, &is_connected)));
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -305,9 +330,9 @@ TEST_F(ControlConnectionUnitTest, Close) {
 
   bool is_closed(false);
   for (size_t i = 0; i < 10; ++i) {
-    ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                         PROTOCOL_VERSION,
-                                                         bind_callback(on_connection_close, &is_closed)));
+    ControlConnector::Ptr connector(
+        new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                             bind_callback(on_connection_close, &is_closed)));
     connector->connect(loop());
     connectors.push_back(connector);
   }
@@ -325,9 +350,9 @@ TEST_F(ControlConnectionUnitTest, Cancel) {
 
   ControlConnector::ControlConnectionError error_code(ControlConnector::CONTROL_CONNECTION_OK);
   for (size_t i = 0; i < 10; ++i) {
-    ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                         PROTOCOL_VERSION,
-                                                         bind_callback(on_connection_error_code, &error_code)));
+    ControlConnector::Ptr connector(
+        new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                             bind_callback(on_connection_error_code, &error_code)));
     connector->connect(loop());
     connectors.push_back(connector);
   }
@@ -355,12 +380,10 @@ TEST_F(ControlConnectionUnitTest, StatusChangeEvents) {
   listener.add_event(StatusChangeEvent::up(address));
   listener.add_event(StatusChangeEvent::down(address));
 
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(address)),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_event, &listener)));
-  connector
-      ->with_listener(&listener)
-      ->connect(loop());
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(address)), PROTOCOL_VERSION,
+                           bind_callback(on_connection_event, &listener)));
+  connector->with_listener(&listener)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -387,12 +410,10 @@ TEST_F(ControlConnectionUnitTest, TopologyChangeEvents) {
   listener.add_event(TopologyChangeEvent::new_node(address2));
   listener.add_event(TopologyChangeEvent::removed_node(address2));
 
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(address1)),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_event, &listener)));
-  connector
-      ->with_listener(&listener)
-      ->connect(loop());
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(address1)), PROTOCOL_VERSION,
+                           bind_callback(on_connection_event, &listener)));
+  connector->with_listener(&listener)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -424,8 +445,10 @@ TEST_F(ControlConnectionUnitTest, SchemaChangeEvents) {
   listener.add_event(SchemaChangeEvent::table(SchemaChangeEvent::UPDATED, "keyspace1", "table1"));
   listener.add_event(SchemaChangeEvent::table(SchemaChangeEvent::DROPPED, "keyspace1", "table1"));
 
-  listener.add_event(SchemaChangeEvent::user_type(SchemaChangeEvent::UPDATED, "keyspace1", "type1"));
-  listener.add_event(SchemaChangeEvent::user_type(SchemaChangeEvent::DROPPED, "keyspace1", "type1"));
+  listener.add_event(
+      SchemaChangeEvent::user_type(SchemaChangeEvent::UPDATED, "keyspace1", "type1"));
+  listener.add_event(
+      SchemaChangeEvent::user_type(SchemaChangeEvent::DROPPED, "keyspace1", "type1"));
 
   listener.add_event(SchemaChangeEvent::function(SchemaChangeEvent::UPDATED, "keyspace1",
                                                  "function1", Vector<String>(1, "int")));
@@ -437,12 +460,10 @@ TEST_F(ControlConnectionUnitTest, SchemaChangeEvents) {
   listener.add_event(SchemaChangeEvent::aggregate(SchemaChangeEvent::DROPPED, "keyspace1",
                                                   "aggregate1", Vector<String>(1, "varchar")));
 
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(address)),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_event, &listener)));
-  connector
-      ->with_listener(&listener)
-      ->connect(loop());
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(address)), PROTOCOL_VERSION,
+                           bind_callback(on_connection_event, &listener)));
+  connector->with_listener(&listener)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -520,8 +541,7 @@ TEST_F(ControlConnectionUnitTest, EventDuringStartup) {
   Address address("127.0.0.1", PORT);
 
   mockssandra::SimpleRequestHandlerBuilder builder;
-  builder
-      .on(mockssandra::OPCODE_QUERY)
+  builder.on(mockssandra::OPCODE_QUERY)
       .up_event(address) // Send UP event during startup
       .system_local()
       .system_peers()
@@ -532,12 +552,10 @@ TEST_F(ControlConnectionUnitTest, EventDuringStartup) {
   RecordingControlConnectionListener listener;
 
   bool is_connected;
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(address)),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_connected, &is_connected)));
-  connector
-      ->with_listener(&listener)
-      ->connect(loop());
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(address)), PROTOCOL_VERSION,
+                           bind_callback(on_connection_connected, &is_connected)));
+  connector->with_listener(&listener)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -554,9 +572,10 @@ TEST_F(ControlConnectionUnitTest, InvalidProtocol) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   ControlConnector::ControlConnectionError error_code(ControlConnector::CONTROL_CONNECTION_OK);
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       0x7F, // Invalid protocol version
-                                                       bind_callback(on_connection_error_code, &error_code)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
+                           0x7F, // Invalid protocol version
+                           bind_callback(on_connection_error_code, &error_code)));
   connector->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
@@ -570,16 +589,14 @@ TEST_F(ControlConnectionUnitTest, InvalidAuth) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   ControlConnector::ControlConnectionError error_code(ControlConnector::CONTROL_CONNECTION_OK);
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_error_code, &error_code)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_connection_error_code, &error_code)));
 
   ControlConnectionSettings settings;
   settings.connection_settings.auth_provider.reset(new PlainTextAuthProvider("invalid", "invalid"));
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -593,18 +610,16 @@ TEST_F(ControlConnectionUnitTest, InvalidSsl) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   ControlConnector::ControlConnectionError error_code(ControlConnector::CONTROL_CONNECTION_OK);
-  ControlConnector::Ptr connector(new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                                                       PROTOCOL_VERSION,
-                                                       bind_callback(on_connection_error_code, &error_code)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                           bind_callback(on_connection_error_code, &error_code)));
 
   SslContext::Ptr ssl_context(SslContextFactory::create()); // No trusted cert
 
   ControlConnectionSettings settings;
   settings.connection_settings.socket_settings.ssl_context = ssl_context;
 
-  connector
-      ->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
diff --git a/gtests/src/unit/tests/test_copy_on_write.cpp b/gtests/src/unit/tests/test_copy_on_write.cpp
index 1b183dde9..5c80d6983 100644
--- a/gtests/src/unit/tests/test_copy_on_write.cpp
+++ b/gtests/src/unit/tests/test_copy_on_write.cpp
@@ -22,22 +22,25 @@
 #include "string.hpp"
 #include "vector.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 TEST(CopyOnWriteUnitTest, Simple) {
-  cass::Vector<int>* ptr = new cass::Vector<int>();
-  cass::CopyOnWritePtr<cass::Vector<int> > vec(ptr);
+  Vector<int>* ptr = new Vector<int>();
+  CopyOnWritePtr<Vector<int> > vec(ptr);
 
   // Only a single reference so no copy should be made
-  EXPECT_EQ(static_cast<const cass::CopyOnWritePtr<cass::Vector<int> >&>(vec).operator->(),  ptr);
+  EXPECT_EQ(static_cast<const CopyOnWritePtr<Vector<int> >&>(vec).operator->(), ptr);
   vec->push_back(1);
-  EXPECT_EQ(static_cast<const cass::CopyOnWritePtr<cass::Vector<int> >&>(vec).operator->(),  ptr);
+  EXPECT_EQ(static_cast<const CopyOnWritePtr<Vector<int> >&>(vec).operator->(), ptr);
 
   // Make const reference to object
-  const cass::CopyOnWritePtr<cass::Vector<int> > const_vec(vec);
+  const CopyOnWritePtr<Vector<int> > const_vec(vec);
   EXPECT_EQ((*const_vec)[0], 1);
-  EXPECT_EQ(const_vec.operator->(),  ptr);
+  EXPECT_EQ(const_vec.operator->(), ptr);
 
   // Force copy to be made
   vec->push_back(2);
-  EXPECT_NE(static_cast<const cass::CopyOnWritePtr<cass::Vector<int> >&>(vec).operator->(), ptr);
+  EXPECT_NE(static_cast<const CopyOnWritePtr<Vector<int> >&>(vec).operator->(), ptr);
   EXPECT_EQ(const_vec.operator->(), ptr);
 }
diff --git a/gtests/src/unit/tests/test_cql_type_parser.cpp b/gtests/src/unit/tests/test_cql_type_parser.cpp
index 57bdcdfdb..300eaf976 100644
--- a/gtests/src/unit/tests/test_cql_type_parser.cpp
+++ b/gtests/src/unit/tests/test_cql_type_parser.cpp
@@ -18,111 +18,113 @@
 
 #include "data_type_parser.hpp"
 
+using namespace datastax::internal::core;
+
 TEST(CqlTypeParserUnitTest, Simple) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
-  data_type = cass::DataTypeCqlNameParser::parse("ascii", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("ascii", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_ASCII);
 
-  data_type = cass::DataTypeCqlNameParser::parse("bigint", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("bigint", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_BIGINT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("blob", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("blob", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_BLOB);
 
-  data_type = cass::DataTypeCqlNameParser::parse("boolean", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("boolean", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_BOOLEAN);
 
-  data_type = cass::DataTypeCqlNameParser::parse("counter", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("counter", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_COUNTER);
 
-  data_type = cass::DataTypeCqlNameParser::parse("date", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("date", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_DATE);
 
-  data_type = cass::DataTypeCqlNameParser::parse("decimal", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("decimal", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_DECIMAL);
 
-  data_type = cass::DataTypeCqlNameParser::parse("double", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("double", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_DOUBLE);
 
-  data_type = cass::DataTypeCqlNameParser::parse("float", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("float", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_FLOAT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("inet", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("inet", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_INET);
 
-  data_type = cass::DataTypeCqlNameParser::parse("int", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("int", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_INT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("smallint", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("smallint", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_SMALL_INT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("time", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("time", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TIME);
 
-  data_type = cass::DataTypeCqlNameParser::parse("timestamp", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("timestamp", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TIMESTAMP);
 
-  data_type = cass::DataTypeCqlNameParser::parse("timeuuid", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("timeuuid", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TIMEUUID);
 
-  data_type = cass::DataTypeCqlNameParser::parse("tinyint", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("tinyint", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TINY_INT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("text", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("text", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TEXT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("uuid", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("uuid", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_UUID);
 
-  data_type = cass::DataTypeCqlNameParser::parse("varchar", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("varchar", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_VARCHAR);
 
-  data_type = cass::DataTypeCqlNameParser::parse("varint", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("varint", cache, &keyspace);
   EXPECT_EQ(data_type->value_type(), CASS_VALUE_TYPE_VARINT);
 }
 
 TEST(CqlTypeParserUnitTest, Collections) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
-  data_type = cass::DataTypeCqlNameParser::parse("list<int>", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("list<int>", cache, &keyspace);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
-  cass::CollectionType::ConstPtr list = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr list = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(list->types().size(), 1u);
   EXPECT_EQ(list->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("set<int>", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("set<int>", cache, &keyspace);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_SET);
-  cass::CollectionType::ConstPtr set = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr set = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(set->types().size(), 1u);
   EXPECT_EQ(set->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
 
-  data_type = cass::DataTypeCqlNameParser::parse("map<int, text>", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("map<int, text>", cache, &keyspace);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_MAP);
-  cass::CollectionType::ConstPtr map = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr map = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(map->types().size(), 2u);
   EXPECT_EQ(map->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
   EXPECT_EQ(map->types()[1]->value_type(), CASS_VALUE_TYPE_TEXT);
 }
 
 TEST(CqlTypeParserUnitTest, Tuple) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
-  data_type = cass::DataTypeCqlNameParser::parse("tuple<int, bigint, text>", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("tuple<int, bigint, text>", cache, &keyspace);
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_TUPLE);
-  cass::CollectionType::ConstPtr tuple = static_cast<cass::CollectionType::ConstPtr>(data_type);
+  CollectionType::ConstPtr tuple = static_cast<CollectionType::ConstPtr>(data_type);
   ASSERT_EQ(tuple->types().size(), 3u);
   EXPECT_EQ(tuple->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
   EXPECT_EQ(tuple->types()[1]->value_type(), CASS_VALUE_TYPE_BIGINT);
@@ -130,18 +132,18 @@ TEST(CqlTypeParserUnitTest, Tuple) {
 }
 
 TEST(CqlTypeParserUnitTest, UserDefinedType) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
   EXPECT_TRUE(keyspace.user_types().empty());
 
-  data_type = cass::DataTypeCqlNameParser::parse("type1", cache, &keyspace);
+  data_type = DataTypeCqlNameParser::parse("type1", cache, &keyspace);
 
   ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_UDT);
-  cass::UserType::ConstPtr udt = static_cast<cass::UserType::ConstPtr>(data_type);
+  UserType::ConstPtr udt = static_cast<UserType::ConstPtr>(data_type);
   EXPECT_EQ(udt->type_name(), "type1");
   EXPECT_EQ(udt->keyspace(), "keyspace1");
 
@@ -149,25 +151,25 @@ TEST(CqlTypeParserUnitTest, UserDefinedType) {
 }
 
 TEST(CqlTypeParserUnitTest, Frozen) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
   {
-    data_type = cass::DataTypeCqlNameParser::parse("frozen<list<int>>", cache, &keyspace);
+    data_type = DataTypeCqlNameParser::parse("frozen<list<int>>", cache, &keyspace);
     ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
-    cass::CollectionType::ConstPtr list = static_cast<cass::CollectionType::ConstPtr>(data_type);
+    CollectionType::ConstPtr list = static_cast<CollectionType::ConstPtr>(data_type);
     ASSERT_EQ(list->types().size(), 1u);
     EXPECT_TRUE(list->is_frozen());
     EXPECT_EQ(list->types()[0]->value_type(), CASS_VALUE_TYPE_INT);
   }
 
   {
-    data_type = cass::DataTypeCqlNameParser::parse("list<frozen<list<int>>>", cache, &keyspace);
+    data_type = DataTypeCqlNameParser::parse("list<frozen<list<int>>>", cache, &keyspace);
     ASSERT_EQ(data_type->value_type(), CASS_VALUE_TYPE_LIST);
-    cass::CollectionType::ConstPtr list = static_cast<cass::CollectionType::ConstPtr>(data_type);
+    CollectionType::ConstPtr list = static_cast<CollectionType::ConstPtr>(data_type);
     ASSERT_EQ(list->types().size(), 1u);
     EXPECT_FALSE(list->is_frozen());
 
@@ -177,30 +179,30 @@ TEST(CqlTypeParserUnitTest, Frozen) {
 }
 
 TEST(CqlTypeParserUnitTest, Invalid) {
-  cass::DataType::ConstPtr data_type;
+  DataType::ConstPtr data_type;
 
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::KeyspaceMetadata keyspace("keyspace1");
+  KeyspaceMetadata keyspace("keyspace1");
 
   // Invalid number of parameters
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("list<>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("set<>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("map<>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("tuple<>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("list<>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("set<>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("map<>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("tuple<>", cache, &keyspace));
 
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("list<int, int>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("set<int, int>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("map<int>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("map<int, int, int>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("list<int, int>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("set<int, int>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("map<int>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("map<int, int, int>", cache, &keyspace));
 
   // Invalid brackets
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("list<", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("list>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("<>", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("<", cache, &keyspace));
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse(">", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("list<", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("list>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("<>", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("<", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse(">", cache, &keyspace));
 
   // Empty
-  EXPECT_FALSE(cass::DataTypeCqlNameParser::parse("", cache, &keyspace));
+  EXPECT_FALSE(DataTypeCqlNameParser::parse("", cache, &keyspace));
 }
diff --git a/gtests/src/unit/tests/test_data_type.cpp b/gtests/src/unit/tests/test_data_type.cpp
index 6f3154e9d..fd59437cc 100644
--- a/gtests/src/unit/tests/test_data_type.cpp
+++ b/gtests/src/unit/tests/test_data_type.cpp
@@ -22,18 +22,17 @@
 #include <algorithm>
 #include <ctype.h>
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 class DataTypeWrapper {
 public:
   DataTypeWrapper(CassDataType* data_type)
-    : data_type_(data_type) { }
+      : data_type_(data_type) {}
 
-  ~DataTypeWrapper() {
-    cass_data_type_free(data_type_);
-  }
+  ~DataTypeWrapper() { cass_data_type_free(data_type_); }
 
-  operator CassDataType*() {
-    return data_type_;
-  }
+  operator CassDataType*() { return data_type_; }
 
 private:
   CassDataType* data_type_;
@@ -54,10 +53,10 @@ TEST(DataTypeUnitTest, KeyspaceAndTypeName) {
     size_t name_length;
 
     ASSERT_EQ(cass_data_type_keyspace(data_type, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "keyspace1");
+    EXPECT_EQ(String(name, name_length), "keyspace1");
 
     ASSERT_EQ(cass_data_type_type_name(data_type, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "type_name1");
+    EXPECT_EQ(String(name, name_length), "type_name1");
   }
 
   // Invalid type
@@ -66,21 +65,20 @@ TEST(DataTypeUnitTest, KeyspaceAndTypeName) {
     DataTypeWrapper data_type(cass_data_type_new(CASS_VALUE_TYPE_LIST));
 
     EXPECT_EQ(cass_data_type_set_keyspace(data_type, "keyspace1"),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     EXPECT_EQ(cass_data_type_set_type_name(data_type, "type_name1"),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const char* name;
     size_t name_length;
 
     EXPECT_EQ(cass_data_type_keyspace(data_type, &name, &name_length),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     EXPECT_EQ(cass_data_type_type_name(data_type, &name, &name_length),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
   }
-
 }
 
 TEST(DataTypeUnitTest, ClassName) {
@@ -94,7 +92,7 @@ TEST(DataTypeUnitTest, ClassName) {
     size_t name_length;
 
     ASSERT_EQ(cass_data_type_class_name(data_type, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "class_name1");
+    EXPECT_EQ(String(name, name_length), "class_name1");
   }
 
   // Invalid type
@@ -103,17 +101,16 @@ TEST(DataTypeUnitTest, ClassName) {
     DataTypeWrapper data_type(cass_data_type_new(CASS_VALUE_TYPE_UDT));
 
     EXPECT_EQ(cass_data_type_set_class_name(data_type, "class_name1"),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const char* name;
     size_t name_length;
 
     EXPECT_EQ(cass_data_type_class_name(data_type, &name, &name_length),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
   }
 }
 
-
 TEST(DataTypeUnitTest, FromExisting) {
   // From an existing custom type
   {
@@ -129,7 +126,7 @@ TEST(DataTypeUnitTest, FromExisting) {
     size_t name_length;
 
     ASSERT_EQ(cass_data_type_class_name(data_type_copy, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "class_name1");
+    EXPECT_EQ(String(name, name_length), "class_name1");
   }
 
   // From an existing tuple
@@ -139,7 +136,8 @@ TEST(DataTypeUnitTest, FromExisting) {
     // Tuples support an arbitrary number of parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type_existing, CASS_VALUE_TYPE_TEXT), CASS_OK);
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type_existing, CASS_VALUE_TYPE_INT), CASS_OK);
-    EXPECT_EQ(cass_data_type_add_sub_value_type(data_type_existing, CASS_VALUE_TYPE_BIGINT), CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type(data_type_existing, CASS_VALUE_TYPE_BIGINT),
+              CASS_OK);
 
     // Copy tuple and verify values
     DataTypeWrapper data_type_copy(cass_data_type_new_from_existing(data_type_existing));
@@ -164,9 +162,15 @@ TEST(DataTypeUnitTest, FromExisting) {
   {
     DataTypeWrapper data_type_existing(cass_data_type_new_udt(3));
 
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field1", CASS_VALUE_TYPE_TEXT), CASS_OK);
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field2", CASS_VALUE_TYPE_INT), CASS_OK);
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field3", CASS_VALUE_TYPE_BIGINT), CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field1",
+                                                        CASS_VALUE_TYPE_TEXT),
+              CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field2",
+                                                        CASS_VALUE_TYPE_INT),
+              CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type_existing, "field3",
+                                                        CASS_VALUE_TYPE_BIGINT),
+              CASS_OK);
 
     EXPECT_EQ(cass_data_type_set_keyspace(data_type_existing, "keyspace1"), CASS_OK);
     EXPECT_EQ(cass_data_type_set_type_name(data_type_existing, "type_name1"), CASS_OK);
@@ -193,14 +197,13 @@ TEST(DataTypeUnitTest, FromExisting) {
     size_t name_length;
 
     ASSERT_EQ(cass_data_type_keyspace(data_type_copy, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "keyspace1");
+    EXPECT_EQ(String(name, name_length), "keyspace1");
 
     ASSERT_EQ(cass_data_type_type_name(data_type_copy, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "type_name1");
+    EXPECT_EQ(String(name, name_length), "type_name1");
   }
 }
 
-
 TEST(DataTypeUnitTest, CheckValueType) {
   {
     DataTypeWrapper data_type(cass_data_type_new(CASS_VALUE_TYPE_INT));
@@ -226,16 +229,15 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
 
     // Lists only support a single parameterized type
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type, CASS_VALUE_TYPE_TEXT),
-                      CASS_ERROR_LIB_BAD_PARAMS);
+              CASS_ERROR_LIB_BAD_PARAMS);
 
     // List don't support named parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_INT),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const CassDataType* sub_data_type = cass_data_type_sub_data_type(data_type, 0);
     ASSERT_TRUE(sub_data_type != NULL);
-    EXPECT_EQ(cass_data_type_type(sub_data_type),
-                      CASS_VALUE_TYPE_INT);
+    EXPECT_EQ(cass_data_type_type(sub_data_type), CASS_VALUE_TYPE_INT);
   }
 
   // Set
@@ -245,18 +247,17 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
 
     // Sets only support a single parameterized type
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type, CASS_VALUE_TYPE_TEXT),
-                      CASS_ERROR_LIB_BAD_PARAMS);
+              CASS_ERROR_LIB_BAD_PARAMS);
 
     // Sets don't support named parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_INT),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const CassDataType* sub_data_type = cass_data_type_sub_data_type(data_type, 0);
     ASSERT_TRUE(sub_data_type != NULL);
     EXPECT_EQ(cass_data_type_type(sub_data_type), CASS_VALUE_TYPE_INT);
   }
 
-
   // Map
   {
     DataTypeWrapper data_type(cass_data_type_new(CASS_VALUE_TYPE_MAP));
@@ -265,11 +266,11 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
 
     // Maps only support two parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type, CASS_VALUE_TYPE_BIGINT),
-                      CASS_ERROR_LIB_BAD_PARAMS);
+              CASS_ERROR_LIB_BAD_PARAMS);
 
     // Maps don't support named parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_INT),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const CassDataType* sub_data_type;
 
@@ -293,7 +294,7 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
 
     // Tuples don't support named parameterized types
     EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_INT),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const CassDataType* sub_data_type;
 
@@ -314,20 +315,24 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
 
     // Tuples don't support named fields
     EXPECT_EQ(cass_data_type_sub_type_name(data_type, 0, &name, &name_length),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
   }
 
   // UDT
   {
     DataTypeWrapper data_type(cass_data_type_new(CASS_VALUE_TYPE_UDT));
 
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_TEXT), CASS_OK);
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field2", CASS_VALUE_TYPE_INT), CASS_OK);
-    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field3", CASS_VALUE_TYPE_BIGINT), CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field1", CASS_VALUE_TYPE_TEXT),
+              CASS_OK);
+    EXPECT_EQ(cass_data_type_add_sub_value_type_by_name(data_type, "field2", CASS_VALUE_TYPE_INT),
+              CASS_OK);
+    EXPECT_EQ(
+        cass_data_type_add_sub_value_type_by_name(data_type, "field3", CASS_VALUE_TYPE_BIGINT),
+        CASS_OK);
 
     // UDTs don't support adding fields without a name
     EXPECT_EQ(cass_data_type_add_sub_value_type(data_type, CASS_VALUE_TYPE_TEXT),
-                      CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+              CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
     const CassDataType* sub_data_type;
 
@@ -368,30 +373,30 @@ TEST(DataTypeUnitTest, CheckSubValueType) {
     size_t name_length;
 
     ASSERT_EQ(cass_data_type_sub_type_name(data_type, 0, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "field1");
+    EXPECT_EQ(String(name, name_length), "field1");
 
     ASSERT_EQ(cass_data_type_sub_type_name(data_type, 1, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "field2");
+    EXPECT_EQ(String(name, name_length), "field2");
 
     ASSERT_EQ(cass_data_type_sub_type_name(data_type, 2, &name, &name_length), CASS_OK);
-    EXPECT_EQ(cass::String(name, name_length), "field3");
+    EXPECT_EQ(String(name, name_length), "field3");
   }
 }
 
 TEST(DataTypeUnitTest, CheckValueTypeByClass) {
-#define XX_VALUE_TYPE(name, type, cql, klass)             \
-  EXPECT_TRUE(strlen(klass) == 0 ||                       \
-              cass::ValueTypes::by_class(klass) == name); \
+#define XX_VALUE_TYPE(name, type, cql, klass) \
+  EXPECT_TRUE(strlen(klass) == 0 || ValueTypes::by_class(klass) == name);
 
   CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
 #undef XX_VALUE_TYPE
 }
 
-TEST(DataTypeUnitTest, CheckValueTypeByClassCaseInsensitive) {
-#define XX_VALUE_TYPE(name, type, cql, klass) {                              \
-    cass::String upper(klass);                                                \
-    std::transform(upper.begin(), upper.end(), upper.begin(), toupper);      \
-    EXPECT_TRUE(upper.empty() || cass::ValueTypes::by_class(upper) == name); \
+TEST(DataTypeUnitTest, CheckValueTypeByClassCaseInsensitive){
+#define XX_VALUE_TYPE(name, type, cql, klass)                           \
+  {                                                                     \
+    String upper(klass);                                                \
+    std::transform(upper.begin(), upper.end(), upper.begin(), toupper); \
+    EXPECT_TRUE(upper.empty() || ValueTypes::by_class(upper) == name);  \
   }
 
   CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
@@ -399,19 +404,19 @@ TEST(DataTypeUnitTest, CheckValueTypeByClassCaseInsensitive) {
 }
 
 TEST(DataTypeUnitTest, CheckValueTypesByCql) {
-#define XX_VALUE_TYPE(name, type, cql, klass)         \
-  EXPECT_TRUE(strlen(cql) == 0 ||                     \
-              cass::ValueTypes::by_cql(cql) == name); \
+#define XX_VALUE_TYPE(name, type, cql, klass) \
+  EXPECT_TRUE(strlen(cql) == 0 || ValueTypes::by_cql(cql) == name);
 
   CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
 #undef XX_VALUE_TYPE
 }
 
-TEST(DataTypeUnitTest, CheckValueTypesByCqlCasInsensitive) {
-#define XX_VALUE_TYPE(name, type, cql, klass) {                            \
-    cass::String upper(cql);                                                \
-    std::transform(upper.begin(), upper.end(), upper.begin(), toupper);    \
-    EXPECT_TRUE(upper.empty() || cass::ValueTypes::by_cql(upper) == name); \
+TEST(DataTypeUnitTest, CheckValueTypesByCqlCasInsensitive){
+#define XX_VALUE_TYPE(name, type, cql, klass)                           \
+  {                                                                     \
+    String upper(cql);                                                  \
+    std::transform(upper.begin(), upper.end(), upper.begin(), toupper); \
+    EXPECT_TRUE(upper.empty() || ValueTypes::by_cql(upper) == name);    \
   }
 
   CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
@@ -419,11 +424,11 @@ TEST(DataTypeUnitTest, CheckValueTypesByCqlCasInsensitive) {
 }
 
 TEST(DataTypeUnitTest, SimpleDataTypeCache) {
-  cass::SimpleDataTypeCache cache;
+  SimpleDataTypeCache cache;
 
-  cass::DataType::ConstPtr by_class = cache.by_class("org.apache.cassandra.db.marshal.AsciiType");
-  cass::DataType::ConstPtr by_cql = cache.by_cql("ascii");
-  cass::DataType::ConstPtr by_value_type = cache.by_value_type(CASS_VALUE_TYPE_ASCII);
+  DataType::ConstPtr by_class = cache.by_class("org.apache.cassandra.db.marshal.AsciiType");
+  DataType::ConstPtr by_cql = cache.by_cql("ascii");
+  DataType::ConstPtr by_value_type = cache.by_value_type(CASS_VALUE_TYPE_ASCII);
 
   EXPECT_EQ(by_class->value_type(), CASS_VALUE_TYPE_ASCII);
   EXPECT_EQ(by_cql->value_type(), CASS_VALUE_TYPE_ASCII);
diff --git a/gtests/src/unit/tests/test_date_time.cpp b/gtests/src/unit/tests/test_date_time.cpp
index 5f9f09d7d..8f84c876e 100644
--- a/gtests/src/unit/tests/test_date_time.cpp
+++ b/gtests/src/unit/tests/test_date_time.cpp
@@ -39,12 +39,12 @@ TEST(DateTimeUnitTests, TimeFromEpoch) {
   time_t now = ::time(NULL);
   struct tm* tm = gmtime(&now);
   cass_int64_t actual = cass_time_from_epoch(now);
-  cass_int64_t expected = 1000000000LL * (tm->tm_hour * 3600  + 60 * tm->tm_min + tm->tm_sec);
+  cass_int64_t expected = 1000000000LL * (tm->tm_hour * 3600 + 60 * tm->tm_min + tm->tm_sec);
   EXPECT_EQ(actual, expected);
 }
 
 TEST(DateTimeUnitTests, DateTimeToEpoch) {
-  EXPECT_EQ(cass_date_time_to_epoch(CASS_DATE_EPOCH, 0), 0L); // Epoch
+  EXPECT_EQ(cass_date_time_to_epoch(CASS_DATE_EPOCH, 0), 0L);               // Epoch
   EXPECT_EQ(cass_date_time_to_epoch(CASS_DATE_EPOCH - 1, 0), -24L * 3600L); // Epoch - 1 day
-  EXPECT_EQ(cass_date_time_to_epoch(CASS_DATE_EPOCH + 1, 0), 24L * 3600L); // Epoch + 1 day
+  EXPECT_EQ(cass_date_time_to_epoch(CASS_DATE_EPOCH + 1, 0), 24L * 3600L);  // Epoch + 1 day
 }
diff --git a/gtests/src/unit/tests/test_decoder.cpp b/gtests/src/unit/tests/test_decoder.cpp
index b1048cd0a..33ae4f98f 100644
--- a/gtests/src/unit/tests/test_decoder.cpp
+++ b/gtests/src/unit/tests/test_decoder.cpp
@@ -19,15 +19,19 @@
 #include "decoder.hpp"
 #include "logger.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 // Testing decoder class to expose protected testing methods
-class TestDecoder : public cass::Decoder {
+class TestDecoder : public Decoder {
 public:
   TestDecoder(const char* input, size_t length,
-              cass::ProtocolVersion protocol_version = cass::ProtocolVersion::highest_supported())
-      : cass::Decoder(input, length, protocol_version) { }
+              ProtocolVersion protocol_version = ProtocolVersion::highest_supported())
+      : Decoder(input, length, protocol_version) {}
 
-  inline const char* buffer() const { return cass::Decoder::buffer(); }
-  inline size_t remaining() const { return cass::Decoder::remaining(); }
+  inline const char* buffer() const { return Decoder::buffer(); }
+  inline size_t remaining() const { return Decoder::remaining(); }
 };
 
 class DecoderUnitTest : public testing::Test {
@@ -36,23 +40,21 @@ class DecoderUnitTest : public testing::Test {
     failure_logged_ = false;
     warning_logged_ = false;
     cass_log_set_level(CASS_LOG_WARN);
-    cass::Logger::set_callback(DecoderUnitTest::log, NULL);
+    Logger::set_callback(DecoderUnitTest::log, NULL);
   }
 
   static void log(const CassLogMessage* message, void* data) {
     std::string function = message->function;
-    if (message->severity == CASS_LOG_ERROR &&
-        function.find("Decoder::") != std::string::npos) {
+    if (message->severity == CASS_LOG_ERROR && function.find("Decoder::") != std::string::npos) {
       failure_logged_ = true;
     } else if (message->severity == CASS_LOG_WARN &&
-      function.find("Decoder::") != std::string::npos) {
-        warning_logged_ = true;
+               function.find("Decoder::") != std::string::npos) {
+      warning_logged_ = true;
     }
   }
 
   static bool warning_logged_;
   static bool failure_logged_;
-
 };
 
 bool DecoderUnitTest::failure_logged_ = false;
@@ -173,8 +175,7 @@ TEST_F(DecoderUnitTest, AsInt8) {
 }
 
 TEST_F(DecoderUnitTest, DecodeUInt16) {
-  const char input[4] = { -1, -1,
-                          0, 0 };
+  const char input[4] = { -1, -1, 0, 0 };
   TestDecoder decoder(input, 4);
   uint16_t value = 0;
 
@@ -193,8 +194,7 @@ TEST_F(DecoderUnitTest, DecodeUInt16) {
 }
 
 TEST_F(DecoderUnitTest, DecodeInt16) {
-  const char input[4] = { -128, 0,
-                          127, -1 };
+  const char input[4] = { -128, 0, 127, -1 };
   TestDecoder decoder(input, 4);
   int16_t value = 0;
 
@@ -235,8 +235,7 @@ TEST_F(DecoderUnitTest, AsInt16) {
 }
 
 TEST_F(DecoderUnitTest, DecodeUInt32) {
-  const char input[8] = { -1, -1, -1, -1,
-                          0, 0, 0, 0 };
+  const char input[8] = { -1, -1, -1, -1, 0, 0, 0, 0 };
   TestDecoder decoder(input, 8);
   uint32_t value = 0;
 
@@ -276,8 +275,7 @@ TEST_F(DecoderUnitTest, AsUInt32) {
 }
 
 TEST_F(DecoderUnitTest, DecodeInt32) {
-  const char input[8] = { -128, 0, 0, 0,
-                          127, -1, -1, -1 };
+  const char input[8] = { -128, 0, 0, 0, 127, -1, -1, -1 };
   TestDecoder decoder(input, 8);
   int32_t value = 0;
 
@@ -318,8 +316,7 @@ TEST_F(DecoderUnitTest, AsInt32) {
 }
 
 TEST_F(DecoderUnitTest, DecodeInt64) {
-  const char input[16] = { -128, 0, 0, 0,0, 0, 0, 0,
-                           127, -1, -1, -1, -1, -1, -1, -1 };
+  const char input[16] = { -128, 0, 0, 0, 0, 0, 0, 0, 127, -1, -1, -1, -1, -1, -1, -1 };
   TestDecoder decoder(input, 16);
   int64_t value = 0;
 
@@ -338,7 +335,7 @@ TEST_F(DecoderUnitTest, DecodeInt64) {
 }
 
 TEST_F(DecoderUnitTest, AsInt64) {
-  const char input[8] = { -128, 0, 0, 0,0, 0, 0, 0 };
+  const char input[8] = { -128, 0, 0, 0, 0, 0, 0, 0 };
   TestDecoder decoder(input, 8);
   cass_int64_t value = 0;
 
@@ -360,8 +357,7 @@ TEST_F(DecoderUnitTest, AsInt64) {
 }
 
 TEST_F(DecoderUnitTest, DecodeFloat) {
-  const char input[8] = { 0, -128, 0, 0,
-                          127, 127, -1, -1 };
+  const char input[8] = { 0, -128, 0, 0, 127, 127, -1, -1 };
   TestDecoder decoder(input, 8);
   float value = 0;
 
@@ -402,8 +398,7 @@ TEST_F(DecoderUnitTest, AsFloat) {
 }
 
 TEST_F(DecoderUnitTest, DecodeDouble) {
-  const char input[16] = { 0, 16, 0, 0, 0, 0, 0, 0,
-                           127, -17, -1, -1, -1, -1, -1, -1 };
+  const char input[16] = { 0, 16, 0, 0, 0, 0, 0, 0, 127, -17, -1, -1, -1, -1, -1, -1 };
   TestDecoder decoder(input, 16);
   double value = 0;
 
@@ -445,7 +440,7 @@ TEST_F(DecoderUnitTest, AsDouble) {
 
 TEST_F(DecoderUnitTest, DecodeString) {
   const char input[17] = { 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 5, 67, 47, 67, 43, 43 }; // C/C++
+                           0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 17);
   const char* value = NULL;
   size_t value_size = 0;
@@ -468,9 +463,9 @@ TEST_F(DecoderUnitTest, DecodeString) {
 
 TEST_F(DecoderUnitTest, DecodeStringRef) {
   const char input[17] = { 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 5, 67, 47, 67, 43, 43 }; // C/C++
+                           0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 17);
-  cass::StringRef value;
+  StringRef value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_string(&value));
@@ -490,7 +485,7 @@ TEST_F(DecoderUnitTest, DecodeStringRef) {
 
 TEST_F(DecoderUnitTest, DecodeLongString) {
   const char input[21] = { 0, 0, 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 0, 0, 5, 67, 47, 67, 43, 43 }; // C/C++
+                           0, 0, 0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 21);
   const char* value = NULL;
   size_t value_size = 0;
@@ -513,7 +508,7 @@ TEST_F(DecoderUnitTest, DecodeLongString) {
 
 TEST_F(DecoderUnitTest, DecodeBytes) {
   const char input[21] = { 0, 0, 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 0, 0, 5, 67, 47, 67, 43, 43 }; // C/C++
+                           0, 0, 0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 21);
   const char* value = NULL;
   size_t value_size = 0;
@@ -540,9 +535,9 @@ TEST_F(DecoderUnitTest, DecodeBytes) {
 
 TEST_F(DecoderUnitTest, DecodeBytesRef) {
   const char input[21] = { 0, 0, 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 0, 0, 5, 67, 47, 67, 43, 43 }; // C/C++
+                           0, 0, 0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 21);
-  cass::StringRef value;
+  StringRef value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_bytes(&value));
@@ -565,10 +560,12 @@ TEST_F(DecoderUnitTest, DecodeBytesRef) {
 }
 
 TEST_F(DecoderUnitTest, DecodeInetAddress) {
-  const char input[30] = { 4, 127, 0, 0, 1, 0, 0, 35, 82, // 127.0.0.1:9042
-                           16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 35, 82 }; // [::1]:9042
+  const char input[30] = {
+    4,  127, 0, 0, 1, 0, 0, 35, 82, // 127.0.0.1:9042
+    16, 0,   0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 35, 82
+  }; // [::1]:9042
   TestDecoder decoder(input, 30);
-  cass::Address value;
+  Address value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_inet(&value));
@@ -585,8 +582,8 @@ TEST_F(DecoderUnitTest, DecodeInetAddress) {
 }
 
 TEST_F(DecoderUnitTest, DecodeInetStruct) {
-  const char input[22] = { 4, 127, 0, 0, 1, // 127.0.0.1
-                           16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; // [::1]
+  const char input[22] = { 4,  127, 0, 0, 1,                                       // 127.0.0.1
+                           16, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; // [::1]
   TestDecoder decoder(input, 22);
   CassInet value;
 
@@ -596,14 +593,14 @@ TEST_F(DecoderUnitTest, DecodeInetStruct) {
   ASSERT_EQ(17ul, decoder.remaining());
   for (int i = 0; i < value.address_length; ++i) {
     uint8_t byte = 0;
-    cass::decode_byte(&input[i + 1], byte);
+    decode_byte(&input[i + 1], byte);
     ASSERT_EQ(byte, value.address[i]);
   }
   ASSERT_TRUE(decoder.decode_inet(&value));
   ASSERT_EQ(0ul, decoder.remaining());
   for (int i = 0; i < value.address_length; ++i) {
     uint8_t byte = 0;
-    cass::decode_byte(&input[i + 6], byte);
+    decode_byte(&input[i + 6], byte);
     ASSERT_EQ(byte, value.address[i]);
   }
 
@@ -624,7 +621,7 @@ TEST_F(DecoderUnitTest, AsInetIPv4) {
     ASSERT_EQ(4ul, decoder.remaining());
     for (int j = 0; j < value.address_length; ++j) {
       uint8_t byte = 0;
-      cass::decode_byte(&input[j], byte);
+      decode_byte(&input[j], byte);
       ASSERT_EQ(byte, value.address[j]);
     }
   }
@@ -643,7 +640,7 @@ TEST_F(DecoderUnitTest, AsInetIPv6) {
     ASSERT_EQ(16ul, decoder.remaining());
     for (int j = 0; j < value.address_length; ++j) {
       uint8_t byte = 0;
-      cass::decode_byte(&input[j], byte);
+      decode_byte(&input[j], byte);
       ASSERT_EQ(byte, value.address[j]);
     }
   }
@@ -651,13 +648,12 @@ TEST_F(DecoderUnitTest, AsInetIPv6) {
 }
 
 TEST_F(DecoderUnitTest, DecodeStringMap) {
-  const char input[38] = { 0, 2,
-                           0, 7, 99, 111, 109, 112, 97, 110, 121, // key = company
-                           0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // value = DataStax
-                           0, 8, 108, 97, 110, 103, 117, 97, 103, 101, // key = language
-                           0, 5, 67, 47, 67, 43, 43 }; // value = C/C++
+  const char input[38] = { 0, 2, 0,   7,  99,  111, 109, 112, 97,  110, 121, // key = company
+                           0, 8, 68,  97, 116, 97,  83,  116, 97,  120,      // value = DataStax
+                           0, 8, 108, 97, 110, 103, 117, 97,  103, 101,      // key = language
+                           0, 5, 67,  47, 67,  43,  43 };                    // value = C/C++
   TestDecoder decoder(input, 38);
-  cass::Map<cass::String, cass::String> value;
+  Map<String, String> value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_string_map(value));
@@ -673,11 +669,10 @@ TEST_F(DecoderUnitTest, DecodeStringMap) {
 }
 
 TEST_F(DecoderUnitTest, DecodeStringlistVector) {
-  const char input[19] = { 0, 2,
-                           0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 5, 67, 47, 67, 43, 43 }; // C/C++
+  const char input[19] = { 0, 2, 0,  8,  68, 97, 116, 97, 83, 116, 97, 120, // DataStax
+                           0, 5, 67, 47, 67, 43, 43 };                      // C/C++
   TestDecoder decoder(input, 19);
-  cass::Vector<cass::String> value;
+  Vector<String> value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_stringlist(value));
@@ -693,21 +688,18 @@ TEST_F(DecoderUnitTest, DecodeStringlistVector) {
 }
 
 TEST_F(DecoderUnitTest, DecodeStringlistStringRefVec) {
-  const char input[19] = { 0, 2,
-                           0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 5, 67, 47, 67, 43, 43 }; // C/C++
+  const char input[19] = { 0, 2, 0,  8,  68, 97, 116, 97, 83, 116, 97, 120, // DataStax
+                           0, 5, 67, 47, 67, 43, 43 };                      // C/C++
   TestDecoder decoder(input, 19);
-  cass::StringRefVec value;
+  StringRefVec value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_stringlist(value));
   ASSERT_EQ(&input[19], decoder.buffer());
   ASSERT_EQ(0ul, decoder.remaining());
   ASSERT_EQ(2ul, value.size());
-  ASSERT_STREQ("DataStax",
-               std::string(value[0].data(), value[0].size()).c_str());
-  ASSERT_STREQ("C/C++",
-               std::string(value[1].data(), value[1].size()).c_str());
+  ASSERT_STREQ("DataStax", std::string(value[0].data(), value[0].size()).c_str());
+  ASSERT_STREQ("C/C++", std::string(value[1].data(), value[1].size()).c_str());
 
   // FAIL
   ASSERT_FALSE(decoder.decode_stringlist(value));
@@ -715,11 +707,10 @@ TEST_F(DecoderUnitTest, DecodeStringlistStringRefVec) {
 }
 
 TEST_F(DecoderUnitTest, AsStringlist) {
-  const char input[19] = { 0, 2,
-                           0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 5, 67, 47, 67, 43, 43 }; // C/C++
+  const char input[19] = { 0, 2, 0,  8,  68, 97, 116, 97, 83, 116, 97, 120, // DataStax
+                           0, 5, 67, 47, 67, 43, 43 };                      // C/C++
   TestDecoder decoder(input, 19);
-  cass::StringRefVec value;
+  StringRefVec value;
 
   // SUCCESS
   for (int i = 0; i < 10; ++i) {
@@ -727,10 +718,8 @@ TEST_F(DecoderUnitTest, AsStringlist) {
     ASSERT_EQ(&input[0], decoder.buffer());
     ASSERT_EQ(19ul, decoder.remaining());
     ASSERT_EQ(2ul, value.size());
-    ASSERT_STREQ("DataStax",
-                 std::string(value[0].data(), value[0].size()).c_str());
-    ASSERT_STREQ("C/C++",
-                 std::string(value[1].data(), value[1].size()).c_str());
+    ASSERT_STREQ("DataStax", std::string(value[0].data(), value[0].size()).c_str());
+    ASSERT_STREQ("C/C++", std::string(value[1].data(), value[1].size()).c_str());
   }
 
   // Decode stringlist to finish decoding buffer
@@ -742,39 +731,31 @@ TEST_F(DecoderUnitTest, AsStringlist) {
 }
 
 TEST_F(DecoderUnitTest, DecodeStringMultiMap) {
-  const char input[58] = { 0, 1, 0, 7, 100, 114, 105, 118, 101, 114, 115, // key = drivers
-                           0, 7,
-                           0, 5, 67, 47, 67, 43, 43, // C/C++
-                           0, 2, 67, 35, // C#
-                           0, 4, 74, 97, 118, 97, // Java
-                           0, 7, 78, 111, 100, 101, 46, 106, 115, // Node.js
-                           0, 3, 80, 72, 80, // PHP
-                           0, 6, 80, 121, 116, 104, 111, 110, // Python
-                           0, 4, 82, 117, 98, 121 }; // Ruby
+  const char input[58] = { 0, 1, 0,  7,   100, 114, 105, 118, 101, 114, 115, // key = drivers
+                           0, 7, 0,  5,   67,  47,  67,  43,  43,            // C/C++
+                           0, 2, 67, 35,                                     // C#
+                           0, 4, 74, 97,  118, 97,                           // Java
+                           0, 7, 78, 111, 100, 101, 46,  106, 115,           // Node.js
+                           0, 3, 80, 72,  80,                                // PHP
+                           0, 6, 80, 121, 116, 104, 111, 110,                // Python
+                           0, 4, 82, 117, 98,  121 };                        // Ruby
   TestDecoder decoder(input, 58);
-  cass::Map<cass::String, cass::Vector<cass::String> > value;
+  Map<String, Vector<String> > value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_string_multimap(value));
   ASSERT_EQ(&input[58], decoder.buffer());
   ASSERT_EQ(0ul, decoder.remaining());
   ASSERT_EQ(1ul, value.size());
-  cass::Vector<cass::String> values = value["drivers"];
+  Vector<String> values = value["drivers"];
   ASSERT_EQ(7ul, values.size());
-  ASSERT_STREQ("C/C++",
-               std::string(values[0].data(), values[0].size()).c_str());
-  ASSERT_STREQ("C#",
-               std::string(values[1].data(), values[1].size()).c_str());
-  ASSERT_STREQ("Java",
-               std::string(values[2].data(), values[2].size()).c_str());
-  ASSERT_STREQ("Node.js",
-               std::string(values[3].data(), values[3].size()).c_str());
-  ASSERT_STREQ("PHP",
-               std::string(values[4].data(), values[4].size()).c_str());
-  ASSERT_STREQ("Python",
-               std::string(values[5].data(), values[5].size()).c_str());
-  ASSERT_STREQ("Ruby",
-               std::string(values[6].data(), values[6].size()).c_str());
+  ASSERT_STREQ("C/C++", std::string(values[0].data(), values[0].size()).c_str());
+  ASSERT_STREQ("C#", std::string(values[1].data(), values[1].size()).c_str());
+  ASSERT_STREQ("Java", std::string(values[2].data(), values[2].size()).c_str());
+  ASSERT_STREQ("Node.js", std::string(values[3].data(), values[3].size()).c_str());
+  ASSERT_STREQ("PHP", std::string(values[4].data(), values[4].size()).c_str());
+  ASSERT_STREQ("Python", std::string(values[5].data(), values[5].size()).c_str());
+  ASSERT_STREQ("Ruby", std::string(values[6].data(), values[6].size()).c_str());
 
   // FAIL
   ASSERT_FALSE(decoder.decode_string_multimap(value));
@@ -782,7 +763,7 @@ TEST_F(DecoderUnitTest, DecodeStringMultiMap) {
 }
 
 TEST_F(DecoderUnitTest, DecodeOption) {
-  const char input[14] = { 0, 1, // ASCII
+  const char input[14] = { 0, 1,                                            // ASCII
                            0, 0, 0, 8, 68, 97, 116, 97, 83, 116, 97, 120 }; // Custom = DataStax
   TestDecoder decoder(input, 14);
   uint16_t type;
@@ -806,8 +787,8 @@ TEST_F(DecoderUnitTest, DecodeOption) {
 }
 
 TEST_F(DecoderUnitTest, DecodeUuid) {
-  const char input[32] = { -1, -1, -1, -1, -1, -1, -1, -1,-1, -1, -1, -1, -1, -1, -1, -1,
-                           0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0 };
+  const char input[32] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 };
   TestDecoder decoder(input, 32);
   CassUuid value;
 
@@ -841,7 +822,7 @@ TEST_F(DecoderUnitTest, AsDecimal) {
     ASSERT_EQ(8ul, decoder.remaining());
     for (size_t j = 0; j < value_size; ++j) {
       uint8_t byte = 0;
-      cass::decode_byte(&input[j + sizeof(int32_t)], byte);
+      decode_byte(&input[j + sizeof(int32_t)], byte);
       ASSERT_EQ(byte, value[j]);
     }
   }
@@ -858,7 +839,7 @@ TEST_F(DecoderUnitTest, AsDecimal) {
 }
 
 TEST_F(DecoderUnitTest, AsDuration) {
-  const char input[4] = { 2, 4, 6, -127}; // 1, 2, 3 (zig zag encoding)
+  const char input[4] = { 2, 4, 6, -127 }; // 1, 2, 3 (zig zag encoding)
   TestDecoder decoder(input, 4);
   int32_t months = 0;
   int32_t days = 0;
@@ -886,19 +867,17 @@ TEST_F(DecoderUnitTest, AsDuration) {
 }
 
 TEST_F(DecoderUnitTest, DecodeCustomPayload) {
-  const char input[21] = { 0, 1,
-                           0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
-                           0, 0, 0, 5, 67, 47, 67, 43, 43 }; // C/C++
+  const char input[21] = { 0, 1, 0, 8, 68, 97, 116, 97, 83, 116, 97, 120, // DataStax
+                           0, 0, 0, 5, 67, 47, 67,  43, 43 };             // C/C++
   TestDecoder decoder(input, 21);
-  cass::CustomPayloadVec value;
+  CustomPayloadVec value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_custom_payload(value));
   ASSERT_EQ(0ul, decoder.remaining());
   ASSERT_EQ(1ul, value.size());
   ASSERT_EQ(8ul, value[0].name.size());
-  ASSERT_STREQ("DataStax",
-               std::string(value[0].name.data(), value[0].name.size()).c_str());
+  ASSERT_STREQ("DataStax", std::string(value[0].name.data(), value[0].name.size()).c_str());
   ASSERT_EQ(5ul, value[0].value.size());
   for (int i = 0; i < 5; ++i) {
     ASSERT_EQ(input[i + 16], value[0].value.data()[i]);
@@ -912,7 +891,7 @@ TEST_F(DecoderUnitTest, DecodeCustomPayload) {
 TEST_F(DecoderUnitTest, DecodeFailures) {
   const char input[4] = { 0, 0, 0, 42 };
   TestDecoder decoder(input, 4, 1);
-  cass::FailureVec value;
+  FailureVec value;
   int32_t value_size = 0;
 
   // SUCCESS
@@ -927,13 +906,11 @@ TEST_F(DecoderUnitTest, DecodeFailures) {
 }
 
 TEST_F(DecoderUnitTest, DecodeFailuresWithVector) {
-  const char input[30] = { 0, 0, 0, 2,
-                           4, 127, 0, 0, 1, // 127.0.0.1
-                           0, 1,
-                           16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // [::1] [02]
+  const char input[30] = { 0, 0, 0,  2, 4, 127, 0, 0, 1,                               // 127.0.0.1
+                           0, 1, 16, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // [::1] [02]
                            0, 2 };
   TestDecoder decoder(input, 30, 5);
-  cass::FailureVec value;
+  FailureVec value;
   int32_t value_size = 0;
 
   // SUCCESS
@@ -943,13 +920,13 @@ TEST_F(DecoderUnitTest, DecodeFailuresWithVector) {
   ASSERT_EQ(2, value_size);
   for (int i = 0; i < value[0].endpoint.address_length; ++i) {
     uint8_t byte;
-    cass::decode_byte(&input[i + 5], byte);
+    decode_byte(&input[i + 5], byte);
     ASSERT_EQ(byte, value[0].endpoint.address[i]);
   }
   ASSERT_EQ(1ul, value[0].failurecode);
   for (int i = 0; i < value[1].endpoint.address_length; ++i) {
     uint8_t byte;
-    cass::decode_byte(&input[i + 12], byte);
+    decode_byte(&input[i + 12], byte);
     ASSERT_EQ(byte, value[1].endpoint.address[i]);
   }
   ASSERT_EQ(2ul, value[1].failurecode);
@@ -960,14 +937,15 @@ TEST_F(DecoderUnitTest, DecodeFailuresWithVector) {
 }
 
 TEST_F(DecoderUnitTest, DecodeWriteType) {
-  const char input[67] = { 0, 6, 83, 73, 77, 80, 76, 69, // SIMPLE
-                           0, 5, 66, 65, 84, 67, 72, // BATCH
-                           0, 14, 85, 78, 76, 79, 71, 71, 69, 68, 95, 66, 65, 84, 67, 72, // UNLOGGED_BATCH
-                           0, 7, 67, 79, 85, 78, 84, 69, 82, // COUNTER
-                           0, 9, 66, 65, 84, 67, 72, 95, 76, 79, 71, // BATCH_LOG
-                           0, 3, 67, 65, 83, // CAS
-                           0, 4, 86, 73, 69, 87, // VIEW
-                           0, 3, 67, 68, 67 }; // CDC
+  const char input[67] = { 0,  6,  83, 73, 77, 80, 76, 69, // SIMPLE
+                           0,  5,  66, 65, 84, 67, 72,     // BATCH
+                           0,  14, 85, 78, 76, 79, 71, 71, 69, 68, 95,
+                           66, 65, 84, 67, 72,                         // UNLOGGED_BATCH
+                           0,  7,  67, 79, 85, 78, 84, 69, 82,         // COUNTER
+                           0,  9,  66, 65, 84, 67, 72, 95, 76, 79, 71, // BATCH_LOG
+                           0,  3,  67, 65, 83,                         // CAS
+                           0,  4,  86, 73, 69, 87,                     // VIEW
+                           0,  3,  67, 68, 67 };                       // CDC
   TestDecoder decoder(input, 67);
   CassWriteType value;
 
@@ -1004,23 +982,21 @@ TEST_F(DecoderUnitTest, DecodeWriteType) {
 }
 
 TEST_F(DecoderUnitTest, DecodeWarnings) {
-  const char input[38] = { 0, 2,
-                           0, 16, 87, 97, 114, 110, 105, 110, 103, 32, 78, 117, 109, 98, 101, 114, 32, 49, // Warning Number 1
-                           0, 16, 87, 97, 114, 110, 105, 110, 103, 32, 78, 117, 109, 98, 101, 114, 32, 50 }; // Warning Number 2
+  const char input[38] = { 0,   2,   0,   16,  87,  97,  114, 110, 105, 110,
+                           103, 32,  78,  117, 109, 98,  101, 114, 32,  49, // Warning Number 1
+                           0,   16,  87,  97,  114, 110, 105, 110, 103, 32,
+                           78,  117, 109, 98,  101, 114, 32,  50 }; // Warning Number 2
   TestDecoder decoder(input, 38);
-  cass::WarningVec value;
+  WarningVec value;
 
   // SUCCESS
   ASSERT_TRUE(decoder.decode_warnings(value));
   ASSERT_EQ(0ul, decoder.remaining());
   ASSERT_EQ(2ul, value.size());
-  ASSERT_STREQ("Warning Number 1",
-                std::string(value[0].data(), value[0].size()).c_str());
-  ASSERT_STREQ("Warning Number 2",
-                std::string(value[1].data(), value[1].size()).c_str());
+  ASSERT_STREQ("Warning Number 1", std::string(value[0].data(), value[0].size()).c_str());
+  ASSERT_STREQ("Warning Number 2", std::string(value[1].data(), value[1].size()).c_str());
 
   // FAIL
   ASSERT_FALSE(decoder.decode_warnings(value));
   ASSERT_TRUE(failure_logged_);
 }
-
diff --git a/gtests/src/unit/tests/test_encode.cpp b/gtests/src/unit/tests/test_encode.cpp
index 81c71fea5..1c43a2da5 100644
--- a/gtests/src/unit/tests/test_encode.cpp
+++ b/gtests/src/unit/tests/test_encode.cpp
@@ -20,7 +20,7 @@
 
 #include <time.h>
 
-using namespace cass;
+using namespace datastax::internal::core;
 
 TEST(EncodeDurationUnitTest, Base) {
   CassDuration value(0, 0, 0);
@@ -53,8 +53,7 @@ TEST(EncodeDurationUnitTest, SimpleNegative) {
 }
 
 TEST(EncodeDurationUnitTest, EdgePositive) {
-  CassDuration value(std::numeric_limits<int32_t>::max(),
-                     std::numeric_limits<int32_t>::max(),
+  CassDuration value(std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::max(),
                      std::numeric_limits<int64_t>::max());
   Buffer result = encode(value);
   EXPECT_EQ(19u, result.size());
@@ -91,8 +90,7 @@ TEST(EncodeDurationUnitTest, EdgePositive) {
 }
 
 TEST(EncodeDurationUnitTest, EdgeNegative) {
-  CassDuration value(std::numeric_limits<int32_t>::min(),
-                     std::numeric_limits<int32_t>::min(),
+  CassDuration value(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::min(),
                      std::numeric_limits<int64_t>::min());
   Buffer result = encode(value);
   EXPECT_EQ(19u, result.size());
diff --git a/gtests/src/unit/tests/test_event_loop.cpp b/gtests/src/unit/tests/test_event_loop.cpp
index 94b0d70bf..ffcaf5ede 100644
--- a/gtests/src/unit/tests/test_event_loop.cpp
+++ b/gtests/src/unit/tests/test_event_loop.cpp
@@ -20,56 +20,57 @@
 #include "event_loop.hpp"
 #include "test_utils.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 class EventLoopUnitTest : public testing::Test {
 public:
-  class MarkTaskCompleted : public cass::Task {
+  class MarkTaskCompleted : public Task {
   public:
     MarkTaskCompleted(EventLoopUnitTest* event_loop_unit_test)
-      : event_loop_unit_test_(event_loop_unit_test) { }
-    virtual void run(cass::EventLoop* event_loop) {
-      event_loop_unit_test_->mark_task_completed();
-    }
+        : event_loop_unit_test_(event_loop_unit_test) {}
+    virtual void run(EventLoop* event_loop) { event_loop_unit_test_->mark_task_completed(); }
+
   private:
     EventLoopUnitTest* event_loop_unit_test_;
   };
 
-  class MarkIsRunningOn : public cass::Task {
+  class MarkIsRunningOn : public Task {
   public:
-    MarkIsRunningOn(EventLoopUnitTest* event_loop_unit_test,
-                    cass::EventLoop* event_loop)
-      : event_loop_unit_test_(event_loop_unit_test)
-      , event_loop_(event_loop) { }
-    virtual void run(cass::EventLoop* event_loop) {
+    MarkIsRunningOn(EventLoopUnitTest* event_loop_unit_test, EventLoop* event_loop)
+        : event_loop_unit_test_(event_loop_unit_test)
+        , event_loop_(event_loop) {}
+    virtual void run(EventLoop* event_loop) {
       event_loop_unit_test_->set_is_running_on(event_loop_->is_running_on());
     }
+
   private:
-    EventLoopUnitTest * event_loop_unit_test_;
-    cass::EventLoop* event_loop_;
+    EventLoopUnitTest* event_loop_unit_test_;
+    EventLoop* event_loop_;
   };
 
-  class StartIoTime : public cass::Task {
+  class StartIoTime : public Task {
   public:
-    virtual void run(cass::EventLoop* event_loop) {
-      event_loop->maybe_start_io_time();
-    }
+    virtual void run(EventLoop* event_loop) { event_loop->maybe_start_io_time(); }
   };
 
-  class SetIoTimeElapsed : public cass::Task {
+  class SetIoTimeElapsed : public Task {
   public:
     SetIoTimeElapsed(EventLoopUnitTest* event_loop_unit_test)
-      : event_loop_unit_test_(event_loop_unit_test) { }
-    virtual void run(cass::EventLoop* event_loop) {
+        : event_loop_unit_test_(event_loop_unit_test) {}
+    virtual void run(EventLoop* event_loop) {
       event_loop_unit_test_->set_io_time_elapsed(event_loop->io_time_elapsed());
     }
+
   private:
-    EventLoopUnitTest * event_loop_unit_test_;
+    EventLoopUnitTest* event_loop_unit_test_;
   };
 
 public:
   EventLoopUnitTest()
-    : is_task_completed_(false)
-    , is_running_on_(false)
-    , io_time_elapsed_(0) { }
+      : is_task_completed_(false)
+      , is_running_on_(false)
+      , io_time_elapsed_(0) {}
 
   bool is_task_completed() { return is_task_completed_; }
   bool is_running_on() { return is_running_on_; }
@@ -86,11 +87,11 @@ class EventLoopUnitTest : public testing::Test {
   uint64_t io_time_elapsed_;
 };
 
-class TestEventLoop : public cass::EventLoop {
+class TestEventLoop : public EventLoop {
 public:
   TestEventLoop()
-    : is_on_run_completed_(false)
-    , is_after_run_completed_(false) { }
+      : is_on_run_completed_(false)
+      , is_after_run_completed_(false) {}
 
   bool is_on_run_completed() { return is_on_run_completed_.load(); }
   bool is_after_run_completed() { return is_after_run_completed_; }
@@ -100,12 +101,12 @@ class TestEventLoop : public cass::EventLoop {
   void on_after_run() { is_after_run_completed_ = true; }
 
 private:
-  cass::Atomic<bool> is_on_run_completed_;
+  Atomic<bool> is_on_run_completed_;
   bool is_after_run_completed_;
 };
 
 TEST_F(EventLoopUnitTest, ExecuteTask) {
-  cass::EventLoop event_loop;
+  EventLoop event_loop;
   ASSERT_EQ(0, event_loop.init("EventLoopUnitTest::ExecuteTask"));
   ASSERT_STREQ("EventLoopUnitTest::ExecuteTask", event_loop.name().c_str());
   ASSERT_EQ(0, event_loop.run());
@@ -119,7 +120,7 @@ TEST_F(EventLoopUnitTest, ExecuteTask) {
 }
 
 TEST_F(EventLoopUnitTest, ThreadRunningOn) {
-  cass::EventLoop event_loop;
+  EventLoop event_loop;
   ASSERT_EQ(0, event_loop.init("EventLoopUnitTest::ThreadRunningOn"));
   ASSERT_STREQ("EventLoopUnitTest::ThreadRunningOn", event_loop.name().c_str());
   ASSERT_EQ(0, event_loop.run());
@@ -133,14 +134,14 @@ TEST_F(EventLoopUnitTest, ThreadRunningOn) {
 }
 
 TEST_F(EventLoopUnitTest, ThreadNotRunningOn) {
-  cass::EventLoop event_loop;
+  EventLoop event_loop;
   ASSERT_EQ(0, event_loop.init("EventLoopUnitTest::ThreadNotRunningOn (EventLoop 1)"));
   ASSERT_STREQ("EventLoopUnitTest::ThreadNotRunningOn (EventLoop 1)", event_loop.name().c_str());
   ASSERT_EQ(0, event_loop.run());
 
   ASSERT_FALSE(is_running_on());
 
-  cass::EventLoop event_loop_2;
+  EventLoop event_loop_2;
   ASSERT_EQ(0, event_loop_2.init("EventLoopUnitTest::ThreadNotRunningOn (EventLoop 2)"));
   ASSERT_STREQ("EventLoopUnitTest::ThreadNotRunningOn (EventLoop 2)", event_loop_2.name().c_str());
   ASSERT_EQ(0, event_loop_2.run());
@@ -161,7 +162,8 @@ TEST_F(EventLoopUnitTest, BeforeAndAfterRun) {
   ASSERT_EQ(0, event_loop.init("EventLoopUnitTest::BeforeAndAfterRun"));
   ASSERT_STREQ("EventLoopUnitTest::BeforeAndAfterRun", event_loop.name().c_str());
   ASSERT_EQ(0, event_loop.run());
-  while(!event_loop.is_on_run_completed()) test::Utils::msleep(1); // Poll to wait for thread to be started
+  while (!event_loop.is_on_run_completed())
+    test::Utils::msleep(1); // Poll to wait for thread to be started
   ASSERT_TRUE(event_loop.is_on_run_completed());
   ASSERT_FALSE(event_loop.is_after_run_completed());
 
diff --git a/gtests/src/unit/tests/test_exec_profile.cpp b/gtests/src/unit/tests/test_exec_profile.cpp
index 9d7bcc447..d4b9fdde9 100644
--- a/gtests/src/unit/tests/test_exec_profile.cpp
+++ b/gtests/src/unit/tests/test_exec_profile.cpp
@@ -17,12 +17,13 @@
 
 #include "config.hpp"
 
-bool execution_profile(const cass::Config& config,
-                       const cass::String& name,
-                       cass::ExecutionProfile& profile) {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+bool execution_profile(const Config& config, const String& name, ExecutionProfile& profile) {
   // Handle profile lookup
-  const cass::ExecutionProfile::Map& profiles = config.profiles();
-  cass::ExecutionProfile::Map::const_iterator it = profiles.find(name);
+  const ExecutionProfile::Map& profiles = config.profiles();
+  ExecutionProfile::Map::const_iterator it = profiles.find(name);
   if (it != profiles.end()) {
     profile = it->second;
     return true;
@@ -31,296 +32,273 @@ bool execution_profile(const cass::Config& config,
 }
 
 TEST(ExecutionProfileUnitTest, Consistency) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   ASSERT_EQ(CASS_CONSISTENCY_UNKNOWN, profile.consistency());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(CASS_DEFAULT_CONSISTENCY, profile_lookup.consistency());
-  ASSERT_EQ(CASS_DEFAULT_CONSISTENCY,
-            copy_config.default_profile().consistency());
+  ASSERT_EQ(CASS_DEFAULT_CONSISTENCY, copy_config.default_profile().consistency());
 }
 
 TEST(ExecutionProfileUnitTest, SerialConsistency) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   ASSERT_EQ(CASS_CONSISTENCY_UNKNOWN, profile.serial_consistency());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(CASS_DEFAULT_SERIAL_CONSISTENCY, profile_lookup.serial_consistency());
-  ASSERT_EQ(CASS_DEFAULT_SERIAL_CONSISTENCY,
-            copy_config.default_profile().serial_consistency());
+  ASSERT_EQ(CASS_DEFAULT_SERIAL_CONSISTENCY, copy_config.default_profile().serial_consistency());
 }
 
 TEST(ExecutionProfileUnitTest, RequestTimeout) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   ASSERT_EQ(CASS_UINT64_MAX, profile.request_timeout_ms());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(CASS_DEFAULT_REQUEST_TIMEOUT_MS, profile_lookup.request_timeout_ms());
-  ASSERT_EQ(CASS_DEFAULT_REQUEST_TIMEOUT_MS,
-            copy_config.default_profile().request_timeout_ms());
+  ASSERT_EQ(CASS_DEFAULT_REQUEST_TIMEOUT_MS, copy_config.default_profile().request_timeout_ms());
 }
 
 TEST(ExecutionProfileUnitTest, NullLoadBalancingPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   profile.build_load_balancing_policy();
 
   ASSERT_TRUE(!profile.load_balancing_policy());
 }
 
-//TODO(CPP_404): Remove disabled tests case as the profiles LBPs are initialized
+// TODO(CPP_404): Remove disabled tests case as the profiles LBPs are initialized
 //               by the request processor init method now. The last assertion in
 //               the test is invalid making the whole test invalid.
 TEST(ExecutionProfileUnitTest, DISABLED_ClusterLoadBalancingPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(copy_config.default_profile().load_balancing_policy().get(),
             profile_lookup.load_balancing_policy().get());
 }
 
-//TODO(CPP_404): Remove disabled tests case as the profiles LBPs are initialized
+// TODO(CPP_404): Remove disabled tests case as the profiles LBPs are initialized
 //               by the request processor init method now The last assertion in
 //               the test is invalid making the whole test invalid.
 TEST(ExecutionProfileUnitTest, DISABLED_ClusterLoadBalancingPolicies) {
-  cass::ExecutionProfile profile_1;
-  profile_1.set_load_balancing_policy(new cass::DCAwarePolicy());
-  cass::ExecutionProfile profile_2;
-  cass::ExecutionProfile profile_3;
-  profile_3.set_load_balancing_policy(new cass::RoundRobinPolicy());
+  ExecutionProfile profile_1;
+  profile_1.set_load_balancing_policy(new DCAwarePolicy());
+  ExecutionProfile profile_2;
+  ExecutionProfile profile_3;
+  profile_3.set_load_balancing_policy(new RoundRobinPolicy());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile_1", &profile_1);
   config.set_execution_profile("profile_2", &profile_2);
   config.set_execution_profile("profile_3", &profile_3);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_1_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_1_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_1", profile_1_lookup));
-  cass::ExecutionProfile profile_2_lookup;
+  ExecutionProfile profile_2_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_2", profile_2_lookup));
-  cass::ExecutionProfile profile_3_lookup;
+  ExecutionProfile profile_3_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_3", profile_3_lookup));
-  const cass::LoadBalancingPolicy* profile_1_lbp =
-    profile_1_lookup.load_balancing_policy().get();
-  const cass::LoadBalancingPolicy* profile_2_lbp =
-    profile_2_lookup.load_balancing_policy().get();
-  const cass::LoadBalancingPolicy* profile_3_lbp =
-    profile_3_lookup.load_balancing_policy().get();
+  const LoadBalancingPolicy* profile_1_lbp = profile_1_lookup.load_balancing_policy().get();
+  const LoadBalancingPolicy* profile_2_lbp = profile_2_lookup.load_balancing_policy().get();
+  const LoadBalancingPolicy* profile_3_lbp = profile_3_lookup.load_balancing_policy().get();
   EXPECT_NE(profile_1_lbp, profile_2_lbp);
   EXPECT_NE(profile_2_lbp, profile_3_lbp);
   EXPECT_NE(profile_3_lbp, profile_1_lbp);
-  ASSERT_EQ(copy_config.default_profile().load_balancing_policy().get(),
-            profile_2_lbp);
+  ASSERT_EQ(copy_config.default_profile().load_balancing_policy().get(), profile_2_lbp);
 }
 
 TEST(ExecutionProfileUnitTest, Blacklist) {
-  cass::ExecutionProfile profile;
-  cass::explode(cass::String("0.0.0.0, 0.0.0.2, 0.0.0.4"), profile.blacklist());
+  ExecutionProfile profile;
+  explode(String("0.0.0.0, 0.0.0.2, 0.0.0.4"), profile.blacklist());
   ASSERT_EQ(3u, profile.blacklist().size());
   ASSERT_STREQ("0.0.0.0", profile.blacklist().at(0).c_str());
   ASSERT_STREQ("0.0.0.2", profile.blacklist().at(1).c_str());
   ASSERT_STREQ("0.0.0.4", profile.blacklist().at(2).c_str());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(profile.blacklist().size(), profile_lookup.blacklist().size());
-  ASSERT_STREQ(profile.blacklist().at(0).c_str(),
-               profile_lookup.blacklist().at(0).c_str());
-  ASSERT_STREQ(profile.blacklist().at(1).c_str(),
-               profile_lookup.blacklist().at(1).c_str());
-  ASSERT_STREQ(profile.blacklist().at(2).c_str(),
-               profile_lookup.blacklist().at(2).c_str());
+  ASSERT_STREQ(profile.blacklist().at(0).c_str(), profile_lookup.blacklist().at(0).c_str());
+  ASSERT_STREQ(profile.blacklist().at(1).c_str(), profile_lookup.blacklist().at(1).c_str());
+  ASSERT_STREQ(profile.blacklist().at(2).c_str(), profile_lookup.blacklist().at(2).c_str());
   ASSERT_EQ(0u, copy_config.default_profile().blacklist().size());
 }
 
 TEST(ExecutionProfileUnitTest, BlacklistDC) {
-  cass::ExecutionProfile profile;
-  cass::explode(cass::String("dc1, dc3, dc5"), profile.blacklist_dc());
+  ExecutionProfile profile;
+  explode(String("dc1, dc3, dc5"), profile.blacklist_dc());
   ASSERT_EQ(3u, profile.blacklist_dc().size());
   ASSERT_STREQ("dc1", profile.blacklist_dc().at(0).c_str());
   ASSERT_STREQ("dc3", profile.blacklist_dc().at(1).c_str());
   ASSERT_STREQ("dc5", profile.blacklist_dc().at(2).c_str());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(profile.blacklist_dc().size(), profile_lookup.blacklist_dc().size());
-  ASSERT_STREQ(profile.blacklist_dc().at(0).c_str(),
-               profile_lookup.blacklist_dc().at(0).c_str());
-  ASSERT_STREQ(profile.blacklist_dc().at(1).c_str(),
-               profile_lookup.blacklist_dc().at(1).c_str());
-  ASSERT_STREQ(profile.blacklist_dc().at(2).c_str(),
-               profile_lookup.blacklist_dc().at(2).c_str());
+  ASSERT_STREQ(profile.blacklist_dc().at(0).c_str(), profile_lookup.blacklist_dc().at(0).c_str());
+  ASSERT_STREQ(profile.blacklist_dc().at(1).c_str(), profile_lookup.blacklist_dc().at(1).c_str());
+  ASSERT_STREQ(profile.blacklist_dc().at(2).c_str(), profile_lookup.blacklist_dc().at(2).c_str());
   ASSERT_EQ(0u, copy_config.default_profile().blacklist_dc().size());
 }
 
 TEST(ExecutionProfileUnitTest, Whitelist) {
-  cass::ExecutionProfile profile;
-  cass::explode(cass::String("0.0.0.0, 0.0.0.2, 0.0.0.4"), profile.whitelist());
+  ExecutionProfile profile;
+  explode(String("0.0.0.0, 0.0.0.2, 0.0.0.4"), profile.whitelist());
   ASSERT_EQ(3u, profile.whitelist().size());
   ASSERT_STREQ("0.0.0.0", profile.whitelist().at(0).c_str());
   ASSERT_STREQ("0.0.0.2", profile.whitelist().at(1).c_str());
   ASSERT_STREQ("0.0.0.4", profile.whitelist().at(2).c_str());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(profile.whitelist().size(), profile_lookup.whitelist().size());
-  ASSERT_STREQ(profile.whitelist().at(0).c_str(),
-               profile_lookup.whitelist().at(0).c_str());
-  ASSERT_STREQ(profile.whitelist().at(1).c_str(),
-               profile_lookup.whitelist().at(1).c_str());
-  ASSERT_STREQ(profile.whitelist().at(2).c_str(),
-               profile_lookup.whitelist().at(2).c_str());
+  ASSERT_STREQ(profile.whitelist().at(0).c_str(), profile_lookup.whitelist().at(0).c_str());
+  ASSERT_STREQ(profile.whitelist().at(1).c_str(), profile_lookup.whitelist().at(1).c_str());
+  ASSERT_STREQ(profile.whitelist().at(2).c_str(), profile_lookup.whitelist().at(2).c_str());
   ASSERT_EQ(0u, copy_config.default_profile().whitelist().size());
 }
 
 TEST(ExecutionProfileUnitTest, WhitelistDC) {
-  cass::ExecutionProfile profile;
-  cass::explode(cass::String("dc1, dc3, dc5"), profile.whitelist_dc());
+  ExecutionProfile profile;
+  explode(String("dc1, dc3, dc5"), profile.whitelist_dc());
   ASSERT_EQ(3u, profile.whitelist_dc().size());
   ASSERT_STREQ("dc1", profile.whitelist_dc().at(0).c_str());
   ASSERT_STREQ("dc3", profile.whitelist_dc().at(1).c_str());
   ASSERT_STREQ("dc5", profile.whitelist_dc().at(2).c_str());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(profile.whitelist_dc().size(), profile_lookup.whitelist_dc().size());
-  ASSERT_STREQ(profile.whitelist_dc().at(0).c_str(),
-               profile_lookup.whitelist_dc().at(0).c_str());
-  ASSERT_STREQ(profile.whitelist_dc().at(1).c_str(),
-               profile_lookup.whitelist_dc().at(1).c_str());
-  ASSERT_STREQ(profile.whitelist_dc().at(2).c_str(),
-               profile_lookup.whitelist_dc().at(2).c_str());
+  ASSERT_STREQ(profile.whitelist_dc().at(0).c_str(), profile_lookup.whitelist_dc().at(0).c_str());
+  ASSERT_STREQ(profile.whitelist_dc().at(1).c_str(), profile_lookup.whitelist_dc().at(1).c_str());
+  ASSERT_STREQ(profile.whitelist_dc().at(2).c_str(), profile_lookup.whitelist_dc().at(2).c_str());
   ASSERT_EQ(0u, copy_config.default_profile().whitelist_dc().size());
 }
 
 TEST(ExecutionProfileUnitTest, LatencyAware) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   profile.set_latency_aware_routing(true);
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_FALSE(copy_config.default_profile().latency_aware());
   ASSERT_TRUE(profile_lookup.latency_aware());
 }
 
 TEST(ExecutionProfileUnitTest, TokenAware) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   profile.set_token_aware_routing(false);
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_TRUE(copy_config.default_profile().token_aware_routing());
   ASSERT_FALSE(profile_lookup.token_aware_routing());
 }
 
 TEST(ExecutionProfileUnitTest, NullRetryPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   ASSERT_TRUE(!profile.retry_policy());
 }
 
 TEST(ExecutionProfileUnitTest, ClusterRetryPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_EQ(copy_config.default_profile().retry_policy().get(),
             profile_lookup.retry_policy().get());
 }
 
 TEST(ExecutionProfileUnitTest, ClusterRetryPolicies) {
-  cass::ExecutionProfile profile_1;
-  profile_1.set_retry_policy(new cass::FallthroughRetryPolicy());
-  cass::ExecutionProfile profile_2;
-  cass::ExecutionProfile profile_3;
-  profile_3.set_retry_policy(new cass::DefaultRetryPolicy());
+  ExecutionProfile profile_1;
+  profile_1.set_retry_policy(new FallthroughRetryPolicy());
+  ExecutionProfile profile_2;
+  ExecutionProfile profile_3;
+  profile_3.set_retry_policy(new DefaultRetryPolicy());
 
-  cass::Config config;
+  Config config;
   config.set_execution_profile("profile_1", &profile_1);
   config.set_execution_profile("profile_2", &profile_2);
   config.set_execution_profile("profile_3", &profile_3);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_1_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_1_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_1", profile_1_lookup));
-  cass::ExecutionProfile profile_2_lookup;
+  ExecutionProfile profile_2_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_2", profile_2_lookup));
-  cass::ExecutionProfile profile_3_lookup;
+  ExecutionProfile profile_3_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_3", profile_3_lookup));
-  const cass::RetryPolicy* profile_1_retry_policy =
-    profile_1_lookup.retry_policy().get();
-  const cass::RetryPolicy* profile_2_retry_policy =
-    profile_2_lookup.retry_policy().get();
-  const cass::RetryPolicy* profile_3_retry_policy =
-    profile_3_lookup.retry_policy().get();
+  const RetryPolicy* profile_1_retry_policy = profile_1_lookup.retry_policy().get();
+  const RetryPolicy* profile_2_retry_policy = profile_2_lookup.retry_policy().get();
+  const RetryPolicy* profile_3_retry_policy = profile_3_lookup.retry_policy().get();
   EXPECT_NE(profile_1_retry_policy, profile_2_retry_policy);
   EXPECT_NE(profile_2_retry_policy, profile_3_retry_policy);
   EXPECT_NE(profile_3_retry_policy, profile_1_retry_policy);
-  ASSERT_EQ(copy_config.default_profile().retry_policy().get(),
-            profile_2_retry_policy);
+  ASSERT_EQ(copy_config.default_profile().retry_policy().get(), profile_2_retry_policy);
 }
 
 TEST(ExecutionProfileUnitTest, NullSpeculativeExecutionPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
   ASSERT_TRUE(!profile.speculative_execution_policy());
 }
 
 TEST(ExecutionProfileUnitTest, ClusterSpeculativeExecutionPolicy) {
-  cass::ExecutionProfile profile;
+  ExecutionProfile profile;
 
-  cass::Config config;
-  config.set_speculative_execution_policy(new cass::NoSpeculativeExecutionPolicy());
+  Config config;
+  config.set_speculative_execution_policy(new NoSpeculativeExecutionPolicy());
   config.set_execution_profile("profile", &profile);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile", profile_lookup));
   ASSERT_NE(copy_config.default_profile().speculative_execution_policy().get(),
             profile_lookup.speculative_execution_policy().get());
@@ -329,52 +307,63 @@ TEST(ExecutionProfileUnitTest, ClusterSpeculativeExecutionPolicy) {
 }
 
 TEST(ExecutionProfileUnitTest, ClusterSpeculativeExecutionPolicies) {
-  cass::ExecutionProfile profile_1;
-  profile_1.set_speculative_execution_policy(new cass::ConstantSpeculativeExecutionPolicy(1, 2));
-  cass::ExecutionProfile profile_2;
-  cass::ExecutionProfile profile_3;
-  profile_3.set_speculative_execution_policy(new cass::NoSpeculativeExecutionPolicy());
-
-  cass::Config config;
-  config.set_speculative_execution_policy(new cass::ConstantSpeculativeExecutionPolicy(3, 4));
+  ExecutionProfile profile_1;
+  profile_1.set_speculative_execution_policy(new ConstantSpeculativeExecutionPolicy(1, 2));
+  ExecutionProfile profile_2;
+  ExecutionProfile profile_3;
+  profile_3.set_speculative_execution_policy(new NoSpeculativeExecutionPolicy());
+
+  Config config;
+  config.set_speculative_execution_policy(new ConstantSpeculativeExecutionPolicy(3, 4));
   config.set_execution_profile("profile_1", &profile_1);
   config.set_execution_profile("profile_2", &profile_2);
   config.set_execution_profile("profile_3", &profile_3);
 
-  cass::Config copy_config = config.new_instance();
-  cass::ExecutionProfile profile_1_lookup;
+  Config copy_config = config.new_instance();
+  ExecutionProfile profile_1_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_1", profile_1_lookup));
-  cass::ExecutionProfile profile_2_lookup;
+  ExecutionProfile profile_2_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_2", profile_2_lookup));
-  cass::ExecutionProfile profile_3_lookup;
+  ExecutionProfile profile_3_lookup;
   ASSERT_TRUE(execution_profile(copy_config, "profile_3", profile_3_lookup));
-  const cass::SpeculativeExecutionPolicy* profile_1_speculative_execution_policy =
-    profile_1_lookup.speculative_execution_policy().get();
-  const cass::SpeculativeExecutionPolicy* profile_2_speculative_execution_policy =
-    profile_2_lookup.speculative_execution_policy().get();
-  const cass::SpeculativeExecutionPolicy* profile_3_speculative_execution_policy =
-    profile_3_lookup.speculative_execution_policy().get();
-  const cass::SpeculativeExecutionPolicy* config_speculative_execution_policy =
-    copy_config.default_profile().speculative_execution_policy().get();
-  EXPECT_NE(profile_1_speculative_execution_policy,
-            profile_2_speculative_execution_policy);
-  EXPECT_NE(profile_2_speculative_execution_policy,
-            profile_3_speculative_execution_policy);
-  EXPECT_NE(profile_3_speculative_execution_policy,
-            profile_1_speculative_execution_policy);
-  ASSERT_NE(config_speculative_execution_policy,
-            profile_2_speculative_execution_policy);
+  const SpeculativeExecutionPolicy* profile_1_speculative_execution_policy =
+      profile_1_lookup.speculative_execution_policy().get();
+  const SpeculativeExecutionPolicy* profile_2_speculative_execution_policy =
+      profile_2_lookup.speculative_execution_policy().get();
+  const SpeculativeExecutionPolicy* profile_3_speculative_execution_policy =
+      profile_3_lookup.speculative_execution_policy().get();
+  const SpeculativeExecutionPolicy* config_speculative_execution_policy =
+      copy_config.default_profile().speculative_execution_policy().get();
+  EXPECT_NE(profile_1_speculative_execution_policy, profile_2_speculative_execution_policy);
+  EXPECT_NE(profile_2_speculative_execution_policy, profile_3_speculative_execution_policy);
+  EXPECT_NE(profile_3_speculative_execution_policy, profile_1_speculative_execution_policy);
+  ASSERT_NE(config_speculative_execution_policy, profile_2_speculative_execution_policy);
   ASSERT_EQ(typeid(config_speculative_execution_policy),
             typeid(profile_2_speculative_execution_policy));
   ASSERT_EQ(typeid(config_speculative_execution_policy),
             typeid(profile_1_speculative_execution_policy));
-  ASSERT_EQ(dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)->constant_delay_ms_,
-            dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(profile_2_speculative_execution_policy)->constant_delay_ms_);
-  ASSERT_EQ(dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)->max_speculative_executions_,
-            dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(profile_2_speculative_execution_policy)->max_speculative_executions_);
-  ASSERT_NE(dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)->constant_delay_ms_,
-            dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(profile_1_speculative_execution_policy)->constant_delay_ms_);
-  ASSERT_NE(dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)->max_speculative_executions_,
-            dynamic_cast<const cass::ConstantSpeculativeExecutionPolicy*>(profile_1_speculative_execution_policy)->max_speculative_executions_);
+  ASSERT_EQ(
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)
+          ->constant_delay_ms_,
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(
+          profile_2_speculative_execution_policy)
+          ->constant_delay_ms_);
+  ASSERT_EQ(
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)
+          ->max_speculative_executions_,
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(
+          profile_2_speculative_execution_policy)
+          ->max_speculative_executions_);
+  ASSERT_NE(
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)
+          ->constant_delay_ms_,
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(
+          profile_1_speculative_execution_policy)
+          ->constant_delay_ms_);
+  ASSERT_NE(
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(config_speculative_execution_policy)
+          ->max_speculative_executions_,
+      dynamic_cast<const ConstantSpeculativeExecutionPolicy*>(
+          profile_1_speculative_execution_policy)
+          ->max_speculative_executions_);
 }
-
diff --git a/gtests/src/unit/tests/test_future.cpp b/gtests/src/unit/tests/test_future.cpp
index 21e1fb563..37a20cae8 100644
--- a/gtests/src/unit/tests/test_future.cpp
+++ b/gtests/src/unit/tests/test_future.cpp
@@ -23,8 +23,10 @@
 
 #define DELAY_MS 500 // 500 milliseconds
 
+using datastax::internal::core::Future;
+
 void on_timeout_set_future(uv_timer_t* handle) {
-  cass::Future* future = static_cast<cass::Future*>(handle->data);
+  Future* future = static_cast<Future*>(handle->data);
   future->set();
   uv_close(reinterpret_cast<uv_handle_t*>(handle), NULL);
 }
@@ -35,30 +37,30 @@ void on_future_callback(CassFuture* future, void* data) {
 }
 
 void start_timer(void* arg) {
-  cass::Future* future = static_cast<cass::Future*>(arg);
+  Future* future = static_cast<Future*>(arg);
   test::Utils::msleep(DELAY_MS);
   future->set();
 }
 
 TEST(FutureUnitTest, Types) {
-  cass::Future generic(cass::Future::FUTURE_TYPE_GENERIC);
-  cass::Future session(cass::Future::FUTURE_TYPE_SESSION);
-  cass::Future response(cass::Future::FUTURE_TYPE_RESPONSE);
+  Future generic(Future::FUTURE_TYPE_GENERIC);
+  Future session(Future::FUTURE_TYPE_SESSION);
+  Future response(Future::FUTURE_TYPE_RESPONSE);
 
-  ASSERT_EQ(cass::Future::FUTURE_TYPE_GENERIC, generic.type());
-  ASSERT_EQ(cass::Future::FUTURE_TYPE_SESSION, session.type());
-  ASSERT_EQ(cass::Future::FUTURE_TYPE_RESPONSE, response.type());
+  ASSERT_EQ(Future::FUTURE_TYPE_GENERIC, generic.type());
+  ASSERT_EQ(Future::FUTURE_TYPE_SESSION, session.type());
+  ASSERT_EQ(Future::FUTURE_TYPE_RESPONSE, response.type());
 }
 
 TEST(FutureUnitTest, Ready) {
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   ASSERT_FALSE(future.ready());
   future.set();
   ASSERT_TRUE(future.ready());
 }
 
 TEST(FutureUnitTest, Wait) {
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   uv_thread_t thread;
   ASSERT_EQ(0, uv_thread_create(&thread, start_timer, &future));
 
@@ -69,7 +71,7 @@ TEST(FutureUnitTest, Wait) {
 }
 
 TEST(FutureUnitTest, WaitFor) {
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   uv_thread_t thread;
   ASSERT_EQ(0, uv_thread_create(&thread, start_timer, &future));
 
@@ -85,7 +87,7 @@ TEST(FutureUnitTest, WaitFor) {
 }
 
 TEST(FutureUnitTest, Error) {
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   future.set_error(CASS_ERROR_LIB_BAD_PARAMS, "FutureUnitTest error message");
   ASSERT_TRUE(future.ready());
   ASSERT_TRUE(future.error());
@@ -95,7 +97,7 @@ TEST(FutureUnitTest, Error) {
 
 TEST(FutureUnitTest, Callback) {
   bool is_future_callback_called = false;
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   ASSERT_TRUE(future.set_callback(&on_future_callback, &is_future_callback_called));
 
   ASSERT_FALSE(is_future_callback_called);
@@ -105,14 +107,14 @@ TEST(FutureUnitTest, Callback) {
 }
 
 TEST(FutureUnitTest, CallbackAlreadyAssigned) {
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
   ASSERT_TRUE(future.set_callback(&on_future_callback, NULL));
   ASSERT_FALSE(future.set_callback(&on_future_callback, NULL));
 }
 
 TEST(FutureUnitTest, CallbackAfterFutureIsSet) {
   bool is_future_callback_called = false;
-  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
+  Future future(Future::FUTURE_TYPE_GENERIC);
 
   ASSERT_FALSE(is_future_callback_called);
   future.set();
diff --git a/gtests/src/unit/tests/test_get_time.cpp b/gtests/src/unit/tests/test_get_time.cpp
index d1830d7d7..e68d9de53 100644
--- a/gtests/src/unit/tests/test_get_time.cpp
+++ b/gtests/src/unit/tests/test_get_time.cpp
@@ -16,23 +16,25 @@
 
 #include <gtest/gtest.h>
 
-#include "test_utils.hpp"
 #include "get_time.hpp"
+#include "test_utils.hpp"
+
+using datastax::internal::get_time_monotonic_ns;
 
 TEST(GetTimeUnitTest, Monotonic) {
-  uint64_t prev = cass::get_time_monotonic_ns();
+  uint64_t prev = get_time_monotonic_ns();
   for (int i = 0; i < 100; ++i) {
-    uint64_t current = cass::get_time_monotonic_ns();
+    uint64_t current = get_time_monotonic_ns();
     EXPECT_GE(current, prev);
     prev = current;
   }
 }
 
 TEST(GetTimeUnitTest, MonotonicDuration) {
-  uint64_t start = cass::get_time_monotonic_ns();
+  uint64_t start = get_time_monotonic_ns();
 
   test::Utils::msleep(1000); // 1 second
-  uint64_t elapsed = cass::get_time_monotonic_ns() - start;
+  uint64_t elapsed = get_time_monotonic_ns() - start;
   EXPECT_GE(elapsed, static_cast<double>(NANOSECONDS_PER_SECOND));
   EXPECT_LE(elapsed, static_cast<double>(2 * NANOSECONDS_PER_SECOND));
 }
diff --git a/gtests/src/unit/tests/test_hash_table.cpp b/gtests/src/unit/tests/test_hash_table.cpp
index 95fed87a0..85deda887 100644
--- a/gtests/src/unit/tests/test_hash_table.cpp
+++ b/gtests/src/unit/tests/test_hash_table.cpp
@@ -18,20 +18,23 @@
 
 #include "hash_table.hpp"
 
-struct TestEntry : cass::HashTableEntry<TestEntry> {
-  TestEntry(const cass::String& name)
-    : name(name) { }
-  cass::String name;
+using namespace datastax;
+using namespace datastax::internal::core;
+
+struct TestEntry : HashTableEntry<TestEntry> {
+  TestEntry(const String& name)
+      : name(name) {}
+  String name;
 };
 
 TEST(HashTableUnitTests, Simple) {
-  cass::CaseInsensitiveHashTable<TestEntry> ht(4);
+  CaseInsensitiveHashTable<TestEntry> ht(4);
   ht.add(TestEntry("abc"));
   ht.add(TestEntry("def"));
   ht.add(TestEntry("123"));
   ht.add(TestEntry("456"));
 
-  cass::IndexVec indices;
+  IndexVec indices;
 
   EXPECT_GT(ht.get_indices("abc", &indices), 0u);
   EXPECT_EQ(indices[0], 0u);
@@ -49,12 +52,12 @@ TEST(HashTableUnitTests, Simple) {
 }
 
 TEST(HashTableUnitTests, CaseSensitivity) {
-  cass::CaseInsensitiveHashTable<TestEntry> ht(4);
+  CaseInsensitiveHashTable<TestEntry> ht(4);
   ht.add(TestEntry("abc"));
   ht.add(TestEntry("def"));
   ht.add(TestEntry("DEF"));
 
-  cass::IndexVec indices;
+  IndexVec indices;
 
   EXPECT_GT(ht.get_indices("aBc", &indices), 0u);
   EXPECT_EQ(indices[0], 0u);
@@ -77,15 +80,15 @@ TEST(HashTableUnitTests, CaseSensitivity) {
 }
 
 TEST(HashTableUnitTests, Resize) {
-  cass::CaseInsensitiveHashTable<TestEntry> ht(0);
+  CaseInsensitiveHashTable<TestEntry> ht(0);
 
   for (int i = 0; i < 26; ++i) {
-    cass::String s;
+    String s;
     s.push_back('a' + i);
     ht.add(TestEntry(s));
   }
 
-  cass::IndexVec indices;
+  IndexVec indices;
 
   EXPECT_GT(ht.get_indices("a", &indices), 0u);
   EXPECT_EQ(indices[0], 0u);
diff --git a/gtests/src/unit/tests/test_inet.cpp b/gtests/src/unit/tests/test_inet.cpp
index d2bf0f385..06cbe84d3 100644
--- a/gtests/src/unit/tests/test_inet.cpp
+++ b/gtests/src/unit/tests/test_inet.cpp
@@ -28,7 +28,6 @@ TEST(InetUnitTest, IPv4) {
   cass_inet_string(inet, output);
   EXPECT_EQ(strcmp(ip_address, output), 0);
 
-
   // Inavlid address
   EXPECT_EQ(cass_inet_from_string("<invalid>", &inet), CASS_ERROR_LIB_BAD_PARAMS);
   EXPECT_EQ(cass_inet_from_string("127.0.0.", &inet), CASS_ERROR_LIB_BAD_PARAMS);
@@ -60,7 +59,8 @@ TEST(InetUnitTest, Length) {
   EXPECT_EQ(strcmp(ip_address, output), 0);
 
   const char* max_ip_address = "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255";
-  const char* max_ip_address_v6 = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"; // Last octets converted to hex
+  const char* max_ip_address_v6 =
+      "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"; // Last octets converted to hex
 
   EXPECT_EQ(cass_inet_from_string_n(max_ip_address, strlen(max_ip_address), &inet), CASS_OK);
 
diff --git a/gtests/src/unit/tests/test_load_balancing.cpp b/gtests/src/unit/tests/test_load_balancing.cpp
index aed8fbece..31fdf2f75 100644
--- a/gtests/src/unit/tests/test_load_balancing.cpp
+++ b/gtests/src/unit/tests/test_load_balancing.cpp
@@ -17,8 +17,11 @@
 #include <gtest/gtest.h>
 
 #include "address.hpp"
+#include "blacklist_dc_policy.hpp"
+#include "blacklist_policy.hpp"
 #include "constants.hpp"
 #include "dc_aware_policy.hpp"
+#include "event_loop.hpp"
 #include "latency_aware_policy.hpp"
 #include "murmur3.hpp"
 #include "query_request.hpp"
@@ -27,69 +30,63 @@
 #include "scoped_ptr.hpp"
 #include "string.hpp"
 #include "token_aware_policy.hpp"
-#include "event_loop.hpp"
-#include "whitelist_policy.hpp"
-#include "blacklist_policy.hpp"
 #include "whitelist_dc_policy.hpp"
-#include "blacklist_dc_policy.hpp"
+#include "whitelist_policy.hpp"
 
 #include "test_token_map_utils.hpp"
 #include "test_utils.hpp"
 
 #include <uv.h>
 
-const cass::String LOCAL_DC = "local";
-const cass::String REMOTE_DC = "remote";
-const cass::String BACKUP_DC = "backup";
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+const String LOCAL_DC = "local";
+const String REMOTE_DC = "remote";
+const String BACKUP_DC = "backup";
 
-#define VECTOR_FROM(t, a) cass::Vector<t>(a, a + sizeof(a)/sizeof(a[0]))
+#define VECTOR_FROM(t, a) Vector<t>(a, a + sizeof(a) / sizeof(a[0]))
 
-cass::Address addr_for_sequence(size_t i) {
+Address addr_for_sequence(size_t i) {
   char temp[64];
-  sprintf(temp, "%d.%d.%d.%d",
-          static_cast<int>(i & 0xFF),
-          static_cast<int>((i >> 8) & 0xFF),
-          static_cast<int>((i >> 16) & 0xFF),
-          static_cast<int>((i >> 24) & 0xFF));
-  return cass::Address(temp, 9042);
+  sprintf(temp, "%d.%d.%d.%d", static_cast<int>(i & 0xFF), static_cast<int>((i >> 8) & 0xFF),
+          static_cast<int>((i >> 16) & 0xFF), static_cast<int>((i >> 24) & 0xFF));
+  return Address(temp, 9042);
 }
 
-cass::SharedRefPtr<cass::Host> host_for_addr(const cass::Address addr,
-                                             const cass::String& rack = "rack",
-                                             const cass::String& dc = "dc") {
-  cass::SharedRefPtr<cass::Host>host(new cass::Host(addr));
+SharedRefPtr<Host> host_for_addr(const Address addr, const String& rack = "rack",
+                                 const String& dc = "dc") {
+  SharedRefPtr<Host> host(new Host(addr));
   host->set_rack_and_dc(rack, dc);
   return host;
 }
 
-void populate_hosts(size_t count, const cass::String& rack,
-                    const cass::String& dc, cass::HostMap* hosts) {
-  cass::Address addr;
+void populate_hosts(size_t count, const String& rack, const String& dc, HostMap* hosts) {
+  Address addr;
   size_t first = hosts->size() + 1;
-  for (size_t i = first; i < first+count; ++i) {
+  for (size_t i = first; i < first + count; ++i) {
     addr = addr_for_sequence(i);
     (*hosts)[addr] = host_for_addr(addr, rack, dc);
   }
 }
 
-void verify_sequence(cass::QueryPlan* qp, const cass::Vector<size_t>& sequence) {
-  cass::Address received;
-  for (cass::Vector<size_t>::const_iterator it = sequence.begin();
-       it!= sequence.end();
-       ++it) {
+void verify_sequence(QueryPlan* qp, const Vector<size_t>& sequence) {
+  Address received;
+  for (Vector<size_t>::const_iterator it = sequence.begin(); it != sequence.end(); ++it) {
     ASSERT_TRUE(qp->compute_next(&received));
     EXPECT_EQ(addr_for_sequence(*it), received);
   }
   EXPECT_FALSE(qp->compute_next(&received));
 }
 
-typedef cass::Map<cass::Address, int> QueryCounts;
+typedef Map<Address, int> QueryCounts;
 
-QueryCounts run_policy(cass::LoadBalancingPolicy& policy, int count) {
+QueryCounts run_policy(LoadBalancingPolicy& policy, int count) {
   QueryCounts counts;
   for (int i = 0; i < 12; ++i) {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-    cass::Host::Ptr host(qp->compute_next());
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+    Host::Ptr host(qp->compute_next());
     if (host) {
       counts[host->address()] += 1;
     }
@@ -97,32 +94,28 @@ QueryCounts run_policy(cass::LoadBalancingPolicy& policy, int count) {
   return counts;
 }
 
-void verify_dcs(const QueryCounts& counts,
-                const cass::HostMap& hosts,
-                const cass::String& expected_dc) {
-  for (QueryCounts::const_iterator it = counts.begin(),
-       end = counts.end(); it != end; ++it) {
-    cass::HostMap::const_iterator host_it = hosts.find(it->first);
+void verify_dcs(const QueryCounts& counts, const HostMap& hosts, const String& expected_dc) {
+  for (QueryCounts::const_iterator it = counts.begin(), end = counts.end(); it != end; ++it) {
+    HostMap::const_iterator host_it = hosts.find(it->first);
     ASSERT_NE(host_it, hosts.end());
     EXPECT_EQ(expected_dc, host_it->second->dc());
   }
 }
 
 void verify_query_counts(const QueryCounts& counts, int expected_count) {
-  for (QueryCounts::const_iterator it = counts.begin(),
-       end = counts.end(); it != end; ++it) {
+  for (QueryCounts::const_iterator it = counts.begin(), end = counts.end(); it != end; ++it) {
     EXPECT_EQ(expected_count, it->second);
   }
 }
 
-struct RunPeriodicTask : public cass::EventLoop {
-  RunPeriodicTask(cass::LatencyAwarePolicy* policy)
-    : policy(policy) {
+struct RunPeriodicTask : public EventLoop {
+  RunPeriodicTask(LatencyAwarePolicy* policy)
+      : policy(policy) {
     async.data = this;
   }
 
   int init() {
-    int rc = cass::EventLoop::init();
+    int rc = EventLoop::init();
     if (rc != 0) return rc;
     rc = uv_async_init(loop(), &async, on_async);
     if (rc != 0) return rc;
@@ -130,11 +123,9 @@ struct RunPeriodicTask : public cass::EventLoop {
     return rc;
   }
 
-  void done() {
-    uv_async_send(&async);
-  }
+  void done() { uv_async_send(&async); }
 
-  static void on_async(uv_async_t *handle) {
+  static void on_async(uv_async_t* handle) {
     RunPeriodicTask* task = static_cast<RunPeriodicTask*>(handle->data);
     task->close_handles();
     task->policy->close_handles();
@@ -142,20 +133,19 @@ struct RunPeriodicTask : public cass::EventLoop {
   }
 
   uv_async_t async;
-  cass::LatencyAwarePolicy* policy;
+  LatencyAwarePolicy* policy;
 };
 
 // Latency-aware utility functions
 
 // Don't make "time_between_ns" too high because it spin waits
-uint64_t calculate_moving_average(uint64_t first_latency_ns,
-                                  uint64_t second_latency_ns,
+uint64_t calculate_moving_average(uint64_t first_latency_ns, uint64_t second_latency_ns,
                                   uint64_t time_between_ns) {
   const uint64_t scale = 100LL;
   const uint64_t min_measured = 15LL;
   const uint64_t threshold_to_account = (30LL * min_measured) / 100LL;
 
-  cass::Host host(cass::Address("0.0.0.0", 9042));
+  Host host(Address("0.0.0.0", 9042));
   host.enable_latency_tracking(scale, min_measured);
 
   for (uint64_t i = 0; i < threshold_to_account; ++i) {
@@ -166,146 +156,148 @@ uint64_t calculate_moving_average(uint64_t first_latency_ns,
 
   // Spin wait
   uint64_t start = uv_hrtime();
-  while (uv_hrtime() - start < time_between_ns) {}
+  while (uv_hrtime() - start < time_between_ns) {
+  }
 
   host.update_latency(second_latency_ns);
-  cass::TimestampedAverage current = host.get_current_average();
+  TimestampedAverage current = host.get_current_average();
   return current.average;
 }
 
 void test_dc_aware_policy(size_t local_count, size_t remote_count) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(local_count, "rack", LOCAL_DC, &hosts);
   populate_hosts(remote_count, "rack", REMOTE_DC, &hosts);
-  cass::DCAwarePolicy policy(LOCAL_DC, remote_count, false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  DCAwarePolicy policy(LOCAL_DC, remote_count, false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   const size_t total_hosts = local_count + remote_count;
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-  cass::Vector<size_t> seq(total_hosts);
-  for (size_t i = 0; i < total_hosts; ++i) seq[i] = i + 1;
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  Vector<size_t> seq(total_hosts);
+  for (size_t i = 0; i < total_hosts; ++i)
+    seq[i] = i + 1;
   verify_sequence(qp.get(), seq);
 }
 
 TEST(RoundRobinLoadBalancingUnitTest, Simple) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(2, "rack", "dc", &hosts);
 
-  cass::RoundRobinPolicy policy;
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  RoundRobinPolicy policy;
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   // start on first elem
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-  const size_t seq1[] = {1, 2};
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  const size_t seq1[] = { 1, 2 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
 
   // rotate starting element
-  cass::ScopedPtr<cass::QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
-  const size_t seq2[] = {2, 1};
+  ScopedPtr<QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
+  const size_t seq2[] = { 2, 1 };
   verify_sequence(qp2.get(), VECTOR_FROM(size_t, seq2));
 
   // back around
-  cass::ScopedPtr<cass::QueryPlan> qp3(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp3(policy.new_query_plan("ks", NULL, NULL));
   verify_sequence(qp3.get(), VECTOR_FROM(size_t, seq1));
 }
 
 TEST(RoundRobinLoadBalancingUnitTest, OnAdd) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(2, "rack", "dc", &hosts);
 
-  cass::RoundRobinPolicy policy;
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  RoundRobinPolicy policy;
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   // baseline
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-  const size_t seq1[] = {1, 2};
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  const size_t seq1[] = { 1, 2 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
 
   const size_t seq_new = 5;
-  cass::Address addr_new = addr_for_sequence(seq_new);
-  cass::SharedRefPtr<cass::Host> host = host_for_addr(addr_new);
+  Address addr_new = addr_for_sequence(seq_new);
+  SharedRefPtr<Host> host = host_for_addr(addr_new);
   policy.on_host_added(host);
   policy.on_host_up(host);
 
-  cass::ScopedPtr<cass::QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
-  const size_t seq2[] = {2, seq_new, 1};
+  ScopedPtr<QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
+  const size_t seq2[] = { 2, seq_new, 1 };
   verify_sequence(qp2.get(), VECTOR_FROM(size_t, seq2));
 }
 
 TEST(RoundRobinLoadBalancingUnitTest, OnRemove) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", "dc", &hosts);
 
-  cass::RoundRobinPolicy policy;
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  RoundRobinPolicy policy;
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-  cass::SharedRefPtr<cass::Host> host = hosts.begin()->second;
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  SharedRefPtr<Host> host = hosts.begin()->second;
   policy.on_host_removed(host);
 
-  cass::ScopedPtr<cass::QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp2(policy.new_query_plan("ks", NULL, NULL));
 
   // Both should not have the removed host
-  const size_t seq1[] = {2, 3};
+  const size_t seq1[] = { 2, 3 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
 
-  const size_t seq2[] = {3, 2};
+  const size_t seq2[] = { 3, 2 };
   verify_sequence(qp2.get(), VECTOR_FROM(size_t, seq2));
 }
 
 TEST(RoundRobinLoadBalancingUnitTest, OnUpAndDown) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", "dc", &hosts);
 
-  cass::RoundRobinPolicy policy;
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  RoundRobinPolicy policy;
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp_before1(policy.new_query_plan("ks", NULL, NULL));
-  cass::ScopedPtr<cass::QueryPlan> qp_before2(policy.new_query_plan("ks", NULL, NULL));
-  cass::SharedRefPtr<cass::Host> host = hosts.begin()->second;
+  ScopedPtr<QueryPlan> qp_before1(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp_before2(policy.new_query_plan("ks", NULL, NULL));
+  SharedRefPtr<Host> host = hosts.begin()->second;
 
   // 'before' qp both have the down host
   // Ahead of set_down, it will be returned
   {
-    const size_t seq[] = {1, 2, 3};
+    const size_t seq[] = { 1, 2, 3 };
     verify_sequence(qp_before1.get(), VECTOR_FROM(size_t, seq));
   }
 
   policy.on_host_down(host->address());
   // Following set_down, it is dynamically excluded
   {
-    const size_t seq[] = {2, 3};
+    const size_t seq[] = { 2, 3 };
     verify_sequence(qp_before2.get(), VECTOR_FROM(size_t, seq));
   }
 
   // host is added to the list, but not 'up'
   policy.on_host_up(host);
 
-  cass::ScopedPtr<cass::QueryPlan> qp_after1(policy.new_query_plan("ks", NULL, NULL));
-  cass::ScopedPtr<cass::QueryPlan> qp_after2(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp_after1(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp_after2(policy.new_query_plan("ks", NULL, NULL));
 
   policy.on_host_down(host->address());
   // 1 is dynamically excluded from plan
   {
-    const size_t seq[] = {2, 3};
+    const size_t seq[] = { 2, 3 };
     verify_sequence(qp_after1.get(), VECTOR_FROM(size_t, seq));
   }
 
   policy.on_host_up(host);
   // now included
   {
-    const size_t seq[] = {2, 3, 1};
+    const size_t seq[] = { 2, 3, 1 };
     verify_sequence(qp_after2.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(RoundRobinLoadBalancingUnitTest, VerifyEqualDistribution) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", "dc", &hosts);
 
-  cass::RoundRobinPolicy policy;
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  RoundRobinPolicy policy;
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   { // All nodes
     QueryCounts counts(run_policy(policy, 12));
@@ -340,60 +332,64 @@ TEST(RoundRobinLoadBalancingUnitTest, VerifyEqualDistribution) {
 
 TEST(DatacenterAwareLoadBalancingUnitTest, SomeDatacenterLocalUnspecified) {
   const size_t total_hosts = 3;
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(total_hosts, "rack", LOCAL_DC, &hosts);
-  cass::Host* h = hosts.begin()->second.get();
+  Host* h = hosts.begin()->second.get();
   h->set_rack_and_dc("", "");
 
-  cass::DCAwarePolicy policy(LOCAL_DC, 1, false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  DCAwarePolicy policy(LOCAL_DC, 1, false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
 
-  const size_t seq[] = {2, 3, 1};
+  const size_t seq[] = { 2, 3, 1 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, SingleLocalDown) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
-  cass::SharedRefPtr<cass::Host> target_host = hosts.begin()->second;
+  SharedRefPtr<Host> target_host = hosts.begin()->second;
   populate_hosts(1, "rack", REMOTE_DC, &hosts);
 
-  cass::DCAwarePolicy policy(LOCAL_DC, 1, false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  DCAwarePolicy policy(LOCAL_DC, 1, false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp_before(policy.new_query_plan("ks", NULL, NULL));// has down host ptr in plan
-  cass::ScopedPtr<cass::QueryPlan> qp_after(policy.new_query_plan("ks", NULL, NULL));// should not have down host ptr in plan
+  ScopedPtr<QueryPlan> qp_before(
+      policy.new_query_plan("ks", NULL, NULL)); // has down host ptr in plan
+  ScopedPtr<QueryPlan> qp_after(
+      policy.new_query_plan("ks", NULL, NULL)); // should not have down host ptr in plan
 
   policy.on_host_down(target_host->address());
   {
-    const size_t seq[] = {2, 3, 4};
+    const size_t seq[] = { 2, 3, 4 };
     verify_sequence(qp_before.get(), VECTOR_FROM(size_t, seq));
   }
 
   policy.on_host_up(target_host);
   {
-    const size_t seq[] = {2, 3, 1, 4}; // local dc wrapped before remote offered
+    const size_t seq[] = { 2, 3, 1, 4 }; // local dc wrapped before remote offered
     verify_sequence(qp_after.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, AllLocalRemovedReturned) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(1, "rack", LOCAL_DC, &hosts);
-  cass::SharedRefPtr<cass::Host> target_host = hosts.begin()->second;
+  SharedRefPtr<Host> target_host = hosts.begin()->second;
   populate_hosts(1, "rack", REMOTE_DC, &hosts);
 
-  cass::DCAwarePolicy policy(LOCAL_DC, 1, false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  DCAwarePolicy policy(LOCAL_DC, 1, false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp_before(policy.new_query_plan("ks", NULL, NULL));// has down host ptr in plan
+  ScopedPtr<QueryPlan> qp_before(
+      policy.new_query_plan("ks", NULL, NULL)); // has down host ptr in plan
   policy.on_host_down(target_host->address());
-  cass::ScopedPtr<cass::QueryPlan> qp_after(policy.new_query_plan("ks", NULL, NULL));// should not have down host ptr in plan
+  ScopedPtr<QueryPlan> qp_after(
+      policy.new_query_plan("ks", NULL, NULL)); // should not have down host ptr in plan
 
   {
-    const size_t seq[] = {2};
+    const size_t seq[] = { 2 };
     verify_sequence(qp_before.get(), VECTOR_FROM(size_t, seq));
     verify_sequence(qp_after.get(), VECTOR_FROM(size_t, seq));
   }
@@ -401,29 +397,31 @@ TEST(DatacenterAwareLoadBalancingUnitTest, AllLocalRemovedReturned) {
   policy.on_host_up(target_host);
 
   // make sure we get the local node first after on_up
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
   {
-    const size_t seq[] = {1, 2};
+    const size_t seq[] = { 1, 2 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, RemoteRemovedReturned) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(1, "rack", LOCAL_DC, &hosts);
   populate_hosts(1, "rack", REMOTE_DC, &hosts);
-  cass::Address target_addr("2.0.0.0", 9042);
-  cass::SharedRefPtr<cass::Host> target_host = hosts[target_addr];
+  Address target_addr("2.0.0.0", 9042);
+  SharedRefPtr<Host> target_host = hosts[target_addr];
 
-  cass::DCAwarePolicy policy(LOCAL_DC, 1, false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  DCAwarePolicy policy(LOCAL_DC, 1, false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp_before(policy.new_query_plan("ks", NULL, NULL));// has down host ptr in plan
+  ScopedPtr<QueryPlan> qp_before(
+      policy.new_query_plan("ks", NULL, NULL)); // has down host ptr in plan
   policy.on_host_down(target_host->address());
-  cass::ScopedPtr<cass::QueryPlan> qp_after(policy.new_query_plan("ks", NULL, NULL));// should not have down host ptr in plan
+  ScopedPtr<QueryPlan> qp_after(
+      policy.new_query_plan("ks", NULL, NULL)); // should not have down host ptr in plan
 
   {
-    const size_t seq[] = {1};
+    const size_t seq[] = { 1 };
     verify_sequence(qp_before.get(), VECTOR_FROM(size_t, seq));
     verify_sequence(qp_after.get(), VECTOR_FROM(size_t, seq));
   }
@@ -431,24 +429,24 @@ TEST(DatacenterAwareLoadBalancingUnitTest, RemoteRemovedReturned) {
   policy.on_host_up(target_host);
 
   // make sure we get both nodes, correct order after
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
   {
-    const size_t seq[] = {1, 2};
+    const size_t seq[] = { 1, 2 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, UsedHostsPerDatacenter) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
   populate_hosts(3, "rack", REMOTE_DC, &hosts);
 
   for (size_t used_hosts = 0; used_hosts < 4; ++used_hosts) {
-    cass::DCAwarePolicy policy(LOCAL_DC, used_hosts, false);
-    policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+    DCAwarePolicy policy(LOCAL_DC, used_hosts, false);
+    policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-    cass::Vector<size_t> seq;
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+    Vector<size_t> seq;
     size_t index = 0;
 
     seq.reserve(3 + used_hosts);
@@ -470,86 +468,85 @@ TEST(DatacenterAwareLoadBalancingUnitTest, UsedHostsPerDatacenter) {
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, AllowRemoteDatacentersForLocalConsistencyLevel) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
   populate_hosts(3, "rack", REMOTE_DC, &hosts);
 
   {
     // Not allowing remote DCs for local CLs
     bool allow_remote_dcs_for_local_cl = false;
-    cass::DCAwarePolicy policy(LOCAL_DC, 3, !allow_remote_dcs_for_local_cl);
-    policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+    DCAwarePolicy policy(LOCAL_DC, 3, !allow_remote_dcs_for_local_cl);
+    policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
     // Set local CL
-    cass::QueryRequest::Ptr request(new cass::QueryRequest("", 0));
+    QueryRequest::Ptr request(new QueryRequest("", 0));
     request->set_consistency(CASS_CONSISTENCY_LOCAL_ONE);
-    cass::SharedRefPtr<cass::RequestHandler> request_handler(
-          new cass::RequestHandler(request, cass::ResponseFuture::Ptr()));
+    SharedRefPtr<RequestHandler> request_handler(
+        new RequestHandler(request, ResponseFuture::Ptr()));
 
     // Check for only local hosts are used
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", request_handler.get(), NULL));
-    const size_t seq[] = {1, 2, 3};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", request_handler.get(), NULL));
+    const size_t seq[] = { 1, 2, 3 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 
   {
     // Allowing remote DCs for local CLs
     bool allow_remote_dcs_for_local_cl = true;
-    cass::DCAwarePolicy policy(LOCAL_DC, 3, !allow_remote_dcs_for_local_cl);
-    policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+    DCAwarePolicy policy(LOCAL_DC, 3, !allow_remote_dcs_for_local_cl);
+    policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
     // Set local CL
-    cass::QueryRequest::Ptr request(new cass::QueryRequest("", 0));
+    QueryRequest::Ptr request(new QueryRequest("", 0));
     request->set_consistency(CASS_CONSISTENCY_LOCAL_QUORUM);
-    cass::SharedRefPtr<cass::RequestHandler> request_handler(
-          new cass::RequestHandler(request, cass::ResponseFuture::Ptr()));
+    SharedRefPtr<RequestHandler> request_handler(
+        new RequestHandler(request, ResponseFuture::Ptr()));
 
     // Check for only local hosts are used
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", request_handler.get(), NULL));
-    const size_t seq[] = {1, 2, 3, 4, 5, 6};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", request_handler.get(), NULL));
+    const size_t seq[] = { 1, 2, 3, 4, 5, 6 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, StartWithEmptyLocalDatacenter) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(1, "rack", REMOTE_DC, &hosts);
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
 
   // Set local DC using connected host
   {
-    cass::DCAwarePolicy policy("", 0, false);
-    policy.init(hosts[cass::Address("2.0.0.0", 9042)], hosts, NULL);
+    DCAwarePolicy policy("", 0, false);
+    policy.init(hosts[Address("2.0.0.0", 9042)], hosts, NULL);
 
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-    const size_t seq[] = {2, 3, 4};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+    const size_t seq[] = { 2, 3, 4 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 
   // Set local DC using first host with non-empty DC
   {
-    cass::DCAwarePolicy policy("", 0, false);
-    policy.init(cass::SharedRefPtr<cass::Host>(
-                  new cass::Host(cass::Address("0.0.0.0", 9042))), hosts, NULL);
+    DCAwarePolicy policy("", 0, false);
+    policy.init(SharedRefPtr<Host>(new Host(Address("0.0.0.0", 9042))), hosts, NULL);
 
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
-    const size_t seq[] = {1};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+    const size_t seq[] = { 1 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
-cass::Vector<cass::String> single_token(int64_t token) {
-  cass::OStringStream ss;
+Vector<String> single_token(int64_t token) {
+  OStringStream ss;
   ss << token;
-  return cass::Vector<cass::String>(1, ss.str());
+  return Vector<String>(1, ss.str());
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, VerifyEqualDistributionLocalDc) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
   populate_hosts(3, "rack", REMOTE_DC, &hosts);
 
-  cass::DCAwarePolicy policy("", 0, false);
+  DCAwarePolicy policy("", 0, false);
   policy.init(hosts.begin()->second, hosts, NULL);
 
   { // All local nodes
@@ -588,16 +585,16 @@ TEST(DatacenterAwareLoadBalancingUnitTest, VerifyEqualDistributionLocalDc) {
 }
 
 TEST(DatacenterAwareLoadBalancingUnitTest, VerifyEqualDistributionRemoteDc) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack", LOCAL_DC, &hosts);
   populate_hosts(3, "rack", REMOTE_DC, &hosts);
 
-  cass::DCAwarePolicy policy("", 3, false); // Allow all remote DC nodes
+  DCAwarePolicy policy("", 3, false); // Allow all remote DC nodes
   policy.init(hosts.begin()->second, hosts, NULL);
 
-  cass::Host::Ptr remote_dc_node1;
+  Host::Ptr remote_dc_node1;
   { // Mark down all local nodes
-    cass::HostMap::iterator it = hosts.begin();
+    HostMap::iterator it = hosts.begin();
     for (int i = 0; i < 3; ++i) {
       policy.on_host_down(it->first);
       it++;
@@ -642,8 +639,8 @@ TEST(DatacenterAwareLoadBalancingUnitTest, VerifyEqualDistributionRemoteDc) {
 
 TEST(TokenAwareLoadBalancingUnitTest, Simple) {
   const int64_t num_hosts = 4;
-  cass::HostMap hosts;
-  cass::TokenMap::Ptr token_map(cass::TokenMap::from_partitioner(cass::Murmur3Partitioner::name()));
+  HostMap hosts;
+  TokenMap::Ptr token_map(TokenMap::from_partitioner(Murmur3Partitioner::name()));
 
   // Tokens
   // 1.0.0.0 -4611686018427387905
@@ -652,14 +649,11 @@ TEST(TokenAwareLoadBalancingUnitTest, Simple) {
   // 4.0.0.0  9223372036854775804
 
   const uint64_t partition_size = CASS_UINT64_MAX / num_hosts;
-  cass::Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
+  Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
 
   for (size_t i = 1; i <= num_hosts; ++i) {
-    cass::Host::Ptr host(create_host(addr_for_sequence(i),
-                                     single_token(token),
-                                     cass::Murmur3Partitioner::name().to_string(),
-                                     "rack1",
-                                     LOCAL_DC));
+    Host::Ptr host(create_host(addr_for_sequence(i), single_token(token),
+                               Murmur3Partitioner::name().to_string(), "rack1", LOCAL_DC));
 
     hosts[host->address()] = host;
     token_map->add_host(host);
@@ -669,28 +663,27 @@ TEST(TokenAwareLoadBalancingUnitTest, Simple) {
   add_keyspace_simple("test", 3, token_map.get());
   token_map->build();
 
-  cass::TokenAwarePolicy policy(new cass::RoundRobinPolicy(), false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  TokenAwarePolicy policy(new RoundRobinPolicy(), false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("", 1));
+  QueryRequest::Ptr request(new QueryRequest("", 1));
   const char* value = "kjdfjkldsdjkl"; // hash: 9024137376112061887
-  request->set(0, cass::CassString(value, strlen(value)));
+  request->set(0, CassString(value, strlen(value)));
   request->add_key_index(0);
-  cass::SharedRefPtr<cass::RequestHandler> request_handler(
-        new cass::RequestHandler(request, cass::ResponseFuture::Ptr()));
+  SharedRefPtr<RequestHandler> request_handler(new RequestHandler(request, ResponseFuture::Ptr()));
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 4, 1, 2, 3 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 
   // Bring down the first host
-  cass::HostMap::iterator curr_host_it = hosts.begin(); // 1.0.0.0
+  HostMap::iterator curr_host_it = hosts.begin(); // 1.0.0.0
   policy.on_host_down(curr_host_it->second->address());
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 4, 2, 3 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
@@ -703,7 +696,7 @@ TEST(TokenAwareLoadBalancingUnitTest, Simple) {
   policy.on_host_down(curr_host_it->second->address());
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 1, 2, 3 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
@@ -711,9 +704,9 @@ TEST(TokenAwareLoadBalancingUnitTest, Simple) {
 
 TEST(TokenAwareLoadBalancingUnitTest, NetworkTopology) {
   const size_t num_hosts = 7;
-  cass::HostMap hosts;
+  HostMap hosts;
 
-  cass::TokenMap::Ptr token_map(cass::TokenMap::from_partitioner(cass::Murmur3Partitioner::name()));
+  TokenMap::Ptr token_map(TokenMap::from_partitioner(Murmur3Partitioner::name()));
 
   // Tokens
   // 1.0.0.0 local  -6588122883467697006
@@ -725,14 +718,12 @@ TEST(TokenAwareLoadBalancingUnitTest, NetworkTopology) {
   // 7.0.0.0 local   9223372036854775806
 
   const uint64_t partition_size = CASS_UINT64_MAX / num_hosts;
-  cass::Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
+  Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
 
   for (size_t i = 1; i <= num_hosts; ++i) {
-    cass::Host::Ptr host(create_host(addr_for_sequence(i),
-                                     single_token(token),
-                                     cass::Murmur3Partitioner::name().to_string(),
-                                     "rack1",
-                                     i % 2 == 0 ? REMOTE_DC : LOCAL_DC));
+    Host::Ptr host(create_host(addr_for_sequence(i), single_token(token),
+                               Murmur3Partitioner::name().to_string(), "rack1",
+                               i % 2 == 0 ? REMOTE_DC : LOCAL_DC));
 
     hosts[host->address()] = host;
     token_map->add_host(host);
@@ -745,28 +736,27 @@ TEST(TokenAwareLoadBalancingUnitTest, NetworkTopology) {
   add_keyspace_network_topology("test", replication, token_map.get());
   token_map->build();
 
-  cass::TokenAwarePolicy policy(new cass::DCAwarePolicy(LOCAL_DC, num_hosts / 2, false), false);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  TokenAwarePolicy policy(new DCAwarePolicy(LOCAL_DC, num_hosts / 2, false), false);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("", 1));
+  QueryRequest::Ptr request(new QueryRequest("", 1));
   const char* value = "abc"; // hash: -5434086359492102041
-  request->set(0, cass::CassString(value, strlen(value)));
+  request->set(0, CassString(value, strlen(value)));
   request->add_key_index(0);
-  cass::SharedRefPtr<cass::RequestHandler> request_handler(
-        new cass::RequestHandler(request, cass::ResponseFuture::Ptr()));
+  SharedRefPtr<RequestHandler> request_handler(new RequestHandler(request, ResponseFuture::Ptr()));
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 3, 5, 7, 1, 4, 6, 2 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 
   // Bring down the first host
-  cass::HostMap::iterator curr_host_it = hosts.begin(); // 1.0.0.0
+  HostMap::iterator curr_host_it = hosts.begin(); // 1.0.0.0
   policy.on_host_down(curr_host_it->second->address());
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 3, 5, 7, 4, 6, 2 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
@@ -778,18 +768,18 @@ TEST(TokenAwareLoadBalancingUnitTest, NetworkTopology) {
   policy.on_host_down(curr_host_it->second->address());
 
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     const size_t seq[] = { 5, 7, 1, 6, 2, 4 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq));
   }
 }
 
 TEST(TokenAwareLoadBalancingUnitTest, ShuffleReplicas) {
-  cass::Random random;
+  Random random;
 
   const int64_t num_hosts = 4;
-  cass::HostMap hosts;
-  cass::TokenMap::Ptr token_map(cass::TokenMap::from_partitioner(cass::Murmur3Partitioner::name()));
+  HostMap hosts;
+  TokenMap::Ptr token_map(TokenMap::from_partitioner(Murmur3Partitioner::name()));
 
   // Tokens
   // 1.0.0.0 -4611686018427387905
@@ -798,14 +788,11 @@ TEST(TokenAwareLoadBalancingUnitTest, ShuffleReplicas) {
   // 4.0.0.0  9223372036854775804
 
   const uint64_t partition_size = CASS_UINT64_MAX / num_hosts;
-  cass::Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
+  Murmur3Partitioner::Token token = CASS_INT64_MIN + partition_size;
 
   for (size_t i = 1; i <= num_hosts; ++i) {
-    cass::Host::Ptr host(create_host(addr_for_sequence(i),
-                                     single_token(token),
-                                     cass::Murmur3Partitioner::name().to_string(),
-                                     "rack1",
-                                     LOCAL_DC));
+    Host::Ptr host(create_host(addr_for_sequence(i), single_token(token),
+                               Murmur3Partitioner::name().to_string(), "rack1", LOCAL_DC));
 
     hosts[host->address()] = host;
     token_map->add_host(host);
@@ -815,26 +802,24 @@ TEST(TokenAwareLoadBalancingUnitTest, ShuffleReplicas) {
   add_keyspace_simple("test", 3, token_map.get());
   token_map->build();
 
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("", 1));
+  QueryRequest::Ptr request(new QueryRequest("", 1));
   const char* value = "kjdfjkldsdjkl"; // hash: 9024137376112061887
-  request->set(0, cass::CassString(value, strlen(value)));
+  request->set(0, CassString(value, strlen(value)));
   request->add_key_index(0);
-  cass::SharedRefPtr<cass::RequestHandler> request_handler(
-        new cass::RequestHandler(request, cass::ResponseFuture::Ptr()));
-
+  SharedRefPtr<RequestHandler> request_handler(new RequestHandler(request, ResponseFuture::Ptr()));
 
-  cass::HostVec not_shuffled;
+  HostVec not_shuffled;
   {
-    cass::TokenAwarePolicy policy(new cass::RoundRobinPolicy(), false); // Not shuffled
-    policy.init(cass::SharedRefPtr<cass::Host>(), hosts, &random);
-    cass::ScopedPtr<cass::QueryPlan> qp1(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    TokenAwarePolicy policy(new RoundRobinPolicy(), false); // Not shuffled
+    policy.init(SharedRefPtr<Host>(), hosts, &random);
+    ScopedPtr<QueryPlan> qp1(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     for (int i = 0; i < num_hosts; ++i) {
       not_shuffled.push_back(qp1->compute_next());
     }
 
     // Verify that not shuffled will repeat the same order
-    cass::HostVec not_shuffled_again;
-    cass::ScopedPtr<cass::QueryPlan> qp2(policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    HostVec not_shuffled_again;
+    ScopedPtr<QueryPlan> qp2(policy.new_query_plan("test", request_handler.get(), token_map.get()));
     for (int i = 0; i < num_hosts; ++i) {
       not_shuffled_again.push_back(qp2->compute_next());
     }
@@ -843,11 +828,12 @@ TEST(TokenAwareLoadBalancingUnitTest, ShuffleReplicas) {
 
   // Verify that the shuffle setting does indeed shuffle the replicas
   {
-    cass::TokenAwarePolicy shuffle_policy(new cass::RoundRobinPolicy(), true); // Shuffled
-    shuffle_policy.init(cass::SharedRefPtr<cass::Host>(), hosts, &random);
+    TokenAwarePolicy shuffle_policy(new RoundRobinPolicy(), true); // Shuffled
+    shuffle_policy.init(SharedRefPtr<Host>(), hosts, &random);
 
-    cass::HostVec shuffled_previous;
-    cass::ScopedPtr<cass::QueryPlan> qp(shuffle_policy.new_query_plan("test", request_handler.get(), token_map.get()));
+    HostVec shuffled_previous;
+    ScopedPtr<QueryPlan> qp(
+        shuffle_policy.new_query_plan("test", request_handler.get(), token_map.get()));
     for (int i = 0; i < num_hosts; ++i) {
       shuffled_previous.push_back(qp->compute_next());
     }
@@ -855,11 +841,12 @@ TEST(TokenAwareLoadBalancingUnitTest, ShuffleReplicas) {
     int count;
     const int max_iterations = num_hosts * num_hosts;
     for (count = 0; count < max_iterations; ++count) {
-      cass::ScopedPtr<cass::QueryPlan> qp(shuffle_policy.new_query_plan("test", request_handler.get(), token_map.get()));
+      ScopedPtr<QueryPlan> qp(
+          shuffle_policy.new_query_plan("test", request_handler.get(), token_map.get()));
 
-      cass::HostVec shuffled;
+      HostVec shuffled;
       for (int j = 0; j < num_hosts; ++j) {
-        cass::Host::Ptr host(qp->compute_next());
+        Host::Ptr host(qp->compute_next());
         EXPECT_GT(std::count(not_shuffled.begin(), not_shuffled.end(), host), 0);
         shuffled.push_back(host);
       }
@@ -879,10 +866,10 @@ TEST(LatencyAwareLoadBalancingUnitTest, ThreadholdToAccount) {
   const uint64_t threshold_to_account = (30LL * min_measured) / 100LL;
   const uint64_t one_ms = 1000000LL; // 1 ms in ns
 
-  cass::Host host(cass::Address("0.0.0.0", 9042));
+  Host host(Address("0.0.0.0", 9042));
   host.enable_latency_tracking(scale, min_measured);
 
-  cass::TimestampedAverage current = host.get_current_average();
+  TimestampedAverage current = host.get_current_average();
   for (uint64_t i = 0; i < threshold_to_account; ++i) {
     host.update_latency(one_ms);
     current = host.get_current_average();
@@ -901,32 +888,31 @@ TEST(LatencyAwareLoadBalancingUnitTest, MovingAverage) {
 
   // Verify average is approx. the same when recording the same latency twice
   EXPECT_NEAR(static_cast<double>(calculate_moving_average(one_ms, one_ms, 100LL)),
-              static_cast<double>(one_ms),
-              0.2 * one_ms);
+              static_cast<double>(one_ms), 0.2 * one_ms);
 
   EXPECT_NEAR(static_cast<double>(calculate_moving_average(one_ms, one_ms, 1000LL)),
-              static_cast<double>(one_ms),
-              0.2 * one_ms);
+              static_cast<double>(one_ms), 0.2 * one_ms);
 
   // First average is 100 us and second average is 50 us, expect a 75 us average approx.
   // after a short wait time. This has a high tolerance because the time waited varies.
-  EXPECT_NEAR(static_cast<double>(calculate_moving_average(one_ms, one_ms / 2LL, 50LL)),
-              static_cast<double>((3LL * one_ms) / 4LL),
-              50.0 * one_ms); // Highly variable because it's in the early part of the logarithmic curve
+  EXPECT_NEAR(
+      static_cast<double>(calculate_moving_average(one_ms, one_ms / 2LL, 50LL)),
+      static_cast<double>((3LL * one_ms) / 4LL),
+      50.0 * one_ms); // Highly variable because it's in the early part of the logarithmic curve
 
   // First average is 100 us and second average is 50 us, expect a 50 us average approx.
   // after a longer wait time. This has a high tolerance because the time waited varies
   EXPECT_NEAR(static_cast<double>(calculate_moving_average(one_ms, one_ms / 2LL, 100000LL)),
-              static_cast<double>(one_ms / 2LL),
-              2.0 * one_ms);
+              static_cast<double>(one_ms / 2LL), 2.0 * one_ms);
 }
 
 #if _MSC_VER == 1700 && _M_IX86
-TEST(LatencyAwareLoadBalancingUnitTest, DISABLED_Simple) { // Disabled: See https://datastax-oss.atlassian.net/browse/CPP-654
+TEST(LatencyAwareLoadBalancingUnitTest,
+     DISABLED_Simple) { // Disabled: See https://datastax-oss.atlassian.net/browse/CPP-654
 #else
 TEST(LatencyAwareLoadBalancingUnitTest, Simple) {
 #endif
-  cass::LatencyAwarePolicy::Settings settings;
+  LatencyAwarePolicy::Settings settings;
 
   // Disable min_measured
   settings.min_measured = 0L;
@@ -938,22 +924,22 @@ TEST(LatencyAwareLoadBalancingUnitTest, Simple) {
   settings.retry_period_ns = 1000LL * 1000LL * 1000L;
 
   const int64_t num_hosts = 4;
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(num_hosts, "rack1", LOCAL_DC, &hosts);
-  cass::LatencyAwarePolicy policy(new cass::RoundRobinPolicy(), settings);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  LatencyAwarePolicy policy(new RoundRobinPolicy(), settings);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   // Record some latencies with 100 ns being the minimum
-  for (cass::HostMap::iterator i = hosts.begin(); i != hosts.end(); ++i) {
+  for (HostMap::iterator i = hosts.begin(); i != hosts.end(); ++i) {
     i->second->enable_latency_tracking(settings.scale_ns, settings.min_measured);
   }
 
-  hosts[cass::Address("1.0.0.0", 9042)]->update_latency(100);
-  hosts[cass::Address("4.0.0.0", 9042)]->update_latency(150);
+  hosts[Address("1.0.0.0", 9042)]->update_latency(100);
+  hosts[Address("4.0.0.0", 9042)]->update_latency(150);
 
   // Hosts 2 and 3 will exceed the exclusion threshold
-  hosts[cass::Address("2.0.0.0", 9042)]->update_latency(201);
-  hosts[cass::Address("3.0.0.0", 9042)]->update_latency(1000);
+  hosts[Address("2.0.0.0", 9042)]->update_latency(201);
+  hosts[Address("3.0.0.0", 9042)]->update_latency(1000);
 
   // Verify we don't have a current minimum average
   EXPECT_EQ(policy.min_average(), -1);
@@ -974,8 +960,8 @@ TEST(LatencyAwareLoadBalancingUnitTest, Simple) {
 
   // 1 and 4  are under the minimum, but 2 and 3 will be skipped
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("", NULL, NULL));
-    const size_t seq1[] = {1, 4, 2, 3};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("", NULL, NULL));
+    const size_t seq1[] = { 1, 4, 2, 3 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   }
 
@@ -984,27 +970,29 @@ TEST(LatencyAwareLoadBalancingUnitTest, Simple) {
 
   // After waiting no hosts should be skipped (notice 2 and 3 tried first)
   {
-    cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("", NULL, NULL));
-    const size_t seq1[] = {2, 3, 4, 1};
+    ScopedPtr<QueryPlan> qp(policy.new_query_plan("", NULL, NULL));
+    const size_t seq1[] = { 2, 3, 4, 1 };
     verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   }
 }
 
 #if _MSC_VER == 1700 && _M_IX86
-TEST(LatencyAwareLoadBalancingUnitTest, DISABLED_MinAverageUnderMinMeasured) { // Disabled: See https://datastax-oss.atlassian.net/browse/CPP-654
+TEST(LatencyAwareLoadBalancingUnitTest,
+     DISABLED_MinAverageUnderMinMeasured) { // Disabled: See
+                                            // https://datastax-oss.atlassian.net/browse/CPP-654
 #else
 TEST(LatencyAwareLoadBalancingUnitTest, MinAverageUnderMinMeasured) {
 #endif
-  cass::LatencyAwarePolicy::Settings settings;
+  LatencyAwarePolicy::Settings settings;
 
   const int64_t num_hosts = 4;
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(num_hosts, "rack1", LOCAL_DC, &hosts);
-  cass::LatencyAwarePolicy policy(new cass::RoundRobinPolicy(), settings);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  LatencyAwarePolicy policy(new RoundRobinPolicy(), settings);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
   int count = 1;
-  for (cass::HostMap::iterator i = hosts.begin(); i != hosts.end(); ++i) {
+  for (HostMap::iterator i = hosts.begin(); i != hosts.end(); ++i) {
     i->second->enable_latency_tracking(settings.scale_ns, settings.min_measured);
     i->second->update_latency(100 * count++);
   }
@@ -1029,82 +1017,82 @@ TEST(LatencyAwareLoadBalancingUnitTest, MinAverageUnderMinMeasured) {
 
 TEST(WhitelistLoadBalancingUnitTest, Hosts) {
   const int64_t num_hosts = 100;
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(num_hosts, "rack1", LOCAL_DC, &hosts);
-  cass::ContactPointList whitelist_hosts;
+  ContactPointList whitelist_hosts;
   whitelist_hosts.push_back("37.0.0.0");
   whitelist_hosts.push_back("83.0.0.0");
-  cass::WhitelistPolicy policy(new cass::RoundRobinPolicy(), whitelist_hosts);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  WhitelistPolicy policy(new RoundRobinPolicy(), whitelist_hosts);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
 
   // Verify only hosts 37 and 83 are computed in the query plan
   const size_t seq1[] = { 37, 83 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   // The query plan should now be exhausted
-  cass::Address next_address;
+  Address next_address;
   ASSERT_FALSE(qp.get()->compute_next(&next_address));
 }
 
 TEST(WhitelistLoadBalancingUnitTest, Datacenters) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack1", LOCAL_DC, &hosts);
   populate_hosts(3, "rack1", BACKUP_DC, &hosts);
   populate_hosts(3, "rack1", REMOTE_DC, &hosts);
-  cass::DcList whitelist_dcs;
+  DcList whitelist_dcs;
   whitelist_dcs.push_back(LOCAL_DC);
   whitelist_dcs.push_back(REMOTE_DC);
-  cass::WhitelistDCPolicy policy(new cass::RoundRobinPolicy(), whitelist_dcs);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  WhitelistDCPolicy policy(new RoundRobinPolicy(), whitelist_dcs);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
 
   // Verify only hosts LOCAL_DC and REMOTE_DC are computed in the query plan
   const size_t seq1[] = { 1, 2, 3, 7, 8, 9 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   // The query plan should now be exhausted
-  cass::Address next_address;
+  Address next_address;
   ASSERT_FALSE(qp.get()->compute_next(&next_address));
 }
 
 TEST(BlacklistLoadBalancingUnitTest, Hosts) {
   const int64_t num_hosts = 5;
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(num_hosts, "rack1", LOCAL_DC, &hosts);
-  cass::ContactPointList blacklist_hosts;
+  ContactPointList blacklist_hosts;
   blacklist_hosts.push_back("2.0.0.0");
   blacklist_hosts.push_back("3.0.0.0");
-  cass::BlacklistPolicy policy(new cass::RoundRobinPolicy(), blacklist_hosts);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  BlacklistPolicy policy(new RoundRobinPolicy(), blacklist_hosts);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
 
   // Verify only hosts 1, 4 and 5 are computed in the query plan
   const size_t seq1[] = { 1, 4, 5 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   // The query plan should now be exhausted
-  cass::Address next_address;
+  Address next_address;
   ASSERT_FALSE(qp.get()->compute_next(&next_address));
 }
 
 TEST(BlacklistLoadBalancingUnitTest, Datacenters) {
-  cass::HostMap hosts;
+  HostMap hosts;
   populate_hosts(3, "rack1", LOCAL_DC, &hosts);
   populate_hosts(3, "rack1", BACKUP_DC, &hosts);
   populate_hosts(3, "rack1", REMOTE_DC, &hosts);
-  cass::DcList blacklist_dcs;
+  DcList blacklist_dcs;
   blacklist_dcs.push_back(LOCAL_DC);
   blacklist_dcs.push_back(REMOTE_DC);
-  cass::BlacklistDCPolicy policy(new cass::RoundRobinPolicy(), blacklist_dcs);
-  policy.init(cass::SharedRefPtr<cass::Host>(), hosts, NULL);
+  BlacklistDCPolicy policy(new RoundRobinPolicy(), blacklist_dcs);
+  policy.init(SharedRefPtr<Host>(), hosts, NULL);
 
-  cass::ScopedPtr<cass::QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
+  ScopedPtr<QueryPlan> qp(policy.new_query_plan("ks", NULL, NULL));
 
   // Verify only hosts from BACKUP_DC are computed in the query plan
   const size_t seq1[] = { 4, 5, 6 };
   verify_sequence(qp.get(), VECTOR_FROM(size_t, seq1));
   // The query plan should now be exhausted
-  cass::Address next_address;
+  Address next_address;
   ASSERT_FALSE(qp.get()->compute_next(&next_address));
 }
diff --git a/gtests/src/unit/tests/test_loop_watcher.cpp b/gtests/src/unit/tests/test_loop_watcher.cpp
index 3cf6ea83a..7883ce011 100644
--- a/gtests/src/unit/tests/test_loop_watcher.cpp
+++ b/gtests/src/unit/tests/test_loop_watcher.cpp
@@ -18,33 +18,32 @@
 
 #include "loop_watcher.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 class LoopWatcherUnitTest : public LoopTest {
 public:
   LoopWatcherUnitTest()
-    : is_check_callback_called_(false)
-    , is_prepare_callback_called_(false) { }
+      : is_check_callback_called_(false)
+      , is_prepare_callback_called_(false) {}
 
   bool is_check_callback_called() { return is_check_callback_called_; }
   bool is_prepare_callback_called() { return is_prepare_callback_called_; }
 
 protected:
-  void start(cass::Check* check) {
-    ASSERT_EQ(0, check->start(loop(),
-                              cass::bind_callback(&LoopWatcherUnitTest::on_check,
-                                                  this)));
+  void start(Check* check) {
+    ASSERT_EQ(0, check->start(loop(), bind_callback(&LoopWatcherUnitTest::on_check, this)));
   }
-  void start(cass::Prepare* prepare) {
-    ASSERT_EQ(0, prepare->start(loop(),
-                                cass::bind_callback(&LoopWatcherUnitTest::on_prepare,
-                                                    this)));
+  void start(Prepare* prepare) {
+    ASSERT_EQ(0, prepare->start(loop(), bind_callback(&LoopWatcherUnitTest::on_prepare, this)));
   }
 
 private:
-  void on_check(cass::Check* check) {
+  void on_check(Check* check) {
     is_check_callback_called_ = true;
     check->close_handle();
   }
-  void on_prepare(cass::Prepare* prepare) {
+  void on_prepare(Prepare* prepare) {
     is_prepare_callback_called_ = true;
     prepare->close_handle();
   }
@@ -55,7 +54,7 @@ class LoopWatcherUnitTest : public LoopTest {
 };
 
 TEST_F(LoopWatcherUnitTest, Check) {
-  cass::Check check;
+  Check check;
   ASSERT_FALSE(check.is_running());
 
   start(&check);
@@ -69,7 +68,7 @@ TEST_F(LoopWatcherUnitTest, Check) {
 }
 
 TEST_F(LoopWatcherUnitTest, CheckNotStarted) {
-  cass::Prepare check;
+  Prepare check;
   ASSERT_FALSE(check.is_running());
   ASSERT_FALSE(is_check_callback_called());
 
@@ -80,7 +79,7 @@ TEST_F(LoopWatcherUnitTest, CheckNotStarted) {
 }
 
 TEST_F(LoopWatcherUnitTest, Prepare) {
-  cass::Prepare prepare;
+  Prepare prepare;
   ASSERT_FALSE(prepare.is_running());
 
   start(&prepare);
@@ -94,7 +93,7 @@ TEST_F(LoopWatcherUnitTest, Prepare) {
 }
 
 TEST_F(LoopWatcherUnitTest, PrepareNotStarted) {
-  cass::Prepare prepare;
+  Prepare prepare;
   ASSERT_FALSE(prepare.is_running());
   ASSERT_FALSE(is_prepare_callback_called());
 
diff --git a/gtests/src/unit/tests/test_md5.cpp b/gtests/src/unit/tests/test_md5.cpp
index 71c1a3f45..8a7353246 100644
--- a/gtests/src/unit/tests/test_md5.cpp
+++ b/gtests/src/unit/tests/test_md5.cpp
@@ -18,6 +18,8 @@
 
 #include "md5.hpp"
 
+using datastax::internal::Md5;
+
 static bool hash_equal(uint8_t* hash, const char* hash_str) {
   const char* p = hash_str;
   for (size_t i = 0; i < 16; ++i) {
@@ -32,7 +34,7 @@ static bool hash_equal(uint8_t* hash, const char* hash_str) {
 }
 
 static bool check_hash(const char* data, const char* hash_str) {
-  cass::Md5 m;
+  Md5 m;
   m.update(reinterpret_cast<const uint8_t*>(data), strlen(data));
   uint8_t hash[16];
   m.final(hash);
@@ -44,23 +46,22 @@ TEST(Md5UnitTest, Simple) {
   EXPECT_TRUE(check_hash("a", "0cc175b9c0f1b6a831c399e269772661"));
   EXPECT_TRUE(check_hash("abc", "900150983cd24fb0d6963f7d28e17f72"));
 
-  const char* big_str =
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
-      "012345689abcdef012345689abcdef012345689abcdef012345689abcdef";
+  const char* big_str = "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef"
+                        "012345689abcdef012345689abcdef012345689abcdef012345689abcdef";
 
   EXPECT_TRUE(check_hash(big_str, "15355dec7c48faeb01b46366d90be0be"));
 }
diff --git a/gtests/src/unit/tests/test_metadata.cpp b/gtests/src/unit/tests/test_metadata.cpp
index ad7950a82..904a8fe21 100644
--- a/gtests/src/unit/tests/test_metadata.cpp
+++ b/gtests/src/unit/tests/test_metadata.cpp
@@ -18,17 +18,21 @@
 
 #include "result_metadata.hpp"
 
-cass::SharedRefPtr<cass::ResultMetadata> create_metadata(const char* column_names[]) {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+SharedRefPtr<ResultMetadata> create_metadata(const char* column_names[]) {
   size_t count = 0;
-  while (column_names[count] != NULL) { count++; }
+  while (column_names[count] != NULL) {
+    count++;
+  }
 
-  cass::ResultMetadata::Ptr metadata(
-        new cass::ResultMetadata(count,
-                                 cass::RefBuffer::Ptr()));
+  ResultMetadata::Ptr metadata(new ResultMetadata(count, RefBuffer::Ptr()));
 
   for (size_t i = 0; column_names[i] != NULL; ++i) {
-    cass::ColumnDefinition def;
-    def.name = cass::StringRef(column_names[i]);
+    ColumnDefinition def;
+    def.name = StringRef(column_names[i]);
     def.index = i;
     metadata->add(def);
   }
@@ -38,10 +42,10 @@ cass::SharedRefPtr<cass::ResultMetadata> create_metadata(const char* column_name
 
 TEST(ResultMetadataUnitTest, Simple) {
   const char* column_names[] = { "abc", "def", "xyz", NULL };
-  cass::SharedRefPtr<cass::ResultMetadata> metadata(create_metadata(column_names));
+  SharedRefPtr<ResultMetadata> metadata(create_metadata(column_names));
 
   for (size_t i = 0; column_names[i] != NULL; ++i) {
-    cass::IndexVec indices;
+    IndexVec indices;
     size_t count = metadata->get_indices(column_names[i], &indices);
     EXPECT_EQ(count, 1u);
     EXPECT_GT(indices.size(), 0u);
@@ -51,11 +55,11 @@ TEST(ResultMetadataUnitTest, Simple) {
 
 TEST(ResultMetadataUnitTest, CaseSensitive) {
   const char* column_names[] = { "a", "A", "abc", "Abc", "ABc", "ABC", "aBc", "aBC", "abC", NULL };
-  cass::SharedRefPtr<cass::ResultMetadata> metadata(create_metadata(column_names));
+  SharedRefPtr<ResultMetadata> metadata(create_metadata(column_names));
 
   for (size_t i = 0; column_names[i] != NULL; ++i) {
-    cass::IndexVec indices;
-    cass::String name;
+    IndexVec indices;
+    String name;
     name.push_back('"');
     name.append(column_names[i]);
     name.push_back('"');
@@ -66,13 +70,13 @@ TEST(ResultMetadataUnitTest, CaseSensitive) {
   }
 
   {
-    cass::IndexVec indices;
+    IndexVec indices;
     size_t count = metadata->get_indices("a", &indices);
     EXPECT_EQ(count, 2u);
   }
 
   {
-    cass::IndexVec indices;
+    IndexVec indices;
     size_t count = metadata->get_indices("abc", &indices);
     EXPECT_EQ(count, 7u);
   }
diff --git a/gtests/src/unit/tests/test_metrics.cpp b/gtests/src/unit/tests/test_metrics.cpp
index bc04e21d6..16218f80d 100644
--- a/gtests/src/unit/tests/test_metrics.cpp
+++ b/gtests/src/unit/tests/test_metrics.cpp
@@ -25,9 +25,11 @@
 #define NUM_THREADS 2
 #define NUM_ITERATIONS 100
 
+using datastax::internal::core::Metrics;
+
 struct CounterThreadArgs {
   uv_thread_t thread;
-  cass::Metrics::Counter* counter;
+  Metrics::Counter* counter;
 };
 
 void counter_thread(void* data) {
@@ -40,7 +42,7 @@ void counter_thread(void* data) {
 struct HistogramThreadArgs {
   uv_thread_t thread;
   uint64_t id;
-  cass::Metrics::Histogram* histogram;
+  Metrics::Histogram* histogram;
 };
 
 void histogram_thread(void* data) {
@@ -52,7 +54,7 @@ void histogram_thread(void* data) {
 
 struct MeterThreadArgs {
   uv_thread_t thread;
-  cass::Metrics::Meter* meter;
+  Metrics::Meter* meter;
 };
 
 void meter_thread(void* data) {
@@ -66,8 +68,8 @@ void meter_thread(void* data) {
 }
 
 TEST(MetricsUnitTest, Counter) {
-  cass::Metrics::ThreadState thread_state(1);
-  cass::Metrics::Counter counter(&thread_state);
+  Metrics::ThreadState thread_state(1);
+  Metrics::Counter counter(&thread_state);
 
   EXPECT_EQ(counter.sum(), 0);
 
@@ -85,8 +87,8 @@ TEST(MetricsUnitTest, Counter) {
 TEST(MetricsUnitTest, CounterWithThreads) {
   CounterThreadArgs args[NUM_THREADS];
 
-  cass::Metrics::ThreadState thread_state(NUM_THREADS);
-  cass::Metrics::Counter counter(&thread_state);
+  Metrics::ThreadState thread_state(NUM_THREADS);
+  Metrics::Counter counter(&thread_state);
 
   for (int i = 0; i < NUM_THREADS; ++i) {
     args[i].counter = &counter;
@@ -101,14 +103,14 @@ TEST(MetricsUnitTest, CounterWithThreads) {
 }
 
 TEST(MetricsUnitTest, Histogram) {
-  cass::Metrics::ThreadState thread_state(1);
-  cass::Metrics::Histogram histogram(&thread_state);
+  Metrics::ThreadState thread_state(1);
+  Metrics::Histogram histogram(&thread_state);
 
   for (uint64_t i = 1; i <= 100; ++i) {
     histogram.record_value(i);
   }
 
-  cass::Metrics::Histogram::Snapshot snapshot;
+  Metrics::Histogram::Snapshot snapshot;
   histogram.get_snapshot(&snapshot);
 
   EXPECT_EQ(snapshot.min, 1);
@@ -124,10 +126,10 @@ TEST(MetricsUnitTest, Histogram) {
 }
 
 TEST(MetricsUnitTest, HistogramEmpty) {
-  cass::Metrics::ThreadState thread_state(1);
-  cass::Metrics::Histogram histogram(&thread_state);
+  Metrics::ThreadState thread_state(1);
+  Metrics::Histogram histogram(&thread_state);
 
-  cass::Metrics::Histogram::Snapshot snapshot;
+  Metrics::Histogram::Snapshot snapshot;
   histogram.get_snapshot(&snapshot);
 
   EXPECT_EQ(snapshot.min, 0);
@@ -145,8 +147,8 @@ TEST(MetricsUnitTest, HistogramEmpty) {
 TEST(MetricsUnitTest, HistogramWithThreads) {
   HistogramThreadArgs args[NUM_THREADS];
 
-  cass::Metrics::ThreadState thread_state(NUM_THREADS);
-  cass::Metrics::Histogram histogram(&thread_state);
+  Metrics::ThreadState thread_state(NUM_THREADS);
+  Metrics::Histogram histogram(&thread_state);
 
   for (int i = 0; i < NUM_THREADS; ++i) {
     args[i].histogram = &histogram;
@@ -158,7 +160,7 @@ TEST(MetricsUnitTest, HistogramWithThreads) {
     uv_thread_join(&args[i].thread);
   }
 
-  cass::Metrics::Histogram::Snapshot snapshot;
+  Metrics::Histogram::Snapshot snapshot;
   histogram.get_snapshot(&snapshot);
 
   EXPECT_EQ(snapshot.min, 1);
@@ -173,8 +175,8 @@ TEST(MetricsUnitTest, HistogramWithThreads) {
 }
 
 TEST(MetricsUnitTest, Meter) {
-  cass::Metrics::ThreadState thread_state(1);
-  cass::Metrics::Meter meter(&thread_state);
+  Metrics::ThreadState thread_state(1);
+  Metrics::Meter meter(&thread_state);
 
   // ~10 requests a second (Needs to run for at least 5 seconds)
   for (int i = 0; i < 51; ++i) {
@@ -188,10 +190,10 @@ TEST(MetricsUnitTest, Meter) {
   // Sleep can be off more on Windows; increasing tolerance
   // https://msdn.microsoft.com/en-us/library/windows/desktop/ms686298(v=vs.85).aspx
   tolerance = 25.0;
-# ifndef _M_X64
+#ifndef _M_X64
   // 32-bit metrics are slower on Windows (split operations)
   tolerance *= 1.5;
-# endif
+#endif
 #endif
   double expected = 10;
   double abs_error = tolerance * expected;
@@ -202,8 +204,8 @@ TEST(MetricsUnitTest, Meter) {
 }
 
 TEST(MetricsUnitTest, MeterSpeculative) {
-  cass::Metrics::ThreadState thread_state(1);
-  cass::Metrics::Meter meter(&thread_state);
+  Metrics::ThreadState thread_state(1);
+  Metrics::Meter meter(&thread_state);
 
   // Emulate a situation where for a total of 60 requests sent on the wire,
   // where 15 are unique requests and 45 are dups (speculative executions).
@@ -224,8 +226,8 @@ TEST(MetricsUnitTest, MeterSpeculative) {
 TEST(MetricsUnitTest, MeterWithThreads) {
   MeterThreadArgs args[NUM_THREADS];
 
-  cass::Metrics::ThreadState thread_state(NUM_THREADS);
-  cass::Metrics::Meter meter(&thread_state);
+  Metrics::ThreadState thread_state(NUM_THREADS);
+  Metrics::Meter meter(&thread_state);
 
   for (int i = 0; i < NUM_THREADS; ++i) {
     args[i].meter = &meter;
@@ -237,15 +239,15 @@ TEST(MetricsUnitTest, MeterWithThreads) {
   }
 
   // Sleep can be off by as much as 10+ ms on most systems (or 10% for 100ms)
-    double tolerance = 15.0;
+  double tolerance = 15.0;
 #ifdef _MSC_VER
   // Sleep can be off more on Windows; increasing tolerance
   // https://msdn.microsoft.com/en-us/library/windows/desktop/ms686298(v=vs.85).aspx
   tolerance = 25.0;
-# ifndef _M_X64
+#ifndef _M_X64
   // 32-bit metrics are slower on Windows (split operations)
   tolerance *= 1.5;
-# endif
+#endif
 #endif
   double expected = 10 * NUM_THREADS;
   double abs_error = tolerance * expected;
diff --git a/gtests/src/unit/tests/test_micro_timer.cpp b/gtests/src/unit/tests/test_micro_timer.cpp
index fa7e14441..7931d564d 100644
--- a/gtests/src/unit/tests/test_micro_timer.cpp
+++ b/gtests/src/unit/tests/test_micro_timer.cpp
@@ -18,19 +18,19 @@
 
 #include "loop_test.hpp"
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class MicroTimerUnitTest : public LoopTest {
 public:
   MicroTimerUnitTest()
-    : count_(0)
-    , repeat_timeout_us_(0) { }
+      : count_(0)
+      , repeat_timeout_us_(0) {}
 
   void test_once(uint64_t timeout_us) {
     MicroTimer timer;
 
-    timer.start(loop(), timeout_us,
-                bind_callback(&MicroTimerUnitTest::on_timer_once, this));
+    timer.start(loop(), timeout_us, bind_callback(&MicroTimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -45,8 +45,7 @@ class MicroTimerUnitTest : public LoopTest {
 
     repeat_timeout_us_ = timeout_us;
 
-    timer.start(loop(), timeout_us,
-                bind_callback(&MicroTimerUnitTest::on_timer_repeat, this));
+    timer.start(loop(), timeout_us, bind_callback(&MicroTimerUnitTest::on_timer_repeat, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -59,8 +58,7 @@ class MicroTimerUnitTest : public LoopTest {
   void test_stop() {
     MicroTimer timer;
 
-    timer.start(loop(), 1,
-                bind_callback(&MicroTimerUnitTest::on_timer_once, this));
+    timer.start(loop(), 1, bind_callback(&MicroTimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -68,8 +66,7 @@ class MicroTimerUnitTest : public LoopTest {
 
     EXPECT_FALSE(timer.is_running());
 
-    timer.start(loop(), 1,
-                bind_callback(&MicroTimerUnitTest::on_timer_once, this));
+    timer.start(loop(), 1, bind_callback(&MicroTimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -79,7 +76,6 @@ class MicroTimerUnitTest : public LoopTest {
     EXPECT_EQ(count_, 1);
   }
 
-
 private:
   void on_timer_once(MicroTimer* timer) {
     count_++;
@@ -99,66 +95,36 @@ class MicroTimerUnitTest : public LoopTest {
   uint64_t repeat_timeout_us_;
 };
 
-TEST_F(MicroTimerUnitTest, Once)
-{
-  test_once(2000);
-}
+TEST_F(MicroTimerUnitTest, Once) { test_once(2000); }
 
-TEST_F(MicroTimerUnitTest, OnceZero)
-{
-  test_once(0);
-}
+TEST_F(MicroTimerUnitTest, OnceZero) { test_once(0); }
 
-TEST_F(MicroTimerUnitTest, OnceMilliAndMicroSec)
-{
-  test_once(1200);
-}
+TEST_F(MicroTimerUnitTest, OnceMilliAndMicroSec) { test_once(1200); }
 
-TEST_F(MicroTimerUnitTest, OnceNearThreshold)
-{
+TEST_F(MicroTimerUnitTest, OnceNearThreshold) {
   test_once((1000 * CASS_PERCENT_OF_MILLSECOND_THRESHOLD) / 100);
 }
 
-TEST_F(MicroTimerUnitTest, OnceMilliAndNearThreshold)
-{
+TEST_F(MicroTimerUnitTest, OnceMilliAndNearThreshold) {
   test_once(1000 + (1000 * CASS_PERCENT_OF_MILLSECOND_THRESHOLD) / 100);
 }
 
-TEST_F(MicroTimerUnitTest, OnceMicroSec)
-{
-  test_once(1);
-}
+TEST_F(MicroTimerUnitTest, OnceMicroSec) { test_once(1); }
 
-TEST_F(MicroTimerUnitTest, Repeat)
-{
-  test_repeat(2000);
-}
+TEST_F(MicroTimerUnitTest, Repeat) { test_repeat(2000); }
 
-TEST_F(MicroTimerUnitTest, RepeatZero)
-{
-  test_repeat(0);
-}
+TEST_F(MicroTimerUnitTest, RepeatZero) { test_repeat(0); }
 
-TEST_F(MicroTimerUnitTest, RepeatMilliAndMicroSec)
-{
-  test_repeat(1200);
-}
+TEST_F(MicroTimerUnitTest, RepeatMilliAndMicroSec) { test_repeat(1200); }
 
-TEST_F(MicroTimerUnitTest, RepeatNearThreshold)
-{
+TEST_F(MicroTimerUnitTest, RepeatNearThreshold) {
   test_repeat((1000 * CASS_PERCENT_OF_MILLSECOND_THRESHOLD) / 100);
 }
 
-TEST_F(MicroTimerUnitTest, RepeatMilliAndNearThreshold)
-{
+TEST_F(MicroTimerUnitTest, RepeatMilliAndNearThreshold) {
   test_repeat(1000 + (1000 * CASS_PERCENT_OF_MILLSECOND_THRESHOLD) / 100);
 }
 
-TEST_F(MicroTimerUnitTest, RepeatMicroSec)
-{
-  test_repeat(1);
-}
+TEST_F(MicroTimerUnitTest, RepeatMicroSec) { test_repeat(1); }
 
-TEST_F(MicroTimerUnitTest, Stop) {
-  test_stop();
-}
+TEST_F(MicroTimerUnitTest, Stop) { test_stop(); }
diff --git a/gtests/src/unit/tests/test_name_resolver.cpp b/gtests/src/unit/tests/test_name_resolver.cpp
index 7a28e1ad9..14792d618 100644
--- a/gtests/src/unit/tests/test_name_resolver.cpp
+++ b/gtests/src/unit/tests/test_name_resolver.cpp
@@ -20,35 +20,27 @@
 #include "name_resolver.hpp"
 
 #ifdef WIN32
-#  include "winsock.h"
+#include "winsock.h"
 #endif
 
 #define RESOLVE_TIMEOUT 2000
 
-using cass::Address;
-using cass::bind_callback;
-using cass::Memory;
-using cass::NameResolver;
-using cass::String;
+using namespace datastax;
+using namespace datastax::internal::core;
 
 class NameResolverUnitTest : public LoopTest {
 public:
   NameResolverUnitTest()
-    : status_(NameResolver::NEW) { }
+      : status_(NameResolver::NEW) {}
 
   NameResolver::Ptr create(const Address& address) {
     return NameResolver::Ptr(
-          new NameResolver(address,
-                           bind_callback(&NameResolverUnitTest::on_resolve, this)));
+        new NameResolver(address, bind_callback(&NameResolverUnitTest::on_resolve, this)));
   }
 
-  NameResolver::Status status() const {
-    return status_;
-  }
+  NameResolver::Status status() const { return status_; }
 
-  const String& hostname() const {
-    return hostname_;
-  }
+  const String& hostname() const { return hostname_; }
 
 private:
   void on_resolve(NameResolver* resolver) {
diff --git a/gtests/src/unit/tests/test_pool.cpp b/gtests/src/unit/tests/test_pool.cpp
index 57649f1c9..79bd11504 100644
--- a/gtests/src/unit/tests/test_pool.cpp
+++ b/gtests/src/unit/tests/test_pool.cpp
@@ -18,7 +18,8 @@
 #include "ssl.hpp"
 
 #define NUM_NODES 3u
-using namespace cass;
+
+using namespace datastax::internal::core;
 
 class PoolUnitTest : public LoopTest {
 public:
@@ -27,45 +28,39 @@ class PoolUnitTest : public LoopTest {
   public:
     size_t count(State state) {
       size_t count = 0;
-      for (typename Vector<State>::const_iterator it = results_.begin(),
-           end = results_.end(); it != end; ++it) {
+      for (typename Vector<State>::const_iterator it = results_.begin(), end = results_.end();
+           it != end; ++it) {
         if (*it == state) count++;
       }
       return count;
     }
 
-    Vector<State> results() {
-      return results_;
-    }
-
+    Vector<State> results() { return results_; }
 
   protected:
-    void set(State state) {
-      results_.push_back(state);
-    }
+    void set(State state) { results_.push_back(state); }
 
   private:
     Vector<State> results_;
   };
 
   struct RequestState {
-    enum Enum {
-      SUCCESS,
-      ERROR_NO_CONNECTION,
-      ERROR_FAILED_WRITE,
-      ERROR,
-      ERROR_RESPONSE,
-      TIMEOUT
-    };
+    enum Enum { SUCCESS, ERROR_NO_CONNECTION, ERROR_FAILED_WRITE, ERROR, ERROR_RESPONSE, TIMEOUT };
 
     static const char* to_string(Enum state) {
       switch (state) {
-        case SUCCESS: return "SUCCESS";
-        case ERROR_NO_CONNECTION: return "ERROR_NO_CONNECTION";
-        case ERROR_FAILED_WRITE: return "ERROR_FAILED_WRITE";
-        case ERROR: return "ERROR";
-        case ERROR_RESPONSE: return "ERROR_RESPONSE";
-        case TIMEOUT: return "TIMEOUT";
+        case SUCCESS:
+          return "SUCCESS";
+        case ERROR_NO_CONNECTION:
+          return "ERROR_NO_CONNECTION";
+        case ERROR_FAILED_WRITE:
+          return "ERROR_FAILED_WRITE";
+        case ERROR:
+          return "ERROR";
+        case ERROR_RESPONSE:
+          return "ERROR_RESPONSE";
+        case TIMEOUT:
+          return "TIMEOUT";
       }
       return "";
     }
@@ -76,8 +71,8 @@ class PoolUnitTest : public LoopTest {
       , public Status<RequestState::Enum> {
   public:
     RequestStatus(uv_loop_t* loop, int num_nodes = NUM_NODES)
-      : loop_(loop)
-      , remaining_(num_nodes) { }
+        : loop_(loop)
+        , remaining_(num_nodes) {}
 
     virtual void set(RequestState::Enum state) {
       Status<RequestStatus::Enum>::set(state);
@@ -96,11 +91,10 @@ class PoolUnitTest : public LoopTest {
     size_t remaining_;
   };
 
-  class RequestStatusWithManager
-      : public RequestStatus {
+  class RequestStatusWithManager : public RequestStatus {
   public:
     RequestStatusWithManager(uv_loop_t* loop, int num_nodes = NUM_NODES)
-      : RequestStatus(loop, num_nodes) { }
+        : RequestStatus(loop, num_nodes) {}
 
     ~RequestStatusWithManager() {
       ConnectionPoolManager::Ptr temp(manager());
@@ -108,17 +102,11 @@ class PoolUnitTest : public LoopTest {
       uv_run(loop_, UV_RUN_DEFAULT); // Allow the loop to cleanup
     }
 
-    void set_manager(const ConnectionPoolManager::Ptr& manager) {
-      manager_ = manager;
-    }
+    void set_manager(const ConnectionPoolManager::Ptr& manager) { manager_ = manager; }
 
-    ConnectionPoolManager::Ptr manager() {
-      return manager_;
-    }
+    ConnectionPoolManager::Ptr manager() { return manager_; }
 
-    virtual void set(RequestState::Enum state) {
-      RequestStatus::set(state);
-    }
+    virtual void set(RequestState::Enum state) { RequestStatus::set(state); }
 
   private:
     ConnectionPoolManager::Ptr manager_;
@@ -138,14 +126,22 @@ class PoolUnitTest : public LoopTest {
 
     static const char* to_string(Enum state) {
       switch (state) {
-        case UP: return "UP";
-        case DOWN: return "DOWN";
-        case CRITICAL_ERROR: return "CRITICAL_ERROR";
-        case CRITICAL_ERROR_INVALID_PROTOCOL: return "CRITICAL_ERROR_INVALID_PROTOCOL";
-        case CRITICAL_ERROR_KEYSPACE: return "CRITICAL_ERROR_KEYSPACE";
-        case CRITICAL_ERROR_AUTH: return "CRITICAL_ERROR_AUTH";
-        case CRITICAL_ERROR_SSL_HANDSHAKE: return "CRITICAL_ERROR_SSL_HANDSHAKE";
-        case CRITICAL_ERROR_SSL_VERIFY: return "CRITICAL_ERROR_SSL_VERIFY";
+        case UP:
+          return "UP";
+        case DOWN:
+          return "DOWN";
+        case CRITICAL_ERROR:
+          return "CRITICAL_ERROR";
+        case CRITICAL_ERROR_INVALID_PROTOCOL:
+          return "CRITICAL_ERROR_INVALID_PROTOCOL";
+        case CRITICAL_ERROR_KEYSPACE:
+          return "CRITICAL_ERROR_KEYSPACE";
+        case CRITICAL_ERROR_AUTH:
+          return "CRITICAL_ERROR_AUTH";
+        case CRITICAL_ERROR_SSL_HANDSHAKE:
+          return "CRITICAL_ERROR_SSL_HANDSHAKE";
+        case CRITICAL_ERROR_SSL_VERIFY:
+          return "CRITICAL_ERROR_SSL_VERIFY";
       }
       return "";
     }
@@ -156,22 +152,22 @@ class PoolUnitTest : public LoopTest {
       , public Status<ListenerState::Enum> {
   public:
     ListenerStatus(uv_loop_t* loop, int num_nodes = NUM_NODES)
-      : loop_(loop)
-      , count_(num_nodes)
-      , remaining_(num_nodes) { }
+        : loop_(loop)
+        , count_(num_nodes)
+        , remaining_(num_nodes) {}
 
-    void reset() {
-      remaining_ = count_;
-    }
+    ~ListenerStatus() {}
+
+    void reset() { remaining_ = count_; }
 
-    void up() { set(UP); }
-    void down() { set(DOWN); }
-    void critical_error() { set(CRITICAL_ERROR); }
-    void critical_error_invalid_protocol() { set(CRITICAL_ERROR_INVALID_PROTOCOL); }
-    void critical_error_keyspace() { set(CRITICAL_ERROR_KEYSPACE); }
-    void critical_error_auth() { set(CRITICAL_ERROR_AUTH); }
-    void critical_error_ssl_handshake() { set(CRITICAL_ERROR_SSL_HANDSHAKE); }
-    void critical_error_ssl_verify() { set(CRITICAL_ERROR_SSL_VERIFY); }
+    virtual void up() { set(UP); }
+    virtual void down() { set(DOWN); }
+    virtual void critical_error() { set(CRITICAL_ERROR); }
+    virtual void critical_error_invalid_protocol() { set(CRITICAL_ERROR_INVALID_PROTOCOL); }
+    virtual void critical_error_keyspace() { set(CRITICAL_ERROR_KEYSPACE); }
+    virtual void critical_error_auth() { set(CRITICAL_ERROR_AUTH); }
+    virtual void critical_error_ssl_handshake() { set(CRITICAL_ERROR_SSL_HANDSHAKE); }
+    virtual void critical_error_ssl_verify() { set(CRITICAL_ERROR_SSL_VERIFY); }
 
   private:
     virtual void set(ListenerState::Enum state) {
@@ -185,30 +181,35 @@ class PoolUnitTest : public LoopTest {
     size_t remaining_;
   };
 
+  class ListenerUpStatus : public ListenerStatus {
+  public:
+    ListenerUpStatus(uv_loop_t* loop, int num_nodes = NUM_NODES)
+        : ListenerStatus(loop, num_nodes) {}
+
+    void down() {}
+    void critical_error() {}
+    void critical_error_invalid_protocol() {}
+    void critical_error_keyspace() {}
+    void critical_error_auth() {}
+    void critical_error_ssl_handshake() {}
+    void critical_error_ssl_verify() {}
+  };
+
   class Listener : public ConnectionPoolManagerListener {
   public:
     Listener(ListenerStatus* status)
-      : status_(status) { }
+        : status_(status) {}
 
-    void reset(ListenerStatus* status) {
-      status_ = status;
-    }
+    void reset(ListenerStatus* status) { status_ = status; }
 
-    ListenerStatus* status() const {
-      return status_;
-    }
+    ListenerStatus* status() const { return status_; }
 
-    virtual void on_pool_up(const Address& address)  {
-      status_->up();
-    }
+    virtual void on_pool_up(const Address& address) { status_->up(); }
 
-    virtual void on_pool_down(const Address& address) {
-      status_->down();
-    }
+    virtual void on_pool_down(const Address& address) { status_->down(); }
 
-    virtual void on_pool_critical_error(const Address& address,
-                                        Connector::ConnectionError code,
-                                        const String& message)  {
+    virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                        const String& message) {
       switch (code) {
         case Connector::CONNECTION_ERROR_INVALID_PROTOCOL:
           status_->critical_error_invalid_protocol();
@@ -231,18 +232,17 @@ class PoolUnitTest : public LoopTest {
       }
     }
 
-    virtual void on_close(ConnectionPoolManager* manager) { }
+    virtual void on_close(ConnectionPoolManager* manager) {}
 
   private:
     ListenerStatus* status_;
   };
 
-
   class RequestCallback : public SimpleRequestCallback {
   public:
     RequestCallback(RequestStatus* status)
-      : SimpleRequestCallback("SELECT * FROM blah")
-      , status_(status) { }
+        : SimpleRequestCallback("SELECT * FROM blah")
+        , status_(status) {}
 
     virtual void on_internal_set(ResponseMessage* response) {
       if (response->response_body()->opcode() == CQL_OPCODE_RESULT) {
@@ -252,26 +252,67 @@ class PoolUnitTest : public LoopTest {
       }
     }
 
-    virtual void on_internal_error(CassError code, const String& message) {
-      status_->error();
+    virtual void on_internal_error(CassError code, const String& message) { status_->error(); }
+
+    virtual void on_internal_timeout() { status_->timeout(); }
+
+  private:
+    RequestStatus* status_;
+  };
+
+  class PoolUnitTestReconnectionPolicy : public ReconnectionPolicy {
+  public:
+    typedef SharedRefPtr<PoolUnitTestReconnectionPolicy> Ptr;
+
+    PoolUnitTestReconnectionPolicy()
+        : ReconnectionPolicy(ReconnectionPolicy::CONSTANT)
+        , reconnection_schedule_count_(0)
+        , destroyed_reconnection_schedule_count_(0)
+        , scheduled_delay_count_(0) {}
+
+    virtual const char* name() const { return "blah"; }
+    virtual ReconnectionSchedule* new_reconnection_schedule() {
+      ++reconnection_schedule_count_;
+      return new ClusterUnitTestReconnectionSchedule(&scheduled_delay_count_,
+                                                     &destroyed_reconnection_schedule_count_);
     }
 
-    virtual void on_internal_timeout() {
-      status_->timeout();
+    unsigned reconnection_schedule_count() const { return reconnection_schedule_count_; }
+    unsigned destroyed_reconnection_schedule_count() const {
+      return destroyed_reconnection_schedule_count_;
     }
+    unsigned scheduled_delay_count() const { return scheduled_delay_count_; }
 
   private:
-    RequestStatus* status_;
+    unsigned reconnection_schedule_count_;
+    unsigned destroyed_reconnection_schedule_count_;
+    unsigned scheduled_delay_count_;
+
+    class ClusterUnitTestReconnectionSchedule : public ReconnectionSchedule {
+    public:
+      ClusterUnitTestReconnectionSchedule(unsigned* delay_count, unsigned* destroyed_count)
+          : delay_count_(delay_count)
+          , destroyed_count_(destroyed_count) {}
+
+      ~ClusterUnitTestReconnectionSchedule() { ++*destroyed_count_; }
+
+      virtual uint64_t next_delay_ms() {
+        ++*delay_count_;
+        return 1;
+      }
+
+    private:
+      unsigned* delay_count_;
+      unsigned* destroyed_count_;
+    };
   };
 
-  PoolUnitTest() {
-    loop()->data = NULL;
-  }
+  PoolUnitTest() { loop()->data = NULL; }
 
-  HostMap hosts() const {
+  HostMap hosts(size_t num_nodes = NUM_NODES) const {
     mockssandra::Ipv4AddressGenerator generator;
     HostMap hosts;
-    for (size_t i = 0; i < NUM_NODES; ++i) {
+    for (size_t i = 0; i < num_nodes; ++i) {
       Host::Ptr host(new Host(generator.next()));
       hosts[host->address()] = host;
     }
@@ -283,7 +324,8 @@ class PoolUnitTest : public LoopTest {
     if (connection) {
       RequestStatus status(manager->loop(), 1);
       RequestCallback::Ptr callback(new RequestCallback(&status));
-      EXPECT_TRUE(connection->write(callback.get())) << "Unable to write request to connection " << address.to_string();
+      EXPECT_TRUE(connection->write(callback.get()))
+          << "Unable to write request to connection " << address.to_string();
       connection->flush(); // Flush requests to avoid unnecessary timeouts
       uv_run(loop(), UV_RUN_DEFAULT);
       EXPECT_EQ(status.count(RequestState::SUCCESS), 1u) << status.results();
@@ -292,7 +334,8 @@ class PoolUnitTest : public LoopTest {
     }
   }
 
-  static void on_pool_connected(ConnectionPoolManagerInitializer* initializer, RequestStatusWithManager* status) {
+  static void on_pool_connected(ConnectionPoolManagerInitializer* initializer,
+                                RequestStatusWithManager* status) {
     mockssandra::Ipv4AddressGenerator generator;
     ConnectionPoolManager::Ptr manager = initializer->release_manager();
     status->set_manager(manager);
@@ -301,7 +344,7 @@ class PoolUnitTest : public LoopTest {
       PooledConnection::Ptr connection = manager->find_least_busy(generator.next());
       if (connection) {
         RequestCallback::Ptr callback(new RequestCallback(status));
-        if(!connection->write(callback.get())) {
+        if (!connection->write(callback.get())) {
           status->error_failed_write();
         }
       } else {
@@ -311,7 +354,8 @@ class PoolUnitTest : public LoopTest {
     }
   }
 
-  static void on_pool_nop(ConnectionPoolManagerInitializer* initializer, RequestStatusWithManager* status) {
+  static void on_pool_nop(ConnectionPoolManagerInitializer* initializer,
+                          RequestStatusWithManager* status) {
     ConnectionPoolManager::Ptr manager = initializer->release_manager();
     status->set_manager(manager);
   }
@@ -319,9 +363,11 @@ class PoolUnitTest : public LoopTest {
 
 std::ostream& operator<<(std::ostream& os, const Vector<PoolUnitTest::RequestState::Enum>& states) {
   os << "[";
-  bool first = true;;
+  bool first = true;
+  ;
   for (Vector<PoolUnitTest::RequestState::Enum>::const_iterator it = states.begin(),
-       end = states.end(); it != end; ++it) {
+                                                                end = states.end();
+       it != end; ++it) {
     if (!first) {
       os << ", ";
     } else {
@@ -333,11 +379,14 @@ std::ostream& operator<<(std::ostream& os, const Vector<PoolUnitTest::RequestSta
   return os;
 }
 
-std::ostream& operator<<(std::ostream& os, const Vector<PoolUnitTest::ListenerState::Enum>& states) {
+std::ostream& operator<<(std::ostream& os,
+                         const Vector<PoolUnitTest::ListenerState::Enum>& states) {
   os << "[";
-  bool first = true;;
+  bool first = true;
+  ;
   for (Vector<PoolUnitTest::ListenerState::Enum>::const_iterator it = states.begin(),
-       end = states.end(); it != end; ++it) {
+                                                                 end = states.end();
+       it != end; ++it) {
     if (!first) {
       os << ", ";
     } else {
@@ -355,13 +404,10 @@ TEST_F(PoolUnitTest, Simple) {
 
   RequestStatusWithManager status(loop());
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_connected, &status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_connected, &status)));
 
-  initializer
-      ->initialize(loop(), hosts());
+  initializer->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(status.count(RequestStatus::SUCCESS), NUM_NODES) << status.results();
@@ -370,26 +416,19 @@ TEST_F(PoolUnitTest, Simple) {
 TEST_F(PoolUnitTest, Keyspace) {
   mockssandra::SimpleRequestHandlerBuilder builder;
 
-  builder
-      .on(mockssandra::OPCODE_QUERY)
-      .use_keyspace("foo")
-      .validate_query().void_result();
+  builder.on(mockssandra::OPCODE_QUERY).use_keyspace("foo").validate_query().void_result();
   mockssandra::SimpleCluster cluster(builder.build(), NUM_NODES);
   ASSERT_EQ(cluster.start_all(), 0);
 
   RequestStatusWithManager status(loop());
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_connected, &status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_connected, &status)));
 
   HostMap hosts = this->hosts();
   ASSERT_EQ(hosts.size(), NUM_NODES);
 
-  initializer
-      ->with_keyspace("foo")
-      ->initialize(loop(), hosts);
+  initializer->with_keyspace("foo")->initialize(loop(), hosts);
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(status.count(RequestStatus::SUCCESS), NUM_NODES) << status.results();
@@ -397,8 +436,7 @@ TEST_F(PoolUnitTest, Keyspace) {
   ConnectionPoolManager::Ptr manager = status.manager();
   ASSERT_TRUE(manager);
 
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     const Address& address = it->first;
     PooledConnection::Ptr connection = manager->find_least_busy(address);
     if (connection) {
@@ -415,17 +453,14 @@ TEST_F(PoolUnitTest, Auth) {
 
   RequestStatusWithManager status(loop());
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_connected, &status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_connected, &status)));
 
   ConnectionPoolSettings settings;
-  settings.connection_settings.auth_provider.reset(new PlainTextAuthProvider("cassandra", "cassandra"));
+  settings.connection_settings.auth_provider.reset(
+      new PlainTextAuthProvider("cassandra", "cassandra"));
 
-  initializer
-      ->with_settings(settings)
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(status.count(RequestStatus::SUCCESS), NUM_NODES) << status.results();
@@ -439,14 +474,10 @@ TEST_F(PoolUnitTest, Ssl) {
 
   RequestStatusWithManager status(loop());
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_connected, &status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_connected, &status)));
 
-  initializer
-      ->with_settings(settings)
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(status.count(RequestStatus::SUCCESS), NUM_NODES) << status.results();
@@ -460,14 +491,10 @@ TEST_F(PoolUnitTest, Listener) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(listener_status.count(ListenerStatus::UP), NUM_NODES) << listener_status.results();
@@ -482,18 +509,15 @@ TEST_F(PoolUnitTest, ListenerDown) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(listener_status.count(ListenerStatus::UP), 1u) << listener_status.results();
-  EXPECT_EQ(listener_status.count(ListenerStatus::DOWN), NUM_NODES - 1) << listener_status.results();
+  EXPECT_EQ(listener_status.count(ListenerStatus::DOWN), NUM_NODES - 1)
+      << listener_status.results();
   EXPECT_EQ(initializer->failures().size(), 0u);
 }
 
@@ -507,17 +531,13 @@ TEST_F(PoolUnitTest, AddRemove) {
 
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   HostMap hosts = this->hosts();
   ASSERT_EQ(hosts.size(), NUM_NODES);
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts);
+  initializer->with_listener(listener.get())->initialize(loop(), hosts);
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(listener_status.count(ListenerStatus::UP), NUM_NODES) << listener_status.results();
@@ -526,8 +546,7 @@ TEST_F(PoolUnitTest, AddRemove) {
   ASSERT_TRUE(manager);
 
   listener->reset(&add_remove_listener_status);
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     const Address& address = it->first;
     const Host::Ptr& host = it->second;
     add_remove_listener_status.reset();
@@ -541,8 +560,10 @@ TEST_F(PoolUnitTest, AddRemove) {
     run_request(manager, address);
   }
 
-  EXPECT_EQ(add_remove_listener_status.count(ListenerStatus::DOWN), 3u) << add_remove_listener_status.results();
-  EXPECT_EQ(add_remove_listener_status.count(ListenerStatus::UP), 3u) << add_remove_listener_status.results();
+  EXPECT_EQ(add_remove_listener_status.count(ListenerStatus::DOWN), 3u)
+      << add_remove_listener_status.results();
+  EXPECT_EQ(add_remove_listener_status.count(ListenerStatus::UP), 3u)
+      << add_remove_listener_status.results();
 }
 
 TEST_F(PoolUnitTest, Reconnect) {
@@ -554,21 +575,16 @@ TEST_F(PoolUnitTest, Reconnect) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   HostMap hosts = this->hosts();
   ASSERT_EQ(hosts.size(), NUM_NODES);
 
   ConnectionPoolSettings settings;
-  settings.reconnect_wait_time_ms = 0; // Reconnect immediately
+  settings.reconnection_policy.reset(new ConstantReconnectionPolicy(0)); // Reconnect immediately
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts);
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts);
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(listener_status.count(ListenerStatus::UP), NUM_NODES) << listener_status.results();
@@ -578,8 +594,7 @@ TEST_F(PoolUnitTest, Reconnect) {
 
   listener->reset(&reconnect_listener_status);
   size_t node = 1;
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     const Address& address = it->first;
     reconnect_listener_status.reset();
 
@@ -595,8 +610,10 @@ TEST_F(PoolUnitTest, Reconnect) {
     ++node;
   }
 
-  EXPECT_EQ(reconnect_listener_status.count(ListenerStatus::DOWN), 3u) << reconnect_listener_status.results();
-  EXPECT_EQ(reconnect_listener_status.count(ListenerStatus::UP), 3u) << reconnect_listener_status.results();
+  EXPECT_EQ(reconnect_listener_status.count(ListenerStatus::DOWN), 3u)
+      << reconnect_listener_status.results();
+  EXPECT_EQ(reconnect_listener_status.count(ListenerStatus::UP), 3u)
+      << reconnect_listener_status.results();
 }
 
 TEST_F(PoolUnitTest, Timeout) {
@@ -609,24 +626,18 @@ TEST_F(PoolUnitTest, Timeout) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   ConnectionPoolSettings settings;
   settings.connection_settings.connect_timeout_ms = 200;
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
   EXPECT_EQ(listener_status.count(ListenerStatus::DOWN), NUM_NODES) << listener_status.results();
 }
 
-
 TEST_F(PoolUnitTest, InvalidProtocol) {
   mockssandra::SimpleCluster cluster(simple(), NUM_NODES);
   ASSERT_EQ(cluster.start_all(), 0);
@@ -636,32 +647,27 @@ TEST_F(PoolUnitTest, InvalidProtocol) {
   RequestStatusWithManager request_status(loop(), 0);
 
   ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          0x7F,  // Invalid protocol version
-          bind_callback(on_pool_nop, &request_status)));
+      new ConnectionPoolManagerInitializer(0x7F, // Invalid protocol version
+                                           bind_callback(on_pool_nop, &request_status)));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
-  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_INVALID_PROTOCOL), 0u) << listener_status.results();
+  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_INVALID_PROTOCOL), 0u)
+      << listener_status.results();
 
   ConnectionPoolConnector::Vec failures = initializer->failures();
   EXPECT_EQ(failures.size(), NUM_NODES);
 
-  for (ConnectionPoolConnector::Vec::const_iterator it = failures.begin(),
-       end = failures.end(); it != end; ++it) {
+  for (ConnectionPoolConnector::Vec::const_iterator it = failures.begin(), end = failures.end();
+       it != end; ++it) {
     EXPECT_EQ((*it)->error_code(), Connector::CONNECTION_ERROR_INVALID_PROTOCOL);
   }
 }
 
 TEST_F(PoolUnitTest, InvalidKeyspace) {
   mockssandra::SimpleRequestHandlerBuilder builder;
-  builder
-      .on(mockssandra::OPCODE_QUERY)
-      .use_keyspace("foo")
-      .validate_query().void_result();
+  builder.on(mockssandra::OPCODE_QUERY).use_keyspace("foo").validate_query().void_result();
   mockssandra::SimpleCluster cluster(builder.build(), NUM_NODES);
   ASSERT_EQ(cluster.start_all(), 0);
 
@@ -669,18 +675,14 @@ TEST_F(PoolUnitTest, InvalidKeyspace) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
-
-  initializer
-      ->with_keyspace("invalid")
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
+
+  initializer->with_keyspace("invalid")->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
-  EXPECT_EQ(listener_status.count(ListenerStatus::CRITICAL_ERROR_KEYSPACE), NUM_NODES) << listener_status.results();
+  EXPECT_EQ(listener_status.count(ListenerStatus::CRITICAL_ERROR_KEYSPACE), NUM_NODES)
+      << listener_status.results();
 }
 
 TEST_F(PoolUnitTest, InvalidAuth) {
@@ -691,21 +693,17 @@ TEST_F(PoolUnitTest, InvalidAuth) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   ConnectionPoolSettings settings;
   settings.connection_settings.auth_provider.reset(new PlainTextAuthProvider("invalid", "invalid"));
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
-  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_AUTH), 0u) << listener_status.results();
+  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_AUTH), 0u)
+      << listener_status.results();
 }
 
 TEST_F(PoolUnitTest, InvalidNoSsl) {
@@ -716,10 +714,8 @@ TEST_F(PoolUnitTest, InvalidNoSsl) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   SslContext::Ptr ssl_context(SslContextFactory::create());
 
@@ -727,13 +723,11 @@ TEST_F(PoolUnitTest, InvalidNoSsl) {
   settings.connection_settings.socket_settings.ssl_context = ssl_context;
   settings.connection_settings.socket_settings.hostname_resolution_enabled = true;
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
-  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_SSL_HANDSHAKE), 0u) << listener_status.results();
+  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_SSL_HANDSHAKE), 0u)
+      << listener_status.results();
 }
 
 TEST_F(PoolUnitTest, InvalidSsl) {
@@ -745,10 +739,8 @@ TEST_F(PoolUnitTest, InvalidSsl) {
   ScopedPtr<Listener> listener(new Listener(&listener_status));
   RequestStatusWithManager request_status(loop(), 0);
 
-  ConnectionPoolManagerInitializer::Ptr initializer(
-        new ConnectionPoolManagerInitializer(
-          PROTOCOL_VERSION,
-          bind_callback(on_pool_nop, &request_status)));
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
 
   SslContext::Ptr ssl_context(SslContextFactory::create()); // No trusted cert
 
@@ -756,13 +748,50 @@ TEST_F(PoolUnitTest, InvalidSsl) {
   settings.connection_settings.socket_settings.ssl_context = ssl_context;
   settings.connection_settings.socket_settings.hostname_resolution_enabled = true;
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(loop(), hosts());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts());
   uv_run(loop(), UV_RUN_DEFAULT);
 
-  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_SSL_VERIFY), 0u) << listener_status.results();
+  EXPECT_GT(listener_status.count(ListenerStatus::CRITICAL_ERROR_SSL_VERIFY), 0u)
+      << listener_status.results();
+}
+
+TEST_F(PoolUnitTest, ReconnectionPolicy) {
+  mockssandra::SimpleCluster cluster(simple(), 2);
+  ASSERT_EQ(cluster.start_all(), 0);
+
+  ListenerStatus listener_status(loop(), 2);
+  ListenerStatus reconnect_listener_status(loop(), 1);
+  ScopedPtr<Listener> listener(new Listener(&listener_status));
+  RequestStatusWithManager request_status(loop(), 0);
+
+  ConnectionPoolManagerInitializer::Ptr initializer(new ConnectionPoolManagerInitializer(
+      PROTOCOL_VERSION, bind_callback(on_pool_nop, &request_status)));
+
+  HostMap hosts = this->hosts(2);
+  ConnectionPoolSettings settings;
+  settings.reconnection_policy.reset(new PoolUnitTestReconnectionPolicy());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(loop(), hosts);
+  uv_run(loop(), UV_RUN_DEFAULT);
+  EXPECT_EQ(listener_status.count(ListenerStatus::UP), 2u) << listener_status.results();
+
+  // Stop and start node 1 twice engaging the reconnection policy
+  listener->reset(&reconnect_listener_status);
+  for (int i = 0; i < 2; ++i) {
+    reconnect_listener_status.reset();
+    cluster.stop(1);
+    uv_run(loop(), UV_RUN_DEFAULT);
+    reconnect_listener_status.reset();
+    ASSERT_EQ(cluster.start(1), 0);
+    uv_run(loop(), UV_RUN_DEFAULT);
+  }
+
+  PoolUnitTestReconnectionPolicy::Ptr policy(
+      static_cast<PoolUnitTestReconnectionPolicy::Ptr>(settings.reconnection_policy));
+  EXPECT_EQ(2u, policy->reconnection_schedule_count());
+  EXPECT_EQ(2u, policy->destroyed_reconnection_schedule_count());
+  EXPECT_EQ(2u, policy->scheduled_delay_count());
+  EXPECT_EQ(3u, cluster.connection_attempts(1)); // Includes initial connection attempt
+  EXPECT_EQ(1u, cluster.connection_attempts(2));
 }
 
 TEST_F(PoolUnitTest, PartialReconnect) {
diff --git a/gtests/src/unit/tests/test_protocol_version.cpp b/gtests/src/unit/tests/test_protocol_version.cpp
index 55e51c822..b4608cfcf 100644
--- a/gtests/src/unit/tests/test_protocol_version.cpp
+++ b/gtests/src/unit/tests/test_protocol_version.cpp
@@ -21,26 +21,22 @@
 #include "cassandra.h"
 #include "protocol.hpp"
 
-using cass::ProtocolVersion;
+using datastax::internal::core::ProtocolVersion;
 
-class ProtocolVersionUnitTest : public Unit { };
+class ProtocolVersionUnitTest : public Unit {};
 
 TEST_F(ProtocolVersionUnitTest, LowestSupported) {
-  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V3),
-            ProtocolVersion::lowest_supported());
+  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V3), ProtocolVersion::lowest_supported());
 }
 
 TEST_F(ProtocolVersionUnitTest, HighestSupported) {
-  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V4),
-            ProtocolVersion::highest_supported());
+  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V4), ProtocolVersion::highest_supported());
 }
 
 TEST_F(ProtocolVersionUnitTest, NewestBeta) {
-  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V5),
-            ProtocolVersion::newest_beta());
+  EXPECT_EQ(ProtocolVersion(CASS_PROTOCOL_VERSION_V5), ProtocolVersion::newest_beta());
 }
 
-
 TEST_F(ProtocolVersionUnitTest, IsValid) {
   { // Invalid
     ProtocolVersion invalid;
diff --git a/gtests/src/unit/tests/test_random.cpp b/gtests/src/unit/tests/test_random.cpp
index 00d7d0bff..af8f359b2 100644
--- a/gtests/src/unit/tests/test_random.cpp
+++ b/gtests/src/unit/tests/test_random.cpp
@@ -20,90 +20,223 @@
 #include "third_party/hdr_histogram/hdr_histogram.hpp"
 #include "vector.hpp"
 
+using namespace datastax::internal;
+
 // 626 of the first numbers generated with the default seed of 5489LL using boost::mt19937_64
 uint64_t random_numbers[] = {
-  14514284786278117030ULL,4620546740167642908ULL,13109570281517897720ULL,17462938647148434322ULL,355488278567739596ULL,7469126240319926998ULL,4635995468481642529ULL,418970542659199878ULL,
-  9604170989252516556ULL,6358044926049913402ULL,5058016125798318033ULL,10349215569089701407ULL,2583272014892537200ULL,10032373690199166667ULL,9627645531742285868ULL,15810285301089087632ULL,
-  9219209713614924562ULL,7736011505917826031ULL,13729552270962724157ULL,4596340717661012313ULL,4413874586873285858ULL,5904155143473820934ULL,16795776195466785825ULL,3040631852046752166ULL,
-  4529279813148173111ULL,3658352497551999605ULL,13205889818278417278ULL,17853215078830450730ULL,14193508720503142180ULL,1488787817663097441ULL,8484116316263611556ULL,4745643133208116498ULL,
-  14333959900198994173ULL,10770733876927207790ULL,17529942701849009476ULL,8081518017574486547ULL,5945178879512507902ULL,9821139136195250096ULL,4728986788662773602ULL,840062144447779464ULL,
-  9315169977352719788ULL,12843335216705846126ULL,1682692516156909696ULL,16733405176195045732ULL,570275675392078508ULL,2804578118555336986ULL,18105853946332827420ULL,11444576169427052165ULL,
-  5511269538150904327ULL,6665263661402689669ULL,8872308438533970361ULL,5494304472256329401ULL,5260777597240341458ULL,17048363385688465216ULL,11601203342555724204ULL,13927871433293278342ULL,
-  13168989862813642697ULL,13332527631701716084ULL,1288265801825883165ULL,8980511589347843149ULL,1639193574298669424ULL,14012553476551396225ULL,7818048564976445173ULL,11012385938523194722ULL,
-  1594098091654903511ULL,5035242355473277827ULL,11507220397369885600ULL,4097669440061230013ULL,4158775797243890311ULL,8008476757622511610ULL,18212599999684195413ULL,3892070972454396029ULL,
-  15739033291548026583ULL,5240984520368774617ULL,15428220128146522508ULL,6764778500174078837ULL,17250425930626079997ULL,15862445320841941901ULL,9055707723866709616ULL,407278260229756649ULL,
-  6679883267401891436ULL,13585010976506536654ULL,9580697194899010248ULL,7802093638911637786ULL,535562807229422763ULL,16772549087470588412ULL,2069348082463192648ULL,18080878539236249869ULL,
-  12688200000096479737ULL,8989665349769173357ULL,13575112928849473200ULL,10859033464356012248ULL,9748216112997718693ULL,8405158063935141693ULL,15279502632583570477ULL,16055899490125284200ULL,
-  9066388900883848980ULL,17884680971936629565ULL,16395391805201036549ULL,2550532686790805254ULL,8052938288948613298ULL,6344035301348514175ULL,2193824757648316037ULL,10113332896580941759ULL,
-  14001553499759966766ULL,597702890888347204ULL,1874324574384293454ULL,10826913572691111562ULL,12821185545071087721ULL,14606566723149387105ULL,15679487422249894303ULL,16146086267469614290ULL,
-  11169330698794304272ULL,17590151747242102595ULL,18278229723818623796ULL,15994633360516603469ULL,11881756471423721131ULL,11153906733009525059ULL,16836145075420168747ULL,8614597919830747987ULL,
-  1459907787369619658ULL,16682004712721580156ULL,15261848763679157527ULL,2717413695111288049ULL,14889665525641206303ULL,12338480473037317818ULL,2557597240994564872ULL,12402353581130313583ULL,
-  15355546302939095474ULL,17651033590338072704ULL,11616809212196625943ULL,6561978461173088746ULL,5962436378610109024ULL,1168012300494473422ULL,5175053317267933097ULL,4740525681678845797ULL,
-  1614376253554691208ULL,1358027693590031708ULL,1856992378370522222ULL,2410813678132517023ULL,11582456654366157909ULL,5754940895753314317ULL,17548218371729667895ULL,17945642044770404276ULL,
-  3721164045489467070ULL,13394551493150992827ULL,12475264300415171883ULL,10462606688633056562ULL,13251365510693735175ULL,3876338822302790600ULL,13771801863059799470ULL,13815564444636394855ULL,
-  16495110748802246170ULL,2156091871580385249ULL,12069080176326280986ULL,489805578737239572ULL,5271183164515543116ULL,11286401144444756863ULL,6746000579485080744ULL,5186625150343537151ULL,
-  13119883039086991857ULL,16025170396082521338ULL,2259331576759215945ULL,16362343102415556603ULL,10982898132796723193ULL,14666888772828547003ULL,10462483830193419334ULL,18236154274104239589ULL,
-  17759599582309981676ULL,9339512652453242670ULL,14635458573977612405ULL,13273192362623128494ULL,7419053614262815071ULL,2139880725825605974ULL,15336265650071823816ULL,6291952205449675957ULL,
-  14977329074317573394ULL,4364768269648744391ULL,17232241565077788317ULL,8450549923677533764ULL,15732483035355013039ULL,13831185231495622915ULL,6819123640184841760ULL,11886944798543888851ULL,
-  10879889186777890996ULL,15555433551230813341ULL,105259452319848079ULL,3441909642659419332ULL,5480947869602487239ULL,6247709904124292706ULL,13391610271247915041ULL,18346462037123761313ULL,
-  16636317150577797347ULL,14149179703416851896ULL,2376171948756359367ULL,5152472389910152792ULL,2368047066677070121ULL,16396163399604156946ULL,14864288050288048653ULL,7393398358587456124ULL,
-  9728143941576351989ULL,5481913815176021747ULL,16927964714362701213ULL,14993236783745363262ULL,9552302871570670457ULL,11071069341174528295ULL,15381321939083200837ULL,8816171210895558106ULL,
-  6071991122052964372ULL,10925078611503375837ULL,15239629154712277871ULL,8615167154188153180ULL,4917230293625512515ULL,14895742215835130464ULL,2359753755290725009ULL,6783321469015983851ULL,
-  360705462143558065ULL,2287732638733919300ULL,2984153050512747353ULL,8021412450653308816ULL,12759258587083258672ULL,1585563973173997547ULL,18209504305389149669ULL,11416757620121532143ULL,
-  6846989578536141166ULL,4365862612957164362ULL,2931876801952518067ULL,680191398818283694ULL,1834352496547951770ULL,12616538556720116808ULL,17563613795929063197ULL,14519515363534791688ULL,
-  4349527158980778739ULL,6714794984698083967ULL,6696141578113299617ULL,17231874453010340947ULL,18425812703539835928ULL,3707544366662920973ULL,10197276740411893574ULL,12864434420502416888ULL,
-  12767250491273234520ULL,1588549204908870909ULL,6610295429674120152ULL,5281895767268096036ULL,1739897672032589486ULL,17406469206626426854ULL,8710378533013875691ULL,9587926405039941516ULL,
-  2805299725371867574ULL,7146901261023555807ULL,1825062423171923931ULL,3049052876249887095ULL,10771741767689142181ULL,8733642741329011601ULL,11979515434717210935ULL,10043245691272652957ULL,
-  5830279975302858953ULL,17190113074333440499ULL,18260575806620923460ULL,14335648769917655401ULL,4153816861017702156ULL,14590500750979768984ULL,810991542442466488ULL,7089785717813579612ULL,
-  12357837562747114001ULL,5554121432788679660ULL,5931025703748246718ULL,2097835176693352889ULL,12745618408404359587ULL,6090924568528767236ULL,14734637834598564704ULL,14439652293742648615ULL,
-  132405348116615733ULL,13869945305505934743ULL,7372953811704808036ULL,7756437368369298361ULL,3794582695199039623ULL,12917619229835701974ULL,14320084076906478671ULL,2606626751703588462ULL,
-  3137561743724131360ULL,13808802441028589896ULL,14231944027275971054ULL,16852581317945783254ULL,10323673491841952054ULL,2313335010769237820ULL,13955532667350441768ULL,5747153089934705338ULL,
-  13377135145695875091ULL,6830230899286657495ULL,81856298782858401ULL,1754724887913860152ULL,13750479713795882912ULL,11120120136303124367ULL,15046307382468953177ULL,3696979254055818020ULL,
-  15352898388246644384ULL,1024778962410818770ULL,2388728043318081123ULL,6871857727931721608ULL,17721619206096294273ULL,10585202864517959301ULL,10898249199547365704ULL,9663430180652362739ULL,
-  1737102419936989910ULL,5117227310201589790ULL,16884367896390523102ULL,10498150099412419335ULL,1921007855220546564ULL,7643484074408755248ULL,11318429053286342939ULL,1370093900783164344ULL,
-  6776537281339823025ULL,3450492372588984223ULL,9401014545757436331ULL,7896519943553875907ULL,14303443932332314010ULL,281238069833157985ULL,9628364435514671685ULL,1035647896705322917ULL,
-  940113500519447970ULL,12858978713386075837ULL,2103046007104782505ULL,1170332608028903179ULL,6569179731999105361ULL,9795365446060253382ULL,3663276878692063340ULL,11746321300354091749ULL,
-  5408361990473950532ULL,9735653452670998906ULL,4324195634733601175ULL,9037136744494003310ULL,10715330324656609711ULL,3474343689175121886ULL,5794004792094061662ULL,13295581273946061060ULL,
-  7292949743142825837ULL,10886028626057941279ULL,10688849249577735178ULL,17297010345160851373ULL,13658139148821214513ULL,4468290234101910565ULL,9583516840381960864ULL,2100818272677130469ULL,
-  3835407486618772476ULL,11687972045781987867ULL,2584265809482868424ULL,2184370854727222683ULL,17762352308671769689ULL,10901114407297935135ULL,17932666452350314317ULL,14800534017102555607ULL,
-  16233839909626358812ULL,1704089397092793640ULL,2891239861334407450ULL,18077585692287687954ULL,2363047449739120434ULL,5904357530901606076ULL,16765772907460692007ULL,8757786729323486734ULL,
-  3706883612695347371ULL,14958907430930711064ULL,9624134580897548276ULL,10298009507777483067ULL,5667412839234900228ULL,6828701555684071915ULL,10482797977665945217ULL,13440894740881464138ULL,
-  12078258924098889769ULL,5740761565098658841ULL,13914375003115830180ULL,16808960379045776034ULL,18421450170384511575ULL,16478974619417516521ULL,14381565232287562804ULL,12792472782420522791ULL,
-  6620422687983566193ULL,12025299949416885293ULL,6046334025019123ULL,16769051888439418536ULL,10312203372653850423ULL,720028297035890629ULL,6441255456466558203ULL,9874005816230679263ULL,
-  15903170012916142038ULL,7557768652767625223ULL,17626605079857371651ULL,9092603716684679963ULL,15518831173015579794ULL,300798272301981904ULL,13762040857722893585ULL,3117104080838901168ULL,
-  4702649037537941245ULL,14408238429167682374ULL,17923200330177894118ULL,7470538549881440849ULL,3664543122474851710ULL,17626200978883719521ULL,15355649603762884691ULL,4749231114166154448ULL,
-  11220859020615935192ULL,4740127963151294603ULL,16616708905207951068ULL,9828299274924872726ULL,8985762004928355786ULL,14578866413196595465ULL,11009044264074492189ULL,16196760954725621137ULL,
-  10725252972011913420ULL,4601011175737567235ULL,1441938685024169613ULL,1896485105672535586ULL,6635496128279078494ULL,7401072902622950072ULL,16075245295895555285ULL,11009539992705810569ULL,
-  13666961049432909413ULL,930044899627839572ULL,7899294831116079515ULL,7830402010660588539ULL,5485720725031791061ULL,17051528642209786987ULL,7280223907880312904ULL,10641556535303807158ULL,
-  12639056541805784436ULL,12321318600465693220ULL,10108223508416203621ULL,16243972184205577210ULL,8544062083712081766ULL,11274622334580836223ULL,10844017387984539333ULL,14774228730866078526ULL,
-  560237794062265107ULL,5844494700804214355ULL,12270220729021534083ULL,8560016492134621125ULL,12198417933760222474ULL,10133839346494565561ULL,9295901871619786454ULL,10849442312533122519ULL,
-  18021432643418872607ULL,10155396024449547909ULL,10524212640889309144ULL,16662796689072019468ULL,965963318619140447ULL,8887484786999567242ULL,15714444653107301219ULL,1678356452623540647ULL,
-  11052117692502964420ULL,14549914962216724919ULL,2062106447906584711ULL,9160372737526136799ULL,408961132483689555ULL,16057982805180036489ULL,3569128826873655261ULL,9330490631980133992ULL,
-  1176328083272936519ULL,11222898184704497134ULL,9302091588024171405ULL,10671057562378043302ULL,4098229850247478874ULL,8603114141751656125ULL,5095034292565071557ULL,17972196540767155575ULL,
-  17052421619317624598ULL,1582078615100434096ULL,12012345949788712038ULL,16161371278263065802ULL,2541771182459136706ULL,4555228648728151989ULL,8434259952664443907ULL,11417314755930316675ULL,
-  4859944209493970278ULL,3960064386733120970ULL,831798891742765072ULL,15333350611999607709ULL,16195235791627584805ULL,11597945977924582290ULL,5623573319924035254ULL,11517834322140013944ULL,
-  4133597640080778846ULL,5871425684860123605ULL,1689282515842046354ULL,12636468992840026995ULL,14838814546330146559ULL,521771145052581487ULL,2880434048302248640ULL,8371131723257691693ULL,
-  14881811984607317690ULL,1324986559026356337ULL,15096177686518116013ULL,4421234407032663127ULL,14405416956529710514ULL,3720189381923668652ULL,409223713688462738ULL,9606291214917499037ULL,
-  9223836018030016969ULL,190459553092726002ULL,12216883190512504355ULL,2445407445757699168ULL,4632853494959579227ULL,13184809158706083946ULL,5787237245171889527ULL,10294885203231741175ULL,
-  4191072920233802133ULL,4291939441266046279ULL,16375865614446560083ULL,8623994097296487259ULL,15309273767847758202ULL,9397335507036899909ULL,6747046333776906674ULL,13832845734789247298ULL,
-  7019441607318179720ULL,10005910351872177492ULL,4145022192145704170ULL,4353043221960833896ULL,8973895156742077167ULL,438950987149754489ULL,2185272607213603213ULL,8466605802960622962ULL,
-  12110999198806592422ULL,11821045514824268224ULL,10878266882585355136ULL,11760743717116988087ULL,4184976790109698342ULL,18330309416210613006ULL,1107206443001387417ULL,79384941109554222ULL,
-  9163366224008952362ULL,3321824684344751056ULL,3693723307432954164ULL,6079394558849393056ULL,11401125038466760935ULL,3656219353656357222ULL,1735342045865967049ULL,4042759343240967690ULL,
-  12711975181279962687ULL,9500297538285176400ULL,15298274009373410204ULL,9806309365986113958ULL,10640867530898511005ULL,17462737140104853956ULL,4414872795937286161ULL,14852747253248972903ULL,
-  15278706409822090441ULL,6433625831299907179ULL,3321907667985685429ULL,11390693584827212740ULL,11529629266037992234ULL,10328859824139248147ULL,16428469301035734767ULL,17926643922068445985ULL,
-  705326063324784242ULL,8105287564212541268ULL,15433828269766668455ULL,3714790519415313767ULL,5417718938962187987ULL,7847045502609209896ULL,8025090526912661197ULL,2234136672994823541ULL,
-  16041001438425499955ULL,10050820915370092068ULL,14731208739754682952ULL,9320476318639351023ULL,14993011533295358880ULL,4179632880986595543ULL,8947621078428360390ULL,14715184767037401701ULL,
-  2617407252848328649ULL,4818108510694228841ULL,3602814087839803186ULL,14679368779377024657ULL,7354547195052671772ULL,453184876960970470ULL,15781004944602184656ULL,12000277437894508493ULL,
-  14990587330205222466ULL,13913588124149397652ULL,14252160166631667289ULL,1532590395334038243ULL,10283229111568663870ULL,17325140074534683390ULL,15829693190940193580ULL,7621681592523599724ULL,
-  10682206684717316020ULL,1847393779801417006ULL,3066262069769536156ULL,14633662576956154615ULL,15324290530255177253ULL,14627271171597064522ULL,14334883061544405592ULL,12329324284039697670ULL,
-  14425669906700626239ULL,4967072546582904838ULL,11336784484312139551ULL,9293117687355182150ULL,18198595579111618687ULL,3236555730692485133ULL,3659681352365625914ULL,5185822088933195476ULL,
-  1820961806679957133ULL,5103404090674191862ULL,16176358349875499548ULL,15699479324816269479ULL,6929077312607579230ULL,7724671543660786314ULL,15226863704421704735ULL,10411799650043017788ULL,
-  2743533500235068318ULL,7917895244279791454ULL,9194839772540541837ULL,8170679394364395846ULL,2830213237197365734ULL,7353896603754987224ULL,17634372441601249827ULL,8515117661105161813ULL,
-  5818937363197514778ULL,8536843065945835629ULL,2920190566549352463ULL,4206179361653770600ULL,15470355568872211976ULL,8427825008315838911ULL,5786540713287383830ULL,15547153445796060183ULL,
-  12329720415526259303ULL,5557519966701086911ULL };
+  14514284786278117030ULL, 4620546740167642908ULL,  13109570281517897720ULL,
+  17462938647148434322ULL, 355488278567739596ULL,   7469126240319926998ULL,
+  4635995468481642529ULL,  418970542659199878ULL,   9604170989252516556ULL,
+  6358044926049913402ULL,  5058016125798318033ULL,  10349215569089701407ULL,
+  2583272014892537200ULL,  10032373690199166667ULL, 9627645531742285868ULL,
+  15810285301089087632ULL, 9219209713614924562ULL,  7736011505917826031ULL,
+  13729552270962724157ULL, 4596340717661012313ULL,  4413874586873285858ULL,
+  5904155143473820934ULL,  16795776195466785825ULL, 3040631852046752166ULL,
+  4529279813148173111ULL,  3658352497551999605ULL,  13205889818278417278ULL,
+  17853215078830450730ULL, 14193508720503142180ULL, 1488787817663097441ULL,
+  8484116316263611556ULL,  4745643133208116498ULL,  14333959900198994173ULL,
+  10770733876927207790ULL, 17529942701849009476ULL, 8081518017574486547ULL,
+  5945178879512507902ULL,  9821139136195250096ULL,  4728986788662773602ULL,
+  840062144447779464ULL,   9315169977352719788ULL,  12843335216705846126ULL,
+  1682692516156909696ULL,  16733405176195045732ULL, 570275675392078508ULL,
+  2804578118555336986ULL,  18105853946332827420ULL, 11444576169427052165ULL,
+  5511269538150904327ULL,  6665263661402689669ULL,  8872308438533970361ULL,
+  5494304472256329401ULL,  5260777597240341458ULL,  17048363385688465216ULL,
+  11601203342555724204ULL, 13927871433293278342ULL, 13168989862813642697ULL,
+  13332527631701716084ULL, 1288265801825883165ULL,  8980511589347843149ULL,
+  1639193574298669424ULL,  14012553476551396225ULL, 7818048564976445173ULL,
+  11012385938523194722ULL, 1594098091654903511ULL,  5035242355473277827ULL,
+  11507220397369885600ULL, 4097669440061230013ULL,  4158775797243890311ULL,
+  8008476757622511610ULL,  18212599999684195413ULL, 3892070972454396029ULL,
+  15739033291548026583ULL, 5240984520368774617ULL,  15428220128146522508ULL,
+  6764778500174078837ULL,  17250425930626079997ULL, 15862445320841941901ULL,
+  9055707723866709616ULL,  407278260229756649ULL,   6679883267401891436ULL,
+  13585010976506536654ULL, 9580697194899010248ULL,  7802093638911637786ULL,
+  535562807229422763ULL,   16772549087470588412ULL, 2069348082463192648ULL,
+  18080878539236249869ULL, 12688200000096479737ULL, 8989665349769173357ULL,
+  13575112928849473200ULL, 10859033464356012248ULL, 9748216112997718693ULL,
+  8405158063935141693ULL,  15279502632583570477ULL, 16055899490125284200ULL,
+  9066388900883848980ULL,  17884680971936629565ULL, 16395391805201036549ULL,
+  2550532686790805254ULL,  8052938288948613298ULL,  6344035301348514175ULL,
+  2193824757648316037ULL,  10113332896580941759ULL, 14001553499759966766ULL,
+  597702890888347204ULL,   1874324574384293454ULL,  10826913572691111562ULL,
+  12821185545071087721ULL, 14606566723149387105ULL, 15679487422249894303ULL,
+  16146086267469614290ULL, 11169330698794304272ULL, 17590151747242102595ULL,
+  18278229723818623796ULL, 15994633360516603469ULL, 11881756471423721131ULL,
+  11153906733009525059ULL, 16836145075420168747ULL, 8614597919830747987ULL,
+  1459907787369619658ULL,  16682004712721580156ULL, 15261848763679157527ULL,
+  2717413695111288049ULL,  14889665525641206303ULL, 12338480473037317818ULL,
+  2557597240994564872ULL,  12402353581130313583ULL, 15355546302939095474ULL,
+  17651033590338072704ULL, 11616809212196625943ULL, 6561978461173088746ULL,
+  5962436378610109024ULL,  1168012300494473422ULL,  5175053317267933097ULL,
+  4740525681678845797ULL,  1614376253554691208ULL,  1358027693590031708ULL,
+  1856992378370522222ULL,  2410813678132517023ULL,  11582456654366157909ULL,
+  5754940895753314317ULL,  17548218371729667895ULL, 17945642044770404276ULL,
+  3721164045489467070ULL,  13394551493150992827ULL, 12475264300415171883ULL,
+  10462606688633056562ULL, 13251365510693735175ULL, 3876338822302790600ULL,
+  13771801863059799470ULL, 13815564444636394855ULL, 16495110748802246170ULL,
+  2156091871580385249ULL,  12069080176326280986ULL, 489805578737239572ULL,
+  5271183164515543116ULL,  11286401144444756863ULL, 6746000579485080744ULL,
+  5186625150343537151ULL,  13119883039086991857ULL, 16025170396082521338ULL,
+  2259331576759215945ULL,  16362343102415556603ULL, 10982898132796723193ULL,
+  14666888772828547003ULL, 10462483830193419334ULL, 18236154274104239589ULL,
+  17759599582309981676ULL, 9339512652453242670ULL,  14635458573977612405ULL,
+  13273192362623128494ULL, 7419053614262815071ULL,  2139880725825605974ULL,
+  15336265650071823816ULL, 6291952205449675957ULL,  14977329074317573394ULL,
+  4364768269648744391ULL,  17232241565077788317ULL, 8450549923677533764ULL,
+  15732483035355013039ULL, 13831185231495622915ULL, 6819123640184841760ULL,
+  11886944798543888851ULL, 10879889186777890996ULL, 15555433551230813341ULL,
+  105259452319848079ULL,   3441909642659419332ULL,  5480947869602487239ULL,
+  6247709904124292706ULL,  13391610271247915041ULL, 18346462037123761313ULL,
+  16636317150577797347ULL, 14149179703416851896ULL, 2376171948756359367ULL,
+  5152472389910152792ULL,  2368047066677070121ULL,  16396163399604156946ULL,
+  14864288050288048653ULL, 7393398358587456124ULL,  9728143941576351989ULL,
+  5481913815176021747ULL,  16927964714362701213ULL, 14993236783745363262ULL,
+  9552302871570670457ULL,  11071069341174528295ULL, 15381321939083200837ULL,
+  8816171210895558106ULL,  6071991122052964372ULL,  10925078611503375837ULL,
+  15239629154712277871ULL, 8615167154188153180ULL,  4917230293625512515ULL,
+  14895742215835130464ULL, 2359753755290725009ULL,  6783321469015983851ULL,
+  360705462143558065ULL,   2287732638733919300ULL,  2984153050512747353ULL,
+  8021412450653308816ULL,  12759258587083258672ULL, 1585563973173997547ULL,
+  18209504305389149669ULL, 11416757620121532143ULL, 6846989578536141166ULL,
+  4365862612957164362ULL,  2931876801952518067ULL,  680191398818283694ULL,
+  1834352496547951770ULL,  12616538556720116808ULL, 17563613795929063197ULL,
+  14519515363534791688ULL, 4349527158980778739ULL,  6714794984698083967ULL,
+  6696141578113299617ULL,  17231874453010340947ULL, 18425812703539835928ULL,
+  3707544366662920973ULL,  10197276740411893574ULL, 12864434420502416888ULL,
+  12767250491273234520ULL, 1588549204908870909ULL,  6610295429674120152ULL,
+  5281895767268096036ULL,  1739897672032589486ULL,  17406469206626426854ULL,
+  8710378533013875691ULL,  9587926405039941516ULL,  2805299725371867574ULL,
+  7146901261023555807ULL,  1825062423171923931ULL,  3049052876249887095ULL,
+  10771741767689142181ULL, 8733642741329011601ULL,  11979515434717210935ULL,
+  10043245691272652957ULL, 5830279975302858953ULL,  17190113074333440499ULL,
+  18260575806620923460ULL, 14335648769917655401ULL, 4153816861017702156ULL,
+  14590500750979768984ULL, 810991542442466488ULL,   7089785717813579612ULL,
+  12357837562747114001ULL, 5554121432788679660ULL,  5931025703748246718ULL,
+  2097835176693352889ULL,  12745618408404359587ULL, 6090924568528767236ULL,
+  14734637834598564704ULL, 14439652293742648615ULL, 132405348116615733ULL,
+  13869945305505934743ULL, 7372953811704808036ULL,  7756437368369298361ULL,
+  3794582695199039623ULL,  12917619229835701974ULL, 14320084076906478671ULL,
+  2606626751703588462ULL,  3137561743724131360ULL,  13808802441028589896ULL,
+  14231944027275971054ULL, 16852581317945783254ULL, 10323673491841952054ULL,
+  2313335010769237820ULL,  13955532667350441768ULL, 5747153089934705338ULL,
+  13377135145695875091ULL, 6830230899286657495ULL,  81856298782858401ULL,
+  1754724887913860152ULL,  13750479713795882912ULL, 11120120136303124367ULL,
+  15046307382468953177ULL, 3696979254055818020ULL,  15352898388246644384ULL,
+  1024778962410818770ULL,  2388728043318081123ULL,  6871857727931721608ULL,
+  17721619206096294273ULL, 10585202864517959301ULL, 10898249199547365704ULL,
+  9663430180652362739ULL,  1737102419936989910ULL,  5117227310201589790ULL,
+  16884367896390523102ULL, 10498150099412419335ULL, 1921007855220546564ULL,
+  7643484074408755248ULL,  11318429053286342939ULL, 1370093900783164344ULL,
+  6776537281339823025ULL,  3450492372588984223ULL,  9401014545757436331ULL,
+  7896519943553875907ULL,  14303443932332314010ULL, 281238069833157985ULL,
+  9628364435514671685ULL,  1035647896705322917ULL,  940113500519447970ULL,
+  12858978713386075837ULL, 2103046007104782505ULL,  1170332608028903179ULL,
+  6569179731999105361ULL,  9795365446060253382ULL,  3663276878692063340ULL,
+  11746321300354091749ULL, 5408361990473950532ULL,  9735653452670998906ULL,
+  4324195634733601175ULL,  9037136744494003310ULL,  10715330324656609711ULL,
+  3474343689175121886ULL,  5794004792094061662ULL,  13295581273946061060ULL,
+  7292949743142825837ULL,  10886028626057941279ULL, 10688849249577735178ULL,
+  17297010345160851373ULL, 13658139148821214513ULL, 4468290234101910565ULL,
+  9583516840381960864ULL,  2100818272677130469ULL,  3835407486618772476ULL,
+  11687972045781987867ULL, 2584265809482868424ULL,  2184370854727222683ULL,
+  17762352308671769689ULL, 10901114407297935135ULL, 17932666452350314317ULL,
+  14800534017102555607ULL, 16233839909626358812ULL, 1704089397092793640ULL,
+  2891239861334407450ULL,  18077585692287687954ULL, 2363047449739120434ULL,
+  5904357530901606076ULL,  16765772907460692007ULL, 8757786729323486734ULL,
+  3706883612695347371ULL,  14958907430930711064ULL, 9624134580897548276ULL,
+  10298009507777483067ULL, 5667412839234900228ULL,  6828701555684071915ULL,
+  10482797977665945217ULL, 13440894740881464138ULL, 12078258924098889769ULL,
+  5740761565098658841ULL,  13914375003115830180ULL, 16808960379045776034ULL,
+  18421450170384511575ULL, 16478974619417516521ULL, 14381565232287562804ULL,
+  12792472782420522791ULL, 6620422687983566193ULL,  12025299949416885293ULL,
+  6046334025019123ULL,     16769051888439418536ULL, 10312203372653850423ULL,
+  720028297035890629ULL,   6441255456466558203ULL,  9874005816230679263ULL,
+  15903170012916142038ULL, 7557768652767625223ULL,  17626605079857371651ULL,
+  9092603716684679963ULL,  15518831173015579794ULL, 300798272301981904ULL,
+  13762040857722893585ULL, 3117104080838901168ULL,  4702649037537941245ULL,
+  14408238429167682374ULL, 17923200330177894118ULL, 7470538549881440849ULL,
+  3664543122474851710ULL,  17626200978883719521ULL, 15355649603762884691ULL,
+  4749231114166154448ULL,  11220859020615935192ULL, 4740127963151294603ULL,
+  16616708905207951068ULL, 9828299274924872726ULL,  8985762004928355786ULL,
+  14578866413196595465ULL, 11009044264074492189ULL, 16196760954725621137ULL,
+  10725252972011913420ULL, 4601011175737567235ULL,  1441938685024169613ULL,
+  1896485105672535586ULL,  6635496128279078494ULL,  7401072902622950072ULL,
+  16075245295895555285ULL, 11009539992705810569ULL, 13666961049432909413ULL,
+  930044899627839572ULL,   7899294831116079515ULL,  7830402010660588539ULL,
+  5485720725031791061ULL,  17051528642209786987ULL, 7280223907880312904ULL,
+  10641556535303807158ULL, 12639056541805784436ULL, 12321318600465693220ULL,
+  10108223508416203621ULL, 16243972184205577210ULL, 8544062083712081766ULL,
+  11274622334580836223ULL, 10844017387984539333ULL, 14774228730866078526ULL,
+  560237794062265107ULL,   5844494700804214355ULL,  12270220729021534083ULL,
+  8560016492134621125ULL,  12198417933760222474ULL, 10133839346494565561ULL,
+  9295901871619786454ULL,  10849442312533122519ULL, 18021432643418872607ULL,
+  10155396024449547909ULL, 10524212640889309144ULL, 16662796689072019468ULL,
+  965963318619140447ULL,   8887484786999567242ULL,  15714444653107301219ULL,
+  1678356452623540647ULL,  11052117692502964420ULL, 14549914962216724919ULL,
+  2062106447906584711ULL,  9160372737526136799ULL,  408961132483689555ULL,
+  16057982805180036489ULL, 3569128826873655261ULL,  9330490631980133992ULL,
+  1176328083272936519ULL,  11222898184704497134ULL, 9302091588024171405ULL,
+  10671057562378043302ULL, 4098229850247478874ULL,  8603114141751656125ULL,
+  5095034292565071557ULL,  17972196540767155575ULL, 17052421619317624598ULL,
+  1582078615100434096ULL,  12012345949788712038ULL, 16161371278263065802ULL,
+  2541771182459136706ULL,  4555228648728151989ULL,  8434259952664443907ULL,
+  11417314755930316675ULL, 4859944209493970278ULL,  3960064386733120970ULL,
+  831798891742765072ULL,   15333350611999607709ULL, 16195235791627584805ULL,
+  11597945977924582290ULL, 5623573319924035254ULL,  11517834322140013944ULL,
+  4133597640080778846ULL,  5871425684860123605ULL,  1689282515842046354ULL,
+  12636468992840026995ULL, 14838814546330146559ULL, 521771145052581487ULL,
+  2880434048302248640ULL,  8371131723257691693ULL,  14881811984607317690ULL,
+  1324986559026356337ULL,  15096177686518116013ULL, 4421234407032663127ULL,
+  14405416956529710514ULL, 3720189381923668652ULL,  409223713688462738ULL,
+  9606291214917499037ULL,  9223836018030016969ULL,  190459553092726002ULL,
+  12216883190512504355ULL, 2445407445757699168ULL,  4632853494959579227ULL,
+  13184809158706083946ULL, 5787237245171889527ULL,  10294885203231741175ULL,
+  4191072920233802133ULL,  4291939441266046279ULL,  16375865614446560083ULL,
+  8623994097296487259ULL,  15309273767847758202ULL, 9397335507036899909ULL,
+  6747046333776906674ULL,  13832845734789247298ULL, 7019441607318179720ULL,
+  10005910351872177492ULL, 4145022192145704170ULL,  4353043221960833896ULL,
+  8973895156742077167ULL,  438950987149754489ULL,   2185272607213603213ULL,
+  8466605802960622962ULL,  12110999198806592422ULL, 11821045514824268224ULL,
+  10878266882585355136ULL, 11760743717116988087ULL, 4184976790109698342ULL,
+  18330309416210613006ULL, 1107206443001387417ULL,  79384941109554222ULL,
+  9163366224008952362ULL,  3321824684344751056ULL,  3693723307432954164ULL,
+  6079394558849393056ULL,  11401125038466760935ULL, 3656219353656357222ULL,
+  1735342045865967049ULL,  4042759343240967690ULL,  12711975181279962687ULL,
+  9500297538285176400ULL,  15298274009373410204ULL, 9806309365986113958ULL,
+  10640867530898511005ULL, 17462737140104853956ULL, 4414872795937286161ULL,
+  14852747253248972903ULL, 15278706409822090441ULL, 6433625831299907179ULL,
+  3321907667985685429ULL,  11390693584827212740ULL, 11529629266037992234ULL,
+  10328859824139248147ULL, 16428469301035734767ULL, 17926643922068445985ULL,
+  705326063324784242ULL,   8105287564212541268ULL,  15433828269766668455ULL,
+  3714790519415313767ULL,  5417718938962187987ULL,  7847045502609209896ULL,
+  8025090526912661197ULL,  2234136672994823541ULL,  16041001438425499955ULL,
+  10050820915370092068ULL, 14731208739754682952ULL, 9320476318639351023ULL,
+  14993011533295358880ULL, 4179632880986595543ULL,  8947621078428360390ULL,
+  14715184767037401701ULL, 2617407252848328649ULL,  4818108510694228841ULL,
+  3602814087839803186ULL,  14679368779377024657ULL, 7354547195052671772ULL,
+  453184876960970470ULL,   15781004944602184656ULL, 12000277437894508493ULL,
+  14990587330205222466ULL, 13913588124149397652ULL, 14252160166631667289ULL,
+  1532590395334038243ULL,  10283229111568663870ULL, 17325140074534683390ULL,
+  15829693190940193580ULL, 7621681592523599724ULL,  10682206684717316020ULL,
+  1847393779801417006ULL,  3066262069769536156ULL,  14633662576956154615ULL,
+  15324290530255177253ULL, 14627271171597064522ULL, 14334883061544405592ULL,
+  12329324284039697670ULL, 14425669906700626239ULL, 4967072546582904838ULL,
+  11336784484312139551ULL, 9293117687355182150ULL,  18198595579111618687ULL,
+  3236555730692485133ULL,  3659681352365625914ULL,  5185822088933195476ULL,
+  1820961806679957133ULL,  5103404090674191862ULL,  16176358349875499548ULL,
+  15699479324816269479ULL, 6929077312607579230ULL,  7724671543660786314ULL,
+  15226863704421704735ULL, 10411799650043017788ULL, 2743533500235068318ULL,
+  7917895244279791454ULL,  9194839772540541837ULL,  8170679394364395846ULL,
+  2830213237197365734ULL,  7353896603754987224ULL,  17634372441601249827ULL,
+  8515117661105161813ULL,  5818937363197514778ULL,  8536843065945835629ULL,
+  2920190566549352463ULL,  4206179361653770600ULL,  15470355568872211976ULL,
+  8427825008315838911ULL,  5786540713287383830ULL,  15547153445796060183ULL,
+  12329720415526259303ULL, 5557519966701086911ULL
+};
 
 TEST(RandomUnitTest, RandomShuffle) {
-  cass::Random r;
+  Random r;
 
   const int num_elements = 8;
   const int max_iterations = num_elements * num_elements;
@@ -117,7 +250,7 @@ TEST(RandomUnitTest, RandomShuffle) {
   int count;
   for (count = 0; count < max_iterations; ++count) {
     std::vector<int> copy(previous);
-    cass::random_shuffle(copy.begin(), copy.end(), &r);
+    random_shuffle(copy.begin(), copy.end(), &r);
     if (copy != previous) {
       break;
     }
@@ -135,7 +268,7 @@ TEST(RandomUnitTest, RandomSeed) {
     int count;
     // Keep trying while seed equals previous value
     for (count = 0; count < max_iterations; ++count) {
-      uint64_t seed = cass::get_random_seed(previous);
+      uint64_t seed = get_random_seed(previous);
       if (seed != previous) {
         previous = seed;
         break;
diff --git a/gtests/src/unit/tests/test_reconnection_policy.cpp b/gtests/src/unit/tests/test_reconnection_policy.cpp
new file mode 100644
index 000000000..33cfa909f
--- /dev/null
+++ b/gtests/src/unit/tests/test_reconnection_policy.cpp
@@ -0,0 +1,124 @@
+/*
+  Copyright (c) DataStax, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+
+#include "constants.hpp"
+#include "reconnection_policy.hpp"
+#include "scoped_ptr.hpp"
+
+using datastax::internal::ScopedPtr;
+using datastax::internal::core::ConstantReconnectionPolicy;
+using datastax::internal::core::ConstantReconnectionSchedule;
+using datastax::internal::core::ExponentialReconnectionPolicy;
+using datastax::internal::core::ExponentialReconnectionSchedule;
+using datastax::internal::core::ReconnectionPolicy;
+using datastax::internal::core::ReconnectionSchedule;
+
+#define FIFTEEN_PERCENT(value) static_cast<double>(value - ((value * 85) / 100))
+
+TEST(ReconnectionPolicyUnitTest, Constant) {
+  { // Ensure default value is assigned
+    ConstantReconnectionPolicy policy;
+    EXPECT_EQ(ReconnectionPolicy::CONSTANT, policy.type());
+    EXPECT_EQ(CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS, policy.delay_ms());
+    EXPECT_STREQ("constant", policy.name());
+  }
+
+  { // Ensure assigned value
+    ConstantReconnectionPolicy policy(65535u);
+    EXPECT_EQ(ReconnectionPolicy::CONSTANT, policy.type());
+    EXPECT_EQ(65535u, policy.delay_ms());
+    EXPECT_STREQ("constant", policy.name());
+  }
+}
+
+TEST(ReconnectionPolicyUnitTest, ConstantSchedule) {
+  { // Ensure default value is scheduled
+    ConstantReconnectionPolicy policy;
+    ScopedPtr<ReconnectionSchedule> schedule(policy.new_reconnection_schedule());
+    EXPECT_EQ(CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS, schedule->next_delay_ms());
+
+    for (int i = 0; i < 1000; ++i) {
+      EXPECT_EQ(CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS, schedule->next_delay_ms());
+    }
+  }
+
+  { // Ensure assigned value is scheduled
+    ConstantReconnectionPolicy policy(65535u);
+    ScopedPtr<ReconnectionSchedule> schedule(policy.new_reconnection_schedule());
+    EXPECT_EQ(65535u, schedule->next_delay_ms());
+
+    for (int i = 0; i < 1000; ++i) {
+      EXPECT_EQ(65535u, schedule->next_delay_ms());
+    }
+  }
+}
+
+TEST(ReconnectionPolicyUnitTest, Exponential) {
+  { // Ensure default value is assigned
+    ExponentialReconnectionPolicy policy;
+    EXPECT_EQ(CASS_DEFAULT_EXPONENTIAL_RECONNECT_BASE_DELAY_MS, policy.base_delay_ms());
+    EXPECT_EQ(CASS_DEFAULT_EXPONENTIAL_RECONNECT_MAX_DELAY_MS, policy.max_delay_ms());
+    EXPECT_STREQ("exponential", policy.name());
+  }
+
+  { // Ensure assigned value
+    ExponentialReconnectionPolicy policy(1u, 2u);
+    EXPECT_EQ(1u, policy.base_delay_ms());
+    EXPECT_EQ(2u, policy.max_delay_ms());
+    EXPECT_STREQ("exponential", policy.name());
+  }
+}
+
+TEST(ReconnectionPolicyUnitTest, ExponentialSchedule) {
+  ExponentialReconnectionPolicy policy(2u, 16u);
+  ScopedPtr<ReconnectionSchedule> schedule(policy.new_reconnection_schedule());
+  EXPECT_NEAR(2.0, static_cast<double>(schedule->next_delay_ms()), FIFTEEN_PERCENT(2));
+  EXPECT_NEAR(4.0, static_cast<double>(schedule->next_delay_ms()), FIFTEEN_PERCENT(4));
+  EXPECT_NEAR(8.0, static_cast<double>(schedule->next_delay_ms()), FIFTEEN_PERCENT(8));
+  EXPECT_NEAR(16.0, static_cast<double>(schedule->next_delay_ms()), FIFTEEN_PERCENT(16));
+  EXPECT_NEAR(16.0, static_cast<double>(schedule->next_delay_ms()), FIFTEEN_PERCENT(16));
+}
+
+TEST(ReconnectionPolicyUnitTest, ExponentialScheduleOverflow) {
+  for (uint64_t base_delay_ms = 2; base_delay_ms < 4294967295u; base_delay_ms += base_delay_ms) {
+    uint64_t max_delay_ms = base_delay_ms * base_delay_ms;
+    ExponentialReconnectionPolicy policy(base_delay_ms, max_delay_ms);
+    ScopedPtr<ReconnectionSchedule> schedule(policy.new_reconnection_schedule());
+    uint64_t delay_ms = schedule->next_delay_ms();
+    while (delay_ms != max_delay_ms) {
+      delay_ms = schedule->next_delay_ms();
+    }
+
+    for (int j = 0; j < 63; ++j) {
+      EXPECT_NEAR(static_cast<double>(max_delay_ms), static_cast<double>(schedule->next_delay_ms()),
+                  FIFTEEN_PERCENT(max_delay_ms));
+    }
+  }
+}
+
+TEST(ReconnectionPolicyUnitTest, ExponentialScheduleIndependent) {
+  ExponentialReconnectionPolicy policy(2u, 16u);
+
+  ScopedPtr<ReconnectionSchedule> schedule_1(policy.new_reconnection_schedule());
+  EXPECT_NEAR(2.0, static_cast<double>(schedule_1->next_delay_ms()), FIFTEEN_PERCENT(2));
+  EXPECT_NEAR(4.0, static_cast<double>(schedule_1->next_delay_ms()), FIFTEEN_PERCENT(4));
+
+  ScopedPtr<ReconnectionSchedule> schedule_2(policy.new_reconnection_schedule());
+  EXPECT_NEAR(2.0, static_cast<double>(schedule_2->next_delay_ms()), FIFTEEN_PERCENT(2));
+  EXPECT_NEAR(4.0, static_cast<double>(schedule_2->next_delay_ms()), FIFTEEN_PERCENT(4));
+}
diff --git a/gtests/src/unit/tests/test_replication_strategy.cpp b/gtests/src/unit/tests/test_replication_strategy.cpp
index 06d176047..e17984137 100644
--- a/gtests/src/unit/tests/test_replication_strategy.cpp
+++ b/gtests/src/unit/tests/test_replication_strategy.cpp
@@ -16,22 +16,26 @@
 
 #include <gtest/gtest.h>
 
-#include "test_token_map_utils.hpp"
 #include "set.hpp"
 #include "string.hpp"
+#include "test_token_map_utils.hpp"
 #include "vector.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 namespace {
 
-static const cass::CopyOnWriteHostVec NO_REPLICAS(NULL);
+static const CopyOnWriteHostVec NO_REPLICAS(NULL);
 
 template <class Partitioner>
 struct MockTokenMap {
-  typedef typename cass::ReplicationStrategy<Partitioner>::Token Token;
-  typedef typename cass::ReplicationStrategy<Partitioner>::TokenHost TokenHost;
-  typedef typename cass::ReplicationStrategy<Partitioner>::TokenHostVec TokenHostVec;
-  typedef typename cass::ReplicationStrategy<Partitioner>::TokenReplicas TokenReplicas;
-  typedef typename cass::ReplicationStrategy<Partitioner>::TokenReplicasVec TokenReplicasVec;
+  typedef typename ReplicationStrategy<Partitioner>::Token Token;
+  typedef typename ReplicationStrategy<Partitioner>::TokenHost TokenHost;
+  typedef typename ReplicationStrategy<Partitioner>::TokenHostVec TokenHostVec;
+  typedef typename ReplicationStrategy<Partitioner>::TokenReplicas TokenReplicas;
+  typedef typename ReplicationStrategy<Partitioner>::TokenReplicasVec TokenReplicasVec;
 
   struct TokenReplicasCompare {
     bool operator()(const TokenReplicas& lhs, const TokenReplicas& rhs) const {
@@ -39,86 +43,83 @@ struct MockTokenMap {
     }
   };
 
-  cass::HostSet hosts;
-  cass::IdGenerator dc_ids;
-  cass::IdGenerator rack_ids;
+  HostSet hosts;
+  IdGenerator dc_ids;
+  IdGenerator rack_ids;
 
-  cass::ReplicationStrategy<Partitioner> strategy;
+  ReplicationStrategy<Partitioner> strategy;
   TokenHostVec tokens;
   TokenReplicasVec replicas;
-  cass::DatacenterMap datacenters;
+  DatacenterMap datacenters;
 
   void init_simple_strategy(size_t replication_factor) {
-    cass::DataType::ConstPtr varchar_data_type(new cass::DataType(CASS_VALUE_TYPE_VARCHAR));
+    DataType::ConstPtr varchar_data_type(new DataType(CASS_VALUE_TYPE_VARCHAR));
 
     ColumnMetadataVec column_metadata;
     column_metadata.push_back(ColumnMetadata("keyspace_name", varchar_data_type));
-    column_metadata.push_back(ColumnMetadata("replication", cass::CollectionType::map(varchar_data_type, varchar_data_type, true)));
+    column_metadata.push_back(ColumnMetadata(
+        "replication", CollectionType::map(varchar_data_type, varchar_data_type, true)));
     RowResultResponseBuilder builder(column_metadata);
 
     ReplicationMap replication;
     replication["class"] = CASS_SIMPLE_STRATEGY;
 
-    cass::OStringStream ss;
+    OStringStream ss;
     ss << replication_factor;
     replication["replication_factor"] = ss.str();
 
     builder.append_keyspace_row_v3("ks1", replication);
     builder.finish();
 
-    cass::ResultIterator iterator(builder.finish());
+    ResultIterator iterator(builder.finish());
     EXPECT_TRUE(iterator.next());
-    strategy.init(dc_ids, cass::VersionNumber(3, 0, 0), iterator.row());
+    strategy.init(dc_ids, VersionNumber(3, 0, 0), iterator.row());
   }
 
   void init_network_topology_strategy(ReplicationMap& replication) {
-    cass::DataType::ConstPtr varchar_data_type(new cass::DataType(CASS_VALUE_TYPE_VARCHAR));
+    DataType::ConstPtr varchar_data_type(new DataType(CASS_VALUE_TYPE_VARCHAR));
 
     ColumnMetadataVec column_metadata;
     column_metadata.push_back(ColumnMetadata("keyspace_name", varchar_data_type));
-    column_metadata.push_back(ColumnMetadata("replication", cass::CollectionType::map(varchar_data_type, varchar_data_type, true)));
+    column_metadata.push_back(ColumnMetadata(
+        "replication", CollectionType::map(varchar_data_type, varchar_data_type, true)));
     RowResultResponseBuilder builder(column_metadata);
 
     replication["class"] = CASS_NETWORK_TOPOLOGY_STRATEGY;
     builder.append_keyspace_row_v3("ks1", replication);
     builder.finish();
 
-    cass::ResultIterator iterator(builder.finish());
+    ResultIterator iterator(builder.finish());
     EXPECT_TRUE(iterator.next());
-    strategy.init(dc_ids, cass::VersionNumber(3, 0, 0), iterator.row());
+    strategy.init(dc_ids, VersionNumber(3, 0, 0), iterator.row());
   }
 
-  void add_token(Token token,
-                 const cass::String& address,
-                 const cass::String& rack = "",
-                 const cass::String& dc = "") {
+  void add_token(Token token, const String& address, const String& rack = "",
+                 const String& dc = "") {
     tokens.push_back(TokenHost(token, create_host(address, rack, dc)));
   }
 
   void build_replicas() {
     std::sort(tokens.begin(), tokens.end()); // We assume sorted tokens
-    cass::build_datacenters(hosts, datacenters);
+    build_datacenters(hosts, datacenters);
     strategy.build_replicas(tokens, datacenters, replicas);
   }
 
-
-  const cass::CopyOnWriteHostVec& find_hosts(Token token) {
-    typename TokenReplicasVec::const_iterator i = std::lower_bound(replicas.begin(), replicas.end(),
-                                                                   TokenReplicas(token, NO_REPLICAS),
-                                                                   TokenReplicasCompare());
+  const CopyOnWriteHostVec& find_hosts(Token token) {
+    typename TokenReplicasVec::const_iterator i =
+        std::lower_bound(replicas.begin(), replicas.end(), TokenReplicas(token, NO_REPLICAS),
+                         TokenReplicasCompare());
     if (i != replicas.end() && i->first == token) {
       return i->second;
     }
     return NO_REPLICAS;
   }
 
-  cass::Host* create_host(const cass::String& address,
-                          const cass::String& rack = "",
-                          const cass::String& dc = "") {
-    cass::Host::Ptr host(new cass::Host(cass::Address(address, 9042)));
+  Host* create_host(const String& address, const String& rack = "", const String& dc = "") {
+    Host::Ptr host(new Host(Address(address, 9042)));
     host->set_rack_and_dc(rack, dc);
     host->set_rack_and_dc_ids(rack_ids.get(rack), dc_ids.get(dc));
-    cass::HostSet::iterator i = hosts.find(host);
+    HostSet::iterator i = hosts.find(host);
     if (i != hosts.end()) {
       return i->get();
     } else {
@@ -128,27 +129,24 @@ struct MockTokenMap {
   }
 };
 
-void check_host(const cass::SharedRefPtr<cass::Host>& host,
-                const cass::String& ip,
-                const cass::String& rack = "",
-                const cass::String& dc = "") {
-  EXPECT_EQ(host->address(), cass::Address(ip, 9042));
+void check_host(const SharedRefPtr<Host>& host, const String& ip, const String& rack = "",
+                const String& dc = "") {
+  EXPECT_EQ(host->address(), Address(ip, 9042));
   EXPECT_EQ(host->rack(), rack);
   EXPECT_EQ(host->dc(), dc);
 }
 
 } // namespace
 
-TEST(ReplicationStrategyUnitTest, Simple)
-{
-  MockTokenMap<cass::Murmur3Partitioner> token_map;
+TEST(ReplicationStrategyUnitTest, Simple) {
+  MockTokenMap<Murmur3Partitioner> token_map;
 
   token_map.init_simple_strategy(3);
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t1 = 0;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t2 = 100;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t3 = 200;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t4 = 300;
+  MockTokenMap<Murmur3Partitioner>::Token t1 = 0;
+  MockTokenMap<Murmur3Partitioner>::Token t2 = 100;
+  MockTokenMap<Murmur3Partitioner>::Token t3 = 200;
+  MockTokenMap<Murmur3Partitioner>::Token t4 = 300;
 
   token_map.add_token(t1, "1.0.0.1");
   token_map.add_token(t2, "1.0.0.2");
@@ -158,7 +156,7 @@ TEST(ReplicationStrategyUnitTest, Simple)
   token_map.build_replicas();
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.1");
     check_host((*hosts)[1], "1.0.0.2");
@@ -166,30 +164,29 @@ TEST(ReplicationStrategyUnitTest, Simple)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
     check_host((*hosts)[0], "1.0.0.2");
     check_host((*hosts)[1], "1.0.0.3");
     check_host((*hosts)[2], "1.0.0.4");
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
     check_host((*hosts)[0], "1.0.0.3");
     check_host((*hosts)[1], "1.0.0.4");
     check_host((*hosts)[2], "1.0.0.1");
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
     check_host((*hosts)[0], "1.0.0.4");
     check_host((*hosts)[1], "1.0.0.1");
     check_host((*hosts)[2], "1.0.0.2");
   }
 }
 
-TEST(ReplicationStrategyUnitTest, NetworkTopology)
-{
-  MockTokenMap<cass::Murmur3Partitioner> token_map;
+TEST(ReplicationStrategyUnitTest, NetworkTopology) {
+  MockTokenMap<Murmur3Partitioner> token_map;
 
   ReplicationMap replication;
   replication["dc1"] = "2";
@@ -197,20 +194,20 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
 
   token_map.init_network_topology_strategy(replication);
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t1 = 0;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t2 = 100;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t3 = 200;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t4 = 300;
+  MockTokenMap<Murmur3Partitioner>::Token t1 = 0;
+  MockTokenMap<Murmur3Partitioner>::Token t2 = 100;
+  MockTokenMap<Murmur3Partitioner>::Token t3 = 200;
+  MockTokenMap<Murmur3Partitioner>::Token t4 = 300;
 
   token_map.add_token(t1, "1.0.0.1", "rack1", "dc1");
   token_map.add_token(t2, "1.0.0.2", "rack1", "dc1");
   token_map.add_token(t3, "1.0.0.3", "rack2", "dc1");
   token_map.add_token(t4, "1.0.0.4", "rack2", "dc1");
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t5 = 400;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t6 = 500;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t7 = 600;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t8 = 700;
+  MockTokenMap<Murmur3Partitioner>::Token t5 = 400;
+  MockTokenMap<Murmur3Partitioner>::Token t6 = 500;
+  MockTokenMap<Murmur3Partitioner>::Token t7 = 600;
+  MockTokenMap<Murmur3Partitioner>::Token t8 = 700;
 
   token_map.add_token(t5, "2.0.0.1", "rack1", "dc2");
   token_map.add_token(t6, "2.0.0.2", "rack1", "dc2");
@@ -220,7 +217,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   token_map.build_replicas();
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "1.0.0.1", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.3", "rack2", "dc1");
@@ -229,7 +226,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "1.0.0.2", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.3", "rack2", "dc1");
@@ -238,7 +235,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "1.0.0.3", "rack2", "dc1");
     check_host((*hosts)[1], "2.0.0.1", "rack1", "dc2");
@@ -247,7 +244,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "1.0.0.4", "rack2", "dc1");
     check_host((*hosts)[1], "2.0.0.1", "rack1", "dc2");
@@ -256,7 +253,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t5);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t5);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "2.0.0.1", "rack1", "dc2");
     check_host((*hosts)[1], "2.0.0.3", "rack2", "dc2");
@@ -265,7 +262,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t6);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t6);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "2.0.0.2", "rack1", "dc2");
     check_host((*hosts)[1], "2.0.0.3", "rack2", "dc2");
@@ -274,7 +271,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t7);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t7);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "2.0.0.3", "rack2", "dc2");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
@@ -283,7 +280,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t8);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t8);
     ASSERT_TRUE(hosts && hosts->size() == 4);
     check_host((*hosts)[0], "2.0.0.4", "rack2", "dc2");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
@@ -292,9 +289,8 @@ TEST(ReplicationStrategyUnitTest, NetworkTopology)
   }
 }
 
-TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
-{
-  MockTokenMap<cass::Murmur3Partitioner> token_map;
+TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack) {
+  MockTokenMap<Murmur3Partitioner> token_map;
 
   ReplicationMap replication;
   replication["dc1"] = "2";
@@ -302,17 +298,17 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
 
   token_map.init_network_topology_strategy(replication);
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t1 = 100;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t2 = 200;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t3 = 300;
+  MockTokenMap<Murmur3Partitioner>::Token t1 = 100;
+  MockTokenMap<Murmur3Partitioner>::Token t2 = 200;
+  MockTokenMap<Murmur3Partitioner>::Token t3 = 300;
 
   token_map.add_token(t1, "1.0.0.1", "rack1", "dc1");
   token_map.add_token(t2, "1.0.0.2", "rack1", "dc1");
   token_map.add_token(t3, "1.0.0.3", "rack1", "dc1");
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t4 = 400;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t5 = 500;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t6 = 600;
+  MockTokenMap<Murmur3Partitioner>::Token t4 = 400;
+  MockTokenMap<Murmur3Partitioner>::Token t5 = 500;
+  MockTokenMap<Murmur3Partitioner>::Token t6 = 600;
 
   token_map.add_token(t4, "2.0.0.1", "rack1", "dc2");
   token_map.add_token(t5, "2.0.0.2", "rack1", "dc2");
@@ -321,7 +317,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   token_map.build_replicas();
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.1", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.2", "rack1", "dc1");
@@ -329,7 +325,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.2", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.3", "rack1", "dc1");
@@ -337,7 +333,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.3", "rack1", "dc1");
     check_host((*hosts)[1], "2.0.0.1", "rack1", "dc2");
@@ -345,7 +341,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "2.0.0.1", "rack1", "dc2");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
@@ -353,7 +349,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t5);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t5);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "2.0.0.2", "rack1", "dc2");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
@@ -361,7 +357,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t6);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t6);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "2.0.0.3", "rack1", "dc2");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
@@ -369,19 +365,18 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologySameRack)
   }
 }
 
-TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks)
-{
-  MockTokenMap<cass::Murmur3Partitioner> token_map;
+TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks) {
+  MockTokenMap<Murmur3Partitioner> token_map;
 
   ReplicationMap replication;
   replication["dc1"] = "3";
 
   token_map.init_network_topology_strategy(replication);
 
-  MockTokenMap<cass::Murmur3Partitioner>::Token t1 = 100;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t2 = 200;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t3 = 300;
-  MockTokenMap<cass::Murmur3Partitioner>::Token t4 = 400;
+  MockTokenMap<Murmur3Partitioner>::Token t1 = 100;
+  MockTokenMap<Murmur3Partitioner>::Token t2 = 200;
+  MockTokenMap<Murmur3Partitioner>::Token t3 = 300;
+  MockTokenMap<Murmur3Partitioner>::Token t4 = 400;
 
   token_map.add_token(t1, "1.0.0.1", "rack1", "dc1");
   token_map.add_token(t2, "1.0.0.2", "rack1", "dc1");
@@ -391,7 +386,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks)
   token_map.build_replicas();
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t1);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.1", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.4", "rack2", "dc1");
@@ -399,7 +394,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t2);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.2", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.4", "rack2", "dc1");
@@ -407,7 +402,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t3);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.3", "rack1", "dc1");
     check_host((*hosts)[1], "1.0.0.4", "rack2", "dc1");
@@ -415,7 +410,7 @@ TEST(ReplicationStrategyUnitTest, NetworkTopologyNotEnoughRacks)
   }
 
   {
-    const cass::CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
+    const CopyOnWriteHostVec& hosts = token_map.find_hosts(t4);
     ASSERT_TRUE(hosts && hosts->size() == 3);
     check_host((*hosts)[0], "1.0.0.4", "rack2", "dc1");
     check_host((*hosts)[1], "1.0.0.1", "rack1", "dc1");
diff --git a/gtests/src/unit/tests/test_request_processor.cpp b/gtests/src/unit/tests/test_request_processor.cpp
index 716a223b3..80c83ca9b 100644
--- a/gtests/src/unit/tests/test_request_processor.cpp
+++ b/gtests/src/unit/tests/test_request_processor.cpp
@@ -18,18 +18,19 @@
 
 #include "event_loop.hpp"
 #include "query_request.hpp"
+#include "ref_counted.hpp"
 #include "request_handler.hpp"
 #include "request_processor_initializer.hpp"
-#include "ref_counted.hpp"
 
 #define NUM_NODES 3
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class RequestProcessorUnitTest : public EventLoopTest {
 public:
   RequestProcessorUnitTest()
-    : EventLoopTest("RequestProcessorUnitTest") { }
+      : EventLoopTest("RequestProcessorUnitTest") {}
 
   HostMap generate_hosts() {
     HostMap hosts;
@@ -52,17 +53,17 @@ class RequestProcessorUnitTest : public EventLoopTest {
 
     processor->process_request(request_handler);
     ASSERT_TRUE(response_future->wait_for(wait_for_time_us)) << "Timed out waiting for response";
-    ASSERT_FALSE(response_future->error())
-        << cass_error_desc(response_future->error()->code) << ": "
-        << response_future->error()->message;;
+    ASSERT_FALSE(response_future->error()) << cass_error_desc(response_future->error()->code)
+                                           << ": " << response_future->error()->message;
+    ;
   }
 
-  class Future : public cass::Future {
+  class Future : public core::Future {
   public:
     typedef SharedRefPtr<Future> Ptr;
 
     Future()
-      : cass::Future(FUTURE_TYPE_GENERIC) { }
+        : core::Future(FUTURE_TYPE_GENERIC) {}
 
     ~Future() {
       if (processor_) {
@@ -89,33 +90,29 @@ class RequestProcessorUnitTest : public EventLoopTest {
     typedef SharedRefPtr<CloseListener> Ptr;
 
     CloseListener(const Future::Ptr& close_future = Future::Ptr())
-      : close_future_(close_future)
-      , processor_(NULL) {
+        : close_future_(close_future)
+        , processor_(NULL) {
       inc_ref();
     }
 
-    virtual ~CloseListener() { }
+    virtual ~CloseListener() {}
 
-    virtual void on_connect(RequestProcessor* processor) {
-      processor_ = processor;
-    }
+    virtual void on_connect(RequestProcessor* processor) { processor_ = processor; }
 
-    virtual void on_pool_up(const Address& address)  {
+    virtual void on_pool_up(const Address& address) {
       // In the absence of a Cluster object the processor must notify itself
       // that a host is ready.
       if (processor_) {
-        processor_->notify_host_ready(
-              Host::Ptr(new Host(address)));
+        processor_->notify_host_ready(Host::Ptr(new Host(address)));
       }
     }
-    virtual void on_pool_down(const Address& address) { }
-    virtual void on_pool_critical_error(const Address& address,
-                                        Connector::ConnectionError code,
-                                        const String& message) { }
+    virtual void on_pool_down(const Address& address) {}
+    virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                        const String& message) {}
     virtual void on_keyspace_changed(const String& keyspace,
-                                     const KeyspaceChangedHandler::Ptr& handler) { }
+                                     const KeyspaceChangedHandler::Ptr& handler) {}
     virtual void on_prepared_metadata_changed(const String& id,
-                                              const PreparedMetadata::Entry::Ptr& entry) { }
+                                              const PreparedMetadata::Entry::Ptr& entry) {}
 
     virtual void on_close(RequestProcessor* processor) {
       if (close_future_) {
@@ -135,18 +132,17 @@ class RequestProcessorUnitTest : public EventLoopTest {
       return std::count(error_codes_.begin(), error_codes_.end(), code);
     }
 
-    virtual void on_pool_up(const Address& address)  { }
-    virtual void on_pool_down(const Address& address) { }
-    virtual void on_pool_critical_error(const Address& address,
-                                        Connector::ConnectionError code,
+    virtual void on_pool_up(const Address& address) {}
+    virtual void on_pool_down(const Address& address) {}
+    virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
                                         const String& message) {
       error_codes_.push_back(code);
     }
     virtual void on_keyspace_changed(const String& keyspace,
-                                     const KeyspaceChangedHandler::Ptr& handler) { }
+                                     const KeyspaceChangedHandler::Ptr& handler) {}
     virtual void on_prepared_metadata_changed(const String& id,
-                                              const PreparedMetadata::Entry::Ptr& entry) { }
-    virtual void on_close(RequestProcessor* processor) { }
+                                              const PreparedMetadata::Entry::Ptr& entry) {}
+    virtual void on_close(RequestProcessor* processor) {}
 
   private:
     Vector<Connector::ConnectionError> error_codes_;
@@ -156,14 +152,13 @@ class RequestProcessorUnitTest : public EventLoopTest {
   public:
     typedef SharedRefPtr<UpDownListener> Ptr;
 
-    UpDownListener(const Future::Ptr& up_future,
-                   const Future::Ptr& down_future,
+    UpDownListener(const Future::Ptr& up_future, const Future::Ptr& down_future,
                    const Host::Ptr& target_host = Host::Ptr())
-      : up_future_(up_future)
-      , down_future_(down_future)
-      , target_host_(target_host) { }
+        : up_future_(up_future)
+        , down_future_(down_future)
+        , target_host_(target_host) {}
 
-    virtual void on_pool_up(const Address& address)  {
+    virtual void on_pool_up(const Address& address) {
       if (target_host_ && target_host_->address() != address) return;
       up_future_->set();
     }
@@ -185,20 +180,17 @@ class RequestProcessorUnitTest : public EventLoopTest {
     } else {
       switch (initializer->error_code()) {
         case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_KEYSPACE:
-          future->set_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE,
-                            initializer->error_message());
+          future->set_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE, initializer->error_message());
           break;
         case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_NO_HOSTS_AVAILABLE:
           future->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
                             "Unable to connect to any contact points");
           break;
         case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_UNABLE_TO_INIT:
-          future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT,
-                            initializer->error_message());
+          future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT, initializer->error_message());
           break;
         default:
-          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT,
-                            initializer->error_message());
+          future->set_error(CASS_ERROR_LIB_UNABLE_TO_CONNECT, initializer->error_message());
           break;
       }
     }
@@ -212,11 +204,9 @@ TEST_F(RequestProcessorUnitTest, Simple) {
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   initializer->initialize(event_loop());
 
@@ -233,11 +223,9 @@ TEST_F(RequestProcessorUnitTest, CloseWithRequestsPending) {
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   initializer->initialize(event_loop());
 
@@ -258,8 +246,8 @@ TEST_F(RequestProcessorUnitTest, CloseWithRequestsPending) {
 
   processor->close();
 
-  for (Vector<ResponseFuture::Ptr>::const_iterator it = futures.begin(),
-       end = futures.end(); it != end; ++it) {
+  for (Vector<ResponseFuture::Ptr>::const_iterator it = futures.begin(), end = futures.end();
+       it != end; ++it) {
     ResponseFuture::Ptr response_future(*it);
     ASSERT_TRUE(response_future->wait_for(WAIT_FOR_TIME));
     EXPECT_FALSE(response_future->error());
@@ -273,19 +261,15 @@ TEST_F(RequestProcessorUnitTest, Auth) {
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
   settings.connection_pool_settings.connection_settings.auth_provider.reset(
-        new PlainTextAuthProvider("cassandra", "cassandra"));
+      new PlainTextAuthProvider("cassandra", "cassandra"));
 
-  initializer
-      ->with_settings(settings)
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -296,21 +280,17 @@ TEST_F(RequestProcessorUnitTest, Auth) {
 TEST_F(RequestProcessorUnitTest, Ssl) {
   mockssandra::SimpleCluster cluster(simple(), NUM_NODES);
   RequestProcessorSettings settings;
-  settings.connection_pool_settings.connection_settings =  use_ssl(&cluster);
+  settings.connection_pool_settings.connection_settings = use_ssl(&cluster);
   ASSERT_EQ(cluster.start_all(), 0);
 
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
-  initializer
-      ->with_settings(settings)
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -330,21 +310,17 @@ TEST_F(RequestProcessorUnitTest, NotifyAddRemoveHost) {
   Future::Ptr connect_future(new Future());
   Future::Ptr up_future(new Future());
   Future::Ptr down_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
-  settings.connection_pool_settings.reconnect_wait_time_ms = 1; // Reconnect immediately
+  settings.connection_pool_settings.reconnection_policy.reset(
+      new ConstantReconnectionPolicy(1)); // Reconnect immediately
 
   UpDownListener::Ptr listener(new UpDownListener(up_future, down_future, to_add_remove));
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -366,21 +342,17 @@ TEST_F(RequestProcessorUnitTest, CloseDuringReconnect) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
-  settings.connection_pool_settings.reconnect_wait_time_ms = 100000; // Make sure we're reconnecting when we close.
+  settings.connection_pool_settings.reconnection_policy.reset(
+      new ConstantReconnectionPolicy(100000)); // Make sure we're reconnecting when we close.
 
   CloseListener::Ptr listener(new CloseListener(close_future));
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -405,17 +377,13 @@ TEST_F(RequestProcessorUnitTest, CloseDuringAddNewHost) {
 
   Future::Ptr close_future(new Future());
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   CloseListener::Ptr listener(new CloseListener(close_future));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -439,17 +407,13 @@ TEST_F(RequestProcessorUnitTest, PoolDown) {
   Future::Ptr connect_future(new Future());
   Future::Ptr up_future(new Future());
   Future::Ptr down_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   UpDownListener::Ptr listener(new UpDownListener(up_future, down_future, target_host));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -473,21 +437,17 @@ TEST_F(RequestProcessorUnitTest, PoolUp) {
   Future::Ptr connect_future(new Future());
   Future::Ptr up_future(new Future());
   Future::Ptr down_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
-  settings.connection_pool_settings.reconnect_wait_time_ms = 1; // Reconnect immediately
+  settings.connection_pool_settings.reconnection_policy.reset(
+      new ConstantReconnectionPolicy(1)); // Reconnect immediately
 
   UpDownListener::Ptr listener(new UpDownListener(up_future, down_future, target_host));
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -505,22 +465,17 @@ TEST_F(RequestProcessorUnitTest, InvalidAuth) {
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
   settings.connection_pool_settings.connection_settings.auth_provider.reset(
-        new PlainTextAuthProvider("invalid", "invalid"));
+      new PlainTextAuthProvider("invalid", "invalid"));
 
   CriticalErrorListener listener; // Use stack allocation because it's never closed
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(&listener)
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(&listener)->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(connect_future->error());
@@ -536,11 +491,9 @@ TEST_F(RequestProcessorUnitTest, InvalidSsl) {
   HostMap hosts(generate_hosts());
 
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   SslContext::Ptr ssl_context(SslContextFactory::create()); // No trusted cert
 
@@ -549,10 +502,7 @@ TEST_F(RequestProcessorUnitTest, InvalidSsl) {
 
   CriticalErrorListener listener; // Use stack allocation because it's never closed
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(&listener)
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(&listener)->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(connect_future->error());
@@ -577,26 +527,22 @@ TEST_F(RequestProcessorUnitTest, RollingRestart) {
 
   HostMap hosts(generate_hosts());
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
   RequestProcessorSettings settings;
-  settings.connection_pool_settings.reconnect_wait_time_ms = 10; // Reconnect immediately
+  settings.connection_pool_settings.reconnection_policy.reset(
+      new ConstantReconnectionPolicy(10)); // Reconnect immediately
 
-  initializer
-      ->with_settings(settings)
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_settings(settings)->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
   RequestProcessor::Ptr processor(connect_future->processor());
-  cass::Future::Ptr outage_future = execute_outage_plan(&outage_plan);
+  Future::Ptr outage_future = execute_outage_plan(&outage_plan);
 
-  while (!outage_future->wait_for(1000)) { // 1 millisecond wait
+  while (!outage_future->wait_for(1000)) {     // 1 millisecond wait
     try_request(processor, WAIT_FOR_TIME * 3); // Increase wait time for chaotic tests
   }
 
@@ -613,15 +559,11 @@ TEST_F(RequestProcessorUnitTest, NoHostsAvailable) {
 
   HostMap hosts(generate_hosts());
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
 
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  initializer->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
@@ -653,15 +595,11 @@ TEST_F(RequestProcessorUnitTest, RequestTimeout) {
 
   HostMap hosts(generate_hosts());
   Future::Ptr connect_future(new Future());
-  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(hosts.begin()->second,
-                                                                               PROTOCOL_VERSION,
-                                                                               hosts,
-                                                                               TokenMap::Ptr(),
-                                                                               bind_callback(on_connected, connect_future.get())));
-
-  initializer
-      ->with_listener(listener.get())
-      ->initialize(event_loop());
+  RequestProcessorInitializer::Ptr initializer(new RequestProcessorInitializer(
+      hosts.begin()->second, PROTOCOL_VERSION, hosts, TokenMap::Ptr(),
+      bind_callback(on_connected, connect_future.get())));
+
+  initializer->with_listener(listener.get())->initialize(event_loop());
 
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
diff --git a/gtests/src/unit/tests/test_resolver.cpp b/gtests/src/unit/tests/test_resolver.cpp
index 2969261fa..2efbdd920 100644
--- a/gtests/src/unit/tests/test_resolver.cpp
+++ b/gtests/src/unit/tests/test_resolver.cpp
@@ -21,47 +21,34 @@
 
 #define RESOLVE_TIMEOUT 2000
 
-using cass::Address;
-using cass::AddressVec;
-using cass::bind_callback;
-using cass::MultiResolver;
-using cass::Memory;
-using cass::Resolver;
-using cass::String;
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class ResolverUnitTest : public LoopTest {
 public:
   ResolverUnitTest()
-    : status_(Resolver::NEW) { }
+      : status_(Resolver::NEW) {}
 
   Resolver::Ptr create(const String& hostname, int port = 9042) {
     return Resolver::Ptr(
-          new Resolver(hostname,
-                       port,
-                       bind_callback(&ResolverUnitTest::on_resolve, this)));
+        new Resolver(hostname, port, bind_callback(&ResolverUnitTest::on_resolve, this)));
   }
 
   MultiResolver::Ptr create_multi() {
     return MultiResolver::Ptr(
-          new MultiResolver(bind_callback(&ResolverUnitTest::on_multi_resolve, this)));
+        new MultiResolver(bind_callback(&ResolverUnitTest::on_multi_resolve, this)));
   }
 
-  Resolver::Status status() const {
-    return status_;
-  }
+  Resolver::Status status() const { return status_; }
 
-  const AddressVec& addresses() const {
-    return addresses_;
-  }
+  const AddressVec& addresses() const { return addresses_; }
 
-  const Resolver::Vec& resolvers() const {
-    return resolvers_;
-  }
+  const Resolver::Vec& resolvers() const { return resolvers_; }
 
   void verify_addresses(const AddressVec& addresses) const {
     ASSERT_FALSE(addresses.empty());
-    EXPECT_TRUE(Address("127.0.0.1", 9042) == addresses[0] ||
-        Address("::1", 9042) == addresses[0])
+    EXPECT_TRUE(Address("127.0.0.1", 9042) == addresses[0] || Address("::1", 9042) == addresses[0])
         << "Unable to find \"127.0.0.1\" (IPv4) or \"::1\" (IPv6) in " << addresses;
   }
 
@@ -71,9 +58,7 @@ class ResolverUnitTest : public LoopTest {
     addresses_ = resolver->addresses();
   }
 
-  void on_multi_resolve(MultiResolver* resolver) {
-    resolvers_ = resolver->resolvers();
-  }
+  void on_multi_resolve(MultiResolver* resolver) { resolvers_ = resolver->resolvers(); }
 
 private:
   Resolver::Status status_;
@@ -128,8 +113,8 @@ TEST_F(ResolverUnitTest, Multi) {
   resolver->resolve(loop(), "localhost", 9042, RESOLVE_TIMEOUT);
   run_loop();
   ASSERT_EQ(3u, resolvers().size());
-  for (Resolver::Vec::const_iterator it = resolvers().begin(),
-       end = resolvers().end(); end != it; ++it) {
+  for (Resolver::Vec::const_iterator it = resolvers().begin(), end = resolvers().end(); end != it;
+       ++it) {
     EXPECT_EQ(Resolver::SUCCESS, (*it)->status());
     verify_addresses((*it)->addresses());
   }
@@ -151,8 +136,8 @@ TEST_F(ResolverUnitTest, MultiTimeout) {
 
   run_loop();
   ASSERT_EQ(3u, resolvers().size());
-  for (Resolver::Vec::const_iterator it = resolvers().begin(),
-       end = resolvers().end(); end != it; ++it) {
+  for (Resolver::Vec::const_iterator it = resolvers().begin(), end = resolvers().end(); end != it;
+       ++it) {
     EXPECT_EQ(Resolver::FAILED_TIMED_OUT, (*it)->status());
     EXPECT_TRUE((*it)->addresses().empty());
   }
@@ -165,8 +150,8 @@ TEST_F(ResolverUnitTest, MultiInvalid) {
   resolver->resolve(loop(), "doesnotexist3.dne", 9042, RESOLVE_TIMEOUT);
   run_loop();
   ASSERT_EQ(3u, resolvers().size());
-  for (Resolver::Vec::const_iterator it = resolvers().begin(),
-       end = resolvers().end(); end != it; ++it) {
+  for (Resolver::Vec::const_iterator it = resolvers().begin(), end = resolvers().end(); end != it;
+       ++it) {
     EXPECT_EQ(Resolver::FAILED_UNABLE_TO_RESOLVE, (*it)->status());
     EXPECT_TRUE((*it)->addresses().empty());
   }
@@ -180,8 +165,8 @@ TEST_F(ResolverUnitTest, MultiCancel) {
   resolver->cancel();
   run_loop();
   ASSERT_EQ(3u, resolvers().size());
-  for (Resolver::Vec::const_iterator it = resolvers().begin(),
-       end = resolvers().end(); end != it; ++it) {
+  for (Resolver::Vec::const_iterator it = resolvers().begin(), end = resolvers().end(); end != it;
+       ++it) {
     EXPECT_EQ(Resolver::CANCELED, (*it)->status());
     EXPECT_TRUE((*it)->addresses().empty());
   }
diff --git a/gtests/src/unit/tests/test_retry_policies.cpp b/gtests/src/unit/tests/test_retry_policies.cpp
index bad5f58fc..f0752a283 100644
--- a/gtests/src/unit/tests/test_retry_policies.cpp
+++ b/gtests/src/unit/tests/test_retry_policies.cpp
@@ -18,203 +18,158 @@
 
 #include "retry_policy.hpp"
 
-typedef cass::RetryPolicy RetryPolicy;
-typedef cass::RetryPolicy::RetryDecision RetryDecision;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-void check_decision(RetryDecision decision,
-                    RetryDecision::Type type,
-                    CassConsistency cl,
+typedef RetryPolicy::RetryDecision RetryDecision;
+
+void check_decision(RetryDecision decision, RetryDecision::Type type, CassConsistency cl,
                     bool retry_current_host) {
   EXPECT_EQ(decision.type(), type);
   EXPECT_EQ(decision.retry_consistency(), cl);
   EXPECT_EQ(decision.retry_current_host(), retry_current_host);
 }
 
-
-void check_default(cass::RetryPolicy& policy) {
+void check_default(RetryPolicy& policy) {
   // Read timeout
   {
     // Retry because data wasn't present
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, false, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_QUORUM,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_QUORUM, true);
 
     // Return error because recieved < required
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 2, 3, false, 0),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 
     // Return error because a retry has already happened
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, false, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 
   // Write timeout
   {
     // Retry because of batch log failed to write
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_QUORUM,
-                   true);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 0),
+        RetryDecision::RETRY, CASS_CONSISTENCY_QUORUM, true);
 
     // Return error because a retry has already happened
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 1),
+        RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 
   // Unavailable
   {
     // Retry with next host
     check_decision(policy.on_unavailable(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_QUORUM,
-                   false);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_QUORUM, false);
 
     // Return error because a retry has already happened
     check_decision(policy.on_unavailable(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 }
 
-TEST(RetryPoliciesUnitTest, DefaultPolicy)
-{
-  cass::DefaultRetryPolicy policy;
+TEST(RetryPoliciesUnitTest, DefaultPolicy) {
+  DefaultRetryPolicy policy;
   check_default(policy);
 }
 
-TEST(RetryPoliciesUnitTest, Downgrading)
-{
-  cass::DowngradingConsistencyRetryPolicy policy;
+TEST(RetryPoliciesUnitTest, Downgrading) {
+  DowngradingConsistencyRetryPolicy policy;
 
   // Read timeout
   {
     // Retry because data wasn't present
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, false, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_QUORUM,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_QUORUM, true);
 
     // Downgrade consistency to three
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 4, false, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_THREE,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_THREE, true);
 
     // Downgrade consistency to two
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 2, 4, false, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_TWO,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_TWO, true);
 
     // Downgrade consistency to one
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 1, 4, false, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_ONE,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_ONE, true);
 
     // Return error because no copies
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 0, 4, false, 0),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 
     // Return error because a retry has already happened
     check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, false, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 
   // Write timeout
   {
     // Ignore if at least one copy
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 1, 3, CASS_WRITE_TYPE_SIMPLE, 0),
-                   RetryDecision::IGNORE,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 1, 3, CASS_WRITE_TYPE_SIMPLE, 0),
+        RetryDecision::IGNORE, CASS_CONSISTENCY_UNKNOWN, false);
 
     // Ignore if at least one copy
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 1, 3, CASS_WRITE_TYPE_BATCH, 0),
-                   RetryDecision::IGNORE,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 1, 3, CASS_WRITE_TYPE_BATCH, 0),
+        RetryDecision::IGNORE, CASS_CONSISTENCY_UNKNOWN, false);
 
     // Return error if no copies
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 0, 3, CASS_WRITE_TYPE_SIMPLE, 0),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 0, 3, CASS_WRITE_TYPE_SIMPLE, 0),
+        RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 
     // Downgrade consistency to two
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 2, 3, CASS_WRITE_TYPE_UNLOGGED_BATCH, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_TWO,
-                   true);
+    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 2, 3,
+                                           CASS_WRITE_TYPE_UNLOGGED_BATCH, 0),
+                   RetryDecision::RETRY, CASS_CONSISTENCY_TWO, true);
 
     // Retry because of batch log failed to write
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_QUORUM,
-                   true);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 0),
+        RetryDecision::RETRY, CASS_CONSISTENCY_QUORUM, true);
 
     // Return error because a retry has already happened
-    check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+    check_decision(
+        policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_BATCH_LOG, 1),
+        RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 
   // Unavailable
   {
     // Retry with next host
     check_decision(policy.on_unavailable(NULL, CASS_CONSISTENCY_QUORUM, 3, 2, 0),
-                   RetryDecision::RETRY,
-                   CASS_CONSISTENCY_TWO,
-                   true);
+                   RetryDecision::RETRY, CASS_CONSISTENCY_TWO, true);
 
     // Return error because a retry has already happened
     check_decision(policy.on_unavailable(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, 1),
-                   RetryDecision::RETURN_ERROR,
-                   CASS_CONSISTENCY_UNKNOWN,
-                   false);
+                   RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
   }
 }
 
-TEST(RetryPoliciesUnitTest, Fallthrough)
-{
-  cass::FallthroughRetryPolicy policy;
+TEST(RetryPoliciesUnitTest, Fallthrough) {
+  FallthroughRetryPolicy policy;
 
   // Always fail
 
   check_decision(policy.on_read_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, false, 0),
-                 RetryDecision::RETURN_ERROR,
-                 CASS_CONSISTENCY_UNKNOWN,
-                 false);
+                 RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 
-  check_decision(policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_SIMPLE, 0),
-                 RetryDecision::RETURN_ERROR,
-                 CASS_CONSISTENCY_UNKNOWN,
-                 false);
+  check_decision(
+      policy.on_write_timeout(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, CASS_WRITE_TYPE_SIMPLE, 0),
+      RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 
   check_decision(policy.on_unavailable(NULL, CASS_CONSISTENCY_QUORUM, 3, 3, 0),
-                 RetryDecision::RETURN_ERROR,
-                 CASS_CONSISTENCY_UNKNOWN,
-                 false);
+                 RetryDecision::RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
 }
 
-TEST(RetryPoliciesUnitTest, Logging)
-{
-  cass::SharedRefPtr<cass::DefaultRetryPolicy> policy(
-        new cass::DefaultRetryPolicy());
-  cass::LoggingRetryPolicy logging_policy(policy);
+TEST(RetryPoliciesUnitTest, Logging) {
+  SharedRefPtr<DefaultRetryPolicy> policy(new DefaultRetryPolicy());
+  LoggingRetryPolicy logging_policy(policy);
   cass_log_set_level(CASS_LOG_INFO);
   check_default(logging_policy);
 }
diff --git a/gtests/src/unit/tests/test_routing_key.cpp b/gtests/src/unit/tests/test_routing_key.cpp
index 36d94baaf..598324b17 100644
--- a/gtests/src/unit/tests/test_routing_key.cpp
+++ b/gtests/src/unit/tests/test_routing_key.cpp
@@ -21,15 +21,18 @@
 #include "string.hpp"
 #include "token_map.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 // The java-driver was used as a reference for the hash value
 // below.
 
-struct RoutingKeyUnitTest : public Unit { };
+struct RoutingKeyUnitTest : public Unit {};
 
-TEST_F(RoutingKeyUnitTest, Single)
-{
+TEST_F(RoutingKeyUnitTest, Single) {
   {
-    cass::QueryRequest query("", 1);
+    QueryRequest query("", 1);
 
     CassUuid uuid;
     ASSERT_EQ(cass_uuid_from_string("d8775a70-6ea4-11e4-9fa7-0db22d2a6140", &uuid), CASS_OK);
@@ -37,86 +40,84 @@ TEST_F(RoutingKeyUnitTest, Single)
     query.set(0, uuid);
     query.add_key_index(0);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, 6739078495667776670);
   }
 
   {
-    cass::QueryRequest query("", 1);
+    QueryRequest query("", 1);
 
     cass_int32_t value = 123456789;
     query.set(0, value);
     query.add_key_index(0);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, -567416363967733925);
   }
 
   {
-    cass::QueryRequest query("", 1);
+    QueryRequest query("", 1);
 
     cass_int64_t value = 123456789;
     query.set(0, value);
     query.add_key_index(0);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, 5616923877423390342);
   }
 
   {
-    cass::QueryRequest query("", 1);
+    QueryRequest query("", 1);
 
     query.set(0, cass_true);
     query.add_key_index(0);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, 8849112093580131862);
   }
 
   {
-    cass::QueryRequest query("", 1);
+    QueryRequest query("", 1);
 
     const char* value = "abcdefghijklmnop";
-    query.set(0, cass::CassString(value, strlen(value)));
+    query.set(0, CassString(value, strlen(value)));
     query.add_key_index(0);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, -4266531025627334877);
   }
 }
 
-TEST_F(RoutingKeyUnitTest, EmptyAndNull)
-{
-  cass::QueryRequest query("", 1);
+TEST_F(RoutingKeyUnitTest, EmptyAndNull) {
+  QueryRequest query("", 1);
 
-  cass::String routing_key;
+  String routing_key;
   EXPECT_FALSE(query.get_routing_key(&routing_key));
 
-  query.set(0, cass::CassNull());
+  query.set(0, CassNull());
   query.add_key_index(0);
 
   EXPECT_FALSE(query.get_routing_key(&routing_key));
 }
 
-TEST_F(RoutingKeyUnitTest, Composite)
-{
+TEST_F(RoutingKeyUnitTest, Composite) {
   {
-    cass::QueryRequest query("", 3);
+    QueryRequest query("", 3);
 
     CassUuid uuid;
     ASSERT_EQ(cass_uuid_from_string("d8775a70-6ea4-11e4-9fa7-0db22d2a6140", &uuid), CASS_OK);
@@ -128,18 +129,18 @@ TEST_F(RoutingKeyUnitTest, Composite)
     query.add_key_index(1);
 
     const char* value = "abcdefghijklmnop";
-    query.set(2, cass::CassString(value, strlen(value)));
+    query.set(2, CassString(value, strlen(value)));
     query.add_key_index(2);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, 3838437721532426513);
   }
 
   {
-    cass::QueryRequest query("", 3);
+    QueryRequest query("", 3);
 
     query.set(0, cass_false);
     query.add_key_index(0);
@@ -148,13 +149,13 @@ TEST_F(RoutingKeyUnitTest, Composite)
     query.add_key_index(1);
 
     const char* value = "xyz";
-    query.set(2, cass::CassString(value, strlen(value)));
+    query.set(2, CassString(value, strlen(value)));
     query.add_key_index(2);
 
-    cass::String routing_key;
+    String routing_key;
     EXPECT_TRUE(query.get_routing_key(&routing_key));
 
-    int64_t hash = cass::MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
+    int64_t hash = MurmurHash3_x64_128(routing_key.data(), routing_key.size(), 0);
     EXPECT_EQ(hash, 4466051201071860026);
   }
 }
diff --git a/gtests/src/unit/tests/test_scoped_lock.cpp b/gtests/src/unit/tests/test_scoped_lock.cpp
index d7635a579..f46d5422c 100644
--- a/gtests/src/unit/tests/test_scoped_lock.cpp
+++ b/gtests/src/unit/tests/test_scoped_lock.cpp
@@ -18,10 +18,14 @@
 
 #include "scoped_lock.hpp"
 
+using datastax::internal::ScopedMutex;
+using datastax::internal::ScopedReadLock;
+using datastax::internal::ScopedWriteLock;
+
 struct MutexData {
   MutexData(uv_mutex_t* mutex)
-    : mutex(mutex)
-    , error_code(0) { }
+      : mutex(mutex)
+      , error_code(0) {}
 
   uv_mutex_t* mutex;
   int error_code;
@@ -29,8 +33,8 @@ struct MutexData {
 
 struct RwlockData {
   RwlockData(uv_rwlock_t* rwlock)
-    : rwlock(rwlock)
-    , error_code(0) { }
+      : rwlock(rwlock)
+      , error_code(0) {}
 
   uv_rwlock_t* rwlock;
   int error_code;
@@ -60,7 +64,7 @@ TEST(ScopedLockUnitTest, ScopedMutex) {
   MutexData mutex_data(&mutex);
 
   {
-    cass::ScopedMutex lock(&mutex);
+    ScopedMutex lock(&mutex);
 
     uv_thread_t thread;
     uv_thread_create(&thread, on_mutex_trylock, &mutex_data);
@@ -77,7 +81,7 @@ TEST(ScopedLockUnitTest, ScopedMutexDefaultUnlocked) {
   MutexData mutex_data(&mutex);
 
   {
-    cass::ScopedMutex lock(&mutex, false);
+    ScopedMutex lock(&mutex, false);
 
     uv_thread_t thread;
     uv_thread_create(&thread, on_mutex_trylock, &mutex_data);
@@ -94,10 +98,11 @@ TEST(ScopedLockUnitTest, ScopedReadLock) {
   RwlockData rwlock_data(&rwlock);
 
   {
-    cass::ScopedReadLock rl(&rwlock);
+    ScopedReadLock rl(&rwlock);
 
     uv_thread_t thread;
-    uv_thread_create(&thread, on_rwlock_trywrlock, &rwlock_data); // Lock for writing to force busy for write
+    uv_thread_create(&thread, on_rwlock_trywrlock,
+                     &rwlock_data); // Lock for writing to force busy for write
     uv_thread_join(&thread);
   }
 
@@ -111,7 +116,7 @@ TEST(ScopedLockUnitTest, ScopedReadLockDefaultUnlocked) {
   RwlockData rwlock_data(&rwlock);
 
   {
-    cass::ScopedReadLock rl(&rwlock, false);
+    ScopedReadLock rl(&rwlock, false);
 
     uv_thread_t thread;
     uv_thread_create(&thread, on_rwlock_trywrlock, &rwlock_data);
@@ -128,7 +133,7 @@ TEST(ScopedLockUnitTest, ScopedWriteLock) {
   RwlockData rwlock_data(&rwlock);
 
   {
-    cass::ScopedWriteLock wl(&rwlock);
+    ScopedWriteLock wl(&rwlock);
 
     uv_thread_t thread;
     uv_thread_create(&thread, on_rwlock_trywrlock, &rwlock_data);
@@ -145,7 +150,7 @@ TEST(ScopedLockUnitTest, ScopedWriteLockDefaultUnlocked) {
   RwlockData rwlock_data(&rwlock);
 
   {
-    cass::ScopedWriteLock wl(&rwlock, false);
+    ScopedWriteLock wl(&rwlock, false);
 
     uv_thread_t thread;
     uv_thread_create(&thread, on_rwlock_trywrlock, &rwlock_data);
@@ -162,10 +167,11 @@ TEST(ScopedLockUnitTest, ScopedWriteLockBusy) {
   RwlockData rwlock_data(&rwlock);
 
   {
-    cass::ScopedWriteLock wl(&rwlock);
+    ScopedWriteLock wl(&rwlock);
 
     uv_thread_t thread;
-    uv_thread_create(&thread, on_rwlock_tryrdlock, &rwlock_data); // Lock for reading to force busy for read
+    uv_thread_create(&thread, on_rwlock_tryrdlock,
+                     &rwlock_data); // Lock for reading to force busy for read
     uv_thread_join(&thread);
   }
 
diff --git a/gtests/src/unit/tests/test_serialization.cpp b/gtests/src/unit/tests/test_serialization.cpp
index 5aee9095a..fe4420c5d 100644
--- a/gtests/src/unit/tests/test_serialization.cpp
+++ b/gtests/src/unit/tests/test_serialization.cpp
@@ -16,21 +16,21 @@
 
 #include <gtest/gtest.h>
 
-#include "serialization.hpp"
 #include "buffer.hpp"
+#include "serialization.hpp"
 
-TEST(SerializationTest, DecodeZigZag) {
-  ASSERT_EQ(1LL << 63, cass::decode_zig_zag((long) -1));
-}
+using namespace datastax::internal;
+
+TEST(SerializationTest, DecodeZigZag) { ASSERT_EQ(1LL << 63, decode_zig_zag((long)-1)); }
 
 TEST(SerializationTest, DecodeByte) {
   const char input[2] = { -1, 0 };
   uint8_t value = 0;
 
-  const char* pos = cass::decode_byte(&input[0], value);
+  const char* pos = decode_byte(&input[0], value);
   ASSERT_EQ(&input[1], pos);
   ASSERT_EQ(std::numeric_limits<uint8_t>::max(), value);
-  pos = cass::decode_byte(pos, value);
+  pos = decode_byte(pos, value);
   ASSERT_EQ(std::numeric_limits<uint8_t>::min(), value);
 }
 
@@ -38,108 +38,101 @@ TEST(SerializationTest, DecodeInt8) {
   const char input[2] = { -128, 127 };
   int8_t value = 0;
 
-  const char* pos = cass::decode_int8(&input[0], value);
+  const char* pos = decode_int8(&input[0], value);
   ASSERT_EQ(&input[1], pos);
   ASSERT_EQ(std::numeric_limits<int8_t>::min(), value);
-  pos = cass::decode_int8(pos, value);
+  pos = decode_int8(pos, value);
   ASSERT_EQ(std::numeric_limits<int8_t>::max(), value);
 }
 
 TEST(SerializationTest, DecodeUInt16) {
-  const char input[4] = { -1, -1,
-                          0, 0 };
+  const char input[4] = { -1, -1, 0, 0 };
   uint16_t value = 0;
 
-  const char* pos = cass::decode_uint16(&input[0], value);
+  const char* pos = decode_uint16(&input[0], value);
   ASSERT_EQ(&input[2], pos);
   ASSERT_EQ(std::numeric_limits<uint16_t>::max(), value);
-  pos = cass::decode_uint16(pos, value);
+  pos = decode_uint16(pos, value);
   ASSERT_EQ(std::numeric_limits<uint16_t>::min(), value);
 }
 
 TEST(SerializationTest, DecodeInt16) {
-  const char input[4] = { -128, 0,
-                          127, -1 };
+  const char input[4] = { -128, 0, 127, -1 };
   int16_t value = 0;
 
   // SUCCESS
-  const char *pos = cass::decode_int16(&input[0], value);
+  const char* pos = decode_int16(&input[0], value);
   ASSERT_EQ(&input[2], pos);
   ASSERT_EQ(std::numeric_limits<int16_t>::min(), value);
-  pos = cass::decode_int16(pos, value);
+  pos = decode_int16(pos, value);
   ASSERT_EQ(std::numeric_limits<int16_t>::max(), value);
 }
 
 TEST(SerializationTest, DecodeUInt32) {
-  const char input[8] = { -1, -1, -1, -1,
-                          0, 0, 0, 0 };
+  const char input[8] = { -1, -1, -1, -1, 0, 0, 0, 0 };
   uint32_t value = 0;
 
-  const char* pos = cass::decode_uint32(&input[0], value);
+  const char* pos = decode_uint32(&input[0], value);
   ASSERT_EQ(&input[4], pos);
   ASSERT_EQ(std::numeric_limits<uint32_t>::max(), value);
-  pos = cass::decode_uint32(pos, value);
+  pos = decode_uint32(pos, value);
   ASSERT_EQ(std::numeric_limits<uint32_t>::min(), value);
 }
 
 TEST(SerializationTest, DecodeInt32) {
-  const char input[8] = { -128, 0, 0, 0,
-                          127, -1, -1, -1 };
+  const char input[8] = { -128, 0, 0, 0, 127, -1, -1, -1 };
   int32_t value = 0;
 
-  const char *pos = cass::decode_int32(&input[0], value);
+  const char* pos = decode_int32(&input[0], value);
   ASSERT_EQ(&input[4], pos);
   ASSERT_EQ(std::numeric_limits<int32_t>::min(), value);
-  pos = cass::decode_int32(pos, value);
+  pos = decode_int32(pos, value);
   ASSERT_EQ(std::numeric_limits<int32_t>::max(), value);
 }
 
 TEST(SerializationTest, DecodeInt64) {
-  const char input[16] = { -128, 0, 0, 0,0, 0, 0, 0,
-                           127, -1, -1, -1, -1, -1, -1, -1 };
+  const char input[16] = { -128, 0, 0, 0, 0, 0, 0, 0, 127, -1, -1, -1, -1, -1, -1, -1 };
   int64_t value = 0;
 
-  const char *pos = cass::decode_int64(&input[0], value);
+  const char* pos = decode_int64(&input[0], value);
   ASSERT_EQ(&input[8], pos);
   ASSERT_EQ(std::numeric_limits<int64_t>::min(), value);
-  pos = cass::decode_int64(pos, value);
+  pos = decode_int64(pos, value);
   ASSERT_EQ(std::numeric_limits<int64_t>::max(), value);
 }
 
 TEST(SerializationTest, DecodeFloat) {
-  const char input[8] = { 0, -128, 0, 0,
-                          127, 127, -1, -1 };
+  const char input[8] = { 0, -128, 0, 0, 127, 127, -1, -1 };
   float value = 0;
 
-  const char *pos = cass::decode_float(&input[0], value);
+  const char* pos = decode_float(&input[0], value);
   ASSERT_EQ(&input[4], pos);
   ASSERT_EQ(std::numeric_limits<float>::min(), value);
-  pos = cass::decode_float(pos, value);
+  pos = decode_float(pos, value);
   ASSERT_EQ(std::numeric_limits<float>::max(), value);
 }
 
 TEST(SerializationTest, DecodeDouble) {
-  const char input[16] = { 0, 16, 0, 0,0, 0, 0, 0,
-                           127, -17, -1, -1, -1, -1, -1, -1 };
+  const char input[16] = { 0, 16, 0, 0, 0, 0, 0, 0, 127, -17, -1, -1, -1, -1, -1, -1 };
   double value = 0;
 
-  const char *pos = cass::decode_double(&input[0], value);
+  const char* pos = decode_double(&input[0], value);
   ASSERT_EQ(&input[8], pos);
   ASSERT_EQ(std::numeric_limits<double>::min(), value);
-  pos = cass::decode_double(pos, value);
+  pos = decode_double(pos, value);
   ASSERT_EQ(std::numeric_limits<double>::max(), value);
 }
 
 TEST(SerializationTest, DecodeUuid) {
-  const char input[32] = { -1, -1, -1, -1, -1, -1, -1, -1,-1, -1, -1, -1, -1, -1, -1, -1,
-                           0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0 };
+  const char input[32] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 };
   CassUuid value;
 
-  const char *pos = cass::decode_uuid(&input[0], &value);
+  const char* pos = decode_uuid(&input[0], &value);
   ASSERT_EQ(&input[16], pos);
   ASSERT_EQ(std::numeric_limits<uint64_t>::max(), value.clock_seq_and_node);
   ASSERT_EQ(std::numeric_limits<uint64_t>::max(), value.time_and_version);
-  pos = cass::decode_uuid(pos, &value);
+  pos = decode_uuid(pos, &value);
   ASSERT_EQ(std::numeric_limits<uint64_t>::min(), value.clock_seq_and_node);
   ASSERT_EQ(std::numeric_limits<uint64_t>::min(), value.time_and_version);
 }
diff --git a/gtests/src/unit/tests/test_session.cpp b/gtests/src/unit/tests/test_session.cpp
index 082686e93..6693183cb 100644
--- a/gtests/src/unit/tests/test_session.cpp
+++ b/gtests/src/unit/tests/test_session.cpp
@@ -19,13 +19,16 @@
 #include "session.hpp"
 
 #define KEYSPACE "datastax"
-#define NUM_THREADS 2 // Number of threads to execute queries using a session
+#define NUM_THREADS 2         // Number of threads to execute queries using a session
 #define OUTAGE_PLAN_DELAY 250 // Reduced delay to incorporate larger outage plan
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 class SessionUnitTest : public EventLoopTest {
 public:
   SessionUnitTest()
-    : EventLoopTest("SessionUnitTest") { }
+      : EventLoopTest("SessionUnitTest") {}
 
   void populate_outage_plan(OutagePlan* outage_plan) {
     // Multiple rolling restarts
@@ -44,7 +47,7 @@ class SessionUnitTest : public EventLoopTest {
     outage_plan->stop_node(1, OUTAGE_PLAN_DELAY);
   }
 
-  void query_on_threads(cass::Session* session) {
+  void query_on_threads(Session* session) {
     uv_thread_t threads[NUM_THREADS];
     for (int i = 0; i < NUM_THREADS; ++i) {
       ASSERT_EQ(0, uv_thread_create(&threads[i], query, session));
@@ -54,24 +57,21 @@ class SessionUnitTest : public EventLoopTest {
     }
   }
 
-  static void connect(const cass::Config& config,
-                      cass::Session* session,
+  static void connect(const Config& config, Session* session,
                       uint64_t wait_for_time_us = WAIT_FOR_TIME) {
-    cass::Future::Ptr connect_future(session->connect(config));
-    ASSERT_TRUE(connect_future->wait_for(wait_for_time_us)) << "Timed out waiting for session to connect";
-    ASSERT_FALSE(connect_future->error())
-        << cass_error_desc(connect_future->error()->code) << ": "
-        << connect_future->error()->message;
+    Future::Ptr connect_future(session->connect(config));
+    ASSERT_TRUE(connect_future->wait_for(wait_for_time_us))
+        << "Timed out waiting for session to connect";
+    ASSERT_FALSE(connect_future->error()) << cass_error_desc(connect_future->error()->code) << ": "
+                                          << connect_future->error()->message;
   }
 
-  static void connect(cass::Session* session,
-                      cass::SslContext* ssl_context = NULL,
-                      uint64_t wait_for_time_us = WAIT_FOR_TIME,
-                      size_t num_nodes = 3) {
-    cass::Config config;
-    config.set_reconnect_wait_time(100); // Faster reconnect time to handle cluster starts and stops
+  static void connect(Session* session, SslContext* ssl_context = NULL,
+                      uint64_t wait_for_time_us = WAIT_FOR_TIME, size_t num_nodes = 3) {
+    Config config;
+    config.set_constant_reconnect(100); // Faster reconnect time to handle cluster starts and stops
     for (size_t i = 1; i <= num_nodes; ++i) {
-      cass::OStringStream ss;
+      OStringStream ss;
       ss << "127.0.0." << i;
       config.contact_points().push_back(ss.str());
     }
@@ -81,53 +81,45 @@ class SessionUnitTest : public EventLoopTest {
     connect(config, session, wait_for_time_us);
   }
 
-  static void close(cass::Session* session,
-                    uint64_t wait_for_time_us = WAIT_FOR_TIME) {
-    cass::Future::Ptr close_future(session->close());
-    ASSERT_TRUE(close_future->wait_for(wait_for_time_us)) << "Timed out waiting for session to close";
+  static void close(Session* session, uint64_t wait_for_time_us = WAIT_FOR_TIME) {
+    Future::Ptr close_future(session->close());
+    ASSERT_TRUE(close_future->wait_for(wait_for_time_us))
+        << "Timed out waiting for session to close";
     ASSERT_FALSE(close_future->error())
-        << cass_error_desc(close_future->error()->code) << ": "
-        << close_future->error()->message;
+        << cass_error_desc(close_future->error()->code) << ": " << close_future->error()->message;
   }
 
-  static void query(cass::Session* session) {
-    cass::QueryRequest::Ptr request(new cass::QueryRequest("blah", 0));
+  static void query(Session* session) {
+    QueryRequest::Ptr request(new QueryRequest("blah", 0));
     request->set_is_idempotent(true);
 
-    cass::Future::Ptr future = session->execute(request, NULL);
+    Future::Ptr future = session->execute(request, NULL);
     ASSERT_TRUE(future->wait_for(WAIT_FOR_TIME)) << "Timed out executing query";
-    ASSERT_FALSE(future->error())
-        << cass_error_desc(future->error()->code) << ": "
-        << future->error()->message;
+    ASSERT_FALSE(future->error()) << cass_error_desc(future->error()->code) << ": "
+                                  << future->error()->message;
   }
 
   // uv_thread_create
   static void query(void* arg) {
-    cass::Session* session = static_cast<cass::Session*>(arg);
+    Session* session = static_cast<Session*>(arg);
     query(session);
   }
 
-  class HostEventFuture : public cass::Future {
+  class HostEventFuture : public Future {
   public:
     typedef SharedRefPtr<HostEventFuture> Ptr;
 
-    enum Type {
-      INVALID,
-      START_NODE,
-      STOP_NODE,
-      ADD_NODE,
-      REMOVE_NODE
-    };
+    enum Type { INVALID, START_NODE, STOP_NODE, ADD_NODE, REMOVE_NODE };
 
     typedef std::pair<Type, Address> Event;
 
     HostEventFuture()
-      : cass::Future(cass::Future::FUTURE_TYPE_GENERIC) { }
+        : Future(Future::FUTURE_TYPE_GENERIC) {}
 
     Type type() { return event_.first; }
 
     void set_event(Type type, const Address& host) {
-      cass::ScopedMutex lock(&mutex_);
+      ScopedMutex lock(&mutex_);
       if (!is_set()) {
         event_ = Event(type, host);
         internal_set(lock);
@@ -135,43 +127,36 @@ class SessionUnitTest : public EventLoopTest {
     }
 
     Event wait_for_event(uint64_t timeout_us) {
-      cass::ScopedMutex lock(&mutex_);
-      return internal_wait_for(lock, timeout_us) ? event_ : Event(INVALID,
-                                                                  Address());
+      ScopedMutex lock(&mutex_);
+      return internal_wait_for(lock, timeout_us) ? event_ : Event(INVALID, Address());
     }
 
   private:
     Event event_;
   };
 
-  class TestHostListener : public cass::DefaultHostListener {
+  class TestHostListener : public DefaultHostListener {
   public:
-    typedef cass::SharedRefPtr<TestHostListener> Ptr;
+    typedef SharedRefPtr<TestHostListener> Ptr;
 
     TestHostListener() {
-      events_.push_back(
-            HostEventFuture::Ptr(
-              new HostEventFuture()));
+      events_.push_back(HostEventFuture::Ptr(new HostEventFuture()));
       uv_mutex_init(&mutex_);
     }
 
-    ~TestHostListener() {
-      uv_mutex_destroy(&mutex_);
-    }
+    ~TestHostListener() { uv_mutex_destroy(&mutex_); }
 
-    virtual void on_host_up(const cass::Host::Ptr& host) {
-      push_back(HostEventFuture::START_NODE, host);
-    }
+    virtual void on_host_up(const Host::Ptr& host) { push_back(HostEventFuture::START_NODE, host); }
 
-    virtual void on_host_down(const cass::Host::Ptr& host) {
+    virtual void on_host_down(const Host::Ptr& host) {
       push_back(HostEventFuture::STOP_NODE, host);
     }
 
-    virtual void on_host_added(const cass::Host::Ptr& host) {
+    virtual void on_host_added(const Host::Ptr& host) {
       push_back(HostEventFuture::ADD_NODE, host);
     }
 
-    virtual void on_host_removed(const cass::Host::Ptr& host) {
+    virtual void on_host_removed(const Host::Ptr& host) {
       push_back(HostEventFuture::REMOVE_NODE, host);
     }
 
@@ -182,30 +167,28 @@ class SessionUnitTest : public EventLoopTest {
     }
 
     size_t event_count() {
-      cass::ScopedMutex lock(&mutex_);
+      ScopedMutex lock(&mutex_);
       size_t count = events_.size();
       return events_.front()->ready() ? count : count - 1;
     }
 
   private:
-    typedef cass::Deque<HostEventFuture::Ptr> EventQueue;
+    typedef Deque<HostEventFuture::Ptr> EventQueue;
 
     HostEventFuture::Ptr front() {
-      cass::ScopedMutex lock(&mutex_);
+      ScopedMutex lock(&mutex_);
       return events_.front();
     }
 
     void pop_front() {
-      cass::ScopedMutex lock(&mutex_);
+      ScopedMutex lock(&mutex_);
       events_.pop_front();
     }
 
-    void push_back(HostEventFuture::Type type, const cass::Host::Ptr& host) {
-      cass::ScopedMutex lock(&mutex_);
+    void push_back(HostEventFuture::Type type, const Host::Ptr& host) {
+      ScopedMutex lock(&mutex_);
       events_.back()->set_event(type, host->address());
-      events_.push_back(
-            HostEventFuture::Ptr(
-              new HostEventFuture()));
+      events_.push_back(HostEventFuture::Ptr(new HostEventFuture()));
     }
 
   private:
@@ -215,10 +198,10 @@ class SessionUnitTest : public EventLoopTest {
 };
 
 TEST_F(SessionUnitTest, ExecuteQueryNotConnected) {
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("blah", 0));
+  QueryRequest::Ptr request(new QueryRequest("blah", 0));
 
-  cass::Session session;
-  cass::Future::Ptr future = session.execute(request, NULL);
+  Session session;
+  Future::Ptr future = session.execute(request, NULL);
   ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, future->error()->code);
 }
 
@@ -232,11 +215,11 @@ TEST_F(SessionUnitTest, InvalidKeyspace) {
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
-  cass::Session session;
+  Session session;
 
-  cass::Future::Ptr connect_future(session.connect(config, "invalid"));
+  Future::Ptr connect_future(session.connect(config, "invalid"));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_EQ(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE, connect_future->error()->code);
 
@@ -247,36 +230,29 @@ TEST_F(SessionUnitTest, InvalidDataCenter) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
-  config.set_load_balancing_policy(new cass::DCAwarePolicy(
-                                     "invalid_data_center",
-                                     0,
-                                     false));
-  cass::Session session;
+  config.set_load_balancing_policy(new DCAwarePolicy("invalid_data_center", 0, false));
+  Session session;
 
-  cass::Future::Ptr connect_future(session.connect(config));
+  Future::Ptr connect_future(session.connect(config));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connect_future->error()->code);
 
   ASSERT_TRUE(session.close()->wait_for(WAIT_FOR_TIME));
 }
 
-
 TEST_F(SessionUnitTest, InvalidLocalAddress) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.set_local_address(Address("1.1.1.1", PORT)); // Invalid
   config.contact_points().push_back("127.0.0.1");
-  config.set_load_balancing_policy(new cass::DCAwarePolicy(
-                                     "invalid_data_center",
-                                     0,
-                                     false));
-  cass::Session session;
+  config.set_load_balancing_policy(new DCAwarePolicy("invalid_data_center", 0, false));
+  Session session;
 
-  cass::Future::Ptr connect_future(session.connect(config, "invalid"));
+  Future::Ptr connect_future(session.connect(config, "invalid"));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connect_future->error()->code);
 
@@ -287,7 +263,7 @@ TEST_F(SessionUnitTest, ExecuteQueryReusingSession) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   for (int i = 0; i < 2; ++i) {
     connect(&session);
     query(&session);
@@ -297,10 +273,10 @@ TEST_F(SessionUnitTest, ExecuteQueryReusingSession) {
 
 TEST_F(SessionUnitTest, ExecuteQueryReusingSessionUsingSsl) {
   mockssandra::SimpleCluster cluster(simple());
-  cass::SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
+  SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   for (int i = 0; i < 2; ++i) {
     connect(&session, ssl_context.get());
     query(&session);
@@ -315,8 +291,8 @@ TEST_F(SessionUnitTest, ExecuteQueryReusingSessionChaotic) {
   OutagePlan outage_plan(loop(), &cluster);
   populate_outage_plan(&outage_plan);
 
-  cass::Session session;
-  cass::Future::Ptr outage_future = execute_outage_plan(&outage_plan);
+  Session session;
+  Future::Ptr outage_future = execute_outage_plan(&outage_plan);
   while (!outage_future->wait_for(1000)) { // 1 millisecond wait
     connect(&session, NULL, WAIT_FOR_TIME * 3, 4);
     query(&session);
@@ -326,14 +302,14 @@ TEST_F(SessionUnitTest, ExecuteQueryReusingSessionChaotic) {
 
 TEST_F(SessionUnitTest, ExecuteQueryReusingSessionUsingSslChaotic) {
   mockssandra::SimpleCluster cluster(simple(), 4);
-  cass::SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
+  SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
   ASSERT_EQ(cluster.start_all(), 0);
 
   OutagePlan outage_plan(loop(), &cluster);
   populate_outage_plan(&outage_plan);
 
-  cass::Session session;
-  cass::Future::Ptr outage_future = execute_outage_plan(&outage_plan);
+  Session session;
+  Future::Ptr outage_future = execute_outage_plan(&outage_plan);
   while (!outage_future->wait_for(1000)) { // 1 millisecond wait
     connect(&session, ssl_context.get(), WAIT_FOR_TIME * 3, 4);
     query(&session);
@@ -345,13 +321,13 @@ TEST_F(SessionUnitTest, ExecuteQueryWithCompleteOutage) {
   mockssandra::SimpleCluster cluster(simple(), 3);
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session);
 
   // Full outage
   cluster.stop_all();
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("blah", 0));
-  cass::Future::Ptr future = session.execute(request, NULL);
+  QueryRequest::Ptr request(new QueryRequest("blah", 0));
+  Future::Ptr future = session.execute(request, NULL);
   ASSERT_TRUE(future->wait_for(WAIT_FOR_TIME));
   ASSERT_TRUE(future->error());
   EXPECT_TRUE(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE == future->error()->code ||
@@ -369,7 +345,7 @@ TEST_F(SessionUnitTest, ExecuteQueryWithCompleteOutageSpinDown) {
   mockssandra::SimpleCluster cluster(simple(), 3);
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session);
 
   // Spin down nodes while querying
@@ -381,8 +357,8 @@ TEST_F(SessionUnitTest, ExecuteQueryWithCompleteOutageSpinDown) {
   cluster.stop(2);
 
   // Full outage
-  cass::QueryRequest::Ptr request(new cass::QueryRequest("blah", 0));
-  cass::Future::Ptr future = session.execute(request, NULL);
+  QueryRequest::Ptr request(new QueryRequest("blah", 0));
+  Future::Ptr future = session.execute(request, NULL);
   ASSERT_TRUE(future->wait_for(WAIT_FOR_TIME));
   ASSERT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, future->error()->code);
 
@@ -398,7 +374,7 @@ TEST_F(SessionUnitTest, ExecuteQueryWithThreads) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session);
   query_on_threads(&session);
   close(&session);
@@ -406,10 +382,10 @@ TEST_F(SessionUnitTest, ExecuteQueryWithThreads) {
 
 TEST_F(SessionUnitTest, ExecuteQueryWithThreadsUsingSsl) {
   mockssandra::SimpleCluster cluster(simple());
-  cass::SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
+  SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session, ssl_context.get());
   query_on_threads(&session);
   close(&session);
@@ -419,13 +395,13 @@ TEST_F(SessionUnitTest, ExecuteQueryWithThreadsChaotic) {
   mockssandra::SimpleCluster cluster(simple(), 4);
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session);
 
   OutagePlan outage_plan(loop(), &cluster);
   populate_outage_plan(&outage_plan);
 
-  cass::Future::Ptr outage_future = execute_outage_plan(&outage_plan);
+  Future::Ptr outage_future = execute_outage_plan(&outage_plan);
   while (!outage_future->wait_for(1000)) { // 1 millisecond wait
     query_on_threads(&session);
   }
@@ -435,16 +411,16 @@ TEST_F(SessionUnitTest, ExecuteQueryWithThreadsChaotic) {
 
 TEST_F(SessionUnitTest, ExecuteQueryWithThreadsUsingSslChaotic) {
   mockssandra::SimpleCluster cluster(simple(), 4);
-  cass::SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
+  SslContext::Ptr ssl_context = use_ssl(&cluster).socket_settings.ssl_context;
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Session session;
+  Session session;
   connect(&session, ssl_context.get());
 
   OutagePlan outage_plan(loop(), &cluster);
   populate_outage_plan(&outage_plan);
 
-  cass::Future::Ptr outage_future = execute_outage_plan(&outage_plan);
+  Future::Ptr outage_future = execute_outage_plan(&outage_plan);
   while (!outage_future->wait_for(1000)) { // 1 millisecond wait
     query_on_threads(&session);
   }
@@ -458,60 +434,50 @@ TEST_F(SessionUnitTest, HostListener) {
 
   TestHostListener::Ptr listener(new TestHostListener());
 
-  cass::Config config;
-  config.set_reconnect_wait_time(100); // Reconnect immediately
+  Config config;
+  config.set_constant_reconnect(100); // Reconnect immediately
   config.contact_points().push_back("127.0.0.2");
   config.set_host_listener(listener);
 
-  cass::Session session;
+  Session session;
   connect(config, &session);
 
   { // Initial nodes available from peers table
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.remove(1);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE,
-                                     Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::REMOVE_NODE,
-                                     Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::REMOVE_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.add(1);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-                                     Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-                                     Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.stop(2);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE,
-                                     Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.start(2);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-                                     Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
@@ -526,33 +492,28 @@ TEST_F(SessionUnitTest, HostListenerDCAwareLocal) {
 
   TestHostListener::Ptr listener(new TestHostListener());
 
-  cass::Config config;
-  config.set_reconnect_wait_time(100); // Reconnect immediately
+  Config config;
+  config.set_constant_reconnect(100); // Reconnect immediately
   config.contact_points().push_back("127.0.0.1");
   config.set_host_listener(listener);
 
-  cass::Session session;
+  Session session;
   connect(config, &session);
 
   { // Initial nodes available from peers table
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   { // Node 3 is DC2 should be ignored
     cluster.stop(3);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::INVALID,
-              Address()),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::INVALID, Address()),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
@@ -568,43 +529,33 @@ TEST_F(SessionUnitTest, HostListenerDCAwareRemote) {
 
   TestHostListener::Ptr listener(new TestHostListener());
 
-  cass::Config config;
-  config.set_reconnect_wait_time(100); // Reconnect immediately
+  Config config;
+  config.set_constant_reconnect(100); // Reconnect immediately
   config.contact_points().push_back("127.0.0.1");
-  config.set_load_balancing_policy(new cass::DCAwarePolicy(
-                                   "dc1",
-                                   1,
-                                   false));
+  config.set_load_balancing_policy(new DCAwarePolicy("dc1", 1, false));
   config.set_host_listener(listener);
 
-  cass::Session session;
+  Session session;
   connect(config, &session);
 
   { // Initial nodes available from peers table
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.3", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.3", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.3", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.3", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.stop(3);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE,
-              Address("127.0.0.3", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE, Address("127.0.0.3", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
@@ -620,45 +571,37 @@ TEST_F(SessionUnitTest, HostListenerNodeDown) {
 
   TestHostListener::Ptr listener(new TestHostListener());
 
-  cass::Config config;
-  config.set_reconnect_wait_time(100); // Reconnect immediately
+  Config config;
+  config.set_constant_reconnect(100); // Reconnect immediately
   config.contact_points().push_back("127.0.0.1");
   config.set_host_listener(listener);
 
-  cass::Session session;
+  Session session;
   connect(config, &session);
 
   { // Initial nodes available from peers table
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.1", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.1", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE,
-              Address("127.0.0.3", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::ADD_NODE, Address("127.0.0.3", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.3", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.3", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   { // Node 2 connection should not be established (node down event)
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::STOP_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
   {
     cluster.start(2);
-    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE,
-              Address("127.0.0.2", 9042)),
+    EXPECT_EQ(HostEventFuture::Event(HostEventFuture::START_NODE, Address("127.0.0.2", 9042)),
               listener->wait_for_event(WAIT_FOR_TIME));
   }
 
diff --git a/gtests/src/unit/tests/test_session_base.cpp b/gtests/src/unit/tests/test_session_base.cpp
index 4e99aad36..031bec368 100644
--- a/gtests/src/unit/tests/test_session_base.cpp
+++ b/gtests/src/unit/tests/test_session_base.cpp
@@ -22,37 +22,38 @@
 
 #define KEYSPACE "datastax"
 
-class TestSessionBase : public cass::SessionBase {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+class TestSessionBase : public SessionBase {
 public:
   TestSessionBase()
-    : connected_(0)
-    , failed_(0)
-    , closed_(0) { }
+      : connected_(0)
+      , failed_(0)
+      , closed_(0) {}
 
-  virtual void on_host_up(const cass::Host::Ptr& host) { }
-  virtual void on_host_down(const cass::Host::Ptr& host) { }
-  virtual void on_host_added(const cass::Host::Ptr& host) { }
-  virtual void on_host_removed(const cass::Host::Ptr& host) { }
-  virtual void on_token_map_updated(const cass::TokenMap::Ptr& token_map) { }
+  virtual void on_host_up(const Host::Ptr& host) {}
+  virtual void on_host_down(const Host::Ptr& host) {}
+  virtual void on_host_added(const Host::Ptr& host) {}
+  virtual void on_host_removed(const Host::Ptr& host) {}
+  virtual void on_token_map_updated(const TokenMap::Ptr& token_map) {}
 
   int connected() { return connected_; }
   int failed() { return failed_; }
   int closed() { return closed_; }
 
 protected:
-  virtual void on_connect(const cass::Host::Ptr& connected_host,
-                          cass::ProtocolVersion protocol_version,
-                          const cass::HostMap& hosts,
-                          const cass::TokenMap::Ptr& token_map) {
+  virtual void on_connect(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                          const HostMap& hosts, const TokenMap::Ptr& token_map) {
     ++connected_;
     ASSERT_STREQ("127.0.0.1", connected_host->address_string().c_str());
-    ASSERT_EQ(cass::ProtocolVersion(PROTOCOL_VERSION), protocol_version);
+    ASSERT_EQ(ProtocolVersion(PROTOCOL_VERSION), protocol_version);
     ASSERT_EQ(1u, hosts.size());
     ASSERT_EQ(state(), SESSION_STATE_CONNECTING);
     notify_connected();
   }
 
-  virtual void on_connect_failed(CassError code, const cass::String& message) {
+  virtual void on_connect_failed(CassError code, const String& message) {
     ++failed_;
     ASSERT_EQ(state(), SESSION_STATE_CONNECTING);
     notify_connect_failed(code, message);
@@ -71,19 +72,19 @@ class TestSessionBase : public cass::SessionBase {
   int closed_;
 };
 
-class SessionBaseUnitTest : public Unit { };
+class SessionBaseUnitTest : public Unit {};
 
 TEST_F(SessionBaseUnitTest, Simple) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
-  ASSERT_EQ(session_base.state(), cass::SessionBase::SESSION_STATE_CONNECTED);
+  ASSERT_EQ(session_base.state(), SessionBase::SESSION_STATE_CONNECTED);
   EXPECT_STREQ(KEYSPACE, session_base.connect_keyspace().c_str());
   EXPECT_NE(&session_base.config(), &config);
   EXPECT_TRUE(session_base.random() != NULL);
@@ -101,14 +102,14 @@ TEST_F(SessionBaseUnitTest, SimpleEmptyKeyspaceWithoutRandom) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   config.set_use_randomized_contact_points(false);
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config));
+  Future::Ptr connect_future(session_base.connect(config));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
-  ASSERT_EQ(session_base.state(), cass::SessionBase::SESSION_STATE_CONNECTED);
+  ASSERT_EQ(session_base.state(), SessionBase::SESSION_STATE_CONNECTED);
   EXPECT_TRUE(session_base.connect_keyspace().empty());
   EXPECT_NE(&session_base.config(), &config);
   EXPECT_TRUE(session_base.random() == NULL);
@@ -124,17 +125,17 @@ TEST_F(SessionBaseUnitTest, SimpleEmptyKeyspaceWithoutRandom) {
 
 TEST_F(SessionBaseUnitTest, Ssl) {
   mockssandra::SimpleCluster cluster(simple());
-  cass::ConnectionSettings settings(use_ssl(&cluster));
+  ConnectionSettings settings(use_ssl(&cluster));
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   config.set_ssl_context(settings.socket_settings.ssl_context.get());
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
-  ASSERT_EQ(session_base.state(), cass::SessionBase::SESSION_STATE_CONNECTED);
+  ASSERT_EQ(session_base.state(), SessionBase::SESSION_STATE_CONNECTED);
   EXPECT_STREQ(KEYSPACE, session_base.connect_keyspace().c_str());
   EXPECT_NE(&session_base.config(), &config);
   EXPECT_TRUE(session_base.random() != NULL);
@@ -152,13 +153,13 @@ TEST_F(SessionBaseUnitTest, SimpleInvalidContactPointsIp) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.set_use_randomized_contact_points(false);
   config.contact_points().push_back("123.456.789.012");
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_STREQ(KEYSPACE, session_base.connect_keyspace().c_str());
   EXPECT_NE(&session_base.config(), &config);
@@ -177,12 +178,12 @@ TEST_F(SessionBaseUnitTest, SimpleInvalidContactPointsHostname) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("doesnotexist.dne");
   config.contact_points().push_back("localhost");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_STREQ(KEYSPACE, session_base.connect_keyspace().c_str());
   EXPECT_NE(&session_base.config(), &config);
@@ -203,11 +204,11 @@ TEST_F(SessionBaseUnitTest, InvalidProtocol) {
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_LIB_UNABLE_TO_DETERMINE_PROTOCOL, connect_future->error()->code);
   EXPECT_EQ(0, session_base.connected());
@@ -220,14 +221,14 @@ TEST_F(SessionBaseUnitTest, SslError) {
   use_ssl(&cluster);
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::SslContext::Ptr invalid_ssl_context(cass::SslContextFactory::create());
+  SslContext::Ptr invalid_ssl_context(SslContextFactory::create());
   invalid_ssl_context->set_verify_flags(CASS_SSL_VERIFY_PEER_CERT);
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   config.set_ssl_context(invalid_ssl_context.get());
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_SSL_INVALID_PEER_CERT, connect_future->error()->code);
   EXPECT_EQ(0, session_base.connected());
@@ -239,12 +240,12 @@ TEST_F(SessionBaseUnitTest, Auth) {
   mockssandra::SimpleCluster cluster(auth());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   config.set_credentials("cassandra", "cassandra");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_FALSE(connect_future->error());
   EXPECT_EQ(1, session_base.connected());
@@ -261,11 +262,11 @@ TEST_F(SessionBaseUnitTest, BadCredentials) {
   mockssandra::SimpleCluster cluster(auth());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_SERVER_BAD_CREDENTIALS, connect_future->error()->code);
   EXPECT_EQ(0, session_base.connected());
@@ -274,11 +275,11 @@ TEST_F(SessionBaseUnitTest, BadCredentials) {
 }
 
 TEST_F(SessionBaseUnitTest, NoHostsAvailable) {
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connect_future->error()->code);
   EXPECT_EQ(0, session_base.connected());
@@ -290,20 +291,20 @@ TEST_F(SessionBaseUnitTest, ConnectWhenAlreadyConnected) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
   {
-    cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+    Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
     ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
     EXPECT_EQ(1, session_base.connected());
     EXPECT_EQ(0, session_base.failed());
     EXPECT_EQ(0, session_base.closed());
   }
 
-  {// Attempt second session connection
-    cass::Future::Ptr connect_future(session_base.connect(config, ""));
+  { // Attempt second session connection
+    Future::Ptr connect_future(session_base.connect(config, ""));
     ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
     EXPECT_EQ(CASS_ERROR_LIB_UNABLE_TO_CONNECT, connect_future->error()->code);
     EXPECT_EQ(1, session_base.connected());
@@ -321,11 +322,11 @@ TEST_F(SessionBaseUnitTest, CloseWhenAlreadyClosed) {
   mockssandra::SimpleCluster cluster(simple());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.contact_points().push_back("127.0.0.1");
   TestSessionBase session_base;
 
-  cass::Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
+  Future::Ptr connect_future(session_base.connect(config, KEYSPACE));
   ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(1, session_base.connected());
   EXPECT_EQ(0, session_base.failed());
@@ -337,7 +338,7 @@ TEST_F(SessionBaseUnitTest, CloseWhenAlreadyClosed) {
   EXPECT_EQ(1, session_base.closed());
 
   // Attempt second session close
-  cass::Future::Ptr close_future(session_base.close());
+  Future::Ptr close_future(session_base.close());
   ASSERT_TRUE(close_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_LIB_UNABLE_TO_CLOSE, close_future->error()->code);
   EXPECT_EQ(1, session_base.connected());
@@ -351,7 +352,7 @@ TEST_F(SessionBaseUnitTest, CloseWhenNotConnected) {
 
   TestSessionBase session_base;
 
-  cass::Future::Ptr close_future(session_base.close());
+  Future::Ptr close_future(session_base.close());
   ASSERT_TRUE(close_future->wait_for(WAIT_FOR_TIME));
   EXPECT_EQ(CASS_ERROR_LIB_UNABLE_TO_CLOSE, close_future->error()->code);
   EXPECT_EQ(0, session_base.connected());
diff --git a/gtests/src/unit/tests/test_small_vector.cpp b/gtests/src/unit/tests/test_small_vector.cpp
index 5d215fd44..cf7c8a112 100644
--- a/gtests/src/unit/tests/test_small_vector.cpp
+++ b/gtests/src/unit/tests/test_small_vector.cpp
@@ -18,9 +18,10 @@
 
 #include "small_vector.hpp"
 
-TEST(SmallVectorUnitTest, Simple)
-{
-  cass::SmallVector<int, 5> vec;
+using datastax::internal::SmallVector;
+
+TEST(SmallVectorUnitTest, Simple) {
+  SmallVector<int, 5> vec;
   EXPECT_EQ(vec.fixed().data.address(), vec.data());
   EXPECT_EQ(vec.fixed().is_used, true);
 
diff --git a/gtests/src/unit/tests/test_socket.cpp b/gtests/src/unit/tests/test_socket.cpp
index c17182647..26f77d31a 100644
--- a/gtests/src/unit/tests/test_socket.cpp
+++ b/gtests/src/unit/tests/test_socket.cpp
@@ -24,12 +24,14 @@
 #define SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME SSL_VERIFY_PEER_DNS_RELATIVE_HOSTNAME "."
 #define SSL_VERIFY_PEER_DNS_IP_ADDRESS "127.254.254.254"
 
-using namespace cass;
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class TestSocketHandler : public SocketHandler {
 public:
   TestSocketHandler(String* result)
-    : result_(result) { }
+      : result_(result) {}
 
   virtual void on_read(Socket* socket, ssize_t nread, const uv_buf_t* buf) {
     if (nread > 0) {
@@ -41,11 +43,9 @@ class TestSocketHandler : public SocketHandler {
     }
   }
 
-  virtual void on_write(Socket* socket, int status, SocketRequest* request) {
-    delete request;
-  }
+  virtual void on_write(Socket* socket, int status, SocketRequest* request) { delete request; }
 
-  virtual void on_close() { }
+  virtual void on_close() {}
 
 private:
   String* result_;
@@ -54,8 +54,8 @@ class TestSocketHandler : public SocketHandler {
 class SslTestSocketHandler : public SslSocketHandler {
 public:
   SslTestSocketHandler(SslSession* ssl_session, String* result)
-    : SslSocketHandler(ssl_session)
-    , result_(result) { }
+      : SslSocketHandler(ssl_session)
+      , result_(result) {}
 
   virtual void on_ssl_read(Socket* socket, char* buf, size_t size) {
     result_->append(buf, size);
@@ -64,11 +64,9 @@ class SslTestSocketHandler : public SslSocketHandler {
     }
   }
 
-  virtual void on_write(Socket* socket, int status, SocketRequest* request) {
-    delete request;
-  }
+  virtual void on_write(Socket* socket, int status, SocketRequest* request) { delete request; }
 
-  virtual void on_close() { }
+  virtual void on_close() {}
 
 private:
   String* result_;
@@ -90,21 +88,13 @@ class SocketUnitTest : public LoopTest {
     return settings;
   }
 
-  void listen() {
-    ASSERT_EQ(server_.listen(), 0);
-  }
+  void listen() { ASSERT_EQ(server_.listen(), 0); }
 
-  void reset(const Address& address) {
-    server_.reset(address);
-  }
+  void reset(const Address& address) { server_.reset(address); }
 
-  void close() {
-    server_.close();
-  }
+  void close() { server_.close(); }
 
-  void use_close_immediately() {
-    server_.use_close_immediately();
-  }
+  void use_close_immediately() { server_.use_close_immediately(); }
 
   virtual void TearDown() {
     LoopTest::TearDown();
@@ -115,12 +105,9 @@ class SocketUnitTest : public LoopTest {
     Socket::Ptr socket = connector->release_socket();
     if (connector->error_code() == SocketConnector::SOCKET_OK) {
       if (connector->ssl_session()) {
-        socket->set_handler(
-              new SslTestSocketHandler(
-                connector->ssl_session().release(), result));
+        socket->set_handler(new SslTestSocketHandler(connector->ssl_session().release(), result));
       } else {
-        socket->set_handler(
-              new TestSocketHandler(result));
+        socket->set_handler(new TestSocketHandler(result));
       }
       const char* data = "The socket is successfully connected and wrote data - ";
       socket->write(new BufferSocketRequest(Buffer(data, strlen(data))));
@@ -149,19 +136,15 @@ class SocketUnitTest : public LoopTest {
     }
   }
 
-  static void on_request(uv_getnameinfo_t* handle,
-                         int status,
-                         const char* hostname,
+  static void on_request(uv_getnameinfo_t* handle, int status, const char* hostname,
                          const char* service) {
-    if(status) {
-      FAIL()
-          << "Unable to Execute Test SocketUnitTest.SslVerifyIdentityDns: "
-          << "Add /etc/hosts entry " << SSL_VERIFY_PEER_DNS_IP_ADDRESS << "\t"
-          << SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME;
+    if (status) {
+      FAIL() << "Unable to Execute Test SocketUnitTest.SslVerifyIdentityDns: "
+             << "Add /etc/hosts entry " << SSL_VERIFY_PEER_DNS_IP_ADDRESS << "\t"
+             << SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME;
     } else if (String(hostname) != String(SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME)) {
-      FAIL()
-          << "Invalid /etc/hosts entry for: '" << hostname << "' != '"
-          << SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME << "'";
+      FAIL() << "Invalid /etc/hosts entry for: '" << hostname << "' != '"
+             << SSL_VERIFY_PEER_DNS_ABSOLUTE_HOSTNAME << "'";
     }
   }
 
@@ -173,8 +156,8 @@ TEST_F(SocketUnitTest, Simple) {
   listen();
 
   String result;
-  SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                     cass::bind_callback(on_socket_connected, &result)));
+  SocketConnector::Ptr connector(
+      new SocketConnector(Address("127.0.0.1", 8888), bind_callback(on_socket_connected, &result)));
 
   connector->connect(loop());
 
@@ -189,12 +172,10 @@ TEST_F(SocketUnitTest, Ssl) {
   SocketSettings settings(use_ssl());
 
   String result;
-  SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                     cass::bind_callback(on_socket_connected, &result)));
-
+  SocketConnector::Ptr connector(
+      new SocketConnector(Address("127.0.0.1", 8888), bind_callback(on_socket_connected, &result)));
 
-  connector->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -203,8 +184,8 @@ TEST_F(SocketUnitTest, Ssl) {
 
 TEST_F(SocketUnitTest, Refused) {
   bool is_refused = false;
-  SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                     cass::bind_callback(on_socket_refused, &is_refused)));
+  SocketConnector::Ptr connector(new SocketConnector(
+      Address("127.0.0.1", 8888), bind_callback(on_socket_refused, &is_refused)));
   connector->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
@@ -222,12 +203,10 @@ TEST_F(SocketUnitTest, SslClose) {
 
   bool is_closed = false;
   for (size_t i = 0; i < 10; ++i) {
-    SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                       cass::bind_callback(on_socket_closed, &is_closed)));
+    SocketConnector::Ptr connector(new SocketConnector(
+        Address("127.0.0.1", 8888), bind_callback(on_socket_closed, &is_closed)));
 
-    connector
-        ->with_settings(settings)
-        ->connect(loop());
+    connector->with_settings(settings)->connect(loop());
     connectors.push_back(connector);
   }
 
@@ -243,8 +222,8 @@ TEST_F(SocketUnitTest, Cancel) {
 
   bool is_canceled = false;
   for (size_t i = 0; i < 10; ++i) {
-    SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                       cass::bind_callback(on_socket_canceled, &is_canceled)));
+    SocketConnector::Ptr connector(new SocketConnector(
+        Address("127.0.0.1", 8888), bind_callback(on_socket_canceled, &is_canceled)));
     connector->connect(loop());
     connectors.push_back(connector);
   }
@@ -270,10 +249,9 @@ TEST_F(SocketUnitTest, SslCancel) {
 
   bool is_canceled = false;
   for (size_t i = 0; i < 10; ++i) {
-    SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                       cass::bind_callback(on_socket_canceled, &is_canceled)));
-    connector->with_settings(settings)
-        ->connect(loop());
+    SocketConnector::Ptr connector(new SocketConnector(
+        Address("127.0.0.1", 8888), bind_callback(on_socket_canceled, &is_canceled)));
+    connector->with_settings(settings)->connect(loop());
     connectors.push_back(connector);
   }
 
@@ -296,11 +274,10 @@ TEST_F(SocketUnitTest, SslVerifyIdentity) {
   settings.ssl_context->set_verify_flags(CASS_SSL_VERIFY_PEER_IDENTITY);
 
   String result;
-  SocketConnector::Ptr connector(new SocketConnector(Address("127.0.0.1", 8888),
-                                                     cass::bind_callback(on_socket_connected, &result)));
+  SocketConnector::Ptr connector(
+      new SocketConnector(Address("127.0.0.1", 8888), bind_callback(on_socket_connected, &result)));
 
-  connector->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
@@ -312,17 +289,15 @@ TEST_F(SocketUnitTest, SslVerifyIdentityDns) {
   Address verify_entry;
   Address::from_string(SSL_VERIFY_PEER_DNS_IP_ADDRESS, 8888, &verify_entry);
   uv_getnameinfo_t request;
-  ASSERT_EQ(0, uv_getnameinfo(loop(),
-                              &request,
-                              on_request,
-                              static_cast<const Address>(verify_entry).addr(),
-                              0));
+  ASSERT_EQ(0, uv_getnameinfo(loop(), &request, on_request,
+                              static_cast<const Address>(verify_entry).addr(), 0));
   uv_run(loop(), UV_RUN_DEFAULT);
   if (this->HasFailure()) { // Make test fail due to DNS not configured
     return;
   }
 
-  reset(Address(SSL_VERIFY_PEER_DNS_IP_ADDRESS, 8888)); // Ensure the echo server is listening on the correct address
+  reset(Address(SSL_VERIFY_PEER_DNS_IP_ADDRESS,
+                8888)); // Ensure the echo server is listening on the correct address
   listen();
 
   SocketSettings settings(use_ssl(SSL_VERIFY_PEER_DNS_RELATIVE_HOSTNAME));
@@ -330,10 +305,9 @@ TEST_F(SocketUnitTest, SslVerifyIdentityDns) {
 
   String result;
   SocketConnector::Ptr connector(new SocketConnector(Address(SSL_VERIFY_PEER_DNS_IP_ADDRESS, 8888),
-                                                     cass::bind_callback(on_socket_connected, &result)));
+                                                     bind_callback(on_socket_connected, &result)));
 
-  connector->with_settings(settings)
-      ->connect(loop());
+  connector->with_settings(settings)->connect(loop());
 
   uv_run(loop(), UV_RUN_DEFAULT);
 
diff --git a/gtests/src/unit/tests/test_startup_options.cpp b/gtests/src/unit/tests/test_startup_options.cpp
index d7007cb74..5288bdc2a 100644
--- a/gtests/src/unit/tests/test_startup_options.cpp
+++ b/gtests/src/unit/tests/test_startup_options.cpp
@@ -24,14 +24,16 @@
 #define APPLICATION_NAME "DataStax C/C++ Test Harness"
 #define APPLICATION_VERSION "1.0.0"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 inline bool operator==(const CassUuid& rhs, const CassUuid& lhs) {
   return rhs.clock_seq_and_node == lhs.clock_seq_and_node &&
-    rhs.time_and_version == lhs.time_and_version;
+         rhs.time_and_version == lhs.time_and_version;
 }
 
-inline bool operator!=(const CassUuid& rhs, const CassUuid& lhs) {
-  return !(rhs == lhs);
-}
+inline bool operator!=(const CassUuid& rhs, const CassUuid& lhs) { return !(rhs == lhs); }
 
 class StartupRequestUnitTest : public Unit {
 public:
@@ -40,46 +42,45 @@ class StartupRequestUnitTest : public Unit {
     Unit::TearDown();
   }
 
-  cass::Session& session() { return session_; }
-  const cass::String& client_id() const { return client_id_; }
-  cass::Config& config() { return config_; }
+  Session& session() { return session_; }
+  const String& client_id() const { return client_id_; }
+  Config& config() { return config_; }
   const mockssandra::RequestHandler* simple_with_client_options() {
     mockssandra::SimpleRequestHandlerBuilder builder;
     builder.on(mockssandra::OPCODE_QUERY)
-      .system_local()
-      .system_peers()
-      .client_options() // Allow for fake query to get client options
-      .empty_rows_result(1);
+        .system_local()
+        .system_peers()
+        .client_options() // Allow for fake query to get client options
+        .empty_rows_result(1);
     return builder.build();
   }
 
   void connect() {
     config_.contact_points().push_back("127.0.0.1");
-    cass::Future::Ptr connect_future(session_.connect(config_));
-    ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME)) << "Timed out waiting for session to connect";
-    ASSERT_FALSE(connect_future->error())
-      << cass_error_desc(connect_future->error()->code) << ": "
-      << connect_future->error()->message;
+    internal::core::Future::Ptr connect_future(session_.connect(config_));
+    ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME))
+        << "Timed out waiting for session to connect";
+    ASSERT_FALSE(connect_future->error()) << cass_error_desc(connect_future->error()->code) << ": "
+                                          << connect_future->error()->message;
 
     char client_id[CASS_UUID_STRING_LENGTH];
     cass_uuid_string(session_.client_id(), client_id);
     client_id_ = client_id;
   }
 
-  cass::Map<cass::String, cass::String> client_options() {
-    cass::SharedRefPtr<cass::QueryRequest> request(new cass::QueryRequest(CLIENT_OPTIONS_QUERY, 0));
-    cass::ResponseFuture::Ptr future = static_cast<cass::ResponseFuture::Ptr>(session_.execute(request, NULL));
+  Map<String, String> client_options() {
+    SharedRefPtr<QueryRequest> request(new QueryRequest(CLIENT_OPTIONS_QUERY, 0));
+    ResponseFuture::Ptr future = static_cast<ResponseFuture::Ptr>(session_.execute(request, NULL));
     EXPECT_TRUE(future->wait_for(WAIT_FOR_TIME)) << "Timed out executing query";
-    EXPECT_FALSE(future->error())
-      << cass_error_desc(future->error()->code) << ": "
-      << future->error()->message;
+    EXPECT_FALSE(future->error()) << cass_error_desc(future->error()->code) << ": "
+                                  << future->error()->message;
 
-    cass::Map<cass::String, cass::String> options;
-    cass::ResultResponse::Ptr response = static_cast<cass::ResultResponse::Ptr>(future->response());
-    const cass::Row row = response->first_row();
+    Map<String, String> options;
+    ResultResponse::Ptr response = static_cast<ResultResponse::Ptr>(future->response());
+    const Row row = response->first_row();
     for (size_t i = 0; i < row.values.size(); ++i) {
-      cass::String key = response->metadata()->get_column_definition(i).name.to_string();
-      cass::String value = row.values[i].decoder().as_string();
+      String key = response->metadata()->get_column_definition(i).name.to_string();
+      String value = row.values[i].decoder().as_string();
       options[key] = value;
     }
 
@@ -87,9 +88,9 @@ class StartupRequestUnitTest : public Unit {
   }
 
 private:
-  cass::Config config_;
-  cass::Session session_;
-  cass::String client_id_;
+  Config config_;
+  Session session_;
+  String client_id_;
 };
 
 TEST_F(StartupRequestUnitTest, Standard) {
@@ -97,13 +98,13 @@ TEST_F(StartupRequestUnitTest, Standard) {
   ASSERT_EQ(cluster.start_all(), 0);
 
   connect();
-  cass::Map<cass::String, cass::String> options = client_options();
+  Map<String, String> options = client_options();
   ASSERT_EQ(4u, options.size());
 
   ASSERT_EQ(client_id(), options["CLIENT_ID"]);
   ASSERT_EQ(CASS_DEFAULT_CQL_VERSION, options["CQL_VERSION"]);
-  ASSERT_EQ(cass::driver_name(), options["DRIVER_NAME"]);
-  ASSERT_EQ(cass::driver_version(), options["DRIVER_VERSION"]);
+  ASSERT_EQ(driver_name(), options["DRIVER_NAME"]);
+  ASSERT_EQ(driver_version(), options["DRIVER_VERSION"]);
 }
 
 TEST_F(StartupRequestUnitTest, EnableNoCompact) {
@@ -112,13 +113,13 @@ TEST_F(StartupRequestUnitTest, EnableNoCompact) {
 
   config().set_no_compact(true);
   connect();
-  cass::Map<cass::String, cass::String> options = client_options();
+  Map<String, String> options = client_options();
   ASSERT_EQ(5u, options.size());
 
   ASSERT_EQ(client_id(), options["CLIENT_ID"]);
   ASSERT_EQ(CASS_DEFAULT_CQL_VERSION, options["CQL_VERSION"]);
-  ASSERT_EQ(cass::driver_name(), options["DRIVER_NAME"]);
-  ASSERT_EQ(cass::driver_version(), options["DRIVER_VERSION"]);
+  ASSERT_EQ(driver_name(), options["DRIVER_NAME"]);
+  ASSERT_EQ(driver_version(), options["DRIVER_VERSION"]);
   ASSERT_EQ("true", options["NO_COMPACT"]);
 }
 
@@ -129,15 +130,15 @@ TEST_F(StartupRequestUnitTest, Application) {
   config().set_application_name(APPLICATION_NAME);
   config().set_application_version(APPLICATION_VERSION);
   connect();
-  cass::Map<cass::String, cass::String> options = client_options();
+  Map<String, String> options = client_options();
   ASSERT_EQ(6u, options.size());
 
   ASSERT_EQ(APPLICATION_NAME, options["APPLICATION_NAME"]);
   ASSERT_EQ(APPLICATION_VERSION, options["APPLICATION_VERSION"]);
   ASSERT_EQ(client_id(), options["CLIENT_ID"]);
   ASSERT_EQ(CASS_DEFAULT_CQL_VERSION, options["CQL_VERSION"]);
-  ASSERT_EQ(cass::driver_name(), options["DRIVER_NAME"]);
-  ASSERT_EQ(cass::driver_version(), options["DRIVER_VERSION"]);
+  ASSERT_EQ(driver_name(), options["DRIVER_NAME"]);
+  ASSERT_EQ(driver_version(), options["DRIVER_VERSION"]);
 }
 
 TEST_F(StartupRequestUnitTest, SetClientId) {
@@ -147,19 +148,18 @@ TEST_F(StartupRequestUnitTest, SetClientId) {
   CassUuid generated_client_id = session().client_id();
   CassUuid assigned_client_id;
   ASSERT_EQ(CASS_OK,
-            cass_uuid_from_string("03398c99-c635-4fad-b30a-3b2c49f785c2",
-                                  &assigned_client_id));
+            cass_uuid_from_string("03398c99-c635-4fad-b30a-3b2c49f785c2", &assigned_client_id));
   config().set_client_id(assigned_client_id);
 
   connect();
   CassUuid current_client_id = session().client_id();
   ASSERT_EQ(assigned_client_id, current_client_id);
   ASSERT_NE(generated_client_id, current_client_id);
-  cass::Map<cass::String, cass::String> options = client_options();
+  Map<String, String> options = client_options();
   ASSERT_EQ(4u, options.size());
 
   ASSERT_EQ("03398c99-c635-4fad-b30a-3b2c49f785c2", options["CLIENT_ID"]);
   ASSERT_EQ(CASS_DEFAULT_CQL_VERSION, options["CQL_VERSION"]);
-  ASSERT_EQ(cass::driver_name(), options["DRIVER_NAME"]);
-  ASSERT_EQ(cass::driver_version(), options["DRIVER_VERSION"]);
-}
\ No newline at end of file
+  ASSERT_EQ(driver_name(), options["DRIVER_NAME"]);
+  ASSERT_EQ(driver_version(), options["DRIVER_VERSION"]);
+}
diff --git a/gtests/src/unit/tests/test_statement.cpp b/gtests/src/unit/tests/test_statement.cpp
index 7149f197c..7abd83a9c 100644
--- a/gtests/src/unit/tests/test_statement.cpp
+++ b/gtests/src/unit/tests/test_statement.cpp
@@ -16,10 +16,12 @@
 
 #include "unit.hpp"
 
-#include "query_request.hpp"
+#include "constants.hpp"
 #include "control_connection.hpp"
+#include "query_request.hpp"
 #include "session.hpp"
-#include "constants.hpp"
+
+using namespace datastax::internal::core;
 
 class StatementUnitTest : public Unit {
 public:
@@ -28,35 +30,34 @@ class StatementUnitTest : public Unit {
     Unit::TearDown();
   }
 
-  void connect(const cass::Config& config = cass::Config()) {
-    cass::Config temp(config);
+  void connect(const Config& config = Config()) {
+    Config temp(config);
     temp.contact_points().push_back("127.0.0.1");
     temp.contact_points().push_back("127.0.0.2"); // At least one more host (in case node 1 is down)
-    cass::Future::Ptr connect_future(session.connect(temp));
+    Future::Ptr connect_future(session.connect(temp));
     ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME))
         << "Timed out waiting for session to connect";
-    ASSERT_FALSE(connect_future->error())
-        << cass_error_desc(connect_future->error()->code) << ": "
-        << connect_future->error()->message;
+    ASSERT_FALSE(connect_future->error()) << cass_error_desc(connect_future->error()->code) << ": "
+                                          << connect_future->error()->message;
   }
 
-  void get_rpc_address(const cass::Response::Ptr& response, cass::Address* output) {
+  void get_rpc_address(const Response::Ptr& response, Address* output) {
     ASSERT_TRUE(response);
     ASSERT_EQ(response->opcode(), CQL_OPCODE_RESULT);
 
-    cass::ResultResponse::Ptr result(response);
+    ResultResponse::Ptr result(response);
 
-    const cass::Value* value = result->first_row().get_by_name("rpc_address");
+    const Value* value = result->first_row().get_by_name("rpc_address");
     ASSERT_TRUE(value);
     ASSERT_EQ(value->value_type(), CASS_VALUE_TYPE_INET);
 
     CassInet inet;
     ASSERT_TRUE(value->decoder().as_inet(value->size(), &inet));
 
-    ASSERT_TRUE(cass::Address::from_inet(inet.address, inet.address_length, 9042, output));
+    ASSERT_TRUE(Address::from_inet(inet.address, inet.address_length, 9042, output));
   }
 
-  cass::Session session;
+  Session session;
 };
 
 TEST_F(StatementUnitTest, SetHost) {
@@ -68,15 +69,15 @@ TEST_F(StatementUnitTest, SetHost) {
   mockssandra::Ipv4AddressGenerator gen;
 
   for (int i = 0; i < 2; ++i) {
-    cass::Address expected_host(gen.next());
+    Address expected_host(gen.next());
 
-    cass::Statement::Ptr request(new cass::QueryRequest(SELECT_LOCAL, 0));
+    Statement::Ptr request(new QueryRequest(SELECT_LOCAL, 0));
     request->set_host(expected_host);
 
-    cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+    ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
     future->wait();
 
-    cass::Address actual_host;
+    Address actual_host;
     get_rpc_address(future->response(), &actual_host);
 
     EXPECT_EQ(expected_host, actual_host);
@@ -89,12 +90,12 @@ TEST_F(StatementUnitTest, SetHostWithInvalidPort) {
 
   connect();
 
-  cass::Address expected_host(cass::Address("127.0.0.1", 8888)); // Invalid port
+  Address expected_host(Address("127.0.0.1", 8888)); // Invalid port
 
-  cass::Statement::Ptr request(new cass::QueryRequest(SELECT_LOCAL, 0));
+  Statement::Ptr request(new QueryRequest(SELECT_LOCAL, 0));
   request->set_host(expected_host);
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->error());
@@ -109,12 +110,12 @@ TEST_F(StatementUnitTest, SetHostWhereHostIsDown) {
 
   connect();
 
-  cass::Address expected_host(cass::Address("127.0.0.1", 9042));
+  Address expected_host(Address("127.0.0.1", 9042));
 
-  cass::Statement::Ptr request(new cass::QueryRequest(SELECT_LOCAL, 0));
+  Statement::Ptr request(new QueryRequest(SELECT_LOCAL, 0));
   request->set_host(expected_host);
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->error());
diff --git a/gtests/src/unit/tests/test_stream_manager.cpp b/gtests/src/unit/tests/test_stream_manager.cpp
index 56e238948..7a0e3ad1e 100644
--- a/gtests/src/unit/tests/test_stream_manager.cpp
+++ b/gtests/src/unit/tests/test_stream_manager.cpp
@@ -18,42 +18,39 @@
 
 #include "stream_manager.hpp"
 
-TEST(StreamManagerUnitTest, MaxStreams)
-{
-  ASSERT_EQ(cass::StreamManager<int>().max_streams(), 32768u);
-}
+using datastax::internal::core::StreamManager;
 
-TEST(StreamManagerUnitTest, Simple)
-{
-    cass::StreamManager<int> streams;
+TEST(StreamManagerUnitTest, MaxStreams) { ASSERT_EQ(StreamManager<int>().max_streams(), 32768u); }
 
-    for (size_t i = 0; i < streams.max_streams(); ++i) {
-      int stream = streams.acquire(i);
-      ASSERT_GE(stream, 0);
-    }
+TEST(StreamManagerUnitTest, Simple) {
+  StreamManager<int> streams;
 
-    // Verify there are no more streams left
-    EXPECT_LT(streams.acquire(streams.max_streams()), 0);
+  for (size_t i = 0; i < streams.max_streams(); ++i) {
+    int stream = streams.acquire(i);
+    ASSERT_GE(stream, 0);
+  }
 
-    for (size_t i = 0; i < streams.max_streams(); ++i) {
-      int item = -1;
-      EXPECT_TRUE(streams.get(i, item));
-      streams.release(i);
-      EXPECT_GE(item, 0);
-    }
+  // Verify there are no more streams left
+  EXPECT_LT(streams.acquire(streams.max_streams()), 0);
 
-    for (size_t i = 0; i < streams.max_streams(); ++i) {
-      int stream = streams.acquire(i);
-      ASSERT_GE(stream, 0);
-    }
+  for (size_t i = 0; i < streams.max_streams(); ++i) {
+    int item = -1;
+    EXPECT_TRUE(streams.get(i, item));
+    streams.release(i);
+    EXPECT_GE(item, 0);
+  }
+
+  for (size_t i = 0; i < streams.max_streams(); ++i) {
+    int stream = streams.acquire(i);
+    ASSERT_GE(stream, 0);
+  }
 
-    // Verify there are no more streams left
-    EXPECT_LT(streams.acquire(streams.max_streams()), 0);
+  // Verify there are no more streams left
+  EXPECT_LT(streams.acquire(streams.max_streams()), 0);
 }
 
-TEST(StreamManagerUnitTest, Release)
-{
-  cass::StreamManager<int> streams;
+TEST(StreamManagerUnitTest, Release) {
+  StreamManager<int> streams;
 
   for (size_t i = 0; i < streams.max_streams(); ++i) {
     int stream = streams.acquire(i);
diff --git a/gtests/src/unit/tests/test_string_ref.cpp b/gtests/src/unit/tests/test_string_ref.cpp
index f9692dbac..be46f4307 100644
--- a/gtests/src/unit/tests/test_string_ref.cpp
+++ b/gtests/src/unit/tests/test_string_ref.cpp
@@ -18,10 +18,11 @@
 
 #include "string_ref.hpp"
 
-TEST(StringRefUnitTest, Compare)
-{
+using datastax::StringRef;
+
+TEST(StringRefUnitTest, Compare) {
   const char* value = "abc";
-  cass::StringRef s(value);
+  StringRef s(value);
 
   // Equals
   EXPECT_EQ(s.compare(s), 0);
@@ -30,87 +31,81 @@ TEST(StringRefUnitTest, Compare)
 
   // Not equals
   EXPECT_NE(s, "xyz");
-  EXPECT_NE(s, cass::StringRef("xyz"));
+  EXPECT_NE(s, StringRef("xyz"));
 
   // Case insensitive
   EXPECT_TRUE(s.iequals("ABC"));
-  EXPECT_TRUE(cass::iequals(s, "ABC"));
+  EXPECT_TRUE(iequals(s, "ABC"));
 }
 
-TEST(StringRefUnitTest, Empty)
-{
-  cass::StringRef s;
+TEST(StringRefUnitTest, Empty) {
+  StringRef s;
 
   EXPECT_TRUE(s.empty());
   EXPECT_EQ(s, "");
   EXPECT_NE(s, "abc");
 
-  EXPECT_TRUE(cass::starts_with(s, ""));
-  EXPECT_TRUE(cass::ends_with(s, ""));
+  EXPECT_TRUE(starts_with(s, ""));
+  EXPECT_TRUE(ends_with(s, ""));
 
-  EXPECT_FALSE(cass::starts_with(s, "abc"));
-  EXPECT_FALSE(cass::ends_with(s, "abc"));
+  EXPECT_FALSE(starts_with(s, "abc"));
+  EXPECT_FALSE(ends_with(s, "abc"));
 }
 
-TEST(StringRefUnitTest, Substr)
-{
-  cass::StringRef s("abcxyz");
+TEST(StringRefUnitTest, Substr) {
+  StringRef s("abcxyz");
 
   // Full string
   EXPECT_EQ(s.substr(0, s.length()), s);
 
   // Exceeds length
   EXPECT_EQ(s.substr(0, s.length() + 1), s);
-  EXPECT_EQ(s.substr(0, cass::StringRef::npos), s);
+  EXPECT_EQ(s.substr(0, StringRef::npos), s);
 
   // More tests in "starts_with" and "ends_with"
 }
 
-TEST(StringRefUnitTest, Find)
-{
-  cass::StringRef s("abcxyz");
+TEST(StringRefUnitTest, Find) {
+  StringRef s("abcxyz");
 
   EXPECT_EQ(s.find(""), 0u);
   EXPECT_EQ(s.find("abc"), 0u);
   EXPECT_EQ(s.find("xyz"), 3u);
   EXPECT_EQ(s.find("z"), 5u);
 
-  EXPECT_EQ(s.find("invalid"), cass::StringRef::npos);
-  EXPECT_EQ(s.find("abcxyza"), cass::StringRef::npos);
+  EXPECT_EQ(s.find("invalid"), StringRef::npos);
+  EXPECT_EQ(s.find("abcxyza"), StringRef::npos);
 
   EXPECT_EQ(s.find(""), 0u);
-  EXPECT_EQ(cass::StringRef("").find(""), 0u);
+  EXPECT_EQ(StringRef("").find(""), 0u);
 }
 
-
-TEST(StringRefUnitTest, StartsWith)
-{
-  cass::StringRef s("abcxyz");
+TEST(StringRefUnitTest, StartsWith) {
+  StringRef s("abcxyz");
 
   // Various lengths
   for (size_t i = 0; i < s.length(); ++i) {
-    EXPECT_TRUE(cass::starts_with(s, s.substr(0, i)));
+    EXPECT_TRUE(starts_with(s, s.substr(0, i)));
   }
 
   // Does not start with
-  EXPECT_FALSE(cass::starts_with(s, "xyz"));
+  EXPECT_FALSE(starts_with(s, "xyz"));
 
   // Too long
-  EXPECT_FALSE(cass::starts_with(s, "abcxyzabcxyz"));
+  EXPECT_FALSE(starts_with(s, "abcxyzabcxyz"));
 }
 
-TEST(StringRefUnitTest, EndsWith)
-{
-  cass::StringRef s("abcxyz");
+TEST(StringRefUnitTest, EndsWith) {
+  StringRef s("abcxyz");
 
   // Various lengths
   for (size_t i = 0; i < s.length(); ++i) {
-    EXPECT_TRUE(cass::ends_with(s, s.substr(i, cass::StringRef::npos)));
+    EXPECT_TRUE(ends_with(s, s.substr(i, StringRef::npos)));
   }
 
   // Does not end with
-  EXPECT_FALSE(cass::ends_with(s, "abc"));
+  EXPECT_FALSE(ends_with(s, "abc"));
 
   // Too long
-  EXPECT_FALSE(cass::ends_with(s, "abcxyzabcxyz"));
+  EXPECT_FALSE(ends_with(s, "abcxyzabcxyz"));
 }
diff --git a/gtests/src/unit/tests/test_tcp_connector.cpp b/gtests/src/unit/tests/test_tcp_connector.cpp
index 726f7c1ca..47f699fbe 100644
--- a/gtests/src/unit/tests/test_tcp_connector.cpp
+++ b/gtests/src/unit/tests/test_tcp_connector.cpp
@@ -19,15 +19,13 @@
 #include "callback.hpp"
 #include "tcp_connector.hpp"
 
-using cass::Address;
-using cass::bind_callback;
-using cass::Memory;
-using cass::TcpConnector;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class TcpConnectorUnitTest : public LoopTest {
 public:
   TcpConnectorUnitTest()
-    : status_(TcpConnector::NEW) { }
+      : status_(TcpConnector::NEW) {}
 
   virtual void SetUp() {
     LoopTest::SetUp();
@@ -41,22 +39,16 @@ class TcpConnectorUnitTest : public LoopTest {
     server_.close();
   }
 
-  void close() {
-    server_.close();
-  }
+  void close() { server_.close(); }
 
   void connect(const TcpConnector::Ptr& connector) {
     connector->connect(&tcp_, bind_callback(&TcpConnectorUnitTest::on_connect, this));
   }
 
-  TcpConnector::Status status() const {
-    return status_;
-  }
+  TcpConnector::Status status() const { return status_; }
 
 private:
-  void on_connect(TcpConnector* connector) {
-    status_ = connector->status();
-  }
+  void on_connect(TcpConnector* connector) { status_ = connector->status(); }
 
 private:
   uv_tcp_t tcp_;
diff --git a/gtests/src/unit/tests/test_timer.cpp b/gtests/src/unit/tests/test_timer.cpp
index 492172b84..dda118890 100644
--- a/gtests/src/unit/tests/test_timer.cpp
+++ b/gtests/src/unit/tests/test_timer.cpp
@@ -18,21 +18,20 @@
 
 #include "timer.hpp"
 
-using namespace cass;
+using datastax::internal::bind_callback;
+using datastax::internal::core::Timer;
 
 class TimerUnitTest : public LoopTest {
 public:
-
   TimerUnitTest()
-    : count_(0)
-    , repeat_timeout_(0)
-    , restart_count_(0) { }
+      : count_(0)
+      , repeat_timeout_(0)
+      , restart_count_(0) {}
 
   void test_once(uint64_t timeout) {
     Timer timer;
 
-    timer.start(loop(), timeout,
-                bind_callback(&TimerUnitTest::on_timer_once, this));
+    timer.start(loop(), timeout, bind_callback(&TimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -47,8 +46,7 @@ class TimerUnitTest : public LoopTest {
 
     repeat_timeout_ = timeout;
 
-    timer.start(loop(), timeout,
-                bind_callback(&TimerUnitTest::on_timer_repeat, this));
+    timer.start(loop(), timeout, bind_callback(&TimerUnitTest::on_timer_repeat, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -61,8 +59,7 @@ class TimerUnitTest : public LoopTest {
   void test_stop() {
     Timer timer;
 
-    timer.start(loop(), 1,
-                bind_callback(&TimerUnitTest::on_timer_once, this));
+    timer.start(loop(), 1, bind_callback(&TimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -70,8 +67,7 @@ class TimerUnitTest : public LoopTest {
 
     EXPECT_FALSE(timer.is_running());
 
-    timer.start(loop(), 1,
-                bind_callback(&TimerUnitTest::on_timer_once, this));
+    timer.start(loop(), 1, bind_callback(&TimerUnitTest::on_timer_once, this));
 
     EXPECT_TRUE(timer.is_running());
 
@@ -81,15 +77,12 @@ class TimerUnitTest : public LoopTest {
     EXPECT_EQ(count_, 1);
   }
 
-
   void test_restart() {
     Timer timer;
 
-    restart_timer_.start(loop(), 10,
-                             bind_callback(&TimerUnitTest::on_timer_once, this));
+    restart_timer_.start(loop(), 10, bind_callback(&TimerUnitTest::on_timer_once, this));
 
-    timer.start(loop(), 1,
-                bind_callback(&TimerUnitTest::on_timer_restart, this));
+    timer.start(loop(), 1, bind_callback(&TimerUnitTest::on_timer_restart, this));
 
     EXPECT_TRUE(restart_timer_.is_running());
     EXPECT_TRUE(timer.is_running());
@@ -113,21 +106,18 @@ class TimerUnitTest : public LoopTest {
     EXPECT_FALSE(timer->is_running());
     count_++;
     if (count_ == 1) {
-      timer->start(loop(), repeat_timeout_,
-                   bind_callback(&TimerUnitTest::on_timer_repeat, this));
+      timer->start(loop(), repeat_timeout_, bind_callback(&TimerUnitTest::on_timer_repeat, this));
     }
   }
 
   void on_timer_restart(Timer* timer) {
     restart_count_++;
-    if  (restart_count_ == 10) {
+    if (restart_count_ == 10) {
       restart_timer_.stop();
     } else {
-      restart_timer_.start(loop(), 10,
-                             bind_callback(&TimerUnitTest::on_timer_once, this));
+      restart_timer_.start(loop(), 10, bind_callback(&TimerUnitTest::on_timer_once, this));
 
-      timer->start(loop(), 1,
-                   bind_callback(&TimerUnitTest::on_timer_restart, this));
+      timer->start(loop(), 1, bind_callback(&TimerUnitTest::on_timer_restart, this));
     }
   }
 
@@ -138,32 +128,14 @@ class TimerUnitTest : public LoopTest {
   Timer restart_timer_;
 };
 
-TEST_F(TimerUnitTest, Once)
-{
-  test_once(1);
-}
-
-TEST_F(TimerUnitTest, OnceZero)
-{
-  test_once(0);
-}
-
-TEST_F(TimerUnitTest, Repeat)
-{
-  test_repeat(1);
-}
-
-TEST_F(TimerUnitTest, RepeatZero)
-{
-  test_repeat(0);
-}
-
-TEST_F(TimerUnitTest, Stop)
-{
-  test_stop();
-}
-
-TEST_F(TimerUnitTest, Restart)
-{
-  test_restart();
-}
+TEST_F(TimerUnitTest, Once) { test_once(1); }
+
+TEST_F(TimerUnitTest, OnceZero) { test_once(0); }
+
+TEST_F(TimerUnitTest, Repeat) { test_repeat(1); }
+
+TEST_F(TimerUnitTest, RepeatZero) { test_repeat(0); }
+
+TEST_F(TimerUnitTest, Stop) { test_stop(); }
+
+TEST_F(TimerUnitTest, Restart) { test_restart(); }
diff --git a/gtests/src/unit/tests/test_timestamp_gen.cpp b/gtests/src/unit/tests/test_timestamp_gen.cpp
index f1bbdad89..1a5b3b610 100644
--- a/gtests/src/unit/tests/test_timestamp_gen.cpp
+++ b/gtests/src/unit/tests/test_timestamp_gen.cpp
@@ -21,31 +21,33 @@
 
 #include <utility>
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 static void clock_skew_log_callback(const CassLogMessage* message, void* data) {
-  cass::String msg(message->message);
+  String msg(message->message);
   int* counter = reinterpret_cast<int*>(data);
-  if (msg.find("Clock skew detected") != cass::String::npos) {
+  if (msg.find("Clock skew detected") != String::npos) {
     (*counter)++;
   }
 }
 
 class TimestampGenUnitTest : public Unit {
 public:
-  int run_monotonic_timestamp_gen(uint64_t warning_threshold_us,
-                                  uint64_t warning_interval_ms,
+  int run_monotonic_timestamp_gen(uint64_t warning_threshold_us, uint64_t warning_interval_ms,
                                   uint64_t duration_ms) {
     const int NUM_TIMESTAMPS_PER_ITERATION = 1000;
 
-    cass::MonotonicTimestampGenerator gen(warning_threshold_us,
-                                          warning_interval_ms);
+    MonotonicTimestampGenerator gen(warning_threshold_us, warning_interval_ms);
 
     int timestamp_count = 0;
     int warn_count = 0;
 
-    cass::Logger::set_log_level(CASS_LOG_WARN);
-    cass::Logger::set_callback(clock_skew_log_callback, &warn_count);
+    Logger::set_log_level(CASS_LOG_WARN);
+    Logger::set_callback(clock_skew_log_callback, &warn_count);
 
-    uint64_t start = cass::get_time_since_epoch_ms();
+    uint64_t start = get_time_since_epoch_ms();
     uint64_t elapsed;
 
     do {
@@ -58,7 +60,7 @@ class TimestampGenUnitTest : public Unit {
         timestamp_count++;
       }
 
-      elapsed = cass::get_time_since_epoch_ms() - start;
+      elapsed = get_time_since_epoch_ms() - start;
     } while (elapsed < duration_ms);
 
     // We can generate at most 1,000,000 timestamps in a second. If we exceed
@@ -67,8 +69,8 @@ class TimestampGenUnitTest : public Unit {
     double timestamp_rate = (static_cast<double>(timestamp_count) / elapsed) * 1000;
     if (timestamp_rate <= 1000000.0 ||
         elapsed * MICROSECONDS_PER_MILLISECOND <= warning_threshold_us) {
-      fprintf(stderr, "Warning: The test may not have exceeded the timestamp " \
-              "generator's maximum rate.");
+      fprintf(stderr, "Warning: The test may not have exceeded the timestamp "
+                      "generator's maximum rate.");
     }
 
     EXPECT_GT(warn_count, 0);
@@ -77,15 +79,13 @@ class TimestampGenUnitTest : public Unit {
   }
 };
 
-TEST_F(TimestampGenUnitTest, Server)
-{
-  cass::ServerSideTimestampGenerator gen;
+TEST_F(TimestampGenUnitTest, Server) {
+  ServerSideTimestampGenerator gen;
   EXPECT_EQ(gen.next(), CASS_INT64_MIN);
 }
 
-TEST_F(TimestampGenUnitTest, Monotonic)
-{
-  cass::MonotonicTimestampGenerator gen;
+TEST_F(TimestampGenUnitTest, Monotonic) {
+  MonotonicTimestampGenerator gen;
 
   int64_t prev = gen.next();
   for (int i = 0; i < 100; ++i) {
@@ -96,7 +96,7 @@ TEST_F(TimestampGenUnitTest, Monotonic)
   }
 }
 
-TEST_F(TimestampGenUnitTest, MonotonicExceedWarningThreshold)  {
+TEST_F(TimestampGenUnitTest, MonotonicExceedWarningThreshold) {
   // Set the threshold to something small that we're guaranteed to easily exceed.
   run_monotonic_timestamp_gen(1, 1000, 1000);
 }
diff --git a/gtests/src/unit/tests/test_token.cpp b/gtests/src/unit/tests/test_token.cpp
index 7b97547b7..5bd982113 100644
--- a/gtests/src/unit/tests/test_token.cpp
+++ b/gtests/src/unit/tests/test_token.cpp
@@ -23,47 +23,49 @@
 #include <ctype.h>
 #include <stdio.h>
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 namespace {
 
-cass::String to_string(cass::RandomPartitioner::Token token) {
+String to_string(RandomPartitioner::Token token) {
   return numeric::uint128_t(token.lo, token.hi).to_string();
 }
 
 } // namespace
 
-TEST(TokenUnitTest, RandomAbs)
-{
+TEST(TokenUnitTest, RandomAbs) {
   // Two's complement: -170141183460469231731687303715884105728
   {
-    uint8_t digest[16] = { };
+    uint8_t digest[16] = {};
     digest[0] = 0x80;
 
-    cass::RandomPartitioner::Token token;
-    token.hi = cass::RandomPartitioner::encode(digest);
-    token.lo = cass::RandomPartitioner::encode(digest + 8);
-    token = cass::RandomPartitioner::abs(token);
+    RandomPartitioner::Token token;
+    token.hi = RandomPartitioner::encode(digest);
+    token.lo = RandomPartitioner::encode(digest + 8);
+    token = RandomPartitioner::abs(token);
 
     EXPECT_EQ(to_string(token), "170141183460469231731687303715884105728");
-
   }
 
   // Two's complement: -170141183460469231731687303715884105727
   {
-    uint8_t digest[16] = { };
+    uint8_t digest[16] = {};
     digest[0] = 0x80;
     digest[15] = 0x01;
 
-    cass::RandomPartitioner::Token token;
-    token.hi = cass::RandomPartitioner::encode(digest);
-    token.lo = cass::RandomPartitioner::encode(digest + 8);
-    token = cass::RandomPartitioner::abs(token);
+    RandomPartitioner::Token token;
+    token.hi = RandomPartitioner::encode(digest);
+    token.lo = RandomPartitioner::encode(digest + 8);
+    token = RandomPartitioner::abs(token);
 
     EXPECT_EQ(to_string(token), "170141183460469231731687303715884105727");
   }
 
   // Two's complement: -18446744073709551616
   {
-    uint8_t digest[16] = { };
+    uint8_t digest[16] = {};
     digest[0] = 0xFF;
     digest[1] = 0xFF;
     digest[2] = 0xFF;
@@ -73,39 +75,39 @@ TEST(TokenUnitTest, RandomAbs)
     digest[6] = 0xFF;
     digest[7] = 0xFF;
 
-    cass::RandomPartitioner::Token token;
-    token.hi = cass::RandomPartitioner::encode(digest);
-    token.lo = cass::RandomPartitioner::encode(digest + 8);
-    token = cass::RandomPartitioner::abs(token);
+    RandomPartitioner::Token token;
+    token.hi = RandomPartitioner::encode(digest);
+    token.lo = RandomPartitioner::encode(digest + 8);
+    token = RandomPartitioner::abs(token);
 
     EXPECT_EQ(to_string(token), "18446744073709551616");
   }
 
   // Two's complement: 0
   {
-    uint8_t digest[16] = { };
+    uint8_t digest[16] = {};
 
-    cass::RandomPartitioner::Token token;
-    token.hi = cass::RandomPartitioner::encode(digest);
-    token.lo = cass::RandomPartitioner::encode(digest + 8);
-    token = cass::RandomPartitioner::abs(token);
+    RandomPartitioner::Token token;
+    token.hi = RandomPartitioner::encode(digest);
+    token.lo = RandomPartitioner::encode(digest + 8);
+    token = RandomPartitioner::abs(token);
 
     EXPECT_EQ(numeric::uint128_t(token.lo, token.hi).to_string(), "0");
   }
 
   // Two's complement: 170141183460469231731687303715884105727
   {
-    uint8_t digest[16] = { };
-    digest[0]  = 0x7F;
-    digest[1]  = 0xFF;
-    digest[2]  = 0xFF;
-    digest[3]  = 0xFF;
-    digest[4]  = 0xFF;
-    digest[5]  = 0xFF;
-    digest[6]  = 0xFF;
-    digest[7]  = 0xFF;
-    digest[8]  = 0xFF;
-    digest[9]  = 0xFF;
+    uint8_t digest[16] = {};
+    digest[0] = 0x7F;
+    digest[1] = 0xFF;
+    digest[2] = 0xFF;
+    digest[3] = 0xFF;
+    digest[4] = 0xFF;
+    digest[5] = 0xFF;
+    digest[6] = 0xFF;
+    digest[7] = 0xFF;
+    digest[8] = 0xFF;
+    digest[9] = 0xFF;
     digest[10] = 0xFF;
     digest[11] = 0xFF;
     digest[12] = 0xFF;
@@ -113,36 +115,35 @@ TEST(TokenUnitTest, RandomAbs)
     digest[14] = 0xFF;
     digest[15] = 0xFF;
 
-    cass::RandomPartitioner::Token token;
-    token.hi = cass::RandomPartitioner::encode(digest);
-    token.lo = cass::RandomPartitioner::encode(digest + 8);
-    token = cass::RandomPartitioner::abs(token);
+    RandomPartitioner::Token token;
+    token.hi = RandomPartitioner::encode(digest);
+    token.lo = RandomPartitioner::encode(digest + 8);
+    token = RandomPartitioner::abs(token);
 
     EXPECT_EQ(to_string(token), "170141183460469231731687303715884105727");
   }
 }
 
-TEST(TokenUnitTest, RandomLessThan)
-{
+TEST(TokenUnitTest, RandomLessThan) {
   // 'hi' is the same and 'lo' is less than
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 0
     {
-      uint8_t digest[16] = { };
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      uint8_t digest[16] = {};
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 1
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[15] = 0x01;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_TRUE(t1 < t2);
@@ -150,25 +151,25 @@ TEST(TokenUnitTest, RandomLessThan)
 
   // 'lo' is the same and 'hi' is less than
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
 
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 36893488147419103232
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x02;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_TRUE(t1 < t2);
@@ -176,25 +177,25 @@ TEST(TokenUnitTest, RandomLessThan)
 
   // Absolute value of negative values
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: -170141183460469231731687303715884105727
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[0] = 0x80;
       digest[15] = 0x01;
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: -170141183460469231731687303715884105728
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[0] = 0x80;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_TRUE(t1 < t2);
@@ -202,24 +203,24 @@ TEST(TokenUnitTest, RandomLessThan)
 
   // Same value
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_FALSE(t1 < t2);
@@ -227,48 +228,47 @@ TEST(TokenUnitTest, RandomLessThan)
 
   // Zero
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     {
-      uint8_t digest[16] = { };
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      uint8_t digest[16] = {};
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     {
-      uint8_t digest[16] = { };
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      uint8_t digest[16] = {};
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_FALSE(t1 < t2);
   }
 }
 
-TEST(TokenUnitTest, RandomEqual)
-{
+TEST(TokenUnitTest, RandomEqual) {
   // Same value
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_TRUE(t1 == t2);
@@ -276,20 +276,20 @@ TEST(TokenUnitTest, RandomEqual)
 
   // Zero
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     {
-      uint8_t digest[16] = { };
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      uint8_t digest[16] = {};
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     {
-      uint8_t digest[16] = { };
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      uint8_t digest[16] = {};
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_TRUE(t1 == t2);
@@ -297,23 +297,23 @@ TEST(TokenUnitTest, RandomEqual)
 
   // 'hi' is the same and 'lo' is less than
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 0
     {
-      uint8_t digest[16] = { };
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      uint8_t digest[16] = {};
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 1
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[15] = 0x01;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_FALSE(t1 == t2);
@@ -321,46 +321,46 @@ TEST(TokenUnitTest, RandomEqual)
 
   // 'lo' is the same and 'hi' is less than
   {
-    cass::RandomPartitioner::Token t1, t2;
+    RandomPartitioner::Token t1, t2;
 
     // Two's complement: 18446744073709551616
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x01;
 
-      t1.hi = cass::RandomPartitioner::encode(digest);
-      t1.lo = cass::RandomPartitioner::encode(digest + 8);
-      t1 = cass::RandomPartitioner::abs(t1);
+      t1.hi = RandomPartitioner::encode(digest);
+      t1.lo = RandomPartitioner::encode(digest + 8);
+      t1 = RandomPartitioner::abs(t1);
     }
 
     // Two's complement: 36893488147419103232
     {
-      uint8_t digest[16] = { };
+      uint8_t digest[16] = {};
       digest[7] = 0x02;
-      t2.hi = cass::RandomPartitioner::encode(digest);
-      t2.lo = cass::RandomPartitioner::encode(digest + 8);
-      t2 = cass::RandomPartitioner::abs(t2);
+      t2.hi = RandomPartitioner::encode(digest);
+      t2.lo = RandomPartitioner::encode(digest + 8);
+      t2 = RandomPartitioner::abs(t2);
     }
 
     EXPECT_FALSE(t1 == t2);
   }
 }
 
-TEST(TokenUnitTest, RandomHash)
-{
+TEST(TokenUnitTest, RandomHash) {
   // Sampled using: SELECT token(key) FROM sometable;
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("a")), "16955237001963240173058271559858726497");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("b")), "144992942750327304334463589818972416113");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("c")), "99079589977253916124855502156832923443");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("d")), "166860289390734216023086131251507064403");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("abc")), "148866708576779697295343134153845407886");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::hash("xyz")), "61893731502141497228477852773302439842");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("a")), "16955237001963240173058271559858726497");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("b")), "144992942750327304334463589818972416113");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("c")), "99079589977253916124855502156832923443");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("d")), "166860289390734216023086131251507064403");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("abc")), "148866708576779697295343134153845407886");
+  EXPECT_EQ(to_string(RandomPartitioner::hash("xyz")), "61893731502141497228477852773302439842");
 }
 
-TEST(TokenUnitTest, RandomFromString)
-{
-  EXPECT_EQ(to_string(cass::RandomPartitioner::from_string("0")), "0");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::from_string("1")), "1");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::from_string("170141183460469231731687303715884105727")), "170141183460469231731687303715884105727");
-  EXPECT_EQ(to_string(cass::RandomPartitioner::from_string("170141183460469231731687303715884105728")), "170141183460469231731687303715884105728");
+TEST(TokenUnitTest, RandomFromString) {
+  EXPECT_EQ(to_string(RandomPartitioner::from_string("0")), "0");
+  EXPECT_EQ(to_string(RandomPartitioner::from_string("1")), "1");
+  EXPECT_EQ(to_string(RandomPartitioner::from_string("170141183460469231731687303715884105727")),
+            "170141183460469231731687303715884105727");
+  EXPECT_EQ(to_string(RandomPartitioner::from_string("170141183460469231731687303715884105728")),
+            "170141183460469231731687303715884105728");
 }
diff --git a/gtests/src/unit/tests/test_token_map.cpp b/gtests/src/unit/tests/test_token_map.cpp
index dfd031177..6c12268cc 100644
--- a/gtests/src/unit/tests/test_token_map.cpp
+++ b/gtests/src/unit/tests/test_token_map.cpp
@@ -16,41 +16,45 @@
 
 #include <gtest/gtest.h>
 
-#include "test_token_map_utils.hpp"
 #include "map.hpp"
 #include "set.hpp"
+#include "test_token_map_utils.hpp"
+
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 namespace {
 
 template <class Partitioner>
 struct TestTokenMap {
-  typedef typename cass::ReplicationStrategy<Partitioner>::Token Token;
-  typedef cass::Map<Token, cass::Host::Ptr> TokenHostMap;
+  typedef typename ReplicationStrategy<Partitioner>::Token Token;
+  typedef Map<Token, Host::Ptr> TokenHostMap;
 
   TokenHostMap tokens;
-  cass::TokenMap::Ptr token_map;
+  TokenMap::Ptr token_map;
 
   TestTokenMap()
-    : token_map(cass::TokenMap::from_partitioner(Partitioner::name())) { }
+      : token_map(TokenMap::from_partitioner(Partitioner::name())) {}
 
-  void add_host(const cass::Host::Ptr& host) {
-    for (cass::Vector<cass::String>::const_iterator i = host->tokens().begin(),
-         end = host->tokens().end(); i != end; ++i) {
-      const cass::String v(*i);
+  void add_host(const Host::Ptr& host) {
+    for (Vector<String>::const_iterator i = host->tokens().begin(), end = host->tokens().end();
+         i != end; ++i) {
+      const String v(*i);
       tokens[Partitioner::from_string(*i)] = host;
     }
   }
 
-  void build(const cass::String& keyspace_name = "ks", size_t replication_factor = 3) {
+  void build(const String& keyspace_name = "ks", size_t replication_factor = 3) {
     add_keyspace_simple(keyspace_name, replication_factor, token_map.get());
-    for (typename TokenHostMap::const_iterator i = tokens.begin(),
-         end = tokens.end(); i != end; ++i) {
+    for (typename TokenHostMap::const_iterator i = tokens.begin(), end = tokens.end(); i != end;
+         ++i) {
       token_map->add_host(i->second);
     }
     token_map->build();
   }
 
-  const cass::Host::Ptr& get_replica(const cass::String& key) {
+  const Host::Ptr& get_replica(const String& key) {
     typename TokenHostMap::const_iterator i = tokens.upper_bound(Partitioner::hash(key));
     if (i != tokens.end()) {
       return i->second;
@@ -59,17 +63,17 @@ struct TestTokenMap {
     }
   }
 
-  void verify(const cass::String& keyspace_name = "ks") {
-    const cass::String keys[] = { "test", "abc", "def", "a", "b", "c", "d" };
+  void verify(const String& keyspace_name = "ks") {
+    const String keys[] = { "test", "abc", "def", "a", "b", "c", "d" };
 
-    for (size_t i = 0; i < sizeof(keys)/sizeof(keys[0]); ++i) {
-      const cass::String& key = keys[i];
+    for (size_t i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i) {
+      const String& key = keys[i];
 
-      const cass::CopyOnWriteHostVec& hosts = token_map->get_replicas(keyspace_name, key);
+      const CopyOnWriteHostVec& hosts = token_map->get_replicas(keyspace_name, key);
       ASSERT_TRUE(hosts);
-      ASSERT_GT(hosts->size(), 0);
+      ASSERT_GT(hosts->size(), 0u);
 
-      const cass::Host::Ptr& host = get_replica(key);
+      const Host::Ptr& host = get_replica(key);
       ASSERT_TRUE(host);
 
       EXPECT_EQ(hosts->front()->address(), host->address());
@@ -79,9 +83,8 @@ struct TestTokenMap {
 
 } // namespace
 
-TEST(TokenMapUnitTest, Murmur3)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_murmur3;
+TEST(TokenMapUnitTest, Murmur3) {
+  TestTokenMap<Murmur3Partitioner> test_murmur3;
 
   test_murmur3.add_host(create_host("1.0.0.1", single_token(CASS_INT64_MIN / 2)));
   test_murmur3.add_host(create_host("1.0.0.2", single_token(0)));
@@ -91,9 +94,8 @@ TEST(TokenMapUnitTest, Murmur3)
   test_murmur3.verify();
 }
 
-TEST(TokenMapUnitTest, Murmur3MultipleTokensPerHost)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_murmur3;
+TEST(TokenMapUnitTest, Murmur3MultipleTokensPerHost) {
+  TestTokenMap<Murmur3Partitioner> test_murmur3;
 
   const size_t tokens_per_host = 256;
   MT19937_64 rng;
@@ -107,9 +109,8 @@ TEST(TokenMapUnitTest, Murmur3MultipleTokensPerHost)
   test_murmur3.verify();
 }
 
-TEST(TokenMapUnitTest, Murmur3LargeNumberOfVnodes)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_murmur3;
+TEST(TokenMapUnitTest, Murmur3LargeNumberOfVnodes) {
+  TestTokenMap<Murmur3Partitioner> test_murmur3;
 
   size_t num_dcs = 3;
   size_t num_racks = 3;
@@ -119,7 +120,7 @@ TEST(TokenMapUnitTest, Murmur3LargeNumberOfVnodes)
 
   ReplicationMap replication;
   MT19937_64 rng;
-  cass::TokenMap* token_map = test_murmur3.token_map.get();
+  TokenMap* token_map = test_murmur3.token_map.get();
 
   // Populate tokens
   int host_count = 1;
@@ -139,10 +140,8 @@ TEST(TokenMapUnitTest, Murmur3LargeNumberOfVnodes)
         sprintf(ip, "127.0.%d.%d", host_count / 255, host_count % 255);
         host_count++;
 
-        cass::Host::Ptr host(create_host(ip,
-                                         random_murmur3_tokens(rng, num_vnodes),
-                                         cass::Murmur3Partitioner::name().to_string(),
-                                         rack, dc));
+        Host::Ptr host(create_host(ip, random_murmur3_tokens(rng, num_vnodes),
+                                   Murmur3Partitioner::name().to_string(), rack, dc));
 
         test_murmur3.add_host(host);
         token_map->add_host(host);
@@ -154,57 +153,59 @@ TEST(TokenMapUnitTest, Murmur3LargeNumberOfVnodes)
   add_keyspace_network_topology("ks1", replication, token_map);
   token_map->build();
 
-  const cass::String keys[] = { "test", "abc", "def", "a", "b", "c", "d" };
+  const String keys[] = { "test", "abc", "def", "a", "b", "c", "d" };
 
-  for (size_t i = 0; i < sizeof(keys)/sizeof(keys[0]); ++i) {
-    const cass::String& key = keys[i];
+  for (size_t i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i) {
+    const String& key = keys[i];
 
-    const cass::CopyOnWriteHostVec& hosts = token_map->get_replicas("ks1", key);
+    const CopyOnWriteHostVec& hosts = token_map->get_replicas("ks1", key);
     ASSERT_TRUE(hosts && hosts->size() == replication_factor * num_dcs);
 
-    typedef cass::Map<cass::String, cass::Set<cass::String> > DcRackMap;
+    typedef Map<String, Set<String> > DcRackMap;
 
     // Verify rack counts
     DcRackMap dc_racks;
-    for (cass::HostVec::const_iterator i = hosts->begin(),
-         end = hosts->end(); i != end; ++i) {
-      const cass::Host::Ptr& host = (*i);
+    for (HostVec::const_iterator i = hosts->begin(), end = hosts->end(); i != end; ++i) {
+      const Host::Ptr& host = (*i);
       dc_racks[host->dc()].insert(host->rack());
     }
     EXPECT_EQ(dc_racks.size(), num_dcs);
 
-    for (DcRackMap::const_iterator i = dc_racks.begin(),
-         end = dc_racks.end(); i != end; ++i) {
+    for (DcRackMap::const_iterator i = dc_racks.begin(), end = dc_racks.end(); i != end; ++i) {
       EXPECT_GE(i->second.size(), std::min(num_racks, replication_factor));
     }
 
     // Verify replica
-    cass::Host::Ptr host = test_murmur3.get_replica(key);
+    Host::Ptr host = test_murmur3.get_replica(key);
     ASSERT_TRUE(host);
 
     EXPECT_EQ((*hosts)[0]->address(), host->address());
   }
 }
 
-TEST(TokenMapUnitTest, Random)
-{
-  cass::TokenMap::Ptr token_map(cass::TokenMap::from_partitioner(cass::RandomPartitioner::name()));
+TEST(TokenMapUnitTest, Random) {
+  TokenMap::Ptr token_map(TokenMap::from_partitioner(RandomPartitioner::name()));
 
-  TestTokenMap<cass::RandomPartitioner> test_random;
+  TestTokenMap<RandomPartitioner> test_random;
 
-  test_random.add_host(create_host("1.0.0.1", single_token(create_random_token("42535295865117307932921825928971026432")))); // 2^127 / 4
-  test_random.add_host(create_host("1.0.0.2", single_token(create_random_token("85070591730234615865843651857942052864")))); // 2^127 / 2
-  test_random.add_host(create_host("1.0.0.3", single_token(create_random_token("1605887595351923798765477786913079296")))); // 2^127 * 3 / 4
+  test_random.add_host(create_host(
+      "1.0.0.1",
+      single_token(create_random_token("42535295865117307932921825928971026432")))); // 2^127 / 4
+  test_random.add_host(create_host(
+      "1.0.0.2",
+      single_token(create_random_token("85070591730234615865843651857942052864")))); // 2^127 / 2
+  test_random.add_host(create_host(
+      "1.0.0.3",
+      single_token(create_random_token("1605887595351923798765477786913079296")))); // 2^127 * 3 / 4
 
   test_random.build();
   test_random.verify();
 }
 
-TEST(TokenMapUnitTest, ByteOrdered)
-{
-  cass::TokenMap::Ptr token_map(cass::TokenMap::from_partitioner(cass::ByteOrderedPartitioner::name()));
+TEST(TokenMapUnitTest, ByteOrdered) {
+  TokenMap::Ptr token_map(TokenMap::from_partitioner(ByteOrderedPartitioner::name()));
 
-  TestTokenMap<cass::ByteOrderedPartitioner> test_byte_ordered;
+  TestTokenMap<ByteOrderedPartitioner> test_byte_ordered;
 
   test_byte_ordered.add_host(create_host("1.0.0.1", single_token(create_byte_ordered_token("g"))));
   test_byte_ordered.add_host(create_host("1.0.0.2", single_token(create_byte_ordered_token("m"))));
@@ -214,9 +215,8 @@ TEST(TokenMapUnitTest, ByteOrdered)
   test_byte_ordered.verify();
 }
 
-TEST(TokenMapUnitTest, RemoveHost)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_remove_host;
+TEST(TokenMapUnitTest, RemoveHost) {
+  TestTokenMap<Murmur3Partitioner> test_remove_host;
 
   test_remove_host.add_host(create_host("1.0.0.1", single_token(CASS_INT64_MIN / 2)));
   test_remove_host.add_host(create_host("1.0.0.2", single_token(0)));
@@ -225,51 +225,51 @@ TEST(TokenMapUnitTest, RemoveHost)
   test_remove_host.build("ks", 2);
   test_remove_host.verify();
 
-  cass::TokenMap* token_map = test_remove_host.token_map.get();
+  TokenMap* token_map = test_remove_host.token_map.get();
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 2);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.1", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.1", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.2", 9042));
   }
 
-  TestTokenMap<cass::Murmur3Partitioner>::TokenHostMap::iterator host_to_remove_it = test_remove_host.tokens.begin();
+  TestTokenMap<Murmur3Partitioner>::TokenHostMap::iterator host_to_remove_it =
+      test_remove_host.tokens.begin();
 
   token_map->remove_host_and_build(host_to_remove_it->second);
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 2);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.2", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.3", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.3", 9042));
   }
 
   ++host_to_remove_it;
   token_map->remove_host_and_build(host_to_remove_it->second);
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 1);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.3", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.3", 9042));
   }
 
   ++host_to_remove_it;
   token_map->remove_host_and_build(host_to_remove_it->second);
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("test", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("test", "abc");
 
     EXPECT_FALSE(replicas);
   }
 }
 
-TEST(TokenMapUnitTest, UpdateHost)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_update_host;
+TEST(TokenMapUnitTest, UpdateHost) {
+  TestTokenMap<Murmur3Partitioner> test_update_host;
 
   test_update_host.add_host(create_host("1.0.0.1", single_token(CASS_INT64_MIN / 2)));
   test_update_host.add_host(create_host("1.0.0.2", single_token(CASS_INT64_MIN / 4)));
@@ -277,45 +277,45 @@ TEST(TokenMapUnitTest, UpdateHost)
   test_update_host.build("ks", 4);
   test_update_host.verify();
 
-  cass::TokenMap* token_map = test_update_host.token_map.get();
+  TokenMap* token_map = test_update_host.token_map.get();
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 2);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.1", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.1", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.2", 9042));
   }
 
   {
-    cass::Host::Ptr host(create_host("1.0.0.3", single_token(0)));
+    Host::Ptr host(create_host("1.0.0.3", single_token(0)));
     test_update_host.add_host(host);
     token_map->update_host_and_build(host);
   }
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 3);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.1", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.2", 9042));
-    EXPECT_EQ((*replicas)[2]->address(), cass::Address("1.0.0.3", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.1", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[2]->address(), Address("1.0.0.3", 9042));
   }
 
   {
-    cass::Host::Ptr host(create_host("1.0.0.4", single_token(CASS_INT64_MAX / 2)));
+    Host::Ptr host(create_host("1.0.0.4", single_token(CASS_INT64_MAX / 2)));
     test_update_host.add_host(host);
     token_map->update_host_and_build(host);
   }
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 4);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.1", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.2", 9042));
-    EXPECT_EQ((*replicas)[2]->address(), cass::Address("1.0.0.3", 9042));
-    EXPECT_EQ((*replicas)[3]->address(), cass::Address("1.0.0.4", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.1", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[2]->address(), Address("1.0.0.3", 9042));
+    EXPECT_EQ((*replicas)[3]->address(), Address("1.0.0.4", 9042));
   }
 }
 
@@ -329,9 +329,8 @@ TEST(TokenMapUnitTest, UpdateHost)
  * @test_category token_map
  * @expected_results Host's tokens should be added and removed from the token map.
  */
-TEST(TokenMapUnitTest, UpdateRemoveHostsMurmur3)
-{
-  cass::TokenMapImpl<cass::Murmur3Partitioner> token_map;
+TEST(TokenMapUnitTest, UpdateRemoveHostsMurmur3) {
+  TokenMapImpl<Murmur3Partitioner> token_map;
 
   // Add hosts and build token map
   Murmur3TokenVec tokens1;
@@ -340,10 +339,8 @@ TEST(TokenMapUnitTest, UpdateRemoveHostsMurmur3)
   tokens1.push_back(1LL);
   tokens1.push_back(3LL);
 
-  cass::Host::Ptr host1(create_host("1.0.0.1",
-                                    murmur3_tokens(tokens1),
-                                    cass::Murmur3Partitioner::name().to_string(),
-                                    "rack1", "dc1"));
+  Host::Ptr host1(create_host("1.0.0.1", murmur3_tokens(tokens1),
+                              Murmur3Partitioner::name().to_string(), "rack1", "dc1"));
 
   token_map.add_host(host1);
 
@@ -353,10 +350,8 @@ TEST(TokenMapUnitTest, UpdateRemoveHostsMurmur3)
   tokens2.push_back(2LL);
   tokens2.push_back(4LL);
 
-  cass::Host::Ptr host2(create_host("1.0.0.2",
-                                    murmur3_tokens(tokens2),
-                                    cass::Murmur3Partitioner::name().to_string(),
-                                    "rack1", "dc2"));
+  Host::Ptr host2(create_host("1.0.0.2", murmur3_tokens(tokens2),
+                              Murmur3Partitioner::name().to_string(), "rack1", "dc2"));
 
   token_map.add_host(host2);
 
@@ -433,9 +428,8 @@ TEST(TokenMapUnitTest, UpdateRemoveHostsMurmur3)
   EXPECT_TRUE(token_map.contains(4LL));
 }
 
-TEST(TokenMapUnitTest, DropKeyspace)
-{
-  TestTokenMap<cass::Murmur3Partitioner> test_drop_keyspace;
+TEST(TokenMapUnitTest, DropKeyspace) {
+  TestTokenMap<Murmur3Partitioner> test_drop_keyspace;
 
   test_drop_keyspace.add_host(create_host("1.0.0.1", single_token(CASS_INT64_MIN / 2)));
   test_drop_keyspace.add_host(create_host("1.0.0.2", single_token(0)));
@@ -444,20 +438,20 @@ TEST(TokenMapUnitTest, DropKeyspace)
   test_drop_keyspace.build("ks", 2);
   test_drop_keyspace.verify();
 
-  cass::TokenMap* token_map = test_drop_keyspace.token_map.get();
+  TokenMap* token_map = test_drop_keyspace.token_map.get();
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     ASSERT_TRUE(replicas && replicas->size() == 2);
-    EXPECT_EQ((*replicas)[0]->address(), cass::Address("1.0.0.1", 9042));
-    EXPECT_EQ((*replicas)[1]->address(), cass::Address("1.0.0.2", 9042));
+    EXPECT_EQ((*replicas)[0]->address(), Address("1.0.0.1", 9042));
+    EXPECT_EQ((*replicas)[1]->address(), Address("1.0.0.2", 9042));
   }
 
   token_map->drop_keyspace("ks");
 
   {
-    const cass::CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
+    const CopyOnWriteHostVec& replicas = token_map->get_replicas("ks", "abc");
 
     EXPECT_FALSE(replicas);
   }
diff --git a/gtests/src/unit/tests/test_tracing.cpp b/gtests/src/unit/tests/test_tracing.cpp
index d1572398b..1943e0eed 100644
--- a/gtests/src/unit/tests/test_tracing.cpp
+++ b/gtests/src/unit/tests/test_tracing.cpp
@@ -20,6 +20,8 @@
 #include "session.hpp"
 #include "tracing_data_handler.hpp"
 
+using namespace datastax::internal::core;
+
 class TracingUnitTest : public Unit {
 public:
   void TearDown() {
@@ -27,18 +29,17 @@ class TracingUnitTest : public Unit {
     Unit::TearDown();
   }
 
-  void connect(const cass::Config& config = cass::Config()) {
-    cass::Config temp(config);
+  void connect(const Config& config = Config()) {
+    Config temp(config);
     temp.contact_points().push_back("127.0.0.1");
-    cass::Future::Ptr connect_future(session.connect(temp));
+    Future::Ptr connect_future(session.connect(temp));
     ASSERT_TRUE(connect_future->wait_for(WAIT_FOR_TIME))
         << "Timed out waiting for session to connect";
-    ASSERT_FALSE(connect_future->error())
-        << cass_error_desc(connect_future->error()->code) << ": "
-        << connect_future->error()->message;
+    ASSERT_FALSE(connect_future->error()) << cass_error_desc(connect_future->error()->code) << ": "
+                                          << connect_future->error()->message;
   }
 
-  cass::Session session;
+  Session session;
 };
 
 TEST_F(TracingUnitTest, Simple) {
@@ -53,17 +54,17 @@ TEST_F(TracingUnitTest, Simple) {
 
   connect();
 
-  cass::Statement::Ptr request(new cass::QueryRequest("blah", 0));
+  Statement::Ptr request(new QueryRequest("blah", 0));
   request->set_tracing(true);
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->response());
   EXPECT_TRUE(future->response()->has_tracing_id());
 
   CassUuid tracing_id(future->response()->tracing_id());
-  EXPECT_NE(tracing_id.time_and_version, 0);
+  EXPECT_NE(tracing_id.time_and_version, 0u);
 }
 
 TEST_F(TracingUnitTest, DataNotAvailble) {
@@ -72,26 +73,26 @@ TEST_F(TracingUnitTest, DataNotAvailble) {
       .system_local()
       .system_peers()
       .is_query(SELECT_TRACES_SESSION)
-        .then(mockssandra::Action::Builder().empty_rows_result(0)) // Send back an empty row result
+      .then(mockssandra::Action::Builder().empty_rows_result(0)) // Send back an empty row result
       .empty_rows_result(1);
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
   connect();
 
-  cass::Statement::Ptr request(new cass::QueryRequest("blah", 0));
+  Statement::Ptr request(new QueryRequest("blah", 0));
   request->set_tracing(true);
 
   add_logging_critera("Tracing data not available after 15 ms");
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->response());
   EXPECT_TRUE(future->response()->has_tracing_id());
 
   CassUuid tracing_id(future->response()->tracing_id());
-  EXPECT_NE(tracing_id.time_and_version, 0);
+  EXPECT_NE(tracing_id.time_and_version, 0u);
 
   EXPECT_GT(logging_criteria_count(), 0);
 }
@@ -102,29 +103,29 @@ TEST_F(TracingUnitTest, RequestTimeout) {
       .system_local()
       .system_peers()
       .is_query(SELECT_TRACES_SESSION)
-        .then(mockssandra::Action::Builder().no_result()) // Don't send back a response
+      .then(mockssandra::Action::Builder().no_result()) // Don't send back a response
       .empty_rows_result(1);
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
-  cass::Config config;
+  Config config;
   config.set_max_tracing_wait_time_ms(500);
   connect(config);
 
-  cass::Statement::Ptr request(new cass::QueryRequest("blah", 0));
+  Statement::Ptr request(new QueryRequest("blah", 0));
   request->set_request_timeout_ms(100);
   request->set_tracing(true);
 
   add_logging_critera("A query timeout occurred waiting for tracing data to become available");
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->response());
   EXPECT_TRUE(future->response()->has_tracing_id());
 
   CassUuid tracing_id(future->response()->tracing_id());
-  EXPECT_NE(tracing_id.time_and_version, 0);
+  EXPECT_NE(tracing_id.time_and_version, 0u);
 
   EXPECT_GT(logging_criteria_count(), 0);
 }
@@ -135,27 +136,27 @@ TEST_F(TracingUnitTest, QueryError) {
       .system_local()
       .system_peers()
       .is_query(SELECT_TRACES_SESSION)
-        .then(mockssandra::Action::Builder().error(mockssandra::ERROR_INVALID_QUERY, "Invalid query"))
+      .then(mockssandra::Action::Builder().error(mockssandra::ERROR_INVALID_QUERY, "Invalid query"))
       .empty_rows_result(1);
   mockssandra::SimpleCluster cluster(builder.build());
   ASSERT_EQ(cluster.start_all(), 0);
 
   connect();
 
-  cass::Statement::Ptr request(new cass::QueryRequest("blah", 0));
+  Statement::Ptr request(new QueryRequest("blah", 0));
   request->set_tracing(true);
 
   add_logging_critera("Chained error response 'Invalid query' (0x02002200) for query "
                       "\"SELECT session_id FROM system_traces.sessions WHERE session_id = ?\"");
 
-  cass::ResponseFuture::Ptr future(session.execute(cass::Request::ConstPtr(request)));
+  ResponseFuture::Ptr future(session.execute(Request::ConstPtr(request)));
   future->wait();
 
   ASSERT_TRUE(future->response());
   EXPECT_TRUE(future->response()->has_tracing_id());
 
   CassUuid tracing_id(future->response()->tracing_id());
-  EXPECT_NE(tracing_id.time_and_version, 0);
+  EXPECT_NE(tracing_id.time_and_version, 0u);
 
   EXPECT_GT(logging_criteria_count(), 0);
 }
diff --git a/gtests/src/unit/tests/test_utils.cpp b/gtests/src/unit/tests/test_utils.cpp
index 2b9aad8c2..49f0f3e69 100644
--- a/gtests/src/unit/tests/test_utils.cpp
+++ b/gtests/src/unit/tests/test_utils.cpp
@@ -22,53 +22,53 @@
 #include <ctype.h>
 #include <stdio.h>
 
-TEST(UtilsUnitTest, CqlId)
-{
-  cass::String s;
+using datastax::String;
+using datastax::internal::num_leading_zeros;
+using datastax::internal::to_cql_id;
+
+TEST(UtilsUnitTest, CqlId) {
+  String s;
 
   // valid id
   s = "abc";
-  EXPECT_EQ(cass::to_cql_id(s), cass::String("abc"));
+  EXPECT_EQ(to_cql_id(s), String("abc"));
 
   // test lower cassing
   s = "ABC";
-  EXPECT_EQ(cass::to_cql_id(s), cass::String("abc"));
+  EXPECT_EQ(to_cql_id(s), String("abc"));
 
   // quoted
   s = "\"aBc\"";
-  EXPECT_EQ(cass::to_cql_id(s), cass::String("aBc"));
+  EXPECT_EQ(to_cql_id(s), String("aBc"));
 
   // invalid chars
   s = "!@#";
-  EXPECT_EQ(cass::to_cql_id(s), cass::String("!@#"));
+  EXPECT_EQ(to_cql_id(s), String("!@#"));
 }
 
-TEST(UtilsUnitTest, EscapeId)
-{
-  cass::String s;
+TEST(UtilsUnitTest, EscapeId) {
+  String s;
 
   s = "abc";
-  EXPECT_EQ(cass::escape_id(s), cass::String("abc"));
+  EXPECT_EQ(escape_id(s), String("abc"));
 
   s = "aBc";
-  EXPECT_EQ(cass::escape_id(s), cass::String("\"aBc\""));
+  EXPECT_EQ(escape_id(s), String("\"aBc\""));
 
   s = "\"";
-  EXPECT_EQ(cass::escape_id(s), cass::String("\"\"\"\""));
+  EXPECT_EQ(escape_id(s), String("\"\"\"\""));
 
   s = "a\"Bc";
-  EXPECT_EQ(cass::escape_id(s), cass::String("\"a\"\"Bc\""));
+  EXPECT_EQ(escape_id(s), String("\"a\"\"Bc\""));
 }
 
-TEST(UtilsUnitTest, NumLeadingZeros)
-{
-  EXPECT_EQ(64u, cass::num_leading_zeros(0));
-  EXPECT_EQ(0u, cass::num_leading_zeros(1LL << 63));
-  EXPECT_EQ(0u, cass::num_leading_zeros(1LL << 63 | 1 << 5));
+TEST(UtilsUnitTest, NumLeadingZeros) {
+  EXPECT_EQ(64u, num_leading_zeros(0));
+  EXPECT_EQ(0u, num_leading_zeros(1LL << 63));
+  EXPECT_EQ(0u, num_leading_zeros(1LL << 63 | 1 << 5));
 }
 
-TEST(UtilsUnitTest, NextPow2)
-{
+TEST(UtilsUnitTest, NextPow2) {
   EXPECT_EQ(STATIC_NEXT_POW_2(1u), 2u);
   EXPECT_EQ(STATIC_NEXT_POW_2(1u), 2u);
   EXPECT_EQ(STATIC_NEXT_POW_2(2u), 2u);
diff --git a/gtests/src/unit/tests/test_uuids.cpp b/gtests/src/unit/tests/test_uuids.cpp
index 9843c54f5..2d0c3fb54 100644
--- a/gtests/src/unit/tests/test_uuids.cpp
+++ b/gtests/src/unit/tests/test_uuids.cpp
@@ -24,13 +24,15 @@
 #include <ctype.h>
 #include <string.h>
 
+using namespace datastax;
+using namespace datastax::internal::testing;
+
 inline bool operator!=(const CassUuid& u1, const CassUuid& u2) {
   return u1.clock_seq_and_node != u2.clock_seq_and_node ||
          u1.time_and_version != u2.time_and_version;
 }
 
-TEST(UuidUnitTest, V1)
-{
+TEST(UuidUnitTest, V1) {
   CassUuidGen* uuid_gen = cass_uuid_gen_new();
 
   CassUuid prev_uuid;
@@ -39,7 +41,7 @@ TEST(UuidUnitTest, V1)
 
   for (int i = 0; i < 1000; ++i) {
     CassUuid uuid;
-    uint64_t curr_ts = cass::get_time_since_epoch_in_ms();
+    uint64_t curr_ts = get_time_since_epoch_in_ms();
     cass_uuid_gen_time(uuid_gen, &uuid);
     cass_uint64_t ts = cass_uuid_timestamp(uuid);
 
@@ -61,10 +63,9 @@ TEST(UuidUnitTest, V1)
   cass_uuid_gen_free(uuid_gen);
 }
 
-TEST(UuidUnitTest, V1MinMax)
-{
+TEST(UuidUnitTest, V1MinMax) {
   cass_uint64_t founded_ts = 1270080000; // April 2010
-  cass_uint64_t curr_ts = cass::get_time_since_epoch_in_ms();
+  cass_uint64_t curr_ts = get_time_since_epoch_in_ms();
 
   CassUuid min_uuid_1;
   CassUuid min_uuid_2;
@@ -94,8 +95,7 @@ TEST(UuidUnitTest, V1MinMax)
   EXPECT_NE(min_uuid_2.clock_seq_and_node, max_uuid_2.clock_seq_and_node);
 }
 
-TEST(UuidUnitTest, V1Node)
-{
+TEST(UuidUnitTest, V1Node) {
   CassUuidGen* uuid_gen = cass_uuid_gen_new_with_node(0x0000112233445566LL);
 
   CassUuid uuid;
@@ -110,8 +110,7 @@ TEST(UuidUnitTest, V1Node)
   cass_uuid_gen_free(uuid_gen);
 }
 
-TEST(UuidUnitTest, V4)
-{
+TEST(UuidUnitTest, V4) {
   CassUuidGen* uuid_gen = cass_uuid_gen_new();
 
   CassUuid prev_uuid;
@@ -129,38 +128,42 @@ TEST(UuidUnitTest, V4)
   cass_uuid_gen_free(uuid_gen);
 }
 
-TEST(UuidUnitTest, FromString)
-{
+TEST(UuidUnitTest, FromString) {
   CassUuid uuid;
-  const cass::String expected = "c3b54ca0-7b01-11e4-aea6-c30dd51eaa64";
+  const String expected = "c3b54ca0-7b01-11e4-aea6-c30dd51eaa64";
   char actual[CASS_UUID_STRING_LENGTH];
 
   EXPECT_EQ(cass_uuid_from_string(expected.c_str(), &uuid), CASS_OK);
   cass_uuid_string(uuid, actual);
   EXPECT_EQ(expected, actual);
 
-  cass::String upper  = expected;
+  String upper = expected;
   std::transform(upper.begin(), upper.end(), upper.begin(), toupper);
   EXPECT_EQ(cass_uuid_from_string(upper.c_str(), &uuid), CASS_OK);
   cass_uuid_string(uuid, actual);
   EXPECT_EQ(expected, actual);
 }
 
-TEST(UuidUnitTest, FromStringInvalid)
-{
+TEST(UuidUnitTest, FromStringInvalid) {
   CassUuid uuid;
   // Empty
   EXPECT_EQ(cass_uuid_from_string("", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
   // One char short
-  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaa6", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaa6", &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
   // All '-'
-  EXPECT_EQ(cass_uuid_from_string("------------------------------------", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string("------------------------------------", &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
   // Invalid char
-  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaz64", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaz64", &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
   // Extra '-'
-  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaa-4", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string("c3b54ca0-7b01-11e4-aea6-c30dd51eaa-4", &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
   // Invalid group
-  EXPECT_EQ(cass_uuid_from_string("c3b54ca07b0-1-11e4-aea6-c30dd51eaa64", &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string("c3b54ca07b0-1-11e4-aea6-c30dd51eaa64", &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
   // String longer then str_length
-  EXPECT_EQ(cass_uuid_from_string_n("00-00-00-00-11-11-11-11-22-22-22-22-deadbeaf", 36, &uuid), CASS_ERROR_LIB_BAD_PARAMS);
+  EXPECT_EQ(cass_uuid_from_string_n("00-00-00-00-11-11-11-11-22-22-22-22-deadbeaf", 36, &uuid),
+            CASS_ERROR_LIB_BAD_PARAMS);
 }
diff --git a/gtests/src/unit/tests/test_value.cpp b/gtests/src/unit/tests/test_value.cpp
index 93cbded13..cce7a06ce 100644
--- a/gtests/src/unit/tests/test_value.cpp
+++ b/gtests/src/unit/tests/test_value.cpp
@@ -16,34 +16,34 @@
 
 #include <gtest/gtest.h>
 
-#include "value.hpp"
 #include "cassandra.h"
+#include "value.hpp"
 
 #include <time.h>
 
+using namespace datastax::internal::core;
+
 // The following CassValue's are used in tests as "bad data".
 
 // Create a CassValue representing a text type.
-static cass::DataType::ConstPtr s_text_type(new cass::DataType(CASS_VALUE_TYPE_TEXT));
-static cass::Value s_text_value_Value(s_text_type, cass::Decoder(NULL, 0));
+static DataType::ConstPtr s_text_type(new DataType(CASS_VALUE_TYPE_TEXT));
+static Value s_text_value_Value(s_text_type, Decoder(NULL, 0));
 static CassValue* s_text_value = CassValue::to(&s_text_value_Value);
 
-// ST is simple-type name (e.g. int8 and the like) and T is the full type name (e.g. cass_int8_t, CassUuid, etc.).
-#define TEST_TYPE(ST, T, SLT) \
-TEST(ValueUnitTest, Bad##ST) \
-{ \
-  T output; \
-  EXPECT_EQ(cass_value_get_##ST(s_text_value, &output), \
-  CASS_ERROR_LIB_INVALID_VALUE_TYPE); \
-  cass::DataType::ConstPtr data_type(new cass::DataType(CASS_VALUE_TYPE_##SLT)); \
-  cass::Value null_value(data_type); \
-  EXPECT_EQ(cass_value_get_##ST(NULL, &output), \
-  CASS_ERROR_LIB_NULL_VALUE); \
-  EXPECT_EQ(cass_value_get_##ST(CassValue::to(&null_value), &output), \
-  CASS_ERROR_LIB_NULL_VALUE); \
-  cass::Value invalid_value(data_type, cass::Decoder("", 0)); \
-  EXPECT_EQ(cass_value_get_##ST(CassValue::to(&invalid_value), &output), \
-  CASS_ERROR_LIB_NOT_ENOUGH_DATA); \
+// ST is simple-type name (e.g. int8 and the like) and T is the full type name (e.g. cass_int8_t,
+// CassUuid, etc.).
+#define TEST_TYPE(ST, T, SLT)                                                                 \
+  TEST(ValueUnitTest, Bad##ST) {                                                              \
+    T output;                                                                                 \
+    EXPECT_EQ(cass_value_get_##ST(s_text_value, &output), CASS_ERROR_LIB_INVALID_VALUE_TYPE); \
+    DataType::ConstPtr data_type(new DataType(CASS_VALUE_TYPE_##SLT));                        \
+    Value null_value(data_type);                                                              \
+    EXPECT_EQ(cass_value_get_##ST(NULL, &output), CASS_ERROR_LIB_NULL_VALUE);                 \
+    EXPECT_EQ(cass_value_get_##ST(CassValue::to(&null_value), &output),                       \
+              CASS_ERROR_LIB_NULL_VALUE);                                                     \
+    Value invalid_value(data_type, Decoder("", 0));                                           \
+    EXPECT_EQ(cass_value_get_##ST(CassValue::to(&invalid_value), &output),                    \
+              CASS_ERROR_LIB_NOT_ENOUGH_DATA);                                                \
   }
 
 #define TEST_SIMPLE_TYPE(T, SLT) TEST_TYPE(T, cass_##T##_t, SLT)
@@ -58,62 +58,52 @@ TEST_SIMPLE_TYPE(double, DOUBLE)
 TEST_SIMPLE_TYPE(bool, BOOLEAN)
 TEST_TYPE(uuid, CassUuid, UUID)
 
-TEST(ValueUnitTest, BadBytes)
-{
+TEST(ValueUnitTest, BadBytes) {
   const cass_byte_t* bytes = NULL;
   size_t bytes_size = 0;
-  EXPECT_EQ(cass_value_get_bytes(NULL, &bytes, &bytes_size),
-            CASS_ERROR_LIB_NULL_VALUE);
+  EXPECT_EQ(cass_value_get_bytes(NULL, &bytes, &bytes_size), CASS_ERROR_LIB_NULL_VALUE);
 }
 
-TEST(ValueUnitTest, BadString)
-{
+TEST(ValueUnitTest, BadString) {
   const char* str = NULL;
   size_t str_length = 0;
-  EXPECT_EQ(cass_value_get_string(NULL, &str, &str_length),
-            CASS_ERROR_LIB_NULL_VALUE);
+  EXPECT_EQ(cass_value_get_string(NULL, &str, &str_length), CASS_ERROR_LIB_NULL_VALUE);
 }
 
-TEST(ValueUnitTest, BadInet)
-{
+TEST(ValueUnitTest, BadInet) {
   CassInet inet;
-  cass::DataType::ConstPtr data_type(new cass::DataType(CASS_VALUE_TYPE_INET));
+  DataType::ConstPtr data_type(new DataType(CASS_VALUE_TYPE_INET));
 
-  EXPECT_EQ(cass_value_get_inet(NULL, &inet),
-            CASS_ERROR_LIB_NULL_VALUE);
+  EXPECT_EQ(cass_value_get_inet(NULL, &inet), CASS_ERROR_LIB_NULL_VALUE);
 
-  cass::Value null_value(data_type);
-  EXPECT_EQ(cass_value_get_inet(CassValue::to(&null_value), &inet),
-            CASS_ERROR_LIB_NULL_VALUE);
+  Value null_value(data_type);
+  EXPECT_EQ(cass_value_get_inet(CassValue::to(&null_value), &inet), CASS_ERROR_LIB_NULL_VALUE);
 
-  cass::Value invalid_value(data_type, cass::Decoder("12345678901234567", 17));
-  EXPECT_EQ(cass_value_get_inet(CassValue::to(&invalid_value), &inet),
-            CASS_ERROR_LIB_INVALID_DATA);
+  Value invalid_value(data_type, Decoder("12345678901234567", 17));
+  EXPECT_EQ(cass_value_get_inet(CassValue::to(&invalid_value), &inet), CASS_ERROR_LIB_INVALID_DATA);
 }
 
-TEST(ValueUnitTest, BadDuration)
-{
+TEST(ValueUnitTest, BadDuration) {
   cass_int32_t months, days;
   cass_int64_t nanos;
   EXPECT_EQ(cass_value_get_duration(s_text_value, &months, &days, &nanos),
             CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
-  cass::DataType::ConstPtr data_type(new cass::DataType(CASS_VALUE_TYPE_DURATION));
-  cass::Value invalid_value(data_type, cass::Decoder("", 0));
+  DataType::ConstPtr data_type(new DataType(CASS_VALUE_TYPE_DURATION));
+  Value invalid_value(data_type, Decoder("", 0));
   EXPECT_EQ(cass_value_get_duration(CassValue::to(&invalid_value), &months, &days, &nanos),
             CASS_ERROR_LIB_NOT_ENOUGH_DATA);
 }
 
-TEST(ValueUnitTest, BadDecimal)
-{
+TEST(ValueUnitTest, BadDecimal) {
   const cass_byte_t* varint;
   size_t varint_size;
   cass_int32_t scale;
   EXPECT_EQ(cass_value_get_decimal(s_text_value, &varint, &varint_size, &scale),
             CASS_ERROR_LIB_INVALID_VALUE_TYPE);
 
-  cass::DataType::ConstPtr data_type(new cass::DataType(CASS_VALUE_TYPE_DECIMAL));
-  cass::Value invalid_value(data_type, cass::Decoder("", 0));
+  DataType::ConstPtr data_type(new DataType(CASS_VALUE_TYPE_DECIMAL));
+  Value invalid_value(data_type, Decoder("", 0));
   EXPECT_EQ(cass_value_get_decimal(CassValue::to(&invalid_value), &varint, &varint_size, &scale),
             CASS_ERROR_LIB_NOT_ENOUGH_DATA);
 }
diff --git a/gtests/src/unit/tests/test_wait_for_handler.cpp b/gtests/src/unit/tests/test_wait_for_handler.cpp
index 105f4c65f..85e02743c 100644
--- a/gtests/src/unit/tests/test_wait_for_handler.cpp
+++ b/gtests/src/unit/tests/test_wait_for_handler.cpp
@@ -19,10 +19,11 @@
 #include "connector.hpp"
 #include "query_request.hpp"
 #include "request_handler.hpp"
-#include "wait_for_handler.hpp"
 #include "timer.hpp"
+#include "wait_for_handler.hpp"
 
-using namespace cass;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class WaitForHandlerUnitTest : public LoopTest {
 public:
@@ -30,14 +31,11 @@ class WaitForHandlerUnitTest : public LoopTest {
   public:
     typedef SharedRefPtr<TestWaitForHandler> Ptr;
 
-    TestWaitForHandler(uint64_t max_wait_time = 2000,
-                       uint64_t retry_wait_time = 200)
-      : WaitForHandler(RequestHandler::Ptr(
-                         new RequestHandler(
-                           QueryRequest::Ptr(new QueryRequest("")),
-                           ResponseFuture::Ptr(new ResponseFuture()))),
-                       Host::Ptr(new Host(Address())),
-                       Response::Ptr(), max_wait_time, retry_wait_time) { }
+    TestWaitForHandler(uint64_t max_wait_time = 2000, uint64_t retry_wait_time = 200)
+        : WaitForHandler(
+              RequestHandler::Ptr(new RequestHandler(QueryRequest::Ptr(new QueryRequest("")),
+                                                     ResponseFuture::Ptr(new ResponseFuture()))),
+              Host::Ptr(new Host(Address())), Response::Ptr(), max_wait_time, retry_wait_time) {}
 
     virtual RequestCallback::Ptr callback() = 0;
 
@@ -57,9 +55,8 @@ class WaitForHandlerUnitTest : public LoopTest {
     }
 
   private:
-    virtual void on_error(WaitForError code, const String& message)  {
-      EXPECT_TRUE(WAIT_FOR_ERROR_CONNECTION_CLOSED == code ||
-                  WAIT_FOR_ERROR_REQUEST_ERROR == code);
+    virtual void on_error(WaitForError code, const String& message) {
+      EXPECT_TRUE(WAIT_FOR_ERROR_CONNECTION_CLOSED == code || WAIT_FOR_ERROR_REQUEST_ERROR == code);
     }
   };
 
@@ -67,7 +64,8 @@ class WaitForHandlerUnitTest : public LoopTest {
   public:
     virtual RequestCallback::Ptr callback() {
       WaitforRequestVec requests;
-      QueryRequest::Ptr local_request(new QueryRequest("SELECT * FROM system.local WHERE key='local'"));
+      QueryRequest::Ptr local_request(
+          new QueryRequest("SELECT * FROM system.local WHERE key='local'"));
       QueryRequest::Ptr peers_request(new QueryRequest("SELECT * FROM system.peers"));
       local_request->set_is_idempotent(true);
       peers_request->set_is_idempotent(true);
@@ -77,7 +75,7 @@ class WaitForHandlerUnitTest : public LoopTest {
     }
 
   private:
-    virtual void on_error(WaitForError code, const String& message)  {
+    virtual void on_error(WaitForError code, const String& message) {
       EXPECT_TRUE(WAIT_FOR_ERROR_CONNECTION_CLOSED == code ||
                   WAIT_FOR_ERROR_REQUEST_TIMEOUT == code);
     }
@@ -91,9 +89,8 @@ class WaitForHandlerUnitTest : public LoopTest {
     timeout_ = timeout;
 
     Connector::Ptr connector(
-          new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))),
-                        PROTOCOL_VERSION,
-                        bind_callback(&WaitForHandlerUnitTest::on_connected, this)));
+        new Connector(Host::Ptr(new Host(Address("127.0.0.1", PORT))), PROTOCOL_VERSION,
+                      bind_callback(&WaitForHandlerUnitTest::on_connected, this)));
     connector->connect(loop());
 
     uv_run(loop(), UV_RUN_DEFAULT);
@@ -102,7 +99,7 @@ class WaitForHandlerUnitTest : public LoopTest {
 private:
   struct CloseConnectionHandler {
     CloseConnectionHandler(const Connection::Ptr& connection)
-      : connection(connection) { }
+        : connection(connection) {}
 
     void on_timeout(Timer* timer) {
       connection->close();
@@ -110,8 +107,7 @@ class WaitForHandlerUnitTest : public LoopTest {
     }
 
     void start(uint64_t timeout) {
-      timer.start(connection->loop(),
-                  timeout,
+      timer.start(connection->loop(), timeout,
                   bind_callback(&CloseConnectionHandler::on_timeout, this));
     }
 
@@ -134,8 +130,7 @@ class WaitForHandlerUnitTest : public LoopTest {
         connection->close();
       }
     } else {
-      ASSERT_TRUE(false) << "Connection had a failure: "
-                         << connector->error_message();
+      ASSERT_TRUE(false) << "Connection had a failure: " << connector->error_message();
     }
   }
 
diff --git a/gtests/src/unit/uint128.hpp b/gtests/src/unit/uint128.hpp
index 529d74a34..07a2f2c53 100644
--- a/gtests/src/unit/uint128.hpp
+++ b/gtests/src/unit/uint128.hpp
@@ -27,9 +27,9 @@
 
 #include "string.hpp"
 
-#include <stdexcept>
-#include <iostream>
 #include <climits>
+#include <iostream>
+#include <stdexcept>
 #include <stdint.h>
 #include <string>
 
@@ -37,414 +37,408 @@ namespace numeric {
 
 namespace detail {
 template <typename T>
-static void divide(const T &numerator, const T &denominator, T &quotient, T &remainder) {
-
-	static const int bits = sizeof(T) * CHAR_BIT;
-
-	if(denominator == 0) {
-		throw std::domain_error("divide by zero");
-	} else {
-		T n      = numerator;
-		T d      = denominator;
-		T x      = 1;
-		T answer = 0;
-
-		while((n >= d) && (((d >> (bits - 1)) & 1) == 0)) {
-			x <<= 1;
-			d <<= 1;
-		}
-
-		while(x != 0) {
-			if(n >= d) {
-				n -= d;
-				answer |= x;
-			}
-
-			x >>= 1;
-			d >>= 1;
-		}
-
-		quotient = answer;
-		remainder = n;
-	}
-}
-}
+static void divide(const T& numerator, const T& denominator, T& quotient, T& remainder) {
+
+  static const int bits = sizeof(T) * CHAR_BIT;
 
+  if (denominator == 0) {
+    throw std::domain_error("divide by zero");
+  } else {
+    T n = numerator;
+    T d = denominator;
+    T x = 1;
+    T answer = 0;
+
+    while ((n >= d) && (((d >> (bits - 1)) & 1) == 0)) {
+      x <<= 1;
+      d <<= 1;
+    }
+
+    while (x != 0) {
+      if (n >= d) {
+        n -= d;
+        answer |= x;
+      }
+
+      x >>= 1;
+      d >>= 1;
+    }
+
+    quotient = answer;
+    remainder = n;
+  }
+}
+} // namespace detail
 
 // convinience macro
 #define U128_C(s) uint128(#s)
 
 class uint128 {
 public:
-	typedef uint64_t base_type;
+  typedef uint64_t base_type;
 
 public:
-	static const unsigned int size = (sizeof(base_type) + sizeof(base_type)) * CHAR_BIT;
+  static const unsigned int size = (sizeof(base_type) + sizeof(base_type)) * CHAR_BIT;
 
 private:
-	base_type lo;
-	base_type hi;
+  base_type lo;
+  base_type hi;
 
 public:
-	// constructors for all basic types
-	uint128()                     : lo(0), hi(0)                             {}
-	uint128(int value)            : lo(static_cast<base_type>(value)), hi(0) { if(value < 0) hi = static_cast<base_type>(-1); }
-	uint128(unsigned int value)   : lo(static_cast<base_type>(value)), hi(0) {}
-	uint128(float value)          : lo(static_cast<base_type>(value)), hi(0) {}
-	uint128(double value)         : lo(static_cast<base_type>(value)), hi(0) {}
-	uint128(const uint128 &value) : lo(value.lo), hi (value.hi)              {}
-	uint128(base_type value)      : lo(value), hi(0)                         {}
-	uint128(base_type lo, base_type hi) : lo(lo), hi(hi)                     {}
-
-	uint128(const cass::String &sz) : lo(0), hi(0) {
-
-		// do we have at least one character?
-		if(!sz.empty()) {
-			// make some reasonable assumptions
-			int radix = 10;
-			bool minus = false;
-
-			cass::String::const_iterator i = sz.begin();
-
-			// check for minus sign, i suppose technically this should only apply
-			// to base 10, but who says that -0x1 should be invalid?
-			if(*i == '-') {
-				++i;
-				minus = true;
-			}
-
-			// check if there is radix changing prefix (0 or 0x)
-			if(i != sz.end()) {
-				if(*i == '0') {
-					radix = 8;
-					++i;
-					if(i != sz.end()) {
-						if(*i == 'x') {
-							radix = 16;
-							++i;
-						}
-					}
-				}
-
-				while(i != sz.end()) {
-					unsigned int n;
-					const char ch = *i;
-
-					if(ch >= 'A' && ch <= 'Z') {
-						if(((ch - 'A') + 10) < radix) {
-							n = (ch - 'A') + 10;
-						} else {
-							break;
-						}
-					} else if(ch >= 'a' && ch <= 'z') {
-						if(((ch - 'a') + 10) < radix) {
-							n = (ch - 'a') + 10;
-						} else {
-							break;
-						}
-					} else if(ch >= '0' && ch <= '9') {
-						if((ch - '0') < radix) {
-							n = (ch - '0');
-						} else {
-							break;
-						}
-					} else {
-						/* completely invalid character */
-						break;
-					}
-
-					(*this) *= radix;
-					(*this) += n;
-
-					++i;
-				}
-			}
-
-			// if this was a negative number, do that two's compliment madness :-P
-			if(minus) {
-				*this = -*this;
-			}
-		}
-	}
-
-	uint128 &operator=(const uint128 &other) {
-		if(&other != this) {
-			lo = other.lo;
-			hi = other.hi;
-		}
-		return *this;
-	}
+  // constructors for all basic types
+  uint128()
+      : lo(0)
+      , hi(0) {}
+  uint128(int value)
+      : lo(static_cast<base_type>(value))
+      , hi(0) {
+    if (value < 0) hi = static_cast<base_type>(-1);
+  }
+  uint128(unsigned int value)
+      : lo(static_cast<base_type>(value))
+      , hi(0) {}
+  uint128(float value)
+      : lo(static_cast<base_type>(value))
+      , hi(0) {}
+  uint128(double value)
+      : lo(static_cast<base_type>(value))
+      , hi(0) {}
+  uint128(const uint128& value)
+      : lo(value.lo)
+      , hi(value.hi) {}
+  uint128(base_type value)
+      : lo(value)
+      , hi(0) {}
+  uint128(base_type lo, base_type hi)
+      : lo(lo)
+      , hi(hi) {}
+
+  uint128(const datastax::String& sz)
+      : lo(0)
+      , hi(0) {
+
+    // do we have at least one character?
+    if (!sz.empty()) {
+      // make some reasonable assumptions
+      int radix = 10;
+      bool minus = false;
+
+      datastax::String::const_iterator i = sz.begin();
+
+      // check for minus sign, i suppose technically this should only apply
+      // to base 10, but who says that -0x1 should be invalid?
+      if (*i == '-') {
+        ++i;
+        minus = true;
+      }
+
+      // check if there is radix changing prefix (0 or 0x)
+      if (i != sz.end()) {
+        if (*i == '0') {
+          radix = 8;
+          ++i;
+          if (i != sz.end()) {
+            if (*i == 'x') {
+              radix = 16;
+              ++i;
+            }
+          }
+        }
+
+        while (i != sz.end()) {
+          unsigned int n;
+          const char ch = *i;
+
+          if (ch >= 'A' && ch <= 'Z') {
+            if (((ch - 'A') + 10) < radix) {
+              n = (ch - 'A') + 10;
+            } else {
+              break;
+            }
+          } else if (ch >= 'a' && ch <= 'z') {
+            if (((ch - 'a') + 10) < radix) {
+              n = (ch - 'a') + 10;
+            } else {
+              break;
+            }
+          } else if (ch >= '0' && ch <= '9') {
+            if ((ch - '0') < radix) {
+              n = (ch - '0');
+            } else {
+              break;
+            }
+          } else {
+            /* completely invalid character */
+            break;
+          }
+
+          (*this) *= radix;
+          (*this) += n;
+
+          ++i;
+        }
+      }
+
+      // if this was a negative number, do that two's compliment madness :-P
+      if (minus) {
+        *this = -*this;
+      }
+    }
+  }
 
-public: // comparison operators
+  uint128& operator=(const uint128& other) {
+    if (&other != this) {
+      lo = other.lo;
+      hi = other.hi;
+    }
+    return *this;
+  }
 
-	bool operator==(const uint128 &o) const {
-		return hi == o.hi && lo == o.lo;
-	}
+public: // comparison operators
+  bool operator==(const uint128& o) const { return hi == o.hi && lo == o.lo; }
 
-	bool operator!=(const uint128 &o) const {
-		return !(*this == o);
-	}
+  bool operator!=(const uint128& o) const { return !(*this == o); }
 
-	bool operator<(const uint128 &o) const {
-		return (hi == o.hi) ? lo < o.lo : hi < o.hi;
-	}
+  bool operator<(const uint128& o) const { return (hi == o.hi) ? lo < o.lo : hi < o.hi; }
 
-	bool operator>=(const uint128 &o) const {
-		return !(*this < o);
-	}
+  bool operator>=(const uint128& o) const { return !(*this < o); }
 
 public: // unary operators
+  bool operator!() const { return !(hi != 0 || lo != 0); }
+
+  uint128 operator-() const {
+    // standard 2's compliment negation
+    return ~uint128(*this) + 1;
+  }
+
+  uint128 operator~() const {
+    uint128 t(*this);
+    t.lo = ~t.lo;
+    t.hi = ~t.hi;
+    return t;
+  }
+
+  uint128& operator++() {
+    if (++lo == 0) {
+      ++hi;
+    }
+    return *this;
+  }
 
-    bool operator!() const {
-		return !(hi != 0 || lo != 0);
-	}
-
-    uint128 operator-() const {
-		// standard 2's compliment negation
-		return ~uint128(*this) + 1;
-	}
-
-    uint128 operator~() const {
-		uint128 t(*this);
-		t.lo = ~t.lo;
-		t.hi = ~t.hi;
-		return t;
-	}
-
-    uint128 &operator++() {
-    	if(++lo == 0) {
-			++hi;
-		}
-    	return *this;
-	}
-
-    uint128 &operator--() {
-    	if(lo-- == 0) {
-        	--hi;
-		}
-    	return *this;
-	}
+  uint128& operator--() {
+    if (lo-- == 0) {
+      --hi;
+    }
+    return *this;
+  }
 
 public: // basic math operators
+  uint128& operator+=(const uint128& b) {
+    const base_type old_lo = lo;
 
-    uint128 &operator+=(const uint128 &b) {
-		const base_type old_lo = lo;
-
-    	lo += b.lo;
-    	hi += b.hi;
+    lo += b.lo;
+    hi += b.hi;
 
-		if(lo < old_lo) {
-			++hi;
-		}
-
-    	return *this;
-	}
-
-    uint128 &operator-=(const uint128 &b) {
-		// it happens to be way easier to write it
-		// this way instead of make a subtraction algorithm
-		return *this += -b;
+    if (lo < old_lo) {
+      ++hi;
     }
 
-    uint128 operator+(const uint128& b) const {
-			return uint128(*this) += b;
-		}
-
-    uint128 &operator*=(const uint128 &b) {
-
-		// check for multiply by 0
-		// result is always 0 :-P
-		if(b == 0) {
-			hi = 0;
-			lo = 0;
-		} else if(b != 1) {
-
-			// check we aren't multiplying by 1
-
-    		uint128 a(*this);
-    		uint128 t = b;
-
-    		lo = 0;
-    		hi = 0;
-
-    		for (unsigned int i = 0; i < size; ++i) {
-        		if((t & 1) != 0) {
-            		*this += (a << i);
-				}
-
-				 t >>= 1;
-    		}
-		}
-
-    	return *this;
-	}
-
-    uint128 &operator|=(const uint128 &b) {
-    	hi |= b.hi;
-    	lo |= b.lo;
-    	return *this;
-	}
-
-    uint128 &operator&=(const uint128 &b) {
-    	hi &= b.hi;
-    	lo &= b.lo;
-    	return *this;
-	}
-
-    uint128 operator&(const uint128 &b) const {
-			return uint128(*this) &= b;
-		}
-
-		uint128 &operator^=(const uint128 &b) {
-			hi ^= b.hi;
-			lo ^= b.lo;
-			return *this;
-	}
-
-    uint128 &operator/=(const uint128 &b) {
-		uint128 remainder;
-		detail::divide(*this, b, *this, remainder);
-		return *this;
-    }
+    return *this;
+  }
 
-    uint128 &operator%=(const uint128 &b) {
-		uint128 quotient;
-		detail::divide(*this, b, quotient, *this);
-		return *this;
-    }
+  uint128& operator-=(const uint128& b) {
+    // it happens to be way easier to write it
+    // this way instead of make a subtraction algorithm
+    return *this += -b;
+  }
 
-    uint128 &operator<<=(const uint128& rhs) {
+  uint128 operator+(const uint128& b) const { return uint128(*this) += b; }
 
-		unsigned int n = rhs.to_integer();
+  uint128& operator*=(const uint128& b) {
 
-		if(n >= size) {
-			hi = 0;
-			lo = 0;
-		} else {
-			const unsigned int halfsize = size / 2;
+    // check for multiply by 0
+    // result is always 0 :-P
+    if (b == 0) {
+      hi = 0;
+      lo = 0;
+    } else if (b != 1) {
 
-    		if(n >= halfsize){
-        		n -= halfsize;
-        		hi = lo;
-        		lo = 0;
-    		}
+      // check we aren't multiplying by 1
 
-    		if(n != 0) {
-				// shift high half
-        		hi <<= n;
+      uint128 a(*this);
+      uint128 t = b;
 
-				const base_type mask(~(base_type(-1) >> n));
+      lo = 0;
+      hi = 0;
 
-				// and add them to high half
-        		hi |= (lo & mask) >> (halfsize - n);
+      for (unsigned int i = 0; i < size; ++i) {
+        if ((t & 1) != 0) {
+          *this += (a << i);
+        }
 
-				// and finally shift also low half
-        		lo <<= n;
-    		}
-		}
+        t >>= 1;
+      }
+    }
+
+    return *this;
+  }
+
+  uint128& operator|=(const uint128& b) {
+    hi |= b.hi;
+    lo |= b.lo;
+    return *this;
+  }
+
+  uint128& operator&=(const uint128& b) {
+    hi &= b.hi;
+    lo &= b.lo;
+    return *this;
+  }
+
+  uint128 operator&(const uint128& b) const { return uint128(*this) &= b; }
+
+  uint128& operator^=(const uint128& b) {
+    hi ^= b.hi;
+    lo ^= b.lo;
+    return *this;
+  }
+
+  uint128& operator/=(const uint128& b) {
+    uint128 remainder;
+    detail::divide(*this, b, *this, remainder);
+    return *this;
+  }
+
+  uint128& operator%=(const uint128& b) {
+    uint128 quotient;
+    detail::divide(*this, b, quotient, *this);
+    return *this;
+  }
+
+  uint128& operator<<=(const uint128& rhs) {
+
+    unsigned int n = rhs.to_integer();
+
+    if (n >= size) {
+      hi = 0;
+      lo = 0;
+    } else {
+      const unsigned int halfsize = size / 2;
+
+      if (n >= halfsize) {
+        n -= halfsize;
+        hi = lo;
+        lo = 0;
+      }
+
+      if (n != 0) {
+        // shift high half
+        hi <<= n;
+
+        const base_type mask(~(base_type(-1) >> n));
+
+        // and add them to high half
+        hi |= (lo & mask) >> (halfsize - n);
+
+        // and finally shift also low half
+        lo <<= n;
+      }
+    }
 
-    	return *this;
-	}
+    return *this;
+  }
 
-  uint128 operator<<(const uint128& rhs) const {
-		return uint128(*this) <<= rhs;
-	}
+  uint128 operator<<(const uint128& rhs) const { return uint128(*this) <<= rhs; }
 
-    uint128 &operator>>=(const uint128& rhs) {
+  uint128& operator>>=(const uint128& rhs) {
 
-		unsigned int n = rhs.to_integer();
+    unsigned int n = rhs.to_integer();
 
-		if(n >= size) {
-			hi = 0;
-			lo = 0;
-		} else {
-			const unsigned int halfsize = size / 2;
+    if (n >= size) {
+      hi = 0;
+      lo = 0;
+    } else {
+      const unsigned int halfsize = size / 2;
 
-    		if(n >= halfsize) {
-        		n -= halfsize;
-        		lo = hi;
-        		hi = 0;
-    		}
+      if (n >= halfsize) {
+        n -= halfsize;
+        lo = hi;
+        hi = 0;
+      }
 
-    		if(n != 0) {
-				// shift low half
-        		lo >>= n;
+      if (n != 0) {
+        // shift low half
+        lo >>= n;
 
-				// get lower N bits of high half
-				const base_type mask(~(base_type(-1) << n));
+        // get lower N bits of high half
+        const base_type mask(~(base_type(-1) << n));
 
-				// and add them to low qword
-        		lo |= (hi & mask) << (halfsize - n);
+        // and add them to low qword
+        lo |= (hi & mask) << (halfsize - n);
 
-				// and finally shift also high half
-        		hi >>= n;
-    		}
-		}
+        // and finally shift also high half
+        hi >>= n;
+      }
+    }
 
-    	return *this;
-	}
+    return *this;
+  }
 
-  uint128 operator>>(const uint128 &rhs) const {
-		return uint128(*this) >>= rhs;
-	}
+  uint128 operator>>(const uint128& rhs) const { return uint128(*this) >>= rhs; }
 
 public:
-	int to_integer() const {
-		return static_cast<int>(lo);
-	}
+  int to_integer() const { return static_cast<int>(lo); }
 
-	base_type to_base_type() const {
-		return lo;
-	}
+  base_type to_base_type() const { return lo; }
 
-    cass::String to_string(unsigned int radix = 10) const {
-    	if(*this == 0) {
-			return "0";
-		}
+  datastax::String to_string(unsigned int radix = 10) const {
+    if (*this == 0) {
+      return "0";
+    }
 
-    	if(radix < 2 || radix > 37) {
-			return "(invalid radix)";
-		}
+    if (radix < 2 || radix > 37) {
+      return "(invalid radix)";
+    }
 
-		// at worst it will be size digits (base 2) so make our buffer
-		// that plus room for null terminator
-    	static char sz [size + 1];
-		sz[sizeof(sz) - 1] = '\0';
+    // at worst it will be size digits (base 2) so make our buffer
+    // that plus room for null terminator
+    static char sz[size + 1];
+    sz[sizeof(sz) - 1] = '\0';
 
-    	uint128 ii(*this);
-    	int i = size - 1;
+    uint128 ii(*this);
+    int i = size - 1;
 
-    	while (ii != 0 && i) {
+    while (ii != 0 && i) {
 
-			uint128 remainder;
-			detail::divide(ii, uint128(radix), ii, remainder);
-        	sz [--i] = "0123456789abcdefghijklmnopqrstuvwxyz"[remainder.to_integer()];
-    	}
+      uint128 remainder;
+      detail::divide(ii, uint128(radix), ii, remainder);
+      sz[--i] = "0123456789abcdefghijklmnopqrstuvwxyz"[remainder.to_integer()];
+    }
 
-    	return &sz[i];
-	}
+    return &sz[i];
+  }
 };
 
-inline std::ostream &operator<<(std::ostream &o, const uint128 &n) {
-	switch(o.flags() & (std::ios_base::hex | std::ios_base::dec | std::ios_base::oct)) {
-	case std::ios_base::hex:
-		o << n.to_string(16);
-		break;
-	case std::ios_base::dec:
-		o << n.to_string(10);
-		break;
-	case std::ios_base::oct:
-		o << n.to_string(8);
-		break;
-	default:
-		o << n.to_string();
-		break;
-	}
-	return o;
+inline std::ostream& operator<<(std::ostream& o, const uint128& n) {
+  switch (o.flags() & (std::ios_base::hex | std::ios_base::dec | std::ios_base::oct)) {
+    case std::ios_base::hex:
+      o << n.to_string(16);
+      break;
+    case std::ios_base::dec:
+      o << n.to_string(10);
+      break;
+    case std::ios_base::oct:
+      o << n.to_string(8);
+      break;
+    default:
+      o << n.to_string();
+      break;
+  }
+  return o;
 }
 
 typedef uint128 uint128_t;
 
-}
+} // namespace numeric
 
 #endif
diff --git a/gtests/src/unit/unit.cpp b/gtests/src/unit/unit.cpp
index fe43f1075..e1c398e95 100644
--- a/gtests/src/unit/unit.cpp
+++ b/gtests/src/unit/unit.cpp
@@ -15,15 +15,18 @@
 */
 #include "unit.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 Unit::OutagePlan::Action::Action(Type type, size_t node, uint64_t delay_ms)
-  : type(type)
-  , node(node)
-  , delay_ms(delay_ms) { }
+    : type(type)
+    , node(node)
+    , delay_ms(delay_ms) {}
 
-Unit::OutagePlan::OutagePlan(uv_loop_t* loop,
-                             mockssandra::SimpleCluster* cluster)
-  : loop_(loop)
-  , cluster_(cluster) { }
+Unit::OutagePlan::OutagePlan(uv_loop_t* loop, mockssandra::SimpleCluster* cluster)
+    : loop_(loop)
+    , cluster_(cluster) {}
 
 void Unit::OutagePlan::start_node(size_t node, uint64_t delay_ms /*= DEFAULT_OUTAGE_PLAN_DELAY*/) {
   actions_.push_back(Action(START_NODE, node, delay_ms));
@@ -45,24 +48,20 @@ void Unit::OutagePlan::remove_node(size_t node, uint64_t delay_ms /*= DEFAULT_OU
   action_it_ = actions_.begin();
 }
 
-void Unit::OutagePlan::run(cass::Future::Ptr future /*= cass::Future::Ptr()*/) {
+void Unit::OutagePlan::run(core::Future::Ptr future /*= core::Future::Ptr()*/) {
   if (future) future_ = future;
   next();
 }
 
-void Unit::OutagePlan::stop() {
-  timer_.stop();
-}
+void Unit::OutagePlan::stop() { timer_.stop(); }
 
-bool Unit::OutagePlan::is_done() {
-  return (action_it_ == actions_.end());
-}
+bool Unit::OutagePlan::is_done() { return (action_it_ == actions_.end()); }
 
 void Unit::OutagePlan::next() {
   if (!is_done()) {
     if (action_it_->delay_ms > 0 && loop_ != NULL) {
       ASSERT_EQ(0, timer_.start(loop_, action_it_->delay_ms,
-                cass::bind_callback(&OutagePlan::on_timeout, this)));
+                                bind_callback(&OutagePlan::on_timeout, this)));
     } else {
       handle_timeout();
     }
@@ -74,9 +73,7 @@ void Unit::OutagePlan::next() {
   }
 }
 
-void Unit::OutagePlan::on_timeout(Timer* timer) {
-  handle_timeout();
-}
+void Unit::OutagePlan::on_timeout(Timer* timer) { handle_timeout(); }
 
 void Unit::OutagePlan::handle_timeout() {
   switch (action_it_->type) {
@@ -98,15 +95,15 @@ void Unit::OutagePlan::handle_timeout() {
 }
 
 Unit::Unit()
-  : output_log_level_(CASS_LOG_DISABLED)
-  , logging_criteria_count_(0) {
-  cass::Logger::set_log_level(CASS_LOG_TRACE);
-  cass::Logger::set_callback(on_log, this);
+    : output_log_level_(CASS_LOG_DISABLED)
+    , logging_criteria_count_(0) {
+  Logger::set_log_level(CASS_LOG_TRACE);
+  Logger::set_callback(on_log, this);
 }
 
 Unit::~Unit() {
-  cass::Logger::set_log_level(CASS_LOG_DISABLED);
-  cass::Logger::set_callback(NULL, NULL);
+  Logger::set_log_level(CASS_LOG_DISABLED);
+  Logger::set_callback(NULL, NULL);
 }
 
 void Unit::set_output_log_level(CassLogLevel output_log_level) {
@@ -121,28 +118,23 @@ const mockssandra::RequestHandler* Unit::auth() {
   return mockssandra::AuthRequestHandlerBuilder().build();
 }
 
-cass::ConnectionSettings Unit::use_ssl(mockssandra::Cluster* cluster,
-                                       const cass::String& cn /*= ""*/) {
-  cass::SslContext::Ptr ssl_context(cass::SslContextFactory::create());
+ConnectionSettings Unit::use_ssl(mockssandra::Cluster* cluster, const String& cn /*= ""*/) {
+  SslContext::Ptr ssl_context(SslContextFactory::create());
 
   String cert = cluster->use_ssl(cn);
   EXPECT_FALSE(cert.empty()) << "Unable to enable SSL";
   EXPECT_EQ(ssl_context->add_trusted_cert(cert.data(), cert.size()), CASS_OK);
 
-  cass::ConnectionSettings settings;
+  core::ConnectionSettings settings;
   settings.socket_settings.ssl_context = ssl_context;
   settings.socket_settings.hostname_resolution_enabled = true;
 
   return settings;
 }
 
-void Unit::add_logging_critera(const cass::String& criteria) {
-  logging_criteria_.push_back(criteria);
-}
+void Unit::add_logging_critera(const String& criteria) { logging_criteria_.push_back(criteria); }
 
-int Unit::logging_criteria_count() {
-  return logging_criteria_count_.load();
-}
+int Unit::logging_criteria_count() { return logging_criteria_count_.load(); }
 
 void Unit::on_log(const CassLogMessage* message, void* data) {
   Unit* instance = static_cast<Unit*>(data);
@@ -151,16 +143,14 @@ void Unit::on_log(const CassLogMessage* message, void* data) {
     fprintf(stderr, "%u.%03u [%s] (%s:%d:%s): %s\n",
             static_cast<unsigned int>(message->time_ms / 1000),
             static_cast<unsigned int>(message->time_ms % 1000),
-            cass_log_level_string(message->severity),
-            message->file,
-            message->line,
-            message->function,
-            message->message);
+            cass_log_level_string(message->severity), message->file, message->line,
+            message->function, message->message);
   }
 
   // Determine if the log message matches any of the criteria
-  for (Vector<cass::String>::const_iterator it = instance->logging_criteria_.begin(),
-    end = instance->logging_criteria_.end(); it != end; ++it) {
+  for (Vector<String>::const_iterator it = instance->logging_criteria_.begin(),
+                                      end = instance->logging_criteria_.end();
+       it != end; ++it) {
     if (strstr(message->message, it->c_str()) != NULL) {
       instance->logging_criteria_count_.fetch_add(1);
     }
diff --git a/gtests/src/unit/unit.hpp b/gtests/src/unit/unit.hpp
index 7b390b63a..2b6b42e25 100644
--- a/gtests/src/unit/unit.hpp
+++ b/gtests/src/unit/unit.hpp
@@ -42,12 +42,7 @@ class Unit : public testing::Test {
     /**
      * Type of action to occur during loop execution.
      */
-    enum Type {
-      START_NODE,
-      STOP_NODE,
-      ADD_NODE,
-      REMOVE_NODE
-    };
+    enum Type { START_NODE, STOP_NODE, ADD_NODE, REMOVE_NODE };
 
     /**
      * Action to take place during loop execution.
@@ -66,7 +61,7 @@ class Unit : public testing::Test {
       size_t node;
       uint64_t delay_ms;
     };
-    typedef cass::Vector<Action> Actions;
+    typedef datastax::internal::Vector<Action> Actions;
 
     /**
      * Constructor.
@@ -110,7 +105,8 @@ class Unit : public testing::Test {
      *
      * @param future Future to set when outage plan is running.
      */
-    void run(cass::Future::Ptr future = cass::Future::Ptr());
+    void
+    run(datastax::internal::core::Future::Ptr future = datastax::internal::core::Future::Ptr());
 
     /**
      * Stop the outage plan; must be executed on the same thread that started
@@ -138,37 +134,35 @@ class Unit : public testing::Test {
     Actions actions_;
     uv_loop_t* loop_;
     mockssandra::SimpleCluster* cluster_;
-    cass::Future::Ptr future_;
+    datastax::internal::core::Future::Ptr future_;
   };
 
 public:
   class ExecuteOutagePlan : public Task {
   public:
-    ExecuteOutagePlan(OutagePlan* outage_plan,
-                      cass::Future::Ptr future)
-      : outage_plan_(outage_plan)
-      , future_(future) { }
-    virtual void run(EventLoop* event_loop) {
-      outage_plan_->run(future_);
-    }
+    ExecuteOutagePlan(OutagePlan* outage_plan, datastax::internal::core::Future::Ptr future)
+        : outage_plan_(outage_plan)
+        , future_(future) {}
+    virtual void run(EventLoop* event_loop) { outage_plan_->run(future_); }
+
   private:
-    OutagePlan * outage_plan_;
-    cass::Future::Ptr future_;
+    OutagePlan* outage_plan_;
+    datastax::internal::core::Future::Ptr future_;
   };
 
   class StopOutagePlan : public Task {
   public:
-    StopOutagePlan(OutagePlan* outage_plan,
-                   cass::Future::Ptr future)
-      : outage_plan_(outage_plan)
-      , future_(future) { }
+    StopOutagePlan(OutagePlan* outage_plan, datastax::internal::core::Future::Ptr future)
+        : outage_plan_(outage_plan)
+        , future_(future) {}
     virtual void run(EventLoop* event_loop) {
       outage_plan_->stop();
       future_->set();
     }
+
   private:
-    OutagePlan * outage_plan_;
-    cass::Future::Ptr future_;
+    OutagePlan* outage_plan_;
+    datastax::internal::core::Future::Ptr future_;
   };
 
 public:
@@ -211,15 +205,15 @@ class Unit : public testing::Test {
    *           peer verification)
    * @return A connection settings object setup to use SSL.
    */
-  cass::ConnectionSettings use_ssl(mockssandra::Cluster* cluster,
-                                   const cass::String& cn = "");
+  datastax::internal::core::ConnectionSettings use_ssl(mockssandra::Cluster* cluster,
+                                                       const datastax::String& cn = "");
 
   /**
    * Add criteria to the search criteria for incoming log messages
    *
    * @param criteria Criteria to add
    */
-  void add_logging_critera(const cass::String& criteria);
+  void add_logging_critera(const datastax::String& criteria);
   /**
    * Get the number of log messages that matched the search criteria
    *
@@ -238,8 +232,8 @@ class Unit : public testing::Test {
 
 private:
   CassLogLevel output_log_level_;
-  cass::Vector<cass::String> logging_criteria_;
-  cass::Atomic<int> logging_criteria_count_;
+  datastax::internal::Vector<datastax::String> logging_criteria_;
+  datastax::internal::Atomic<int> logging_criteria_count_;
 };
 
 #endif // UNIT_TEST_HPP
diff --git a/include/cassandra.h b/include/cassandra.h
index 7ab45cd3e..b2d1770b6 100644
--- a/include/cassandra.h
+++ b/include/cassandra.h
@@ -52,7 +52,7 @@
  */
 
 #define CASS_VERSION_MAJOR 2
-#define CASS_VERSION_MINOR 12
+#define CASS_VERSION_MINOR 13
 #define CASS_VERSION_PATCH 0
 #define CASS_VERSION_SUFFIX ""
 
@@ -1735,16 +1735,64 @@ cass_cluster_set_max_connections_per_host(CassCluster* cluster,
 /**
  * Sets the amount of time to wait before attempting to reconnect.
  *
- * <b>Default:</b> 2000 milliseconds
- *
  * @public @memberof CassCluster
  *
+ * @deprecated This is being replaced with cass_cluster_set_constant_reconnect().
+ * Expect this to be removed in a future release.
+ *
  * @param[in] cluster
  * @param[in] wait_time
  */
-CASS_EXPORT void
+CASS_EXPORT CASS_DEPRECATED(void
 cass_cluster_set_reconnect_wait_time(CassCluster* cluster,
-                                     unsigned wait_time);
+                                     unsigned wait_time));
+
+/**
+ * Configures the cluster to use a reconnection policy that waits a constant
+ * time between each reconnection attempt.
+ *
+ * @public @memberof CassCluster
+ *
+ * @param[in] cluster
+ * @param[in] delay_ms Time in milliseconds to delay attempting a reconnection;
+ * 0 to perform a reconnection immediately.
+ */
+CASS_EXPORT void
+cass_cluster_set_constant_reconnect(CassCluster* cluster,
+                                    cass_uint64_t delay_ms);
+
+/**
+ * Configures the cluster to use a reconnection policy that waits exponentially
+ * longer between each reconnection attempt; however will maintain a constant
+ * delay once the maximum delay is reached.
+ *
+ * <b>Default:</b>
+ * <ul>
+ *   <li>2000 milliseconds base delay</li>
+ *   <li>60000 milliseconds max delay</li>
+ * </ul>
+ *
+ * <p>
+ *   <b>Note:</b> A random amount of jitter (+/- 15%) will be added to the pure
+ *   exponential delay value. This helps to prevent situations where multiple
+ *   connections are in the reconnection process at exactly the same time. The
+ *   jitter will never cause the delay to be less than the base delay, or more
+ *   than the max delay.
+ * </p>
+ *
+ * @public @memberof CassCluster
+ *
+ * @param[in] cluster
+ * @param[in] base_delay_ms The base delay (in milliseconds) to use for
+ * scheduling reconnection attempts.
+ * @param[in] max_delay_ms The maximum delay to wait between two reconnection
+ * attempts.
+ * @return CASS_OK if successful, otherwise error occurred.
+ */
+CASS_EXPORT CassError
+cass_cluster_set_exponential_reconnect(CassCluster* cluster,
+                                       cass_uint64_t base_delay_ms,
+                                       cass_uint64_t max_delay_ms);
 
 /**
  * Sets the amount of time, in microseconds, to wait for new requests to
@@ -2699,7 +2747,7 @@ cass_cluster_set_no_compact(CassCluster* cluster,
  * <b>Note:</b> The callback is invoked only when state changes in the cluster
  * are applicable to the configured load balancing policy(s).
  *
- * @public @memberor CassCluster
+ * @public @memberof CassCluster
  *
  * @param[in] cluster
  * @param[in] callback
diff --git a/packaging/build_deb.sh b/packaging/build_deb.sh
index 822463016..75b5cbab6 100755
--- a/packaging/build_deb.sh
+++ b/packaging/build_deb.sh
@@ -39,7 +39,7 @@ release=1
 dist=$(lsb_release -s -c)
 base="cassandra-cpp-driver-$version"
 archive="$base.tar.gz"
-files="CMakeLists.txt cmake cmake_uninstall.cmake.in cassconfig.hpp.in include src"
+files="CMakeLists.txt cmake cmake_uninstall.cmake.in driver_config.hpp.in include src"
 
 echo "Building version $version"
 
diff --git a/packaging/build_rpm.sh b/packaging/build_rpm.sh
index fa5817ac5..aa491feda 100755
--- a/packaging/build_rpm.sh
+++ b/packaging/build_rpm.sh
@@ -42,7 +42,7 @@ fi
 version=$(header_version "../include/cassandra.h")
 base="cassandra-cpp-driver-$version"
 archive="$base.tar.gz"
-files="CMakeLists.txt cmake cmake_uninstall.cmake.in cassconfig.hpp.in include src README.md LICENSE.txt"
+files="CMakeLists.txt cmake cmake_uninstall.cmake.in driver_config.hpp.in include src README.md LICENSE.txt"
 
 echo "Building version $version"
 
diff --git a/packaging/cassandra-cpp-driver.spec b/packaging/cassandra-cpp-driver.spec
index 20e78927e..18ad5a07b 100644
--- a/packaging/cassandra-cpp-driver.spec
+++ b/packaging/cassandra-cpp-driver.spec
@@ -1,4 +1,6 @@
+%if 0%{!?amzn}
 %define distnum %(/usr/lib/rpm/redhat/dist.sh --distnum)
+%endif
 
 Name:    cassandra-cpp-driver
 Epoch:   1
@@ -14,9 +16,11 @@ Source1: cassandra.pc.in
 Source2: cassandra_static.pc.in
 
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
+%if 0%{?distnum}
 %if %{distnum} == 5
 BuildRequires: buildsys-macros >= 5
 %endif
+%endif
 BuildRequires: cmake >= 2.6.4
 BuildRequires: libuv-devel >= %{libuv_version}
 BuildRequires: openssl-devel >= 0.9.8e
diff --git a/src/.clang-format b/src/.clang-format
deleted file mode 100644
index 57d419637..000000000
--- a/src/.clang-format
+++ /dev/null
@@ -1,55 +0,0 @@
----
-Language: Cpp
-AccessModifierOffset: -2
-AlignEscapedNewlinesLeft: true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
-AllowShortIfStatementsOnASingleLine: true
-AllowShortLoopsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: Inline
-AlwaysBreakTemplateDeclarations: true
-AlwaysBreakBeforeMultilineStrings: true
-BreakBeforeBinaryOperators: false
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: true
-BinPackParameters: true
-ColumnLimit: 80
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-DerivePointerBinding: true
-ExperimentalAutoDetectBinPacking: false
-IndentCaseLabels: true
-MaxEmptyLinesToKeep: 1
-KeepEmptyLinesAtTheStartOfBlocks: true
-NamespaceIndentation: None
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: false
-PenaltyBreakBeforeFirstCallParameter: 1
-PenaltyBreakComment: 300
-PenaltyBreakString: 1000
-PenaltyBreakFirstLessLess: 120
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 200
-PointerBindsToType: true
-SpacesBeforeTrailingComments: 1
-Cpp11BracedListStyle: true
-Standard: Auto
-IndentWidth: 2
-TabWidth: 8
-UseTab: Never
-BreakBeforeBraces: Attach
-IndentFunctionDeclarationAfterType: true
-SpacesInParentheses: false
-SpacesInAngles: false
-SpaceInEmptyParentheses: false
-SpacesInCStyleCastParentheses: false
-SpacesInContainerLiterals: true
-SpaceBeforeAssignmentOperators: true
-ContinuationIndentWidth: 4
-CommentPragmas: '^ IWYU pragma:'
-ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
-SpaceBeforeParens: ControlStatements
-DisableFormat:   false
-...
-
diff --git a/src/abstract_data.cpp b/src/abstract_data.cpp
index 81f41f721..63abf8619 100644
--- a/src/abstract_data.cpp
+++ b/src/abstract_data.cpp
@@ -22,7 +22,7 @@
 #include "tuple.hpp"
 #include "user_type_value.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 CassError AbstractData::set(size_t index, CassNull value) {
   CASS_CHECK_INDEX_AND_TYPE(index, value);
@@ -32,8 +32,7 @@ CassError AbstractData::set(size_t index, CassNull value) {
 
 CassError AbstractData::set(size_t index, const Collection* value) {
   CASS_CHECK_INDEX_AND_TYPE(index, value);
-  if (value->type() == CASS_COLLECTION_TYPE_MAP &&
-      value->items().size() % 2 != 0) {
+  if (value->type() == CASS_COLLECTION_TYPE_MAP && value->items().size() % 2 != 0) {
     return CASS_ERROR_LIB_INVALID_ITEM_COUNT;
   }
   elements_[index] = value;
@@ -70,8 +69,7 @@ Buffer AbstractData::encode_with_length() const {
 
 size_t AbstractData::get_buffers_size() const {
   size_t size = 0;
-  for (ElementVec::const_iterator i = elements_.begin(),
-       end = elements_.end(); i != end; ++i) {
+  for (ElementVec::const_iterator i = elements_.begin(), end = elements_.end(); i != end; ++i) {
     if (!i->is_unset()) {
       size += i->get_size();
     } else {
@@ -82,8 +80,7 @@ size_t AbstractData::get_buffers_size() const {
 }
 
 void AbstractData::encode_buffers(size_t pos, Buffer* buf) const {
-  for (ElementVec::const_iterator i = elements_.begin(),
-       end = elements_.end(); i != end; ++i) {
+  for (ElementVec::const_iterator i = elements_.begin(), end = elements_.end(); i != end; ++i) {
     if (!i->is_unset()) {
       pos = i->copy_buffer(pos, buf);
     } else {
@@ -119,5 +116,3 @@ Buffer AbstractData::Element::get_buffer() const {
     return buf_;
   }
 }
-
-} // namespace cass
diff --git a/src/abstract_data.hpp b/src/abstract_data.hpp
index b32745563..d479c1fcf 100644
--- a/src/abstract_data.hpp
+++ b/src/abstract_data.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ABSTRACT_DATA_HPP_INCLUDED__
-#define __CASS_ABSTRACT_DATA_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ABSTRACT_DATA_HPP
+#define DATASTAX_INTERNAL_ABSTRACT_DATA_HPP
 
 #include "allocated.hpp"
 #include "buffer.hpp"
@@ -28,12 +28,13 @@
 #include "types.hpp"
 #include "vector.hpp"
 
-#define CASS_CHECK_INDEX_AND_TYPE(Index, Value) do { \
-  CassError rc = check(Index, Value);               \
-  if (rc != CASS_OK) return rc;                     \
-} while(0)
+#define CASS_CHECK_INDEX_AND_TYPE(Index, Value) \
+  do {                                          \
+    CassError rc = check(Index, Value);         \
+    if (rc != CASS_OK) return rc;               \
+  } while (0)
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Tuple;
 class UserTypeValue;
@@ -42,35 +43,26 @@ class AbstractData : public Allocated {
 public:
   class Element {
   public:
-    enum Type {
-      UNSET,
-      NUL,
-      BUFFER,
-      COLLECTION
-    };
+    enum Type { UNSET, NUL, BUFFER, COLLECTION };
 
     Element()
-      : type_(UNSET) { }
+        : type_(UNSET) {}
 
     Element(CassNull value)
-      : type_(NUL)
-      , buf_(cass::encode_with_length(value)) { }
+        : type_(NUL)
+        , buf_(core::encode_with_length(value)) {}
 
     Element(const Buffer& buf)
-      : type_(BUFFER)
-      , buf_(buf) { }
+        : type_(BUFFER)
+        , buf_(buf) {}
 
     Element(const Collection* collection)
-      : type_(COLLECTION)
-      , collection_(collection) { }
+        : type_(COLLECTION)
+        , collection_(collection) {}
 
-    bool is_unset() const {
-      return type_ == UNSET || (type_ == BUFFER && buf_.size() == 0);
-    }
+    bool is_unset() const { return type_ == UNSET || (type_ == BUFFER && buf_.size() == 0); }
 
-    bool is_null() const {
-      return type_ == NUL;
-    }
+    bool is_null() const { return type_ == NUL; }
 
     size_t get_size() const;
     size_t copy_buffer(size_t pos, Buffer* buf) const;
@@ -86,9 +78,9 @@ class AbstractData : public Allocated {
 
 public:
   AbstractData(size_t count)
-    : elements_(count) { }
+      : elements_(count) {}
 
-  virtual ~AbstractData() { }
+  virtual ~AbstractData() {}
 
   const ElementVec& elements() const { return elements_; }
 
@@ -100,7 +92,7 @@ class AbstractData : public Allocated {
 #define SET_TYPE(Type)                                  \
   CassError set(size_t index, const Type value) {       \
     CASS_CHECK_INDEX_AND_TYPE(index, value);            \
-    elements_[index] = cass::encode_with_length(value); \
+    elements_[index] = core::encode_with_length(value); \
     return CASS_OK;                                     \
   }
 
@@ -127,7 +119,7 @@ class AbstractData : public Allocated {
   CassError set(size_t index, const Tuple* value);
   CassError set(size_t index, const UserTypeValue* value);
 
-  template<class T>
+  template <class T>
   CassError set(StringRef name, const T value) {
     IndexVec indices;
 
@@ -135,8 +127,7 @@ class AbstractData : public Allocated {
       return CASS_ERROR_LIB_NAME_DOES_NOT_EXIST;
     }
 
-    for (IndexVec::const_iterator it = indices.begin(),
-         end = indices.end(); it != end; ++it) {
+    for (IndexVec::const_iterator it = indices.begin(), end = indices.end(); it != end; ++it) {
       size_t index = *it;
       CassError rc = set(index, value);
       if (rc != CASS_OK) return rc;
@@ -149,8 +140,7 @@ class AbstractData : public Allocated {
   Buffer encode_with_length() const;
 
 protected:
-  virtual size_t get_indices(StringRef name,
-                             IndexVec* indices) = 0;
+  virtual size_t get_indices(StringRef name, IndexVec* indices) = 0;
   virtual const DataType::ConstPtr& get_type(size_t index) const = 0;
 
 private:
@@ -177,6 +167,6 @@ class AbstractData : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(AbstractData);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/address.cpp b/src/address.cpp
index 0efd97e8c..5d36a2954 100644
--- a/src/address.cpp
+++ b/src/address.cpp
@@ -24,7 +24,8 @@
 #include <assert.h>
 #include <string.h>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 const Address Address::EMPTY_KEY("0.0.0.0", 0);
 const Address Address::DELETED_KEY("0.0.0.0", 1);
@@ -32,9 +33,7 @@ const Address Address::DELETED_KEY("0.0.0.0", 1);
 const Address Address::BIND_ANY_IPV4("0.0.0.0", 0);
 const Address Address::BIND_ANY_IPV6("::", 0);
 
-Address::Address() {
-  memset(&addr_, 0, sizeof(addr_));
-}
+Address::Address() { memset(&addr_, 0, sizeof(addr_)); }
 
 Address::Address(const String& ip, int port) {
   init();
@@ -105,13 +104,9 @@ bool Address::init(const sockaddr* addr) {
   return false;
 }
 
-void Address::init(const struct sockaddr_in* addr) {
-  *addr_in() = *addr;
-}
+void Address::init(const struct sockaddr_in* addr) { *addr_in() = *addr; }
 
-void Address::init(const struct sockaddr_in6* addr) {
-  *addr_in6() = *addr;
-}
+void Address::init(const struct sockaddr_in6* addr) { *addr_in6() = *addr; }
 
 int Address::port() const {
   if (family() == AF_INET) {
@@ -124,15 +119,13 @@ int Address::port() const {
 
 String Address::to_string(bool with_port) const {
   OStringStream ss;
-  char host[INET6_ADDRSTRLEN + 1] = {'\0'};
+  char host[INET6_ADDRSTRLEN + 1] = { '\0' };
   if (family() == AF_INET) {
-    uv_ip4_name(const_cast<struct sockaddr_in*>(addr_in()), host,
-                INET_ADDRSTRLEN);
+    uv_ip4_name(const_cast<struct sockaddr_in*>(addr_in()), host, INET_ADDRSTRLEN);
     ss << host;
     if (with_port) ss << ":" << port();
   } else if (family() == AF_INET6) {
-    uv_ip6_name(const_cast<struct sockaddr_in6*>(addr_in6()), host,
-                INET6_ADDRSTRLEN);
+    uv_ip6_name(const_cast<struct sockaddr_in6*>(addr_in6()), host, INET6_ADDRSTRLEN);
     if (with_port) ss << "[";
     ss << host;
     if (with_port) ss << "]:" << port();
@@ -169,41 +162,41 @@ int Address::compare(const Address& a, bool with_port) const {
   return 0;
 }
 
-bool determine_address_for_peer_host(const Address& connected_address,
-                                     const Value* peer_value,
-                                     const Value* rpc_value,
-                                     Address* output) {
+namespace datastax { namespace internal { namespace core {
+
+bool determine_address_for_peer_host(const Address& connected_address, const Value* peer_value,
+                                     const Value* rpc_value, Address* output) {
   Address peer_address;
-  if (!peer_value || !peer_value->decoder().as_inet(peer_value->size(),
-                                                    connected_address.port(),
-                                                    &peer_address)) {
+  if (!peer_value ||
+      !peer_value->decoder().as_inet(peer_value->size(), connected_address.port(), &peer_address)) {
     LOG_WARN("Invalid address format for peer address");
     return false;
   }
   if (rpc_value && !rpc_value->is_null()) {
-    if (!rpc_value->decoder().as_inet(rpc_value->size(),
-                                      connected_address.port(),
-                                      output)) {
+    if (!rpc_value->decoder().as_inet(rpc_value->size(), connected_address.port(), output)) {
       LOG_WARN("Invalid address format for rpc address");
       return false;
     }
     if (connected_address == *output || connected_address == peer_address) {
       LOG_DEBUG("system.peers on %s contains a line with rpc_address for itself. "
                 "This is not normal, but is a known problem for some versions of DSE. "
-                "Ignoring this entry.", connected_address.to_string(false).c_str());
+                "Ignoring this entry.",
+                connected_address.to_string(false).c_str());
       return false;
     }
     if (Address::BIND_ANY_IPV4.compare(*output, false) == 0 ||
         Address::BIND_ANY_IPV6.compare(*output, false) == 0) {
-      LOG_WARN("Found host with 'bind any' for rpc_address; using listen_address (%s) to contact instead. "
-               "If this is incorrect you should configure a specific interface for rpc_address on the server.",
+      LOG_WARN("Found host with 'bind any' for rpc_address; using listen_address (%s) to contact "
+               "instead. "
+               "If this is incorrect you should configure a specific interface for rpc_address on "
+               "the server.",
                peer_address.to_string(false).c_str());
       *output = peer_address;
     }
   } else {
     LOG_WARN("No rpc_address for host %s in system.peers on %s. "
-             "Ignoring this entry.", peer_address.to_string(false).c_str(),
-             connected_address.to_string(false).c_str());
+             "Ignoring this entry.",
+             peer_address.to_string(false).c_str(), connected_address.to_string(false).c_str());
     return false;
   }
   return true;
@@ -223,4 +216,4 @@ String determine_listen_address(const Address& address, const Row* row) {
   return "";
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
diff --git a/src/address.hpp b/src/address.hpp
index 94cf41403..77aaa6744 100644
--- a/src/address.hpp
+++ b/src/address.hpp
@@ -14,20 +14,20 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ADDRESS_HPP_INCLUDED__
-#define __CASS_ADDRESS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ADDRESS_HPP
+#define DATASTAX_INTERNAL_ADDRESS_HPP
 
 #include "allocated.hpp"
+#include "dense_hash_set.hpp"
 #include "hash.hpp"
 #include "string.hpp"
 #include "vector.hpp"
-#include "dense_hash_set.hpp"
 
 #include <ostream>
 #include <string.h>
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Row;
 class Value;
@@ -43,18 +43,20 @@ class Address : public Allocated {
   Address();
   Address(const String& ip, int port); // Tests only
 
-  static bool from_string(const String& ip, int port,
-                          Address* output = NULL);
+  static bool from_string(const String& ip, int port, Address* output = NULL);
 
-  static bool from_inet(const void* data, size_t size, int port,
-                        Address* output = NULL);
+  static bool from_inet(const void* data, size_t size, int port, Address* output = NULL);
 
   bool init(const struct sockaddr* addr);
 
 #ifdef _WIN32
   const struct sockaddr* addr() const { return reinterpret_cast<const struct sockaddr*>(&addr_); }
-  const struct sockaddr_in* addr_in() const { return reinterpret_cast<const struct sockaddr_in*>(&addr_); }
-  const struct sockaddr_in6* addr_in6() const { return reinterpret_cast<const struct sockaddr_in6*>(&addr_); }
+  const struct sockaddr_in* addr_in() const {
+    return reinterpret_cast<const struct sockaddr_in*>(&addr_);
+  }
+  const struct sockaddr_in6* addr_in6() const {
+    return reinterpret_cast<const struct sockaddr_in6*>(&addr_);
+  }
 #else
   const struct sockaddr* addr() const { return &addr_; }
   const struct sockaddr_in* addr_in() const { return &addr_in_; }
@@ -76,15 +78,27 @@ class Address : public Allocated {
   void init(const struct sockaddr_in6* addr);
 
 #ifdef _WIN32
-  struct sockaddr* addr() { return reinterpret_cast<struct sockaddr*>(&addr_); }
-  struct sockaddr_in* addr_in() { return reinterpret_cast<struct sockaddr_in*>(&addr_); }
-  struct sockaddr_in6* addr_in6() { return reinterpret_cast<struct sockaddr_in6*>(&addr_); }
+  struct sockaddr* addr() {
+    return reinterpret_cast<struct sockaddr*>(&addr_);
+  }
+  struct sockaddr_in* addr_in() {
+    return reinterpret_cast<struct sockaddr_in*>(&addr_);
+  }
+  struct sockaddr_in6* addr_in6() {
+    return reinterpret_cast<struct sockaddr_in6*>(&addr_);
+  }
 
   struct sockaddr_storage addr_;
 #else
-  struct sockaddr* addr() { return &addr_; }
-  struct sockaddr_in* addr_in() { return &addr_in_; }
-  struct sockaddr_in6* addr_in6() { return &addr_in6_; }
+  struct sockaddr* addr() {
+    return &addr_;
+  }
+  struct sockaddr_in* addr_in() {
+    return &addr_in_;
+  }
+  struct sockaddr_in6* addr_in6() {
+    return &addr_in6_;
+  }
 
   union {
     struct sockaddr addr_;
@@ -95,13 +109,11 @@ class Address : public Allocated {
 };
 
 struct AddressHash {
-  std::size_t operator()(const cass::Address& a) const {
+  std::size_t operator()(const Address& a) const {
     if (a.family() == AF_INET) {
-      return cass::hash::fnv1a(reinterpret_cast<const char*>(a.addr()),
-                               sizeof(struct sockaddr_in));
+      return hash::fnv1a(reinterpret_cast<const char*>(a.addr()), sizeof(struct sockaddr_in));
     } else if (a.family() == AF_INET6) {
-      return cass::hash::fnv1a(reinterpret_cast<const char*>(a.addr()),
-                               sizeof(struct sockaddr_in6));
+      return hash::fnv1a(reinterpret_cast<const char*>(a.addr()), sizeof(struct sockaddr_in6));
     }
     return 0;
   }
@@ -116,17 +128,11 @@ class AddressSet : public DenseHashSet<Address, AddressHash> {
   }
 };
 
-inline bool operator<(const Address& a, const Address& b) {
-  return a.compare(b) < 0;
-}
+inline bool operator<(const Address& a, const Address& b) { return a.compare(b) < 0; }
 
-inline bool operator==(const Address& a, const Address& b) {
-  return a.compare(b) == 0;
-}
+inline bool operator==(const Address& a, const Address& b) { return a.compare(b) == 0; }
 
-inline bool operator!=(const Address& a, const Address& b) {
-  return a.compare(b) != 0;
-}
+inline bool operator!=(const Address& a, const Address& b) { return a.compare(b) != 0; }
 
 inline std::ostream& operator<<(std::ostream& os, const Address& addr) {
   return os << addr.to_string();
@@ -135,8 +141,7 @@ inline std::ostream& operator<<(std::ostream& os, const Address& addr) {
 inline std::ostream& operator<<(std::ostream& os, const AddressVec& v) {
   os << "[";
   bool first = true;
-  for (AddressVec::const_iterator it = v.begin(),
-       end = v.end(); it != end; ++it) {
+  for (AddressVec::const_iterator it = v.begin(), end = v.end(); it != end; ++it) {
     if (!first) os << ", ";
     first = false;
     os << *it;
@@ -145,13 +150,11 @@ inline std::ostream& operator<<(std::ostream& os, const AddressVec& v) {
   return os;
 }
 
-bool determine_address_for_peer_host(const Address& connected_address,
-                                     const Value* peer_value,
-                                     const Value* rpc_value,
-                                     Address* output);
+bool determine_address_for_peer_host(const Address& connected_address, const Value* peer_value,
+                                     const Value* rpc_value, Address* output);
 
 String determine_listen_address(const Address& address, const Row* row);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/aligned_storage.hpp b/src/aligned_storage.hpp
index 2c9b80f80..dde40051d 100644
--- a/src/aligned_storage.hpp
+++ b/src/aligned_storage.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ALIGNED_STORAGE_HPP_INCLUDED__
-#define __CASS_ALIGNED_STORAGE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ALIGNED_STORAGE_HPP
+#define DATASTAX_INTERNAL_ALIGNED_STORAGE_HPP
 
 #include <stddef.h>
 
@@ -29,22 +29,23 @@
 #error Unsupported compiler!
 #endif
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // This allows for the allocation of memory that is of the same size and
 // alignment as a required by a non-POD, but is represented as a POD type (char).
 // The allows for the memory to be correctly allocated without invoking the
 // constructor.
 
-template<size_t N, size_t A>
+template <size_t N, size_t A>
 class AlignedStorage;
 
 #define ALIGNED_STORAGE(Alignment)                \
-  template<size_t N>                              \
+  template <size_t N>                             \
   class AlignedStorage<N, Alignment> {            \
   public:                                         \
     void* address() { return data_; }             \
     const void* address() const { return data_; } \
+                                                  \
   private:                                        \
     ALIGN_AS(Alignment) char data_[N];            \
   }
@@ -59,7 +60,6 @@ ALIGNED_STORAGE(64);
 
 #undef ALIGNED_STORAGE
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
-
diff --git a/src/allocated.cpp b/src/allocated.cpp
index b2596f469..bbe573123 100644
--- a/src/allocated.cpp
+++ b/src/allocated.cpp
@@ -18,22 +18,12 @@
 #include "memory.hpp"
 #include <new>
 
-namespace cass {
+using namespace datastax::internal;
 
-void* Allocated::operator new(size_t size) {
-  return Memory::malloc(size);
-}
+void* Allocated::operator new(size_t size) { return Memory::malloc(size); }
 
-void* Allocated::operator new[](size_t size) {
-  return Memory::malloc(size);
-}
+void* Allocated::operator new[](size_t size) { return Memory::malloc(size); }
 
-void Allocated::operator delete(void* ptr) {
-  Memory::free(ptr);
-}
+void Allocated::operator delete(void* ptr) { Memory::free(ptr); }
 
-void Allocated::operator delete[](void* ptr) {
-  Memory::free(ptr);
-}
-
-} // namespace cass
+void Allocated::operator delete[](void* ptr) { Memory::free(ptr); }
diff --git a/src/allocated.hpp b/src/allocated.hpp
index 5c318aa83..073dcd76e 100644
--- a/src/allocated.hpp
+++ b/src/allocated.hpp
@@ -14,12 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ALLOCATED_HPP_INCLUDED__
-#define __CASS_ALLOCATED_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ALLOCATED_HPP
+#define DATASTAX_INTERNAL_ALLOCATED_HPP
 
 #include <cstddef>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Allocated {
 public:
@@ -28,14 +28,15 @@ class Allocated {
   void operator delete(void* ptr);
   void operator delete[](void* ptr);
 
-  void* operator new(size_t, void* p)  { return p; }
-  void* operator new[](size_t, void* p)  { return p; }
+  void* operator new(size_t, void* p) { return p; }
+  void* operator new[](size_t, void* p) { return p; }
 };
 
 template <class T>
-struct AllocatedT : public Allocated, public T { };
+struct AllocatedT
+    : public Allocated
+    , public T {};
 
-
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/allocator.hpp b/src/allocator.hpp
index 5c7deed4a..149a011d8 100644
--- a/src/allocator.hpp
+++ b/src/allocator.hpp
@@ -5,14 +5,14 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_ALLOCATOR_HPP_INCLUDED__
-#define __DSE_ALLOCATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ALLOCATOR_HPP
+#define DATASTAX_INTERNAL_ALLOCATOR_HPP
 
 #include "memory.hpp"
 
 #include <limits>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 class Allocator {
@@ -25,45 +25,36 @@ class Allocator {
   typedef T& reference;
   typedef const T& const_reference;
 
-  template <class U> struct rebind { typedef Allocator<U> other; };
+  template <class U>
+  struct rebind {
+    typedef Allocator<U> other;
+  };
 
-  Allocator() { }
+  Allocator() {}
 
-  template<class U>
-  Allocator(const Allocator<U> &) { }
+  template <class U>
+  Allocator(const Allocator<U>&) {}
 
-  bool operator !=(const Allocator&) const { return false; }
-  bool operator ==(const Allocator&) const { return true; }
+  bool operator!=(const Allocator&) const { return false; }
+  bool operator==(const Allocator&) const { return true; }
 
-  pointer address(reference x) const {
-    return &x;
-  }
+  pointer address(reference x) const { return &x; }
 
-  const_pointer address(const_reference x) const {
-    return &x;
-  }
+  const_pointer address(const_reference x) const { return &x; }
 
   pointer allocate(size_type n, const_pointer hint = NULL) {
     return static_cast<pointer>(Memory::malloc(sizeof(T) * n));
   }
 
-  void deallocate(pointer p, size_type n) {
-    Memory::free(p);
-  }
+  void deallocate(pointer p, size_type n) { Memory::free(p); }
 
-  void construct(pointer p, const_reference x) {
-    new (p) value_type(x);
-  }
+  void construct(pointer p, const_reference x) { new (p) value_type(x); }
 
-  void destroy(pointer p) {
-    p->~value_type();
-  }
+  void destroy(pointer p) { p->~value_type(); }
 
-  size_type max_size() const throw() {
-    return std::numeric_limits<size_type>::max();
-  }
+  size_type max_size() const throw() { return std::numeric_limits<size_type>::max(); }
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/async.cpp b/src/async.cpp
index 92c695929..a470e4b1e 100644
--- a/src/async.cpp
+++ b/src/async.cpp
@@ -16,14 +16,12 @@
 
 #include "async.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 Async::Async()
-  : handle_(NULL) { }
+    : handle_(NULL) {}
 
-Async::~Async() {
-  close_handle();
-}
+Async::~Async() { close_handle(); }
 
 int Async::start(uv_loop_t* loop, const Async::Callback& callback) {
   if (handle_ == NULL) {
@@ -60,5 +58,3 @@ void Async::on_async(uv_async_t* handle) {
 void Async::on_close(uv_handle_t* handle) {
   delete reinterpret_cast<AllocatedT<uv_async_t>*>(handle);
 }
-
-} // namespace cass
diff --git a/src/async.hpp b/src/async.hpp
index 5949ece04..4f51dc12c 100644
--- a/src/async.hpp
+++ b/src/async.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ASYNC_HPP_INCLUDED__
-#define __CASS_ASYNC_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ASYNC_HPP
+#define DATASTAX_INTERNAL_ASYNC_HPP
 
 #include "allocated.hpp"
 #include "callback.hpp"
@@ -23,7 +23,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A wrapper for uv_async. This is useful for signaling an event loop that's
@@ -31,7 +31,7 @@ namespace cass {
  */
 class Async {
 public:
-  typedef cass::Callback<void, Async*> Callback;
+  typedef internal::Callback<void, Async*> Callback;
 
   Async();
 
@@ -77,6 +77,6 @@ class Async {
   DISALLOW_COPY_AND_ASSIGN(Async);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/atomic.hpp b/src/atomic.hpp
index c10933239..f501a487a 100644
--- a/src/atomic.hpp
+++ b/src/atomic.hpp
@@ -14,10 +14,10 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ATOMIC_HPP_INCLUDED__
-#define __CASS_ATOMIC_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_HPP
+#define DATASTAX_INTERNAL_ATOMIC_HPP
 
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 
 #if defined(HAVE_BOOST_ATOMIC)
 #include "atomic/atomic_boost.hpp"
@@ -28,4 +28,3 @@
 #endif
 
 #endif
-
diff --git a/src/atomic/atomic_boost.hpp b/src/atomic/atomic_boost.hpp
index 28b8ac85e..4e8096868 100644
--- a/src/atomic/atomic_boost.hpp
+++ b/src/atomic/atomic_boost.hpp
@@ -14,12 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ATOMIC_BOOST_HPP_INCLUDED__
-#define __CASS_ATOMIC_BOOST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_BOOST_HPP
+#define DATASTAX_INTERNAL_ATOMIC_BOOST_HPP
 
 #include <boost/atomic.hpp>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 enum MemoryOrder {
   MEMORY_ORDER_RELAXED = boost::memory_order_relaxed,
@@ -34,7 +34,8 @@ template <class T>
 class Atomic {
 public:
   Atomic() {}
-  explicit Atomic(T value) : value_(value) {}
+  explicit Atomic(T value)
+      : value_(value) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     value_.store(value, static_cast<boost::memory_order>(order));
@@ -56,11 +57,14 @@ class Atomic {
     return value_.exchange(value, static_cast<boost::memory_order>(order));
   }
 
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
-    return value_.compare_exchange_strong(expected, desired, static_cast<boost::memory_order>(order));
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+    return value_.compare_exchange_strong(expected, desired,
+                                          static_cast<boost::memory_order>(order));
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return value_.compare_exchange_weak(expected, desired, static_cast<boost::memory_order>(order));
   }
 
@@ -72,6 +76,6 @@ inline void atomic_thread_fence(MemoryOrder order) {
   boost::atomic_thread_fence(static_cast<boost::memory_order>(order));
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/atomic/atomic_intrinsics.hpp b/src/atomic/atomic_intrinsics.hpp
index 19e243841..331f0571d 100644
--- a/src/atomic/atomic_intrinsics.hpp
+++ b/src/atomic/atomic_intrinsics.hpp
@@ -28,15 +28,15 @@
  * Copyright (c) 2014 Andrey Semashev
  */
 
-#ifndef __CASS_ATOMIC_INTRINSICS_HPP_INCLUDED__
-#define __CASS_ATOMIC_INTRINSICS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_INTRINSICS_HPP
+#define DATASTAX_INTERNAL_ATOMIC_INTRINSICS_HPP
 
 // The slower, intrinsics-based implemenations of Atomic<>.
 
 // Note: Please use the boost::atomic<> or std::atomic<>
 // implementations when possible.
 
-namespace cass {
+namespace datastax { namespace internal {
 
 enum MemoryOrder {
   MEMORY_ORDER_RELAXED = 0,
@@ -47,7 +47,7 @@ enum MemoryOrder {
   MEMORY_ORDER_SEQ_CST = 14 // MEMORY_ORDER_ACQ_REL | 8
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #if defined(__GNUC__)
 #include "atomic_intrinsics_gcc.hpp"
diff --git a/src/atomic/atomic_intrinsics_gcc.hpp b/src/atomic/atomic_intrinsics_gcc.hpp
index cc88fbb9a..19defe6bb 100644
--- a/src/atomic/atomic_intrinsics_gcc.hpp
+++ b/src/atomic/atomic_intrinsics_gcc.hpp
@@ -28,18 +28,19 @@
  * Copyright (c) 2014 Andrey Semashev
  */
 
-#ifndef __CASS_ATOMIC_INTRINSICS_GCC_HPP_INCLUDED__
-#define __CASS_ATOMIC_INTRINSICS_GCC_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_INTRINSICS_GCC_HPP
+#define DATASTAX_INTERNAL_ATOMIC_INTRINSICS_GCC_HPP
 
 #include <assert.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 class Atomic {
 public:
   Atomic() {}
-  explicit Atomic(T value) : value_(value) {}
+  explicit Atomic(T value)
+      : value_(value) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     assert(order != MEMORY_ORDER_ACQUIRE);
@@ -84,18 +85,21 @@ class Atomic {
     return __sync_lock_test_and_set(&value_, value);
 #else
     T before = load(MEMORY_ORDER_RELAXED);
-    while (!compare_exchange_weak(before, before, order)) {}
+    while (!compare_exchange_weak(before, before, order)) {
+    }
     return before;
 #endif
   }
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     T temp_expected = expected;
     T previous = __sync_val_compare_and_swap(&value_, temp_expected, desired);
     expected = previous;
     return previous == temp_expected;
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return compare_exchange_strong(expected, desired, order);
   }
 
@@ -109,6 +113,6 @@ inline void atomic_thread_fence(MemoryOrder order) {
   }
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/atomic/atomic_intrinsics_msvc.hpp b/src/atomic/atomic_intrinsics_msvc.hpp
index 0f7bbbda2..253ed7132 100644
--- a/src/atomic/atomic_intrinsics_msvc.hpp
+++ b/src/atomic/atomic_intrinsics_msvc.hpp
@@ -28,15 +28,15 @@
  * Copyright (c) 2014 Andrey Semashev
  */
 
-#ifndef __CASS_ATOMIC_BASE_MSVC_HPP_INCLUDED__
-#define __CASS_ATOMIC_BASE_MSVC_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_BASE_MSVC_HPP
+#define DATASTAX_INTERNAL_ATOMIC_BASE_MSVC_HPP
 
 #ifndef _WINSOCKAPI_
 #define _WINSOCKAPI_
 #endif
 
 // Windows Server 2003 or higher required to build because
-// Interlocked*64() intrinsics are used. The Boost implementation 
+// Interlocked*64() intrinsics are used. The Boost implementation
 // of Atomic<> may offer better compatibility and performance.
 
 // This is often defined in the Visual Studio project settings
@@ -54,20 +54,19 @@
 
 // 32-bit Windows compilation
 #ifndef _M_X64
-# pragma intrinsic(_InterlockedCompareExchange64)
-# define InterlockedCompareExchange64 _InterlockedCompareExchange64
+#pragma intrinsic(_InterlockedCompareExchange64)
+#define InterlockedCompareExchange64 _InterlockedCompareExchange64
 #endif
 
-namespace cass {
+namespace datastax { namespace internal {
 
 namespace impl {
 
 // copy_cast<> wouldn't work because it would lose
 // the "volatile" qualifier when passed to "memcpy()"
 // and the compiler would error.
-template<typename From, typename To>
-inline To union_cast(const From& from)
-{
+template <typename From, typename To>
+inline To union_cast(const From& from) {
   STATIC_ASSERT(sizeof(From) == sizeof(To));
 
   union {
@@ -87,8 +86,8 @@ struct IsIntegral {
 #define IS_INTEGRAL(Type)           \
   template <>                       \
   struct IsIntegral<Type> {         \
-  static const bool value = true; \
-}
+    static const bool value = true; \
+  }
 
 IS_INTEGRAL(char);
 IS_INTEGRAL(short);
@@ -104,7 +103,7 @@ IS_INTEGRAL(unsigned long long);
 
 #undef IS_INTEGRAL
 
-template <class T, bool IsInt = IsIntegral<T>::value >
+template <class T, bool IsInt = IsIntegral<T>::value>
 struct Classify {
   typedef void Type;
 };
@@ -130,8 +129,8 @@ struct IsSigned;
 #define IS_SIGNED(Type, Value)       \
   template <>                        \
   struct IsSigned<Type> {            \
-  static const bool value = Value; \
-}
+    static const bool value = Value; \
+  }
 
 IS_SIGNED(int, true);
 IS_SIGNED(unsigned int, false);
@@ -142,7 +141,7 @@ IS_SIGNED(unsigned long long, false);
 
 #undef IS_SIGNED
 
-template<size_t Size, bool Signed>
+template <size_t Size, bool Signed>
 struct AtomicImpl;
 
 template <size_t NumBytes, bool Signed>
@@ -151,8 +150,8 @@ struct AtomicStorageType;
 #define ATOMIC_STORAGE_TYPE(NumBytes, Signed, StorageType) \
   template <>                                              \
   struct AtomicStorageType<NumBytes, Signed> {             \
-  typedef StorageType Type;                              \
-}
+    typedef StorageType Type;                              \
+  }
 
 ATOMIC_STORAGE_TYPE(4, true, long);
 ATOMIC_STORAGE_TYPE(4, false, unsigned long);
@@ -180,7 +179,8 @@ struct AtomicImpl<4, Signed> {
 
   static inline bool compare_exchange(volatile Type& storage, Type& expected, Type desired) {
     Type temp_expected = expected;
-    Type previous = static_cast<Type>(InterlockedCompareExchange((long*)&storage, (long)desired, (long)temp_expected));
+    Type previous = static_cast<Type>(
+        InterlockedCompareExchange((long*)&storage, (long)desired, (long)temp_expected));
     expected = previous;
     return (previous == temp_expected);
   }
@@ -195,7 +195,8 @@ struct AtomicImpl<8, Signed> {
     return static_cast<Type>(InterlockedExchangeAdd64((__int64*)&storage, (__int64)value));
 #else
     Type old_value = storage;
-    while(!compare_exchange(storage, old_value, (old_value + value))) {}
+    while (!compare_exchange(storage, old_value, (old_value + value))) {
+    }
     return old_value;
 #endif
   }
@@ -210,14 +211,16 @@ struct AtomicImpl<8, Signed> {
     return static_cast<Type>(InterlockedExchange64((__int64*)&storage, (__int64)value));
 #else
     Type ret = storage;
-    while(!compare_exchange(storage, ret, value)) {}
+    while (!compare_exchange(storage, ret, value)) {
+    }
     return ret;
 #endif
   }
 
   static inline bool compare_exchange(volatile Type& storage, Type& expected, Type desired) {
     Type temp_expected = expected;
-    Type previous = static_cast<Type>(InterlockedCompareExchange64((__int64*)&storage, (__int64)desired, (__int64)temp_expected));
+    Type previous = static_cast<Type>(
+        InterlockedCompareExchange64((__int64*)&storage, (__int64)desired, (__int64)temp_expected));
     expected = previous;
     return (previous == temp_expected);
   }
@@ -230,11 +233,12 @@ class AtomicBase;
 template <class T>
 class AtomicBase<T, void> {
 public:
-  typedef typename impl::AtomicImpl<sizeof(T), false > Impl;
+  typedef typename impl::AtomicImpl<sizeof(T), false> Impl;
   typedef typename Impl::Type ImplType;
 
   AtomicBase() {}
-  explicit AtomicBase(T value) : value_(static_cast<ImplType>(value)) {}
+  explicit AtomicBase(T value)
+      : value_(static_cast<ImplType>(value)) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     assert(order != MEMORY_ORDER_ACQUIRE);
@@ -263,14 +267,16 @@ class AtomicBase<T, void> {
     return static_cast<T>(Impl::exchange(value_, static_cast<ImplType>(value)));
   }
 
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     ImplType temp_expected = static_cast<ImplType>(expected);
     bool result = Impl::compare_exchange(value_, temp_expected, static_cast<ImplType>(desired));
     expected = static_cast<T>(temp_expected);
     return result;
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return compare_exchange_strong(expected, desired, order);
   }
 
@@ -286,7 +292,8 @@ class AtomicBase<T, bool> {
   typedef typename Impl::Type ImplType;
 
   AtomicBase() {}
-  explicit AtomicBase(T value) : value_(cast(value)) {}
+  explicit AtomicBase(T value)
+      : value_(cast(value)) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     assert(order != MEMORY_ORDER_ACQUIRE);
@@ -315,25 +322,23 @@ class AtomicBase<T, bool> {
     return cast(Impl::exchange(value_, cast(value)));
   }
 
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     ImplType temp_expected = cast(expected);
     bool result = Impl::compare_exchange(value_, temp_expected, cast(desired));
     expected = cast(temp_expected);
     return result;
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return compare_exchange_strong(expected, desired, order);
   }
 
 private:
-  static inline bool cast(ImplType value) {
-    return static_cast<ImplType>(value ? 1 : 0);
-  }
+  static inline bool cast(ImplType value) { return static_cast<ImplType>(value ? 1 : 0); }
 
-  static inline ImplType cast(bool value) {
-    return static_cast<T>(value != 0);
-  }
+  static inline ImplType cast(bool value) { return static_cast<T>(value != 0); }
 
   typename ImplType value_;
 };
@@ -342,11 +347,12 @@ class AtomicBase<T, bool> {
 template <class T>
 class AtomicBase<T, int> {
 public:
-  typedef typename impl::AtomicImpl<sizeof(T), impl::IsSigned<T>::value > Impl;
+  typedef typename impl::AtomicImpl<sizeof(T), impl::IsSigned<T>::value> Impl;
   typedef typename Impl::Type ImplType;
 
   AtomicBase() {}
-  explicit AtomicBase(T value) : value_(static_cast<ImplType>(value)) {}
+  explicit AtomicBase(T value)
+      : value_(static_cast<ImplType>(value)) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     assert(order != MEMORY_ORDER_ACQUIRE);
@@ -383,14 +389,16 @@ class AtomicBase<T, int> {
     return static_cast<T>(Impl::exchange(value_, static_cast<ImplType>(value)));
   }
 
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     ImplType temp_expected = static_cast<ImplType>(expected);
     bool result = Impl::compare_exchange(value_, temp_expected, static_cast<ImplType>(desired));
     expected = static_cast<T>(temp_expected);
     return result;
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return compare_exchange_strong(expected, desired, order);
   }
 
@@ -402,11 +410,12 @@ class AtomicBase<T, int> {
 template <class T>
 class AtomicBase<T*, void*> {
 public:
-  typedef typename impl::AtomicImpl<sizeof(T*), false > Impl;
+  typedef typename impl::AtomicImpl<sizeof(T*), false> Impl;
   typedef typename Impl::Type ImplType;
 
   AtomicBase() {}
-  explicit AtomicBase(T* value) : value_(union_cast<T*, ImplType>(value)) {}
+  explicit AtomicBase(T* value)
+      : value_(union_cast<T*, ImplType>(value)) {}
 
   inline void store(T* value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     assert(order != MEMORY_ORDER_ACQUIRE);
@@ -432,17 +441,20 @@ class AtomicBase<T*, void*> {
   }
 
   inline T* exchange(T* value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
-    return union_cast<volatile ImplType, T*>(Impl::exchange(value_, union_cast<T*, ImplType>(value)));
+    return union_cast<volatile ImplType, T*>(
+        Impl::exchange(value_, union_cast<T*, ImplType>(value)));
   }
 
-  inline bool compare_exchange_strong(T*& expected, T* desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_strong(T*& expected, T* desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     ImplType temp_expected = union_cast<T*, ImplType>(expected);
     bool result = Impl::compare_exchange(value_, temp_expected, union_cast<T*, ImplType>(desired));
     expected = union_cast<volatile ImplType, T*>(temp_expected);
     return result;
   }
 
-  inline bool compare_exchange_weak(T*& expected, T* desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
+  inline bool compare_exchange_weak(T*& expected, T* desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) volatile {
     return compare_exchange_strong(expected, desired, order);
   }
 
@@ -457,7 +469,7 @@ class Atomic : public impl::AtomicBase<T, typename impl::Classify<T>::Type> {
 public:
   Atomic() {}
   explicit Atomic(T value)
-    : AtomicBase(value) {}
+      : AtomicBase(value) {}
 };
 
 inline void atomic_thread_fence(MemoryOrder order) {
@@ -469,6 +481,6 @@ inline void atomic_thread_fence(MemoryOrder order) {
   _ReadWriteBarrier();
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/atomic/atomic_std.hpp b/src/atomic/atomic_std.hpp
index 4920c8a2d..2ad01034e 100644
--- a/src/atomic/atomic_std.hpp
+++ b/src/atomic/atomic_std.hpp
@@ -14,12 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ATOMIC_STD_HPP_INCLUDED__
-#define __CASS_ATOMIC_STD_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ATOMIC_STD_HPP
+#define DATASTAX_INTERNAL_ATOMIC_STD_HPP
 
 #include <atomic>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 enum MemoryOrder {
   MEMORY_ORDER_RELAXED = std::memory_order_relaxed,
@@ -34,7 +34,8 @@ template <class T>
 class Atomic {
 public:
   Atomic() {}
-  explicit Atomic(T value) : value_(value) {}
+  explicit Atomic(T value)
+      : value_(value) {}
 
   inline void store(T value, MemoryOrder order = MEMORY_ORDER_SEQ_CST) {
     value_.store(value, static_cast<std::memory_order>(order));
@@ -56,11 +57,13 @@ class Atomic {
     return value_.exchange(value, static_cast<std::memory_order>(order));
   }
 
-  inline bool compare_exchange_strong(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) {
+  inline bool compare_exchange_strong(T& expected, T desired,
+                                      MemoryOrder order = MEMORY_ORDER_SEQ_CST) {
     return value_.compare_exchange_strong(expected, desired, static_cast<std::memory_order>(order));
   }
 
-  inline bool compare_exchange_weak(T& expected, T desired, MemoryOrder order = MEMORY_ORDER_SEQ_CST) {
+  inline bool compare_exchange_weak(T& expected, T desired,
+                                    MemoryOrder order = MEMORY_ORDER_SEQ_CST) {
     return value_.compare_exchange_weak(expected, desired, static_cast<std::memory_order>(order));
   }
 
@@ -72,6 +75,6 @@ inline void atomic_thread_fence(MemoryOrder order) {
   std::atomic_thread_fence(static_cast<std::memory_order>(order));
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/auth.cpp b/src/auth.cpp
index 6dbc92b01..6d352b7cf 100644
--- a/src/auth.cpp
+++ b/src/auth.cpp
@@ -22,35 +22,33 @@
 
 #include <algorithm>
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-void cass_authenticator_address(const CassAuthenticator* auth,
-                                CassInet* address) {
+void cass_authenticator_address(const CassAuthenticator* auth, CassInet* address) {
   address->address_length = auth->address().to_inet(address->address);
 }
 
-const char* cass_authenticator_hostname(const CassAuthenticator* auth,
-                                        size_t* length) {
+const char* cass_authenticator_hostname(const CassAuthenticator* auth, size_t* length) {
   if (length != NULL) *length = auth->hostname().length();
   return auth->hostname().c_str();
 }
 
-const char* cass_authenticator_class_name(const CassAuthenticator* auth,
-                                          size_t* length) {
+const char* cass_authenticator_class_name(const CassAuthenticator* auth, size_t* length) {
   if (length != NULL) *length = auth->class_name().length();
   return auth->class_name().c_str();
 }
 
-void* cass_authenticator_exchange_data(CassAuthenticator* auth) {
-  return auth->exchange_data();
-}
+void* cass_authenticator_exchange_data(CassAuthenticator* auth) { return auth->exchange_data(); }
 
 void cass_authenticator_set_exchange_data(CassAuthenticator* auth, void* exchange_data) {
   auth->set_exchange_data(exchange_data);
 }
 
 char* cass_authenticator_response(CassAuthenticator* auth, size_t size) {
-  cass::String* response = auth->response();
+  String* response = auth->response();
 
   if (response != NULL) {
     response->resize(size, 0);
@@ -60,27 +58,24 @@ char* cass_authenticator_response(CassAuthenticator* auth, size_t size) {
   return NULL;
 }
 
-void cass_authenticator_set_response(CassAuthenticator* auth,
-                                     const char* response, size_t response_size) {
+void cass_authenticator_set_response(CassAuthenticator* auth, const char* response,
+                                     size_t response_size) {
   if (auth->response() != NULL) {
     auth->response()->assign(response, response_size);
   }
 }
 
-void cass_authenticator_set_error(CassAuthenticator* auth,
-                                  const char* message) {
+void cass_authenticator_set_error(CassAuthenticator* auth, const char* message) {
   cass_authenticator_set_error_n(auth, message, SAFE_STRLEN(message));
 }
 
-void cass_authenticator_set_error_n(CassAuthenticator* auth,
-                                    const char* message, size_t message_length) {
-  auth->set_error(cass::String(message, message_length));
+void cass_authenticator_set_error_n(CassAuthenticator* auth, const char* message,
+                                    size_t message_length) {
+  auth->set_error(String(message, message_length));
 }
 
 } // extern "C"
 
-namespace cass {
-
 bool PlainTextAuthenticator::initial_response(String* response) {
   response->reserve(username_.size() + password_.size() + 2);
   response->push_back(0);
@@ -100,18 +95,17 @@ bool PlainTextAuthenticator::success(const String& token) {
   return true;
 }
 
-ExternalAuthenticator::ExternalAuthenticator(const Address& address,
-                                             const String& hostname,
+ExternalAuthenticator::ExternalAuthenticator(const Address& address, const String& hostname,
                                              const String& class_name,
                                              const CassAuthenticatorCallbacks* callbacks,
                                              void* data)
-  : address_(address)
-  , hostname_(hostname)
-  , class_name_(class_name)
-  , response_(NULL)
-  , callbacks_(callbacks)
-  , data_(data)
-  , exchange_data_(NULL) { }
+    : address_(address)
+    , hostname_(hostname)
+    , class_name_(class_name)
+    , response_(NULL)
+    , callbacks_(callbacks)
+    , data_(data)
+    , exchange_data_(NULL) {}
 
 ExternalAuthenticator::~ExternalAuthenticator() {
   response_ = NULL;
@@ -136,8 +130,7 @@ bool ExternalAuthenticator::evaluate_challenge(const String& token, String* resp
   }
   response_ = response;
   error_.clear();
-  callbacks_->challenge_callback(CassAuthenticator::to(this), data_,
-                                 token.data(), token.size());
+  callbacks_->challenge_callback(CassAuthenticator::to(this), data_, token.data(), token.size());
   return error_.empty();
 }
 
@@ -147,9 +140,6 @@ bool ExternalAuthenticator::success(const String& token) {
   }
   response_ = NULL;
   error_.clear();
-  callbacks_->success_callback(CassAuthenticator::to(this), data_,
-                               token.data(), token.size());
+  callbacks_->success_callback(CassAuthenticator::to(this), data_, token.data(), token.size());
   return error_.empty();
 }
-
-} // namespace cass
diff --git a/src/auth.hpp b/src/auth.hpp
index d94b2521e..3f6f4a4d0 100644
--- a/src/auth.hpp
+++ b/src/auth.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_AUTH_HPP_INCLUDED__
-#define __CASS_AUTH_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_AUTH_HPP
+#define DATASTAX_INTERNAL_AUTH_HPP
 
 #include "buffer.hpp"
 #include "external.hpp"
@@ -25,14 +25,14 @@
 #include "ref_counted.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Authenticator : public RefCounted<Authenticator> {
 public:
   typedef SharedRefPtr<Authenticator> Ptr;
 
-  Authenticator() { }
-  virtual ~Authenticator() { }
+  Authenticator() {}
+  virtual ~Authenticator() {}
 
   const String& error() { return error_; }
   void set_error(const String& error) { error_ = error; }
@@ -50,10 +50,9 @@ class Authenticator : public RefCounted<Authenticator> {
 
 class PlainTextAuthenticator : public Authenticator {
 public:
-  PlainTextAuthenticator(const String& username,
-                         const String& password)
-    : username_(username)
-    , password_(password) { }
+  PlainTextAuthenticator(const String& username, const String& password)
+      : username_(username)
+      , password_(password) {}
 
   virtual bool initial_response(String* response);
   virtual bool evaluate_challenge(const String& token, String* response);
@@ -69,13 +68,12 @@ class AuthProvider : public RefCounted<AuthProvider> {
   typedef SharedRefPtr<AuthProvider> Ptr;
 
   AuthProvider(const String& name = "")
-    : RefCounted<AuthProvider>()
-    , name_(name) { }
+      : RefCounted<AuthProvider>()
+      , name_(name) {}
 
-  virtual ~AuthProvider() { }
+  virtual ~AuthProvider() {}
 
-  virtual Authenticator::Ptr new_authenticator(const Address& address,
-                                               const String& hostname,
+  virtual Authenticator::Ptr new_authenticator(const Address& address, const String& hostname,
                                                const String& class_name) const {
     return Authenticator::Ptr();
   }
@@ -93,8 +91,7 @@ class AuthProvider : public RefCounted<AuthProvider> {
 
 class ExternalAuthenticator : public Authenticator {
 public:
-  ExternalAuthenticator(const Address& address, const String& hostname,
-                        const String& class_name,
+  ExternalAuthenticator(const Address& address, const String& hostname, const String& class_name,
                         const CassAuthenticatorCallbacks* callbacks, void* data);
 
   ~ExternalAuthenticator();
@@ -126,12 +123,11 @@ class ExternalAuthenticator : public Authenticator {
 class ExternalAuthProvider : public AuthProvider {
 public:
   ExternalAuthProvider(const CassAuthenticatorCallbacks* exchange_callbacks,
-                       CassAuthenticatorDataCleanupCallback cleanup_callback,
-                       void* data)
-    : AuthProvider("ExternalAuthProvider")
-    , exchange_callbacks_(*exchange_callbacks)
-    , cleanup_callback_(cleanup_callback)
-    , data_(data) { }
+                       CassAuthenticatorDataCleanupCallback cleanup_callback, void* data)
+      : AuthProvider("ExternalAuthProvider")
+      , exchange_callbacks_(*exchange_callbacks)
+      , cleanup_callback_(cleanup_callback)
+      , data_(data) {}
 
   ~ExternalAuthProvider() {
     if (cleanup_callback_ != NULL) {
@@ -139,14 +135,10 @@ class ExternalAuthProvider : public AuthProvider {
     }
   }
 
-  virtual Authenticator::Ptr new_authenticator(const Address& address,
-                                               const String& hostname,
+  virtual Authenticator::Ptr new_authenticator(const Address& address, const String& hostname,
                                                const String& class_name) const {
-    return Authenticator::Ptr(new ExternalAuthenticator(address,
-                                                        hostname,
-                                                        class_name,
-                                                        &exchange_callbacks_,
-                                                        data_));
+    return Authenticator::Ptr(
+        new ExternalAuthenticator(address, hostname, class_name, &exchange_callbacks_, data_));
   }
 
 private:
@@ -157,14 +149,12 @@ class ExternalAuthProvider : public AuthProvider {
 
 class PlainTextAuthProvider : public AuthProvider {
 public:
-  PlainTextAuthProvider(const String& username,
-                        const String& password)
-    : AuthProvider("PlainTextAuthProvider")
-    , username_(username)
-    , password_(password) { }
-
-  virtual Authenticator::Ptr new_authenticator(const Address& address,
-                                               const String& hostname,
+  PlainTextAuthProvider(const String& username, const String& password)
+      : AuthProvider("PlainTextAuthProvider")
+      , username_(username)
+      , password_(password) {}
+
+  virtual Authenticator::Ptr new_authenticator(const Address& address, const String& hostname,
                                                const String& class_name) const {
     return Authenticator::Ptr(new PlainTextAuthenticator(username_, password_));
   }
@@ -174,8 +164,8 @@ class PlainTextAuthProvider : public AuthProvider {
   String password_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::ExternalAuthenticator, CassAuthenticator)
+EXTERNAL_TYPE(datastax::internal::core::ExternalAuthenticator, CassAuthenticator)
 
 #endif
diff --git a/src/auth_requests.cpp b/src/auth_requests.cpp
index 4d28e763b..55123d493 100644
--- a/src/auth_requests.cpp
+++ b/src/auth_requests.cpp
@@ -16,9 +16,10 @@
 
 #include "auth_requests.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
-int AuthResponseRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int AuthResponseRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                                BufferVec* bufs) const {
   // <token> [bytes]
   size_t length = sizeof(int32_t) + token_.size();
 
@@ -28,5 +29,3 @@ int AuthResponseRequest::encode(ProtocolVersion version, RequestCallback* callba
 
   return length;
 }
-
-} // namespace cass
diff --git a/src/auth_requests.hpp b/src/auth_requests.hpp
index 69a47867b..586b59145 100644
--- a/src/auth_requests.hpp
+++ b/src/auth_requests.hpp
@@ -14,23 +14,22 @@
   limitations under the License.
 */
 
-#ifndef __CASS_AUTH_REQUESTS_HPP_INCLUDED__
-#define __CASS_AUTH_REQUESTS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_AUTH_REQUESTS_HPP
+#define DATASTAX_INTERNAL_AUTH_REQUESTS_HPP
 
 #include "auth.hpp"
 #include "constants.hpp"
 #include "ref_counted.hpp"
 #include "request.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class AuthResponseRequest : public Request {
 public:
-  AuthResponseRequest(const String& token,
-                      const Authenticator::Ptr& auth)
-    : Request(CQL_OPCODE_AUTH_RESPONSE)
-    , token_(token)
-    , auth_(auth) { }
+  AuthResponseRequest(const String& token, const Authenticator::Ptr& auth)
+      : Request(CQL_OPCODE_AUTH_RESPONSE)
+      , token_(token)
+      , auth_(auth) {}
 
   const Authenticator::Ptr& auth() const { return auth_; }
 
@@ -42,6 +41,6 @@ class AuthResponseRequest : public Request {
   Authenticator::Ptr auth_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/auth_responses.cpp b/src/auth_responses.cpp
index 542cefe07..5df0d896b 100644
--- a/src/auth_responses.cpp
+++ b/src/auth_responses.cpp
@@ -18,7 +18,7 @@
 
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool AuthenticateResponse::decode(Decoder& decoder) {
   decoder.set_type("authentication");
@@ -30,7 +30,7 @@ bool AuthenticateResponse::decode(Decoder& decoder) {
   return true;
 }
 
-bool cass::AuthChallengeResponse::decode(Decoder& decoder) {
+bool AuthChallengeResponse::decode(Decoder& decoder) {
   decoder.set_type("authentication challenge");
   StringRef token;
 
@@ -40,7 +40,7 @@ bool cass::AuthChallengeResponse::decode(Decoder& decoder) {
   return true;
 }
 
-bool cass::AuthSuccessResponse::decode(Decoder& decoder) {
+bool AuthSuccessResponse::decode(Decoder& decoder) {
   decoder.set_type("authentication success");
   StringRef token;
 
@@ -49,5 +49,3 @@ bool cass::AuthSuccessResponse::decode(Decoder& decoder) {
   decoder.maybe_log_remaining();
   return true;
 }
-
-} // namespace cass
diff --git a/src/auth_responses.hpp b/src/auth_responses.hpp
index 63980d92e..0a9fa8ab0 100644
--- a/src/auth_responses.hpp
+++ b/src/auth_responses.hpp
@@ -14,20 +14,20 @@
   limitations under the License.
 */
 
-#ifndef __CASS_AUTH_RESPONSES_HPP_INCLUDED__
-#define __CASS_AUTH_RESPONSES_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_AUTH_RESPONSES_HPP
+#define DATASTAX_INTERNAL_AUTH_RESPONSES_HPP
 
 #include "constants.hpp"
 #include "response.hpp"
 #include "string.hpp"
 #include "string_ref.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class AuthenticateResponse : public Response {
 public:
   AuthenticateResponse()
-    : Response(CQL_OPCODE_AUTHENTICATE) { }
+      : Response(CQL_OPCODE_AUTHENTICATE) {}
 
   const String& class_name() const { return class_name_; }
 
@@ -40,7 +40,7 @@ class AuthenticateResponse : public Response {
 class AuthChallengeResponse : public Response {
 public:
   AuthChallengeResponse()
-    : Response(CQL_OPCODE_AUTH_CHALLENGE) { }
+      : Response(CQL_OPCODE_AUTH_CHALLENGE) {}
 
   const String& token() const { return token_; }
 
@@ -53,7 +53,7 @@ class AuthChallengeResponse : public Response {
 class AuthSuccessResponse : public Response {
 public:
   AuthSuccessResponse()
-    : Response(CQL_OPCODE_AUTH_SUCCESS) { }
+      : Response(CQL_OPCODE_AUTH_SUCCESS) {}
 
   const String& token() const { return token_; }
 
@@ -63,6 +63,6 @@ class AuthSuccessResponse : public Response {
   String token_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/batch_request.cpp b/src/batch_request.cpp
index 29345596f..ce21cd157 100644
--- a/src/batch_request.cpp
+++ b/src/batch_request.cpp
@@ -24,73 +24,65 @@
 #include "serialization.hpp"
 #include "statement.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassBatch* cass_batch_new(CassBatchType type) {
-  cass::BatchRequest* batch = new cass::BatchRequest(type);
+  BatchRequest* batch = new BatchRequest(type);
   batch->inc_ref();
   return CassBatch::to(batch);
 }
 
-void cass_batch_free(CassBatch* batch) {
-  batch->dec_ref();
-}
+void cass_batch_free(CassBatch* batch) { batch->dec_ref(); }
 
 CassError cass_batch_set_keyspace(CassBatch* batch, const char* keyspace) {
   return cass_batch_set_keyspace_n(batch, keyspace, SAFE_STRLEN(keyspace));
 }
 
-CassError cass_batch_set_keyspace_n(CassBatch* batch,
-                                    const char* keyspace,
+CassError cass_batch_set_keyspace_n(CassBatch* batch, const char* keyspace,
                                     size_t keyspace_length) {
-  batch->set_keyspace(cass::String(keyspace, keyspace_length));
+  batch->set_keyspace(String(keyspace, keyspace_length));
   return CASS_OK;
 }
 
-CassError cass_batch_set_consistency(CassBatch* batch,
-                                     CassConsistency consistency) {
+CassError cass_batch_set_consistency(CassBatch* batch, CassConsistency consistency) {
   batch->set_consistency(consistency);
   return CASS_OK;
 }
 
-CassError cass_batch_set_serial_consistency(CassBatch* batch,
-                                            CassConsistency serial_consistency) {
+CassError cass_batch_set_serial_consistency(CassBatch* batch, CassConsistency serial_consistency) {
   batch->set_serial_consistency(serial_consistency);
   return CASS_OK;
 }
 
-CassError cass_batch_set_timestamp(CassBatch* batch,
-                                   cass_int64_t timestamp) {
+CassError cass_batch_set_timestamp(CassBatch* batch, cass_int64_t timestamp) {
   batch->set_timestamp(timestamp);
   return CASS_OK;
 }
 
-CassError cass_batch_set_request_timeout(CassBatch *batch,
-                                         cass_uint64_t timeout_ms) {
+CassError cass_batch_set_request_timeout(CassBatch* batch, cass_uint64_t timeout_ms) {
   batch->set_request_timeout_ms(timeout_ms);
   return CASS_OK;
 }
 
-CassError cass_batch_set_is_idempotent(CassBatch* batch,
-                                       cass_bool_t is_idempotent) {
+CassError cass_batch_set_is_idempotent(CassBatch* batch, cass_bool_t is_idempotent) {
   batch->set_is_idempotent(is_idempotent == cass_true);
   return CASS_OK;
 }
 
-CassError cass_batch_set_retry_policy(CassBatch* batch,
-                                      CassRetryPolicy* retry_policy) {
+CassError cass_batch_set_retry_policy(CassBatch* batch, CassRetryPolicy* retry_policy) {
   batch->set_retry_policy(retry_policy);
   return CASS_OK;
 }
 
-CassError cass_batch_set_custom_payload(CassBatch* batch,
-                                        const CassCustomPayload* payload) {
+CassError cass_batch_set_custom_payload(CassBatch* batch, const CassCustomPayload* payload) {
   batch->set_custom_payload(payload);
   return CASS_OK;
 }
 
-CassError cass_batch_set_tracing(CassBatch* batch,
-                                 cass_bool_t enabled) {
+CassError cass_batch_set_tracing(CassBatch* batch, cass_bool_t enabled) {
   batch->set_tracing(enabled == cass_true);
   return CASS_OK;
 }
@@ -100,28 +92,22 @@ CassError cass_batch_add_statement(CassBatch* batch, CassStatement* statement) {
   return CASS_OK;
 }
 
-CassError cass_batch_set_execution_profile(CassBatch* batch,
-                                           const char* name) {
-  return cass_batch_set_execution_profile_n(batch,
-                                            name,
-                                            SAFE_STRLEN(name));
+CassError cass_batch_set_execution_profile(CassBatch* batch, const char* name) {
+  return cass_batch_set_execution_profile_n(batch, name, SAFE_STRLEN(name));
 }
 
-CassError cass_batch_set_execution_profile_n(CassBatch* batch,
-                                             const char* name,
+CassError cass_batch_set_execution_profile_n(CassBatch* batch, const char* name,
                                              size_t name_length) {
   if (name_length > 0) {
-    batch->set_execution_profile_name(cass::String(name, name_length));
+    batch->set_execution_profile_name(String(name, name_length));
   } else {
-    batch->set_execution_profile_name(cass::String());
+    batch->set_execution_profile_name(String());
   }
   return CASS_OK;
 }
 
 } // extern "C"
 
-namespace cass {
-
 // Format: <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>]
 // where:
 // <type> is a [byte]
@@ -132,7 +118,8 @@ namespace cass {
 // <flags> is a [byte] (or [int] for protocol v5)
 // <serial_consistency> is a [short]
 // <timestamp> is a [long]
-int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                         BufferVec* bufs) const {
   int length = 0;
   uint32_t flags = 0;
 
@@ -149,12 +136,12 @@ int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback, Buf
     length += buf_size;
   }
 
-  for (BatchRequest::StatementVec::const_iterator i = statements_.begin(),
-       end = statements_.end(); i != end; ++i) {
+  for (BatchRequest::StatementVec::const_iterator i = statements_.begin(), end = statements_.end();
+       i != end; ++i) {
     const Statement::Ptr& statement(*i);
     if (statement->has_names_for_values()) {
       callback->on_error(CASS_ERROR_LIB_BAD_PARAMS,
-                        "Batches cannot contain queries with named values");
+                         "Batches cannot contain queries with named values");
       return REQUEST_ERROR_BATCH_WITH_NAMED_VALUES;
     }
     int32_t result = statement->encode_batch(version, callback, bufs);
@@ -228,8 +215,8 @@ void BatchRequest::add_statement(Statement* statement) {
 }
 
 bool BatchRequest::find_prepared_query(const String& id, String* query) const {
-  for (StatementVec::const_iterator it = statements_.begin(),
-       end = statements_.end(); it != end; ++it) {
+  for (StatementVec::const_iterator it = statements_.begin(), end = statements_.end(); it != end;
+       ++it) {
     const Statement::Ptr& statement(*it);
     if (statement->kind() == CASS_BATCH_KIND_PREPARED) {
       ExecuteRequest* execute_request = static_cast<ExecuteRequest*>(statement.get());
@@ -243,13 +230,11 @@ bool BatchRequest::find_prepared_query(const String& id, String* query) const {
 }
 
 bool BatchRequest::get_routing_key(String* routing_key) const {
-  for (BatchRequest::StatementVec::const_iterator i = statements_.begin();
-       i != statements_.end(); ++i) {
+  for (BatchRequest::StatementVec::const_iterator i = statements_.begin(); i != statements_.end();
+       ++i) {
     if ((*i)->get_routing_key(routing_key)) {
       return true;
     }
   }
   return false;
 }
-
-} // namespace cass
diff --git a/src/batch_request.hpp b/src/batch_request.hpp
index b139c2884..efeff0f4c 100644
--- a/src/batch_request.hpp
+++ b/src/batch_request.hpp
@@ -14,20 +14,20 @@
   limitations under the License.
 */
 
-#ifndef __CASS_BATCH_REQUEST_HPP_INCLUDED__
-#define __CASS_BATCH_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_BATCH_REQUEST_HPP
+#define DATASTAX_INTERNAL_BATCH_REQUEST_HPP
 
 #include "cassandra.h"
 #include "constants.hpp"
 #include "external.hpp"
 #include "map.hpp"
-#include "request.hpp"
 #include "ref_counted.hpp"
+#include "request.hpp"
 #include "statement.hpp"
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ExecuteRequest;
 
@@ -37,7 +37,7 @@ class BatchRequest : public RoutableRequest {
 
   BatchRequest(uint8_t type_)
       : RoutableRequest(CQL_OPCODE_BATCH)
-      , type_(type_) { }
+      , type_(type_) {}
 
   uint8_t type() const { return type_; }
 
@@ -57,8 +57,8 @@ class BatchRequest : public RoutableRequest {
   StatementVec statements_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::BatchRequest, CassBatch)
+EXTERNAL_TYPE(datastax::internal::core::BatchRequest, CassBatch)
 
 #endif
diff --git a/src/blacklist_dc_policy.cpp b/src/blacklist_dc_policy.cpp
index a05dcf022..9f3d615c5 100644
--- a/src/blacklist_dc_policy.cpp
+++ b/src/blacklist_dc_policy.cpp
@@ -16,17 +16,14 @@
 
 #include "blacklist_dc_policy.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool BlacklistDCPolicy::is_valid_host(const Host::Ptr& host) const {
   const String& host_dc = host->dc();
-  for (DcList::const_iterator it = dcs_.begin(),
-      end = dcs_.end(); it != end; ++it) {
+  for (DcList::const_iterator it = dcs_.begin(), end = dcs_.end(); it != end; ++it) {
     if (host_dc.compare(*it) == 0) {
       return false;
     }
   }
   return true;
 }
-
-} // namespace cass
diff --git a/src/blacklist_dc_policy.hpp b/src/blacklist_dc_policy.hpp
index 42774b067..29747622a 100644
--- a/src/blacklist_dc_policy.hpp
+++ b/src/blacklist_dc_policy.hpp
@@ -14,22 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_BLACKLIST_DC_POLICY_HPP_INCLUDED__
-#define __CASS_BLACKLIST_DC_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_BLACKLIST_DC_POLICY_HPP
+#define DATASTAX_INTERNAL_BLACKLIST_DC_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
-#include "scoped_ptr.hpp"
 #include "list_policy.hpp"
+#include "load_balancing.hpp"
+#include "scoped_ptr.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class BlacklistDCPolicy : public ListPolicy {
 public:
-  BlacklistDCPolicy(LoadBalancingPolicy* child_policy,
-                    const DcList& dcs)
-    : ListPolicy(child_policy)
-    , dcs_(dcs) {}
+  BlacklistDCPolicy(LoadBalancingPolicy* child_policy, const DcList& dcs)
+      : ListPolicy(child_policy)
+      , dcs_(dcs) {}
 
   virtual ~BlacklistDCPolicy() {}
 
@@ -46,6 +45,6 @@ class BlacklistDCPolicy : public ListPolicy {
   DISALLOW_COPY_AND_ASSIGN(BlacklistDCPolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/blacklist_policy.cpp b/src/blacklist_policy.cpp
index 90f5c2531..c2e0d5aa0 100644
--- a/src/blacklist_policy.cpp
+++ b/src/blacklist_policy.cpp
@@ -16,18 +16,14 @@
 
 #include "blacklist_policy.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool BlacklistPolicy::is_valid_host(const Host::Ptr& host) const {
   const String& host_address = host->address().to_string(false);
-  for (ContactPointList::const_iterator it = hosts_.begin(),
-                                                end = hosts_.end();
-       it != end; ++it) {
+  for (ContactPointList::const_iterator it = hosts_.begin(), end = hosts_.end(); it != end; ++it) {
     if (host_address.compare(*it) == 0) {
       return false;
     }
   }
   return true;
 }
-
-} // namespace cass
diff --git a/src/blacklist_policy.hpp b/src/blacklist_policy.hpp
index 545a32a99..eeb03c303 100644
--- a/src/blacklist_policy.hpp
+++ b/src/blacklist_policy.hpp
@@ -14,22 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_BLACKLIST_POLICY_HPP_INCLUDED__
-#define __CASS_BLACKLIST_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_BLACKLIST_POLICY_HPP
+#define DATASTAX_INTERNAL_BLACKLIST_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
-#include "scoped_ptr.hpp"
 #include "list_policy.hpp"
+#include "load_balancing.hpp"
+#include "scoped_ptr.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class BlacklistPolicy : public ListPolicy {
 public:
-  BlacklistPolicy(LoadBalancingPolicy* child_policy,
-                  const ContactPointList& hosts)
-    : ListPolicy(child_policy)
-    , hosts_ (hosts) {}
+  BlacklistPolicy(LoadBalancingPolicy* child_policy, const ContactPointList& hosts)
+      : ListPolicy(child_policy)
+      , hosts_(hosts) {}
 
   virtual ~BlacklistPolicy() {}
 
@@ -46,6 +45,6 @@ class BlacklistPolicy : public ListPolicy {
   DISALLOW_COPY_AND_ASSIGN(BlacklistPolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/buffer.hpp b/src/buffer.hpp
index e4c4e124e..ba5534ee9 100644
--- a/src/buffer.hpp
+++ b/src/buffer.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_BUFFER_HPP_INCLUDED__
-#define __CASS_BUFFER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_BUFFER_HPP
+#define DATASTAX_INTERNAL_BUFFER_HPP
 
 #include "ref_counted.hpp"
 #include "serialization.hpp"
@@ -23,28 +23,27 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Buffer {
 public:
   Buffer()
-    : size_(0) { }
+      : size_(0) {}
 
   Buffer(const char* data, size_t size)
-    : size_(size) {
+      : size_(size) {
     if (size > FIXED_BUFFER_SIZE) {
       RefBuffer* buffer = RefBuffer::create(size);
       buffer->inc_ref();
       memcpy(buffer->data(), data, size);
       data_.buffer = buffer;
-    } else if (size > 0){
+    } else if (size > 0) {
       memcpy(data_.fixed, data, size);
     }
   }
 
-  explicit
-  Buffer(size_t size)
-    : size_(size) {
+  explicit Buffer(size_t size)
+      : size_(size) {
     if (size > FIXED_BUFFER_SIZE) {
       RefBuffer* buffer = RefBuffer::create(size);
       buffer->inc_ref();
@@ -53,7 +52,7 @@ class Buffer {
   }
 
   Buffer(const Buffer& buf)
-    : size_(0) {
+      : size_(0) {
     copy(buf);
   }
 
@@ -70,55 +69,55 @@ class Buffer {
 
   size_t encode_byte(size_t offset, uint8_t value) {
     assert(offset + sizeof(uint8_t) <= static_cast<size_t>(size_));
-    cass::encode_byte(data() + offset, value);
+    internal::encode_byte(data() + offset, value);
     return offset + sizeof(uint8_t);
   }
 
   size_t encode_int8(size_t offset, int8_t value) {
     assert(offset + sizeof(int8_t) <= static_cast<size_t>(size_));
-    cass::encode_int8(data() + offset, value);
+    internal::encode_int8(data() + offset, value);
     return offset + sizeof(int8_t);
   }
 
   size_t encode_int16(size_t offset, int16_t value) {
     assert(offset + sizeof(int16_t) <= static_cast<size_t>(size_));
-    cass::encode_int16(data() + offset, value);
+    internal::encode_int16(data() + offset, value);
     return offset + sizeof(int16_t);
   }
 
   size_t encode_uint16(size_t offset, uint16_t value) {
     assert(offset + sizeof(uint16_t) <= static_cast<size_t>(size_));
-    cass::encode_uint16(data() + offset, value);
+    internal::encode_uint16(data() + offset, value);
     return offset + sizeof(uint16_t);
   }
 
   size_t encode_int32(size_t offset, int32_t value) {
     assert(offset + sizeof(int32_t) <= static_cast<size_t>(size_));
-    cass::encode_int32(data() + offset, value);
+    internal::encode_int32(data() + offset, value);
     return offset + sizeof(int32_t);
   }
 
   size_t encode_uint32(size_t offset, uint32_t value) {
     assert(offset + sizeof(uint32_t) <= static_cast<size_t>(size_));
-    cass::encode_uint32(data() + offset, value);
+    internal::encode_uint32(data() + offset, value);
     return offset + sizeof(uint32_t);
   }
 
   size_t encode_int64(size_t offset, int64_t value) {
     assert(offset + sizeof(int64_t) <= static_cast<size_t>(size_));
-    cass::encode_int64(data() + offset, value);
+    internal::encode_int64(data() + offset, value);
     return offset + sizeof(int64_t);
   }
 
   size_t encode_float(size_t offset, float value) {
     assert(offset + sizeof(float) <= static_cast<size_t>(size_));
-    cass::encode_float(data() + offset, value);
+    internal::encode_float(data() + offset, value);
     return offset + sizeof(float);
   }
 
   size_t encode_double(size_t offset, double value) {
     assert(offset + sizeof(double) <= static_cast<size_t>(size_));
-    cass::encode_double(data() + offset, value);
+    internal::encode_double(data() + offset, value);
     return offset + sizeof(double);
   }
 
@@ -142,8 +141,7 @@ class Buffer {
 
   size_t encode_string_list(size_t offset, const Vector<String>& value) {
     size_t pos = encode_uint16(offset, static_cast<uint16_t>(value.size()));
-    for (Vector<String>::const_iterator it = value.begin(),
-         end = value.end(); it != end; ++it) {
+    for (Vector<String>::const_iterator it = value.begin(), end = value.end(); it != end; ++it) {
       pos = encode_string(pos, it->data(), static_cast<uint16_t>(it->size()));
     }
     return pos;
@@ -151,8 +149,7 @@ class Buffer {
 
   size_t encode_string_map(size_t offset, const Map<String, String>& value) {
     size_t pos = encode_uint16(offset, static_cast<uint16_t>(value.size()));
-    for (Map<String, String>::const_iterator it = value.begin();
-         it != value.end(); ++it) {
+    for (Map<String, String>::const_iterator it = value.begin(); it != value.end(); ++it) {
       pos = encode_string(pos, it->first.c_str(), static_cast<uint16_t>(it->first.size()));
       pos = encode_string(pos, it->second.c_str(), static_cast<uint16_t>(it->second.size()));
     }
@@ -161,7 +158,7 @@ class Buffer {
 
   size_t encode_uuid(size_t offset, CassUuid value) {
     assert(offset + sizeof(CassUuid) <= static_cast<size_t>(size_));
-    cass::encode_uuid(data() + offset, value);
+    internal::encode_uuid(data() + offset, value);
     return offset + sizeof(CassUuid);
   }
 
@@ -176,15 +173,11 @@ class Buffer {
   }
 
   char* data() {
-    return size_ > FIXED_BUFFER_SIZE
-        ? static_cast<RefBuffer*>(data_.buffer)->data()
-        : data_.fixed;
+    return size_ > FIXED_BUFFER_SIZE ? static_cast<RefBuffer*>(data_.buffer)->data() : data_.fixed;
   }
 
   const char* data() const {
-    return size_ > FIXED_BUFFER_SIZE
-        ? static_cast<RefBuffer*>(data_.buffer)->data()
-        : data_.fixed;
+    return size_ > FIXED_BUFFER_SIZE ? static_cast<RefBuffer*>(data_.buffer)->data() : data_.fixed;
   }
 
   size_t size() const { return size_; }
@@ -216,7 +209,7 @@ class Buffer {
     RefBuffer* buffer;
 
     Data()
-      : buffer(NULL) { }
+        : buffer(NULL) {}
   } data_;
 
   size_t size_;
@@ -224,6 +217,6 @@ class Buffer {
 
 typedef Vector<Buffer> BufferVec;
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/callback.hpp b/src/callback.hpp
index 2ff8786cb..dc8dc3d56 100644
--- a/src/callback.hpp
+++ b/src/callback.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CALLBACK_HPP_INCLUDED__
-#define __CASS_CALLBACK_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CALLBACK_HPP
+#define DATASTAX_INTERNAL_CALLBACK_HPP
 
 #include "aligned_storage.hpp"
 #include "macros.hpp"
@@ -23,19 +23,19 @@
 #include <new>
 #include <stddef.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class R, class Arg>
 class Callback {
 public:
-  struct FunctionWithDataDummy { };
+  struct FunctionWithDataDummy {};
 
   Callback()
-    : invoker_(NULL) { }
+      : invoker_(NULL) {}
 
   template <class F, class T>
   Callback(F func, T* object)
-    : invoker_(new (&storage_) MemberInvoker<F, T>(func, object)) {
+      : invoker_(new (&storage_) MemberInvoker<F, T>(func, object)) {
     typedef MemberInvoker<F, T> MemberInvoker;
     STATIC_ASSERT(sizeof(Storage) >= sizeof(MemberInvoker));
     STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(MemberInvoker));
@@ -43,7 +43,7 @@ class Callback {
 
   template <class F>
   explicit Callback(F func)
-    : invoker_(new (&storage_) FunctionInvoker<F>(func)) {
+      : invoker_(new (&storage_) FunctionInvoker<F>(func)) {
     typedef FunctionInvoker<F> FunctionInvoker;
     STATIC_ASSERT(sizeof(Storage) >= sizeof(FunctionInvoker));
     STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(FunctionInvoker));
@@ -51,14 +51,14 @@ class Callback {
 
   template <class F, class D>
   Callback(F func, const D& data, FunctionWithDataDummy)
-    : invoker_(new (&storage_) FunctionWithDataInvoker<F, D>(func, data)) {
+      : invoker_(new (&storage_) FunctionWithDataInvoker<F, D>(func, data)) {
     typedef FunctionWithDataInvoker<F, D> FunctionWithDataInvoker;
     STATIC_ASSERT(sizeof(Storage) >= sizeof(FunctionWithDataInvoker));
     STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(FunctionWithDataInvoker));
   }
 
   Callback(const Callback& other)
-    : invoker_(other.invoker_ ? other.invoker_->copy(&storage_) : NULL) { }
+      : invoker_(other.invoker_ ? other.invoker_->copy(&storage_) : NULL) {}
 
   Callback& operator=(const Callback& other) {
     invoker_ = other.invoker_ ? other.invoker_->copy(&storage_) : NULL;
@@ -67,9 +67,7 @@ class Callback {
 
   operator bool() const { return invoker_; }
 
-  R operator()(const Arg& arg) const {
-    return invoker_->invoke(arg);
-  }
+  R operator()(const Arg& arg) const { return invoker_->invoke(arg); }
 
 private:
   // This needs to be big enough to fit:
@@ -87,16 +85,12 @@ class Callback {
   template <class F, class T>
   struct MemberInvoker : public Invoker {
     MemberInvoker(F func, T* object)
-      : func(func)
-      , object(object) { }
+        : func(func)
+        , object(object) {}
 
-    R invoke(const Arg& arg) const {
-      return (object->*func)(arg);
-    }
+    R invoke(const Arg& arg) const { return (object->*func)(arg); }
 
-    Invoker* copy(Storage* storage) {
-      return new (storage) MemberInvoker<F, T>(func, object);
-    }
+    Invoker* copy(Storage* storage) { return new (storage) MemberInvoker<F, T>(func, object); }
 
     F func;
     T* object;
@@ -105,15 +99,11 @@ class Callback {
   template <class F>
   struct FunctionInvoker : public Invoker {
     FunctionInvoker(F func)
-      : func(func) { }
+        : func(func) {}
 
-    R invoke(const Arg& arg) const {
-      return func(arg);
-    }
+    R invoke(const Arg& arg) const { return func(arg); }
 
-    Invoker* copy(Storage* storage) {
-      return new (storage) FunctionInvoker<F>(func);
-    }
+    Invoker* copy(Storage* storage) { return new (storage) FunctionInvoker<F>(func); }
 
     F func;
   };
@@ -121,12 +111,10 @@ class Callback {
   template <class F, class D>
   struct FunctionWithDataInvoker : public Invoker {
     FunctionWithDataInvoker(F func, D data)
-      : func(func)
-      , data(data) { }
+        : func(func)
+        , data(data) {}
 
-    R invoke(const Arg& arg) const {
-      return func(arg, data);
-    }
+    R invoke(const Arg& arg) const { return func(arg, data); }
 
     Invoker* copy(Storage* storage) {
       return new (storage) FunctionWithDataInvoker<F, D>(func, data);
@@ -157,6 +145,6 @@ Callback<R, Arg> bind_callback(R (*func)(Arg, D), const D& data) {
   return Callback<R, Arg>(func, data, dummy);
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/cluster.cpp b/src/cluster.cpp
index 3c748fb85..b6c49e544 100644
--- a/src/cluster.cpp
+++ b/src/cluster.cpp
@@ -25,7 +25,10 @@
 #include "speculative_execution.hpp"
 #include "utils.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A task for initiating the cluster close process.
@@ -33,11 +36,9 @@ namespace cass {
 class ClusterRunClose : public Task {
 public:
   ClusterRunClose(const Cluster::Ptr& cluster)
-    : cluster_(cluster) { }
+      : cluster_(cluster) {}
 
-  void run(EventLoop* event_loop) {
-    cluster_->internal_close();
-  }
+  void run(EventLoop* event_loop) { cluster_->internal_close(); }
 
 private:
   Cluster::Ptr cluster_;
@@ -49,12 +50,10 @@ class ClusterRunClose : public Task {
 class ClusterNotifyUp : public Task {
 public:
   ClusterNotifyUp(const Cluster::Ptr& cluster, const Address& address)
-    : cluster_(cluster)
-    , address_(address) { }
+      : cluster_(cluster)
+      , address_(address) {}
 
-  void run(EventLoop* event_loop) {
-    cluster_->internal_notify_host_up(address_);
-  }
+  void run(EventLoop* event_loop) { cluster_->internal_notify_host_up(address_); }
 
 private:
   Cluster::Ptr cluster_;
@@ -67,12 +66,10 @@ class ClusterNotifyUp : public Task {
 class ClusterNotifyDown : public Task {
 public:
   ClusterNotifyDown(const Cluster::Ptr& cluster, const Address& address)
-    : cluster_(cluster)
-    , address_(address) { }
+      : cluster_(cluster)
+      , address_(address) {}
 
-  void run(EventLoop* event_loop) {
-    cluster_->internal_notify_host_down(address_);
-  }
+  void run(EventLoop* event_loop) { cluster_->internal_notify_host_down(address_); }
 
 private:
   Cluster::Ptr cluster_;
@@ -82,11 +79,9 @@ class ClusterNotifyDown : public Task {
 class ClusterStartEvents : public Task {
 public:
   ClusterStartEvents(const Cluster::Ptr& cluster)
-    : cluster_(cluster) { }
+      : cluster_(cluster) {}
 
-  void run(EventLoop* event_loop) {
-    cluster_->internal_start_events();
-  }
+  void run(EventLoop* event_loop) { cluster_->internal_start_events(); }
 
 private:
   Cluster::Ptr cluster_;
@@ -94,14 +89,12 @@ class ClusterStartEvents : public Task {
 
 class ClusterStartClientMonitor : public Task {
 public:
-  ClusterStartClientMonitor(const Cluster::Ptr& cluster,
-                            const String& client_id,
-                            const String& session_id,
-                            const Config& config)
-    : cluster_(cluster)
-    , client_id_(client_id)
-    , session_id_(session_id)
-    , config_(config) { }
+  ClusterStartClientMonitor(const Cluster::Ptr& cluster, const String& client_id,
+                            const String& session_id, const Config& config)
+      : cluster_(cluster)
+      , client_id_(client_id)
+      , session_id_(session_id)
+      , config_(config) {}
 
   void run(EventLoop* event_loop) {
     cluster_->internal_start_monitor_reporting(client_id_, session_id_, config_);
@@ -119,22 +112,23 @@ class ClusterStartClientMonitor : public Task {
  */
 class NopClusterListener : public ClusterListener {
 public:
-  virtual void on_connect(Cluster* cluster) { }
+  virtual void on_connect(Cluster* cluster) {}
 
-  virtual void on_host_up(const Host::Ptr& host) { }
-  virtual void on_host_down(const Host::Ptr& host) { }
+  virtual void on_host_up(const Host::Ptr& host) {}
+  virtual void on_host_down(const Host::Ptr& host) {}
 
-  virtual void on_host_added(const Host::Ptr& host) { }
-  virtual void on_host_removed(const Host::Ptr& host) { }
+  virtual void on_host_added(const Host::Ptr& host) {}
+  virtual void on_host_removed(const Host::Ptr& host) {}
 
-  virtual void on_token_map_updated(const TokenMap::Ptr& token_map) { }
+  virtual void on_token_map_updated(const TokenMap::Ptr& token_map) {}
 
-  virtual void on_close(Cluster* cluster) { }
+  virtual void on_close(Cluster* cluster) {}
 };
 
-void ClusterEvent::process_event(const ClusterEvent& event,
-                                 ClusterListener* listener) {
-  switch(event.type) {
+}}} // namespace datastax::internal::core
+
+void ClusterEvent::process_event(const ClusterEvent& event, ClusterListener* listener) {
+  switch (event.type) {
     case HOST_UP:
       listener->on_host_up(event.host);
       break;
@@ -159,10 +153,8 @@ void ClusterEvent::process_event(const ClusterEvent& event,
   }
 }
 
-void ClusterEvent::process_events(const ClusterEvent::Vec& events,
-                                  ClusterListener* listener) {
-  for (ClusterEvent::Vec::const_iterator it = events.begin(),
-       end = events.end(); it != end; ++it) {
+void ClusterEvent::process_events(const ClusterEvent::Vec& events, ClusterListener* listener) {
+  for (ClusterEvent::Vec::const_iterator it = events.begin(), end = events.end(); it != end; ++it) {
     process_event(*it, listener);
   }
 }
@@ -170,13 +162,11 @@ void ClusterEvent::process_events(const ClusterEvent::Vec& events,
 static NopClusterListener nop_cluster_listener__;
 
 LockedHostMap::LockedHostMap(const HostMap& hosts)
-  : hosts_(hosts) {
+    : hosts_(hosts) {
   uv_mutex_init(&mutex_);
 }
 
-LockedHostMap::~LockedHostMap() {
-  uv_mutex_destroy(&mutex_);
-}
+LockedHostMap::~LockedHostMap() { uv_mutex_destroy(&mutex_); }
 
 LockedHostMap::const_iterator LockedHostMap::find(const Address& address) const {
   return hosts_.find(address);
@@ -199,67 +189,60 @@ Host::Ptr& LockedHostMap::operator[](const Address& address) {
   return hosts_[address];
 }
 
-LockedHostMap&LockedHostMap::operator=(const HostMap& hosts) {
+LockedHostMap& LockedHostMap::operator=(const HostMap& hosts) {
   ScopedMutex l(&mutex_);
   hosts_ = hosts;
   return *this;
 }
 
 ClusterSettings::ClusterSettings()
-  : load_balancing_policy(new RoundRobinPolicy())
-  , port(CASS_DEFAULT_PORT)
-  , reconnect_timeout_ms(CASS_DEFAULT_RECONNECT_WAIT_TIME_MS)
-  , prepare_on_up_or_add_host(CASS_DEFAULT_PREPARE_ON_UP_OR_ADD_HOST)
-  , max_prepares_per_flush(CASS_DEFAULT_MAX_PREPARES_PER_FLUSH)
-  , disable_events_on_startup(false) {
+    : load_balancing_policy(new RoundRobinPolicy())
+    , port(CASS_DEFAULT_PORT)
+    , reconnection_policy(new ExponentialReconnectionPolicy())
+    , prepare_on_up_or_add_host(CASS_DEFAULT_PREPARE_ON_UP_OR_ADD_HOST)
+    , max_prepares_per_flush(CASS_DEFAULT_MAX_PREPARES_PER_FLUSH)
+    , disable_events_on_startup(false) {
   load_balancing_policies.push_back(load_balancing_policy);
 }
 
 ClusterSettings::ClusterSettings(const Config& config)
-  : control_connection_settings(config)
-  , load_balancing_policy(config.load_balancing_policy())
-  , load_balancing_policies(config.load_balancing_policies())
-  , port(config.port())
-  , reconnect_timeout_ms(config.reconnect_wait_time_ms())
-  , prepare_on_up_or_add_host(config.prepare_on_up_or_add_host())
-  , max_prepares_per_flush(CASS_DEFAULT_MAX_PREPARES_PER_FLUSH)
-  , disable_events_on_startup(false) { }
-
-Cluster::Cluster(const ControlConnection::Ptr& connection,
-                 ClusterListener* listener,
-                 EventLoop* event_loop,
-                 const Host::Ptr& connected_host,
-                 const HostMap& hosts,
+    : control_connection_settings(config)
+    , load_balancing_policy(config.load_balancing_policy())
+    , load_balancing_policies(config.load_balancing_policies())
+    , port(config.port())
+    , reconnection_policy(config.reconnection_policy())
+    , prepare_on_up_or_add_host(config.prepare_on_up_or_add_host())
+    , max_prepares_per_flush(CASS_DEFAULT_MAX_PREPARES_PER_FLUSH)
+    , disable_events_on_startup(false) {}
+
+Cluster::Cluster(const ControlConnection::Ptr& connection, ClusterListener* listener,
+                 EventLoop* event_loop, const Host::Ptr& connected_host, const HostMap& hosts,
                  const ControlConnectionSchema& schema,
                  const LoadBalancingPolicy::Ptr& load_balancing_policy,
                  const LoadBalancingPolicy::Vec& load_balancing_policies,
                  const ClusterSettings& settings)
-  : connection_(connection)
-  , listener_(listener ? listener : &nop_cluster_listener__)
-  , event_loop_(event_loop)
-  , load_balancing_policy_(load_balancing_policy)
-  , load_balancing_policies_(load_balancing_policies)
-  , settings_(settings)
-  , is_closing_(false)
-  , connected_host_(connected_host)
-  , hosts_(hosts)
-  , is_recording_events_(settings.disable_events_on_startup) {
+    : connection_(connection)
+    , listener_(listener ? listener : &nop_cluster_listener__)
+    , event_loop_(event_loop)
+    , load_balancing_policy_(load_balancing_policy)
+    , load_balancing_policies_(load_balancing_policies)
+    , settings_(settings)
+    , is_closing_(false)
+    , connected_host_(connected_host)
+    , hosts_(hosts)
+    , is_recording_events_(settings.disable_events_on_startup) {
   inc_ref();
   connection_->set_listener(this);
 
   query_plan_.reset(load_balancing_policy_->new_query_plan("", NULL, NULL));
 
   update_schema(schema);
-  update_token_map(hosts,
-                   connected_host_->partitioner(),
-                   schema);
+  update_token_map(hosts, connected_host_->partitioner(), schema);
 
   listener_->on_reconnect(this);
 }
 
-void Cluster::close() {
-  event_loop_->add(new ClusterRunClose(Ptr(this)));
-}
+void Cluster::close() { event_loop_->add(new ClusterRunClose(Ptr(this))); }
 
 void Cluster::notify_host_up(const Address& address) {
   event_loop_->add(new ClusterNotifyUp(Ptr(this), address));
@@ -269,40 +252,28 @@ void Cluster::notify_host_down(const Address& address) {
   event_loop_->add(new ClusterNotifyDown(Ptr(this), address));
 }
 
-void Cluster::start_events() {
-  event_loop_->add(new ClusterStartEvents(Ptr(this)));
-}
+void Cluster::start_events() { event_loop_->add(new ClusterStartEvents(Ptr(this))); }
 
-void Cluster::start_monitor_reporting(const String& client_id,
-                                      const String& session_id,
+void Cluster::start_monitor_reporting(const String& client_id, const String& session_id,
                                       const Config& config) {
-  event_loop_->add(new ClusterStartClientMonitor(Ptr(this),
-                                                 client_id,
-                                                 session_id,
-                                                 config));
+  event_loop_->add(new ClusterStartClientMonitor(Ptr(this), client_id, session_id, config));
 }
 
-Metadata::SchemaSnapshot Cluster::schema_snapshot() {
-  return metadata_.schema_snapshot();
-}
+Metadata::SchemaSnapshot Cluster::schema_snapshot() { return metadata_.schema_snapshot(); }
 
-Host::Ptr Cluster::find_host(const Address& address) const {
-  return hosts_.get(address);
-}
+Host::Ptr Cluster::find_host(const Address& address) const { return hosts_.get(address); }
 
 PreparedMetadata::Entry::Ptr Cluster::prepared(const String& id) const {
   return prepared_metadata_.get(id);
 }
 
-void Cluster::prepared(const String& id,
-                       const PreparedMetadata::Entry::Ptr& entry) {
+void Cluster::prepared(const String& id, const PreparedMetadata::Entry::Ptr& entry) {
   prepared_metadata_.set(id, entry);
 }
 
 HostMap Cluster::available_hosts() const {
   HostMap available;
-  for (HostMap::const_iterator it = hosts_.begin(),
-       end = hosts_.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts_.begin(), end = hosts_.end(); it != end; ++it) {
     if (!is_host_ignored(it->second)) {
       available[it->first] = it->second;
     }
@@ -318,8 +289,7 @@ void Cluster::update_hosts(const HostMap& hosts) {
   // Update the hosts and properly notify the listener
   HostMap existing(hosts_);
 
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     HostMap::iterator find_it = existing.find(it->first);
     if (find_it != existing.end()) {
       existing.erase(find_it); // Already exists mark as visited
@@ -330,8 +300,7 @@ void Cluster::update_hosts(const HostMap& hosts) {
 
   // Any hosts that existed before, but aren't in the new hosts
   // need to be marked as removed.
-  for (HostMap::const_iterator it = existing.begin(),
-       end = existing.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = existing.begin(), end = existing.end(); it != end; ++it) {
     notify_host_remove(it->first);
   }
 }
@@ -386,8 +355,7 @@ void Cluster::update_schema(const ControlConnectionSchema& schema) {
   metadata_.swap_to_back_and_update_front();
 }
 
-void Cluster::update_token_map(const HostMap& hosts,
-                               const String& partitioner,
+void Cluster::update_token_map(const HostMap& hosts, const String& partitioner,
                                const ControlConnectionSchema& schema) {
   if (settings_.control_connection_settings.token_aware_routing && schema.keyspaces) {
     // Create a new token map and populate it
@@ -396,8 +364,7 @@ void Cluster::update_token_map(const HostMap& hosts,
       return; // Partition is not supported
     }
     token_map_->add_keyspaces(connection_->server_version(), schema.keyspaces.get());
-    for (HostMap::const_iterator it = hosts.begin(),
-         end = hosts.end(); it != end; ++it) {
+    for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
       token_map_->add_host(it->second);
     }
     token_map_->build();
@@ -409,30 +376,30 @@ void Cluster::update_token_map(const HostMap& hosts,
 // important for DC-aware). This method prevents connection pools from being
 // created to ignored hosts.
 bool Cluster::is_host_ignored(const Host::Ptr& host) const {
-  return cass::is_host_ignored(load_balancing_policies_, host);
+  return core::is_host_ignored(load_balancing_policies_, host);
 }
 
 void Cluster::schedule_reconnect() {
-  if (settings_.reconnect_timeout_ms > 0) {
-    timer_.start(connection_->loop(), settings_.reconnect_timeout_ms,
+  if (!reconnection_schedule_) {
+    reconnection_schedule_.reset(settings_.reconnection_policy->new_reconnection_schedule());
+  }
+  uint64_t delay_ms = reconnection_schedule_->next_delay_ms();
+  if (delay_ms > 0) {
+    timer_.start(connection_->loop(), delay_ms,
                  bind_callback(&Cluster::on_schedule_reconnect, this));
   } else {
     handle_schedule_reconnect();
   }
 }
 
-void Cluster::on_schedule_reconnect(Timer* timer) {
-  handle_schedule_reconnect();
-}
+void Cluster::on_schedule_reconnect(Timer* timer) { handle_schedule_reconnect(); }
 
 void Cluster::handle_schedule_reconnect() {
   const Host::Ptr& host = query_plan_->compute_next();
   if (host) {
-    reconnector_.reset(new ControlConnector(host,
-                                            connection_->protocol_version(),
+    reconnector_.reset(new ControlConnector(host, connection_->protocol_version(),
                                             bind_callback(&Cluster::on_reconnect, this)));
-    reconnector_
-        ->with_settings(settings_.control_connection_settings)
+    reconnector_->with_settings(settings_.control_connection_settings)
         ->connect(connection_->loop());
   } else {
     // No more hosts, refresh the query plan and schedule a re-connection
@@ -462,23 +429,21 @@ void Cluster::on_reconnect(ControlConnector* connector) {
     assert(connected_host_ && "Connected host not found in hosts map");
 
     update_schema(connector->schema());
-    update_token_map(connector->hosts(),
-                     connected_host_->partitioner(),
-                     connector->schema());
+    update_token_map(connector->hosts(), connected_host_->partitioner(), connector->schema());
 
     // Notify the listener that we've built a new token map
     if (token_map_) {
       notify_or_record(ClusterEvent(token_map_));
     }
 
-    LOG_INFO("Control connection connected to %s",
-             connected_host_->address_string().c_str());
+    LOG_INFO("Control connection connected to %s", connected_host_->address_string().c_str());
 
     listener_->on_reconnect(this);
+    reconnection_schedule_.reset();
   } else if (!connector->is_canceled()) {
-    LOG_ERROR("Unable to reestablish a control connection to host %s because of the following error: %s",
-              connector->address().to_string().c_str(),
-              connector->error_message().c_str());
+    LOG_ERROR(
+        "Unable to reestablish a control connection to host %s because of the following error: %s",
+        connector->address().to_string().c_str(), connector->error_message().c_str());
     schedule_reconnect();
   }
 }
@@ -491,14 +456,15 @@ void Cluster::internal_close() {
     handle_close();
   } else if (reconnector_) {
     reconnector_->cancel();
-  } else if (connection_)  {
+  } else if (connection_) {
     connection_->close();
   }
 }
 
 void Cluster::handle_close() {
   for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-       end = load_balancing_policies_.end(); it != end; ++it) {
+                                                end = load_balancing_policies_.end();
+       it != end; ++it) {
     (*it)->close_handles();
   }
   connection_.reset();
@@ -510,8 +476,7 @@ void Cluster::internal_notify_host_up(const Address& address) {
   LockedHostMap::const_iterator it = hosts_.find(address);
 
   if (it == hosts_.end()) {
-    LOG_WARN("Attempting to mark host %s that we don't have as UP",
-             address.to_string().c_str());
+    LOG_WARN("Attempting to mark host %s that we don't have as UP", address.to_string().c_str());
     return;
   }
 
@@ -526,7 +491,8 @@ void Cluster::internal_notify_host_up(const Address& address) {
   }
 
   for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-       end = load_balancing_policies_.end(); it != end; ++it) {
+                                                end = load_balancing_policies_.end();
+       it != end; ++it) {
     (*it)->on_host_up(host);
   }
 
@@ -534,8 +500,7 @@ void Cluster::internal_notify_host_up(const Address& address) {
     return; // Ignore host
   }
 
-  if (!prepare_host(host,
-                    bind_callback(&Cluster::on_prepare_host_up, this))) {
+  if (!prepare_host(host, bind_callback(&Cluster::on_prepare_host_up, this))) {
     notify_host_up_after_prepare(host);
   }
 }
@@ -551,8 +516,7 @@ void Cluster::internal_notify_host_down(const Address& address) {
   if (it == hosts_.end()) {
     // Using DEBUG level here because this can happen normally as the result of
     // a remove event.
-    LOG_DEBUG("Attempting to mark host %s that we don't have as DOWN",
-              address.to_string().c_str());
+    LOG_DEBUG("Attempting to mark host %s that we don't have as DOWN", address.to_string().c_str());
     return;
   }
 
@@ -564,7 +528,8 @@ void Cluster::internal_notify_host_down(const Address& address) {
   }
 
   for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-       end = load_balancing_policies_.end(); it != end; ++it) {
+                                                end = load_balancing_policies_.end();
+       it != end; ++it) {
     (*it)->on_host_down(address);
   }
 
@@ -580,32 +545,25 @@ void Cluster::internal_start_events() {
   }
 }
 
-void Cluster::internal_start_monitor_reporting(const String& client_id,
-                                            const String& session_id,
-                                            const Config& config) {
-  monitor_reporting_.reset(create_monitor_reporting(client_id,
-                                                    session_id,
-                                                    config));
+void Cluster::internal_start_monitor_reporting(const String& client_id, const String& session_id,
+                                               const Config& config) {
+  monitor_reporting_.reset(create_monitor_reporting(client_id, session_id, config));
 
-  if (!is_closing_ &&
-      monitor_reporting_->interval_ms(connection_->dse_server_version()) > 0) {
-    monitor_reporting_->send_startup_message(connection_->connection(),
-                                          config,
-                                          available_hosts(),
-                                          load_balancing_policies_);
-    monitor_reporting_timer_.start(event_loop_->loop(),
-                                   monitor_reporting_->interval_ms(connection_->dse_server_version()),
-                                   bind_callback(&Cluster::on_monitor_reporting, this));
+  if (!is_closing_ && monitor_reporting_->interval_ms(connection_->dse_server_version()) > 0) {
+    monitor_reporting_->send_startup_message(connection_->connection(), config, available_hosts(),
+                                             load_balancing_policies_);
+    monitor_reporting_timer_.start(
+        event_loop_->loop(), monitor_reporting_->interval_ms(connection_->dse_server_version()),
+        bind_callback(&Cluster::on_monitor_reporting, this));
   }
 }
 
 void Cluster::on_monitor_reporting(Timer* timer) {
   if (!is_closing_) {
-    monitor_reporting_->send_status_message(connection_->connection(),
-                                            available_hosts());
-    monitor_reporting_timer_.start(event_loop_->loop(),
-                                   monitor_reporting_->interval_ms(connection_->dse_server_version()),
-                                   bind_callback(&Cluster::on_monitor_reporting, this));
+    monitor_reporting_->send_status_message(connection_->connection(), available_hosts());
+    monitor_reporting_timer_.start(
+        event_loop_->loop(), monitor_reporting_->interval_ms(connection_->dse_server_version()),
+        bind_callback(&Cluster::on_monitor_reporting, this));
   }
 }
 
@@ -613,12 +571,12 @@ void Cluster::notify_host_add(const Host::Ptr& host) {
   LockedHostMap::const_iterator host_it = hosts_.find(host->address());
 
   if (host_it != hosts_.end()) {
-    LOG_WARN("Attempting to add host %s that we already have",
-             host->address_string().c_str());
+    LOG_WARN("Attempting to add host %s that we already have", host->address_string().c_str());
     // If an entry already exists then notify that the node has been removed
     // then re-add it.
     for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-         end = load_balancing_policies_.end(); it != end; ++it) {
+                                                  end = load_balancing_policies_.end();
+         it != end; ++it) {
       (*it)->on_host_removed(host_it->second);
     }
     notify_or_record(ClusterEvent(ClusterEvent::HOST_REMOVE, host));
@@ -626,7 +584,8 @@ void Cluster::notify_host_add(const Host::Ptr& host) {
 
   hosts_[host->address()] = host;
   for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-       end = load_balancing_policies_.end(); it != end; ++it) {
+                                                end = load_balancing_policies_.end();
+       it != end; ++it) {
     (*it)->on_host_added(host);
   }
 
@@ -634,8 +593,7 @@ void Cluster::notify_host_add(const Host::Ptr& host) {
     return; // Ignore host
   }
 
-  if (!prepare_host(host,
-                    bind_callback(&Cluster::on_prepare_host_add, this))) {
+  if (!prepare_host(host, bind_callback(&Cluster::on_prepare_host_add, this))) {
     notify_host_add_after_prepare(host);
   }
 }
@@ -653,8 +611,7 @@ void Cluster::notify_host_remove(const Address& address) {
   LockedHostMap::const_iterator it = hosts_.find(address);
 
   if (it == hosts_.end()) {
-    LOG_WARN("Attempting removing host %s that we don't have",
-             address.to_string().c_str());
+    LOG_WARN("Attempting removing host %s that we don't have", address.to_string().c_str());
     return;
   }
 
@@ -673,7 +630,8 @@ void Cluster::notify_host_remove(const Address& address) {
 
   hosts_.erase(address);
   for (LoadBalancingPolicy::Vec::const_iterator it = load_balancing_policies_.begin(),
-       end = load_balancing_policies_.end(); it != end; ++it) {
+                                                end = load_balancing_policies_.end();
+       it != end; ++it) {
     (*it)->on_host_removed(host);
   }
 
@@ -688,15 +646,11 @@ void Cluster::notify_or_record(const ClusterEvent& event) {
   }
 }
 
-bool Cluster::prepare_host(const Host::Ptr& host,
-                           const PrepareHostHandler::Callback& callback) {
+bool Cluster::prepare_host(const Host::Ptr& host, const PrepareHostHandler::Callback& callback) {
   if (connection_ && settings_.prepare_on_up_or_add_host) {
     PrepareHostHandler::Ptr prepare_host_handler(
-          new PrepareHostHandler(host,
-                                 prepared_metadata_.copy(),
-                                 callback,
-                                 connection_->protocol_version(),
-                                 settings_.max_prepares_per_flush));
+        new PrepareHostHandler(host, prepared_metadata_.copy(), callback,
+                               connection_->protocol_version(), settings_.max_prepares_per_flush));
 
     prepare_host_handler->prepare(connection_->loop(),
                                   settings_.control_connection_settings.connection_settings);
@@ -713,10 +667,8 @@ void Cluster::on_prepare_host_up(const PrepareHostHandler* handler) {
   notify_host_up_after_prepare(handler->host());
 }
 
-void Cluster::on_update_schema(SchemaType type,
-                               const ResultResponse::Ptr& result,
-                               const String& keyspace_name,
-                               const String& target_name) {
+void Cluster::on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                               const String& keyspace_name, const String& target_name) {
   switch (type) {
     case KEYSPACE:
       // Virtual keyspaces are not updated (always false)
@@ -751,8 +703,7 @@ void Cluster::on_update_schema(SchemaType type,
   }
 }
 
-void Cluster::on_drop_schema(SchemaType type,
-                             const String& keyspace_name,
+void Cluster::on_drop_schema(SchemaType type, const String& keyspace_name,
                              const String& target_name) {
   switch (type) {
     case KEYSPACE:
@@ -787,8 +738,7 @@ void Cluster::on_up(const Address& address) {
   LockedHostMap::const_iterator it = hosts_.find(address);
 
   if (it == hosts_.end()) {
-    LOG_WARN("Received UP event for an unknown host %s",
-             address.to_string().c_str());
+    LOG_WARN("Received UP event for an unknown host %s", address.to_string().c_str());
     return;
   }
 
@@ -800,22 +750,15 @@ void Cluster::on_down(const Address& address) {
   // `notify_host_down()` to trigger the DOWN status.
 }
 
-void Cluster::on_add(const Host::Ptr& host) {
-  notify_host_add(host);
-}
+void Cluster::on_add(const Host::Ptr& host) { notify_host_add(host); }
 
-void Cluster::on_remove(const Address& address) {
-  notify_host_remove(address);
-}
+void Cluster::on_remove(const Address& address) { notify_host_remove(address); }
 
 void Cluster::on_close(ControlConnection* connection) {
   if (!is_closing_) {
-    LOG_WARN("Lost control connection to host %s",
-             connection_->address_string().c_str());
+    LOG_WARN("Lost control connection to host %s", connection_->address_string().c_str());
     schedule_reconnect();
   } else {
     handle_close();
   }
 }
-
-} // namespace cass
diff --git a/src/cluster.hpp b/src/cluster.hpp
index caadfef6e..5fab3f645 100644
--- a/src/cluster.hpp
+++ b/src/cluster.hpp
@@ -14,21 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CLUSTER_HPP_INCLUDED__
-#define __CASS_CLUSTER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CLUSTER_HPP
+#define DATASTAX_INTERNAL_CLUSTER_HPP
 
-#include "monitor_reporting.hpp"
 #include "config.hpp"
 #include "control_connector.hpp"
-#include "external.hpp"
 #include "event_loop.hpp"
+#include "external.hpp"
 #include "metadata.hpp"
-#include "prepared.hpp"
+#include "monitor_reporting.hpp"
 #include "prepare_host_handler.hpp"
+#include "prepared.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Cluster;
 
@@ -63,7 +63,7 @@ class LockedHostMap {
  */
 class TokenMapListener {
 public:
-  virtual ~TokenMapListener() { }
+  virtual ~TokenMapListener() {}
 
   /**
    * A callback that's called when the token map has changed. This happens as
@@ -79,12 +79,12 @@ class TokenMapListener {
  * A listener that handles cluster events.
  */
 class ClusterListener
-  : public HostListener
-  , public TokenMapListener {
+    : public HostListener
+    , public TokenMapListener {
 public:
   typedef Vector<ClusterListener*> Vec;
 
-  virtual ~ClusterListener() { }
+  virtual ~ClusterListener() {}
 
   /**
    * A callback that's called when the control connection receives an up event.
@@ -93,7 +93,7 @@ class ClusterListener
    *
    * @param host A host that may be available.
    */
-  virtual void on_host_maybe_up(const Host::Ptr& host) { }
+  virtual void on_host_maybe_up(const Host::Ptr& host) {}
 
   /**
    * A callback that's called as the result of `Cluster::notify_host_up()`.
@@ -104,7 +104,7 @@ class ClusterListener
    *
    * @param host A host that's ready to receive queries.
    */
-  virtual void on_host_ready(const Host::Ptr& host) { }
+  virtual void on_host_ready(const Host::Ptr& host) {}
 
   /**
    * A callback that's called when the cluster connects or reconnects to a host.
@@ -113,7 +113,7 @@ class ClusterListener
    *
    * @param cluster The cluster object.
    */
-  virtual void on_reconnect(Cluster* cluster) { }
+  virtual void on_reconnect(Cluster* cluster) {}
 
   /**
    * A callback that's called when the cluster has closed.
@@ -139,12 +139,12 @@ struct ClusterEvent {
   };
 
   ClusterEvent(Type type, const Host::Ptr& host)
-    : type(type)
-    , host(host) { }
+      : type(type)
+      , host(host) {}
 
   ClusterEvent(const TokenMap::Ptr& token_map)
-    : type(TOKEN_MAP_UPDATE)
-    , token_map(token_map) { }
+      : type(TOKEN_MAP_UPDATE)
+      , token_map(token_map) {}
 
   static void process_event(const ClusterEvent& event, ClusterListener* listener);
   static void process_events(const Vec& events, ClusterListener* listener);
@@ -193,9 +193,9 @@ struct ClusterSettings {
   int port;
 
   /**
-   * Time to wait before attempting to reconnect the control connection.
+   * Reconnection policy to use when attempting to reconnect the control connection.
    */
-  uint64_t reconnect_timeout_ms;
+  ReconnectionPolicy::Ptr reconnection_policy;
 
   /**
    * If true then cached prepared statements are prepared when a host is brought
@@ -222,8 +222,9 @@ struct ClusterSettings {
  * explicit call to close because it repeatedly tries to re-establish its
  * connection even if no hosts are available.
  */
-class Cluster : public RefCounted<Cluster>
-              , public ControlConnectionListener {
+class Cluster
+    : public RefCounted<Cluster>
+    , public ControlConnectionListener {
 public:
   typedef SharedRefPtr<Cluster> Ptr;
 
@@ -243,15 +244,11 @@ class Cluster : public RefCounted<Cluster>
    * @param settings The control connection settings to use for reconnecting the
    * control connection.
    */
-  Cluster(const ControlConnection::Ptr& connection,
-          ClusterListener* listener,
-          EventLoop* event_loop,
-          const Host::Ptr& connected_host,
-          const HostMap& hosts,
+  Cluster(const ControlConnection::Ptr& connection, ClusterListener* listener,
+          EventLoop* event_loop, const Host::Ptr& connected_host, const HostMap& hosts,
           const ControlConnectionSchema& schema,
           const LoadBalancingPolicy::Ptr& load_balancing_policy,
-          const LoadBalancingPolicy::Vec& load_balancing_policies,
-          const ClusterSettings& settings);
+          const LoadBalancingPolicy::Vec& load_balancing_policies, const ClusterSettings& settings);
 
   /**
    * Set the listener that will handle events for the cluster
@@ -296,8 +293,7 @@ class Cluster : public RefCounted<Cluster>
    * @param session_id Session ID associated with the session.
    * @param config The config object.
    */
-  void start_monitor_reporting(const String& client_id,
-                               const String& session_id,
+  void start_monitor_reporting(const String& client_id, const String& session_id,
                                const Config& config);
 
   /**
@@ -331,8 +327,7 @@ class Cluster : public RefCounted<Cluster>
    * @param id A prepared ID.
    * @param entry A prepared metadata entry.
    */
-  void prepared(const String& id,
-                const PreparedMetadata::Entry::Ptr& entry);
+  void prepared(const String& id, const PreparedMetadata::Entry::Ptr& entry);
 
   /**
    * Get available hosts (determined by host distance). This filters out ignored
@@ -358,8 +353,7 @@ class Cluster : public RefCounted<Cluster>
 private:
   void update_hosts(const HostMap& hosts);
   void update_schema(const ControlConnectionSchema& schema);
-  void update_token_map(const HostMap& hosts,
-                        const String& partitioner,
+  void update_token_map(const HostMap& hosts, const String& partitioner,
                         const ControlConnectionSchema& schema);
 
   bool is_host_ignored(const Host::Ptr& host) const;
@@ -381,8 +375,7 @@ class Cluster : public RefCounted<Cluster>
   void internal_notify_host_down(const Address& address);
 
   void internal_start_events();
-  void internal_start_monitor_reporting(const String& client_id,
-                                        const String& session_id,
+  void internal_start_monitor_reporting(const String& client_id, const String& session_id,
                                         const Config& config);
 
   void on_monitor_reporting(Timer* timer);
@@ -396,8 +389,7 @@ class Cluster : public RefCounted<Cluster>
   void notify_or_record(const ClusterEvent& event);
 
 private:
-  bool prepare_host(const Host::Ptr& host,
-                    const PrepareHostHandler::Callback& callback);
+  bool prepare_host(const Host::Ptr& host, const PrepareHostHandler::Callback& callback);
 
   void on_prepare_host_add(const PrepareHostHandler* handler);
   void on_prepare_host_up(const PrepareHostHandler* handler);
@@ -405,13 +397,10 @@ class Cluster : public RefCounted<Cluster>
 private:
   // Control connection listener methods
 
-  virtual void on_update_schema(SchemaType type,
-                                const ResultResponse::Ptr& result,
-                                const String& keyspace_name,
-                                const String& target_name);
+  virtual void on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                                const String& keyspace_name, const String& target_name);
 
-  virtual void on_drop_schema(SchemaType type,
-                              const String& keyspace_name,
+  virtual void on_drop_schema(SchemaType type, const String& keyspace_name,
                               const String& target_name);
 
   virtual void on_up(const Address& address);
@@ -442,8 +431,9 @@ class Cluster : public RefCounted<Cluster>
   ClusterEvent::Vec recorded_events_;
   ScopedPtr<MonitorReporting> monitor_reporting_;
   Timer monitor_reporting_timer_;
+  ScopedPtr<ReconnectionSchedule> reconnection_schedule_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/cluster_config.cpp b/src/cluster_config.cpp
index caece85db..9e1dba162 100644
--- a/src/cluster_config.cpp
+++ b/src/cluster_config.cpp
@@ -16,14 +16,14 @@
 
 #include "cluster_config.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-CassCluster* cass_cluster_new() {
-  return CassCluster::to(new cass::ClusterConfig());
-}
+CassCluster* cass_cluster_new() { return CassCluster::to(new ClusterConfig()); }
 
-CassError cass_cluster_set_port(CassCluster* cluster,
-                                int port) {
+CassError cass_cluster_set_port(CassCluster* cluster, int port) {
   if (port <= 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -31,20 +31,18 @@ CassError cass_cluster_set_port(CassCluster* cluster,
   return CASS_OK;
 }
 
-void cass_cluster_set_ssl(CassCluster* cluster,
-                          CassSsl* ssl) {
+void cass_cluster_set_ssl(CassCluster* cluster, CassSsl* ssl) {
   cluster->config().set_ssl_context(ssl->from());
 }
 
-CassError cass_cluster_set_protocol_version(CassCluster* cluster,
-                                            int protocol_version) {
+CassError cass_cluster_set_protocol_version(CassCluster* cluster, int protocol_version) {
   if (cluster->config().use_beta_protocol_version()) {
     LOG_ERROR("The protocol version is already set to the newest beta version %s "
               "and cannot be explicitly set.",
-              cass::ProtocolVersion::newest_beta().to_string().c_str());
+              ProtocolVersion::newest_beta().to_string().c_str());
     return CASS_ERROR_LIB_BAD_PARAMS;
   } else {
-    cass::ProtocolVersion version(protocol_version);
+    ProtocolVersion version(protocol_version);
     if (!version.is_valid()) {
       return CASS_ERROR_LIB_BAD_PARAMS;
     }
@@ -53,16 +51,14 @@ CassError cass_cluster_set_protocol_version(CassCluster* cluster,
   }
 }
 
-CassError cass_cluster_set_use_beta_protocol_version(CassCluster* cluster,
-                                                     cass_bool_t enable) {
+CassError cass_cluster_set_use_beta_protocol_version(CassCluster* cluster, cass_bool_t enable) {
   cluster->config().set_use_beta_protocol_version(enable == cass_true);
-  cluster->config().set_protocol_version(enable ? cass::ProtocolVersion::newest_beta()
-                                                : cass::ProtocolVersion::highest_supported());
+  cluster->config().set_protocol_version(enable ? ProtocolVersion::newest_beta()
+                                                : ProtocolVersion::highest_supported());
   return CASS_OK;
 }
 
-CassError cass_cluster_set_consistency(CassCluster* cluster,
-                                       CassConsistency consistency) {
+CassError cass_cluster_set_consistency(CassCluster* cluster, CassConsistency consistency) {
   if (consistency == CASS_CONSISTENCY_UNKNOWN) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -70,8 +66,7 @@ CassError cass_cluster_set_consistency(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_serial_consistency(CassCluster* cluster,
-                                              CassConsistency consistency) {
+CassError cass_cluster_set_serial_consistency(CassCluster* cluster, CassConsistency consistency) {
   if (consistency == CASS_CONSISTENCY_UNKNOWN) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -79,8 +74,7 @@ CassError cass_cluster_set_serial_consistency(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_num_threads_io(CassCluster* cluster,
-                                          unsigned num_threads) {
+CassError cass_cluster_set_num_threads_io(CassCluster* cluster, unsigned num_threads) {
   if (num_threads == 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -88,8 +82,7 @@ CassError cass_cluster_set_num_threads_io(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_queue_size_io(CassCluster* cluster,
-                                         unsigned queue_size) {
+CassError cass_cluster_set_queue_size_io(CassCluster* cluster, unsigned queue_size) {
   if (queue_size == 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -97,26 +90,20 @@ CassError cass_cluster_set_queue_size_io(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_queue_size_event(CassCluster* cluster,
-                                            unsigned queue_size) {
+CassError cass_cluster_set_queue_size_event(CassCluster* cluster, unsigned queue_size) {
   return CASS_OK;
 }
 
-CassError cass_cluster_set_contact_points(CassCluster* cluster,
-                                          const char* contact_points) {
-  return cass_cluster_set_contact_points_n(cluster,
-                                           contact_points,
-                                           SAFE_STRLEN(contact_points));
+CassError cass_cluster_set_contact_points(CassCluster* cluster, const char* contact_points) {
+  return cass_cluster_set_contact_points_n(cluster, contact_points, SAFE_STRLEN(contact_points));
 }
 
-CassError cass_cluster_set_contact_points_n(CassCluster* cluster,
-                                            const char* contact_points,
+CassError cass_cluster_set_contact_points_n(CassCluster* cluster, const char* contact_points,
                                             size_t contact_points_length) {
   if (contact_points_length == 0) {
     cluster->config().contact_points().clear();
   } else {
-    cass::explode(cass::String(contact_points, contact_points_length),
-                  cluster->config().contact_points());
+    explode(String(contact_points, contact_points_length), cluster->config().contact_points());
   }
   return CASS_OK;
 }
@@ -135,13 +122,35 @@ CassError cass_cluster_set_max_connections_per_host(CassCluster* cluster,
   return CASS_OK;
 }
 
-void cass_cluster_set_reconnect_wait_time(CassCluster* cluster,
-                                          unsigned wait_time_ms) {
-  cluster->config().set_reconnect_wait_time(wait_time_ms);
+void cass_cluster_set_reconnect_wait_time(CassCluster* cluster, unsigned wait_time_ms) {
+  cass_cluster_set_constant_reconnect(cluster, wait_time_ms);
 }
 
-CassError cass_cluster_set_coalesce_delay(CassCluster* cluster,
-                                          cass_int64_t delay_us) {
+void cass_cluster_set_constant_reconnect(CassCluster* cluster, cass_uint64_t delay_ms) {
+  cluster->config().set_constant_reconnect(delay_ms);
+}
+
+CassError cass_cluster_set_exponential_reconnect(CassCluster* cluster, cass_uint64_t base_delay_ms,
+                                                 cass_uint64_t max_delay_ms) {
+  if (base_delay_ms <= 1) {
+    LOG_ERROR("Base delay must be greater than 1");
+    return CASS_ERROR_LIB_BAD_PARAMS;
+  }
+
+  if (max_delay_ms <= 1) {
+    LOG_ERROR("Max delay must be greater than 1");
+    return CASS_ERROR_LIB_BAD_PARAMS;
+  }
+
+  if (max_delay_ms < base_delay_ms) {
+    LOG_ERROR("Max delay cannot be less than base delay");
+    return CASS_ERROR_LIB_BAD_PARAMS;
+  }
+  cluster->config().set_exponential_reconnect(base_delay_ms, max_delay_ms);
+  return CASS_OK;
+}
+
+CassError cass_cluster_set_coalesce_delay(CassCluster* cluster, cass_int64_t delay_us) {
   if (delay_us < 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -149,8 +158,7 @@ CassError cass_cluster_set_coalesce_delay(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_new_request_ratio(CassCluster* cluster,
-                                             cass_int32_t ratio) {
+CassError cass_cluster_set_new_request_ratio(CassCluster* cluster, cass_int32_t ratio) {
   if (ratio <= 0 || ratio > 100) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -158,8 +166,7 @@ CassError cass_cluster_set_new_request_ratio(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_max_concurrent_creation(CassCluster* cluster,
-                                                   unsigned num_connections) {
+CassError cass_cluster_set_max_concurrent_creation(CassCluster* cluster, unsigned num_connections) {
   // Deprecated
   return CASS_OK;
 }
@@ -170,20 +177,17 @@ CassError cass_cluster_set_max_concurrent_requests_threshold(CassCluster* cluste
   return CASS_OK;
 }
 
-CassError cass_cluster_set_max_requests_per_flush(CassCluster* cluster,
-                                                  unsigned num_requests) {
+CassError cass_cluster_set_max_requests_per_flush(CassCluster* cluster, unsigned num_requests) {
   // Deprecated
   return CASS_OK;
 }
 
-CassError cass_cluster_set_write_bytes_high_water_mark(CassCluster* cluster,
-                                                       unsigned num_bytes) {
+CassError cass_cluster_set_write_bytes_high_water_mark(CassCluster* cluster, unsigned num_bytes) {
   // Deprecated
   return CASS_OK;
 }
 
-CassError cass_cluster_set_write_bytes_low_water_mark(CassCluster* cluster,
-                                                      unsigned num_bytes) {
+CassError cass_cluster_set_write_bytes_low_water_mark(CassCluster* cluster, unsigned num_bytes) {
   // Deprecated
   return CASS_OK;
 }
@@ -200,93 +204,75 @@ CassError cass_cluster_set_pending_requests_low_water_mark(CassCluster* cluster,
   return CASS_OK;
 }
 
-void cass_cluster_set_connect_timeout(CassCluster* cluster,
-                                      unsigned timeout_ms) {
+void cass_cluster_set_connect_timeout(CassCluster* cluster, unsigned timeout_ms) {
   cluster->config().set_connect_timeout(timeout_ms);
 }
 
-void cass_cluster_set_request_timeout(CassCluster* cluster,
-                                      unsigned timeout_ms) {
+void cass_cluster_set_request_timeout(CassCluster* cluster, unsigned timeout_ms) {
   cluster->config().set_request_timeout(timeout_ms);
 }
 
-void cass_cluster_set_resolve_timeout(CassCluster* cluster,
-                                      unsigned timeout_ms) {
+void cass_cluster_set_resolve_timeout(CassCluster* cluster, unsigned timeout_ms) {
   cluster->config().set_resolve_timeout(timeout_ms);
 }
 
-void cass_cluster_set_max_schema_wait_time(CassCluster* cluster,
-                                           unsigned wait_time_ms) {
+void cass_cluster_set_max_schema_wait_time(CassCluster* cluster, unsigned wait_time_ms) {
   cluster->config().set_max_schema_wait_time_ms(wait_time_ms);
 }
 
-void cass_cluster_set_tracing_max_wait_time(CassCluster* cluster,
-                                            unsigned wait_time_ms) {
+void cass_cluster_set_tracing_max_wait_time(CassCluster* cluster, unsigned wait_time_ms) {
   cluster->config().set_max_tracing_wait_time_ms(wait_time_ms);
 }
 
-void cass_cluster_set_tracing_retry_wait_time(CassCluster* cluster,
-                                              unsigned wait_time_ms) {
+void cass_cluster_set_tracing_retry_wait_time(CassCluster* cluster, unsigned wait_time_ms) {
   cluster->config().set_retry_tracing_wait_time_ms(wait_time_ms);
 }
 
-void cass_cluster_set_tracing_consistency(CassCluster* cluster,
-                                          CassConsistency consistency) {
+void cass_cluster_set_tracing_consistency(CassCluster* cluster, CassConsistency consistency) {
   cluster->config().set_tracing_consistency(consistency);
 }
 
-void cass_cluster_set_credentials(CassCluster* cluster,
-                                  const char* username,
+void cass_cluster_set_credentials(CassCluster* cluster, const char* username,
                                   const char* password) {
-  return cass_cluster_set_credentials_n(cluster,
-                                        username, SAFE_STRLEN(username),
-                                        password, SAFE_STRLEN(password));
+  return cass_cluster_set_credentials_n(cluster, username, SAFE_STRLEN(username), password,
+                                        SAFE_STRLEN(password));
 }
 
-void cass_cluster_set_credentials_n(CassCluster* cluster,
-                                    const char* username,
-                                    size_t username_length,
-                                    const char* password,
+void cass_cluster_set_credentials_n(CassCluster* cluster, const char* username,
+                                    size_t username_length, const char* password,
                                     size_t password_length) {
-  cluster->config().set_credentials(cass::String(username, username_length),
-                                    cass::String(password, password_length));
+  cluster->config().set_credentials(String(username, username_length),
+                                    String(password, password_length));
 }
 
 void cass_cluster_set_load_balance_round_robin(CassCluster* cluster) {
-  cluster->config().set_load_balancing_policy(new cass::RoundRobinPolicy());
+  cluster->config().set_load_balancing_policy(new RoundRobinPolicy());
 }
 
-CassError cass_cluster_set_load_balance_dc_aware(CassCluster* cluster,
-                                                 const char* local_dc,
+CassError cass_cluster_set_load_balance_dc_aware(CassCluster* cluster, const char* local_dc,
                                                  unsigned used_hosts_per_remote_dc,
                                                  cass_bool_t allow_remote_dcs_for_local_cl) {
   if (local_dc == NULL) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  return cass_cluster_set_load_balance_dc_aware_n(cluster,
-                                                  local_dc,
-                                                  SAFE_STRLEN(local_dc),
+  return cass_cluster_set_load_balance_dc_aware_n(cluster, local_dc, SAFE_STRLEN(local_dc),
                                                   used_hosts_per_remote_dc,
                                                   allow_remote_dcs_for_local_cl);
 }
 
-CassError cass_cluster_set_load_balance_dc_aware_n(CassCluster* cluster,
-                                                   const char* local_dc,
+CassError cass_cluster_set_load_balance_dc_aware_n(CassCluster* cluster, const char* local_dc,
                                                    size_t local_dc_length,
                                                    unsigned used_hosts_per_remote_dc,
                                                    cass_bool_t allow_remote_dcs_for_local_cl) {
   if (local_dc == NULL || local_dc_length == 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  cluster->config().set_load_balancing_policy(
-        new cass::DCAwarePolicy(cass::String(local_dc, local_dc_length),
-                                used_hosts_per_remote_dc,
-                                !allow_remote_dcs_for_local_cl));
+  cluster->config().set_load_balancing_policy(new DCAwarePolicy(
+      String(local_dc, local_dc_length), used_hosts_per_remote_dc, !allow_remote_dcs_for_local_cl));
   return CASS_OK;
 }
 
-void cass_cluster_set_token_aware_routing(CassCluster* cluster,
-                                          cass_bool_t enabled) {
+void cass_cluster_set_token_aware_routing(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_token_aware_routing(enabled == cass_true);
 }
 
@@ -295,18 +281,14 @@ void cass_cluster_set_token_aware_routing_shuffle_replicas(CassCluster* cluster,
   cluster->config().set_token_aware_routing_shuffle_replicas(enabled == cass_true);
 }
 
-void cass_cluster_set_latency_aware_routing(CassCluster* cluster,
-                                            cass_bool_t enabled) {
+void cass_cluster_set_latency_aware_routing(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_latency_aware_routing(enabled == cass_true);
 }
 
-void cass_cluster_set_latency_aware_routing_settings(CassCluster* cluster,
-                                                     cass_double_t exclusion_threshold,
-                                                     cass_uint64_t scale_ms,
-                                                     cass_uint64_t retry_period_ms,
-                                                     cass_uint64_t update_rate_ms,
-                                                     cass_uint64_t min_measured) {
-  cass::LatencyAwarePolicy::Settings settings;
+void cass_cluster_set_latency_aware_routing_settings(
+    CassCluster* cluster, cass_double_t exclusion_threshold, cass_uint64_t scale_ms,
+    cass_uint64_t retry_period_ms, cass_uint64_t update_rate_ms, cass_uint64_t min_measured) {
+  LatencyAwarePolicy::Settings settings;
   settings.exclusion_threshold = exclusion_threshold;
   settings.scale_ns = scale_ms * 1000 * 1000;
   settings.retry_period_ns = retry_period_ms * 1000 * 1000;
@@ -315,126 +297,96 @@ void cass_cluster_set_latency_aware_routing_settings(CassCluster* cluster,
   cluster->config().set_latency_aware_routing_settings(settings);
 }
 
-void cass_cluster_set_whitelist_filtering(CassCluster* cluster,
-                                          const char* hosts) {
-  cass_cluster_set_whitelist_filtering_n(cluster,
-                                         hosts,
-                                         SAFE_STRLEN(hosts));
+void cass_cluster_set_whitelist_filtering(CassCluster* cluster, const char* hosts) {
+  cass_cluster_set_whitelist_filtering_n(cluster, hosts, SAFE_STRLEN(hosts));
 }
 
-void cass_cluster_set_whitelist_filtering_n(CassCluster* cluster,
-                                            const char* hosts,
+void cass_cluster_set_whitelist_filtering_n(CassCluster* cluster, const char* hosts,
                                             size_t hosts_length) {
   if (hosts_length == 0) {
     cluster->config().default_profile().whitelist().clear();
   } else {
-    cass::explode(cass::String(hosts, hosts_length),
-                  cluster->config().default_profile().whitelist());
+    explode(String(hosts, hosts_length), cluster->config().default_profile().whitelist());
   }
 }
 
-void cass_cluster_set_blacklist_filtering(CassCluster* cluster,
-                                          const char* hosts) {
-  cass_cluster_set_blacklist_filtering_n(cluster,
-                                         hosts,
-                                         SAFE_STRLEN(hosts));
+void cass_cluster_set_blacklist_filtering(CassCluster* cluster, const char* hosts) {
+  cass_cluster_set_blacklist_filtering_n(cluster, hosts, SAFE_STRLEN(hosts));
 }
 
-void cass_cluster_set_blacklist_filtering_n(CassCluster* cluster,
-                                            const char* hosts,
+void cass_cluster_set_blacklist_filtering_n(CassCluster* cluster, const char* hosts,
                                             size_t hosts_length) {
   if (hosts_length == 0) {
     cluster->config().default_profile().blacklist().clear();
   } else {
-    cass::explode(cass::String(hosts, hosts_length),
-                  cluster->config().default_profile().blacklist());
+    explode(String(hosts, hosts_length), cluster->config().default_profile().blacklist());
   }
 }
 
-void cass_cluster_set_whitelist_dc_filtering(CassCluster* cluster,
-                                             const char* dcs) {
-  cass_cluster_set_whitelist_dc_filtering_n(cluster,
-                                            dcs,
-                                            SAFE_STRLEN(dcs));
+void cass_cluster_set_whitelist_dc_filtering(CassCluster* cluster, const char* dcs) {
+  cass_cluster_set_whitelist_dc_filtering_n(cluster, dcs, SAFE_STRLEN(dcs));
 }
 
-void cass_cluster_set_whitelist_dc_filtering_n(CassCluster* cluster,
-                                               const char* dcs,
+void cass_cluster_set_whitelist_dc_filtering_n(CassCluster* cluster, const char* dcs,
                                                size_t dcs_length) {
   if (dcs_length == 0) {
     cluster->config().default_profile().whitelist_dc().clear();
   } else {
-    cass::explode(cass::String(dcs, dcs_length),
-                  cluster->config().default_profile().whitelist_dc());
+    explode(String(dcs, dcs_length), cluster->config().default_profile().whitelist_dc());
   }
 }
 
-void cass_cluster_set_blacklist_dc_filtering(CassCluster* cluster,
-                                             const char* dcs) {
-  cass_cluster_set_blacklist_dc_filtering_n(cluster,
-                                            dcs,
-                                            SAFE_STRLEN(dcs));
+void cass_cluster_set_blacklist_dc_filtering(CassCluster* cluster, const char* dcs) {
+  cass_cluster_set_blacklist_dc_filtering_n(cluster, dcs, SAFE_STRLEN(dcs));
 }
 
-void cass_cluster_set_blacklist_dc_filtering_n(CassCluster* cluster,
-                                               const char* dcs,
+void cass_cluster_set_blacklist_dc_filtering_n(CassCluster* cluster, const char* dcs,
                                                size_t dcs_length) {
   if (dcs_length == 0) {
     cluster->config().default_profile().blacklist_dc().clear();
   } else {
-    cass::explode(cass::String(dcs, dcs_length),
-                  cluster->config().default_profile().blacklist_dc());
+    explode(String(dcs, dcs_length), cluster->config().default_profile().blacklist_dc());
   }
 }
 
-void cass_cluster_set_tcp_nodelay(CassCluster* cluster,
-                                  cass_bool_t enabled) {
+void cass_cluster_set_tcp_nodelay(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_tcp_nodelay(enabled == cass_true);
 }
 
-void cass_cluster_set_tcp_keepalive(CassCluster* cluster,
-                                    cass_bool_t enabled,
+void cass_cluster_set_tcp_keepalive(CassCluster* cluster, cass_bool_t enabled,
                                     unsigned delay_secs) {
   cluster->config().set_tcp_keepalive(enabled == cass_true, delay_secs);
 }
 
-CassError cass_cluster_set_authenticator_callbacks(CassCluster* cluster,
-                                                   const CassAuthenticatorCallbacks* exchange_callbacks,
-                                                   CassAuthenticatorDataCleanupCallback cleanup_callback,
-                                                   void* data) {
-  cluster->config().set_auth_provider(cass::AuthProvider::Ptr(
-                                        new cass::ExternalAuthProvider(exchange_callbacks,
-                                                                       cleanup_callback, data)));
+CassError cass_cluster_set_authenticator_callbacks(
+    CassCluster* cluster, const CassAuthenticatorCallbacks* exchange_callbacks,
+    CassAuthenticatorDataCleanupCallback cleanup_callback, void* data) {
+  cluster->config().set_auth_provider(
+      AuthProvider::Ptr(new ExternalAuthProvider(exchange_callbacks, cleanup_callback, data)));
   return CASS_OK;
 }
 
-void cass_cluster_set_connection_heartbeat_interval(CassCluster* cluster,
-                                                    unsigned interval_secs) {
+void cass_cluster_set_connection_heartbeat_interval(CassCluster* cluster, unsigned interval_secs) {
   cluster->config().set_connection_heartbeat_interval_secs(interval_secs);
 }
 
-void cass_cluster_set_connection_idle_timeout(CassCluster* cluster,
-                                              unsigned timeout_secs) {
+void cass_cluster_set_connection_idle_timeout(CassCluster* cluster, unsigned timeout_secs) {
   cluster->config().set_connection_idle_timeout_secs(timeout_secs);
 }
 
-void cass_cluster_set_retry_policy(CassCluster* cluster,
-                                   CassRetryPolicy* retry_policy) {
+void cass_cluster_set_retry_policy(CassCluster* cluster, CassRetryPolicy* retry_policy) {
   cluster->config().set_retry_policy(retry_policy);
 }
 
-void cass_cluster_set_timestamp_gen(CassCluster* cluster,
-                                    CassTimestampGen* timestamp_gen) {
+void cass_cluster_set_timestamp_gen(CassCluster* cluster, CassTimestampGen* timestamp_gen) {
   cluster->config().set_timestamp_gen(timestamp_gen);
 }
 
-void cass_cluster_set_use_schema(CassCluster* cluster,
-                                 cass_bool_t enabled) {
+void cass_cluster_set_use_schema(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_use_schema(enabled == cass_true);
 }
 
-CassError cass_cluster_set_use_hostname_resolution(CassCluster* cluster,
-                                                   cass_bool_t enabled) {
+CassError cass_cluster_set_use_hostname_resolution(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_use_hostname_resolution(enabled == cass_true);
   return CASS_OK;
 }
@@ -452,68 +404,53 @@ CassError cass_cluster_set_constant_speculative_execution_policy(CassCluster* cl
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
   cluster->config().set_speculative_execution_policy(
-        new cass::ConstantSpeculativeExecutionPolicy(constant_delay_ms,
-                                                     max_speculative_executions));
+      new ConstantSpeculativeExecutionPolicy(constant_delay_ms, max_speculative_executions));
   return CASS_OK;
 }
 
 CassError cass_cluster_set_no_speculative_execution_policy(CassCluster* cluster) {
-  cluster->config().set_speculative_execution_policy(
-        new cass::NoSpeculativeExecutionPolicy());
+  cluster->config().set_speculative_execution_policy(new NoSpeculativeExecutionPolicy());
   return CASS_OK;
 }
 
-CassError cass_cluster_set_max_reusable_write_objects(CassCluster* cluster,
-                                                      unsigned num_objects) {
+CassError cass_cluster_set_max_reusable_write_objects(CassCluster* cluster, unsigned num_objects) {
   cluster->config().set_max_reusable_write_objects(num_objects);
   return CASS_OK;
 }
 
-CassError cass_cluster_set_execution_profile(CassCluster* cluster,
-                                             const char* name,
+CassError cass_cluster_set_execution_profile(CassCluster* cluster, const char* name,
                                              CassExecProfile* profile) {
-  return cass_cluster_set_execution_profile_n(cluster,
-                                              name,
-                                              SAFE_STRLEN(name),
-                                              profile);
+  return cass_cluster_set_execution_profile_n(cluster, name, SAFE_STRLEN(name), profile);
 }
 
-CassError cass_cluster_set_execution_profile_n(CassCluster* cluster,
-                                               const char* name,
-                                               size_t name_length,
-                                               CassExecProfile* profile) {
+CassError cass_cluster_set_execution_profile_n(CassCluster* cluster, const char* name,
+                                               size_t name_length, CassExecProfile* profile) {
   if (name_length == 0 || !profile) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  cluster->config().set_execution_profile(cass::String(name, name_length),
-                                          profile);
+  cluster->config().set_execution_profile(String(name, name_length), profile);
   return CASS_OK;
 }
 
-CassError cass_cluster_set_prepare_on_all_hosts(CassCluster* cluster,
-                                                cass_bool_t enabled){
+CassError cass_cluster_set_prepare_on_all_hosts(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_prepare_on_all_hosts(enabled == cass_true);
   return CASS_OK;
 }
 
-CassError cass_cluster_set_prepare_on_up_or_add_host(CassCluster* cluster,
-                                                     cass_bool_t enabled) {
+CassError cass_cluster_set_prepare_on_up_or_add_host(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_prepare_on_up_or_add_host(enabled == cass_true);
   return CASS_OK;
 }
 
-CassError cass_cluster_set_local_address(CassCluster* cluster,
-                                         const char* name) {
+CassError cass_cluster_set_local_address(CassCluster* cluster, const char* name) {
   return cass_cluster_set_local_address_n(cluster, name, SAFE_STRLEN(name));
 }
 
-CassError cass_cluster_set_local_address_n(CassCluster* cluster,
-                                           const char* name,
+CassError cass_cluster_set_local_address_n(CassCluster* cluster, const char* name,
                                            size_t name_length) {
-  cass::Address address;  // default to AF_UNSPEC
-  if (name_length == 0 ||
-      name == NULL ||
-      cass::Address::from_string(cass::String(name, name_length), 0, &address)) {
+  Address address; // default to AF_UNSPEC
+  if (name_length == 0 || name == NULL ||
+      Address::from_string(String(name, name_length), 0, &address)) {
     cluster->config().set_local_address(address);
   } else {
     return CASS_ERROR_LIB_HOST_RESOLUTION;
@@ -521,23 +458,18 @@ CassError cass_cluster_set_local_address_n(CassCluster* cluster,
   return CASS_OK;
 }
 
-CassError cass_cluster_set_no_compact(CassCluster* cluster,
-                                      cass_bool_t enabled) {
+CassError cass_cluster_set_no_compact(CassCluster* cluster, cass_bool_t enabled) {
   cluster->config().set_no_compact(enabled == cass_true);
   return CASS_OK;
 }
 
 CassError cass_cluster_set_host_listener_callback(CassCluster* cluster,
-                                                  CassHostListenerCallback callback,
-                                                  void* data) {
+                                                  CassHostListenerCallback callback, void* data) {
   cluster->config().set_host_listener(
-        cass::DefaultHostListener::Ptr(
-          new cass::ExternalHostListener(callback, data)));
+      DefaultHostListener::Ptr(new ExternalHostListener(callback, data)));
   return CASS_OK;
 }
 
-void cass_cluster_free(CassCluster* cluster) {
-  delete cluster->from();
-}
+void cass_cluster_free(CassCluster* cluster) { delete cluster->from(); }
 
 } // extern "C"
diff --git a/src/cluster_config.hpp b/src/cluster_config.hpp
index 79a4062c8..0010b44db 100644
--- a/src/cluster_config.hpp
+++ b/src/cluster_config.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CLUSTER_CONFIG_HPP_INCLUDED__
-#define __CASS_CLUSTER_CONFIG_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CLUSTER_CONFIG_HPP
+#define DATASTAX_INTERNAL_CLUSTER_CONFIG_HPP
 
 #include "allocated.hpp"
 #include "config.hpp"
@@ -23,7 +23,7 @@
 
 #include "uv.h"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ClusterConfig : public Allocated {
 public:
@@ -34,8 +34,8 @@ class ClusterConfig : public Allocated {
   Config config_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::ClusterConfig, CassCluster)
+EXTERNAL_TYPE(datastax::internal::core::ClusterConfig, CassCluster)
 
 #endif
diff --git a/src/cluster_connector.cpp b/src/cluster_connector.cpp
index 3f2e1fe27..f13cb4a80 100644
--- a/src/cluster_connector.cpp
+++ b/src/cluster_connector.cpp
@@ -20,7 +20,11 @@
 #include "random.hpp"
 #include "round_robin_policy.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A task for running the connection process.
@@ -28,11 +32,9 @@ namespace cass {
 class RunResolveAndConnectCluster : public Task {
 public:
   RunResolveAndConnectCluster(const ClusterConnector::Ptr& connector)
-    : connector_(connector) { }
+      : connector_(connector) {}
 
-  void run(EventLoop* event_loop) {
-    connector_->internal_resolve_and_connect();
-  }
+  void run(EventLoop* event_loop) { connector_->internal_resolve_and_connect(); }
 
 private:
   ClusterConnector::Ptr connector_;
@@ -44,29 +46,28 @@ class RunResolveAndConnectCluster : public Task {
 class RunCancelCluster : public Task {
 public:
   RunCancelCluster(const ClusterConnector::Ptr& connector)
-    : connector_(connector) { }
+      : connector_(connector) {}
 
-  void run(EventLoop* event_loop) {
-    connector_->internal_cancel();
-  }
+  void run(EventLoop* event_loop) { connector_->internal_cancel(); }
 
 private:
   ClusterConnector::Ptr connector_;
 };
 
+}}} // namespace datastax::internal::core
+
 ClusterConnector::ClusterConnector(const ContactPointList& contact_points,
-                                   ProtocolVersion protocol_version,
-                                   const Callback& callback)
-  : remaining_connector_count_(0)
-  , contact_points_(contact_points)
-  , protocol_version_(protocol_version)
-  , listener_(NULL)
-  , event_loop_(NULL)
-  , random_(NULL)
-  , metrics_(NULL)
-  , callback_(callback)
-  , error_code_(CLUSTER_OK)
-  , ssl_error_code_(CASS_OK) { }
+                                   ProtocolVersion protocol_version, const Callback& callback)
+    : remaining_connector_count_(0)
+    , contact_points_(contact_points)
+    , protocol_version_(protocol_version)
+    , listener_(NULL)
+    , event_loop_(NULL)
+    , random_(NULL)
+    , metrics_(NULL)
+    , callback_(callback)
+    , error_code_(CLUSTER_OK)
+    , ssl_error_code_(CASS_OK) {}
 
 ClusterConnector* ClusterConnector::with_listener(ClusterListener* listener) {
   listener_ = listener;
@@ -107,8 +108,8 @@ void ClusterConnector::internal_resolve_and_connect() {
     random_shuffle(contact_points_.begin(), contact_points_.end(), random_);
   }
 
-  for (ContactPointList::const_iterator it = contact_points_.begin(),
-       end = contact_points_.end(); it != end; ++it) {
+  for (ContactPointList::const_iterator it = contact_points_.begin(), end = contact_points_.end();
+       it != end; ++it) {
     const String& contact_point = *it;
     Address address;
     // Attempt to parse the contact point string. If it's an IP address
@@ -118,14 +119,11 @@ void ClusterConnector::internal_resolve_and_connect() {
       contact_points_resolved_.push_back(address);
     } else {
       if (!resolver_) {
-        resolver_.reset(
-              new MultiResolver(
-                bind_callback(&ClusterConnector::on_resolve, this)));
+        resolver_.reset(new MultiResolver(bind_callback(&ClusterConnector::on_resolve, this)));
       }
-      resolver_->resolve(event_loop_->loop(),
-                         contact_point,
-                         settings_.port,
-                         settings_.control_connection_settings.connection_settings.socket_settings.resolve_timeout_ms);
+      resolver_->resolve(event_loop_->loop(), contact_point, settings_.port,
+                         settings_.control_connection_settings.connection_settings.socket_settings
+                             .resolve_timeout_ms);
     }
   }
 
@@ -136,12 +134,10 @@ void ClusterConnector::internal_resolve_and_connect() {
 
 void ClusterConnector::internal_connect(const Address& address, ProtocolVersion version) {
   Host::Ptr host(new Host(address));
-  ControlConnector::Ptr connector(new ControlConnector(host,
-                                                       version,
-                                                       bind_callback(&ClusterConnector::on_connect, this)));
+  ControlConnector::Ptr connector(
+      new ControlConnector(host, version, bind_callback(&ClusterConnector::on_connect, this)));
   connectors_[address] = connector; // Keep track of the connectors so they can be canceled.
-  connector
-      ->with_metrics(metrics_)
+  connector->with_metrics(metrics_)
       ->with_settings(settings_.control_connection_settings)
       ->connect(event_loop_->loop());
 }
@@ -155,7 +151,8 @@ void ClusterConnector::internal_connect_all() {
   }
   remaining_connector_count_ = contact_points_resolved_.size();
   for (AddressVec::const_iterator it = contact_points_resolved_.begin(),
-       end = contact_points_resolved_.end(); it != end; ++it) {
+                                  end = contact_points_resolved_.end();
+       it != end; ++it) {
     internal_connect(*it, protocol_version_);
   }
 }
@@ -163,8 +160,7 @@ void ClusterConnector::internal_connect_all() {
 void ClusterConnector::internal_cancel() {
   error_code_ = CLUSTER_CANCELED;
   if (resolver_) resolver_->cancel();
-  for (ConnectorMap::iterator it = connectors_.begin(),
-       end = connectors_.end(); it != end; ++it) {
+  for (ConnectorMap::iterator it = connectors_.begin(), end = connectors_.end(); it != end; ++it) {
     it->second->cancel();
   }
   if (cluster_) cluster_->close();
@@ -191,8 +187,7 @@ void ClusterConnector::maybe_finish() {
   }
 }
 
-void ClusterConnector::on_error(ClusterConnector::ClusterError code,
-                                const String& message) {
+void ClusterConnector::on_error(ClusterConnector::ClusterError code, const String& message) {
   assert(code != CLUSTER_OK && "Notified error without an error");
   error_message_ = message;
   error_code_ = code;
@@ -200,32 +195,32 @@ void ClusterConnector::on_error(ClusterConnector::ClusterError code,
 }
 
 void ClusterConnector::on_resolve(MultiResolver* resolver) {
-  if (is_canceled())  {
+  if (is_canceled()) {
     finish();
     return;
   }
 
   const Resolver::Vec& resolvers = resolver->resolvers();
-  for (Resolver::Vec::const_iterator it = resolvers.begin(),
-       end = resolvers.end(); it != end; ++it) {
+  for (Resolver::Vec::const_iterator it = resolvers.begin(), end = resolvers.end(); it != end;
+       ++it) {
     const Resolver::Ptr resolver(*it);
     if (resolver->is_success()) {
       const AddressVec& addresses = resolver->addresses();
       if (!addresses.empty()) {
-        for (AddressVec::const_iterator it = addresses.begin(),
-             end = addresses.end(); it != end;  ++it) {
+        for (AddressVec::const_iterator it = addresses.begin(), end = addresses.end(); it != end;
+             ++it) {
           contact_points_resolved_.push_back(*it);
         }
       } else {
-        LOG_ERROR("No addresses resolved for %s:%d\n",
-                  resolver->hostname().c_str(), resolver->port());
+        LOG_ERROR("No addresses resolved for %s:%d\n", resolver->hostname().c_str(),
+                  resolver->port());
       }
     } else if (resolver->is_timed_out()) {
-      LOG_ERROR("Timed out attempting to resolve address for %s:%d\n",
-                resolver->hostname().c_str(), resolver->port());
+      LOG_ERROR("Timed out attempting to resolve address for %s:%d\n", resolver->hostname().c_str(),
+                resolver->port());
     } else if (!resolver->is_canceled()) {
-      LOG_ERROR("Unable to resolve address for %s:%d\n",
-                resolver->hostname().c_str(), resolver->port());
+      LOG_ERROR("Unable to resolve address for %s:%d\n", resolver->hostname().c_str(),
+                resolver->port());
     }
   }
 
@@ -234,9 +229,9 @@ void ClusterConnector::on_resolve(MultiResolver* resolver) {
 
 void ClusterConnector::on_connect(ControlConnector* connector) {
   if (!connector->is_ok() && !connector->is_canceled()) {
-    LOG_ERROR("Unable to establish a control connection to host %s because of the following error: %s",
-              connector->address().to_string().c_str(),
-              connector->error_message().c_str());
+    LOG_ERROR(
+        "Unable to establish a control connection to host %s because of the following error: %s",
+        connector->address().to_string().c_str(), connector->error_message().c_str());
   }
 
   // If the cluster object is successfully initialized or if the connector is
@@ -268,13 +263,14 @@ void ClusterConnector::on_connect(ControlConnector* connector) {
     LoadBalancingPolicy::Ptr default_policy(settings_.load_balancing_policy->new_instance());
     policies.push_back(default_policy);
     for (LoadBalancingPolicy::Vec::const_iterator it = settings_.load_balancing_policies.begin(),
-         end = settings_.load_balancing_policies.end(); it != end; ++it) {
+                                                  end = settings_.load_balancing_policies.end();
+         it != end; ++it) {
       policies.push_back(LoadBalancingPolicy::Ptr((*it)->new_instance()));
     }
 
     // Initialize all created policies
-    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(),
-         end = policies.end(); it != end; ++it) {
+    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(), end = policies.end();
+         it != end; ++it) {
       LoadBalancingPolicy::Ptr policy(*it);
       policy->init(connected_host, hosts, random_);
       policy->register_handles(event_loop_->loop());
@@ -288,26 +284,21 @@ void ClusterConnector::on_connect(ControlConnector* connector) {
                 connector->address().to_string().c_str());
 
       const char* message;
-      if (dynamic_cast<DCAwarePolicy::DCAwareQueryPlan*>(query_plan.get()) != NULL) { // Check if DC-aware
-        message = "No hosts available for the control connection using the " \
-                  "DC-aware load balancing policy. " \
+      if (dynamic_cast<DCAwarePolicy::DCAwareQueryPlan*>(query_plan.get()) !=
+          NULL) { // Check if DC-aware
+        message = "No hosts available for the control connection using the "
+                  "DC-aware load balancing policy. "
                   "Check to see if the configured local datacenter is valid";
       } else {
-        message = "No hosts available for the control connection using the " \
+        message = "No hosts available for the control connection using the "
                   "configured load balancing policy";
       }
       on_error(CLUSTER_ERROR_NO_HOSTS_AVAILABLE, message);
       return;
     }
 
-    cluster_.reset(new Cluster(connector->release_connection(),
-                               listener_,
-                               event_loop_,
-                               connected_host,
-                               hosts,
-                               connector->schema(),
-                               default_policy,
-                               policies,
+    cluster_.reset(new Cluster(connector->release_connection(), listener_, event_loop_,
+                               connected_host, hosts, connector->schema(), default_policy, policies,
                                settings_));
 
     // Clear any connection errors and set the final negotiated protocol version.
@@ -316,8 +307,8 @@ void ClusterConnector::on_connect(ControlConnector* connector) {
     protocol_version_ = connector->protocol_version();
 
     // The cluster is initialized so the rest of the connectors can be canceled.
-    for (ConnectorMap::iterator it = connectors_.begin(),
-         end = connectors_.end(); it != end; ++it) {
+    for (ConnectorMap::iterator it = connectors_.begin(), end = connectors_.end(); it != end;
+         ++it) {
       if (it->first != connector->address()) { // Not the current connector.
         it->second->cancel();
       }
@@ -327,15 +318,14 @@ void ClusterConnector::on_connect(ControlConnector* connector) {
   } else if (connector->is_invalid_protocol()) {
     ProtocolVersion lower_version(connector->protocol_version());
     if (!lower_version.attempt_lower_supported(connector->address().to_string())) {
-      on_error(CLUSTER_ERROR_INVALID_PROTOCOL,
-               "Unable to find supported protocol version");
+      on_error(CLUSTER_ERROR_INVALID_PROTOCOL, "Unable to find supported protocol version");
       return;
     }
     internal_connect(connector->address(), lower_version);
-  } else if(connector->is_ssl_error()) {
+  } else if (connector->is_ssl_error()) {
     ssl_error_code_ = connector->ssl_error_code();
     on_error(CLUSTER_ERROR_SSL_ERROR, connector->error_message());
-  } else if(connector->is_auth_error()) {
+  } else if (connector->is_auth_error()) {
     on_error(CLUSTER_ERROR_AUTH_ERROR, connector->error_message());
   } else {
     assert(!connector->is_canceled() &&
@@ -343,5 +333,3 @@ void ClusterConnector::on_connect(ControlConnector* connector) {
     on_error(CLUSTER_ERROR_NO_HOSTS_AVAILABLE, connector->error_message());
   }
 }
-
-} // namespace cass
diff --git a/src/cluster_connector.hpp b/src/cluster_connector.hpp
index 59f895665..70d943ad4 100644
--- a/src/cluster_connector.hpp
+++ b/src/cluster_connector.hpp
@@ -14,16 +14,19 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CLUSTER_CONNECTOR_HPP_INCLUDED__
-#define __CASS_CLUSTER_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CLUSTER_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_CLUSTER_CONNECTOR_HPP
 
 #include "callback.hpp"
 #include "cluster.hpp"
 #include "resolver.hpp"
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Random;
+
+namespace core {
+
 class Metrics;
 
 /**
@@ -37,7 +40,7 @@ class ClusterConnector : public RefCounted<ClusterConnector> {
 public:
   typedef SharedRefPtr<ClusterConnector> Ptr;
 
-  typedef cass::Callback<void, ClusterConnector*> Callback;
+  typedef internal::Callback<void, ClusterConnector*> Callback;
 
   enum ClusterError {
     CLUSTER_OK,
@@ -57,8 +60,7 @@ class ClusterConnector : public RefCounted<ClusterConnector> {
    * @param callback A callback that is called when a connection to a contact
    * point is established, if an error occurred, or all contact points failed.
    */
-  ClusterConnector(const ContactPointList& contact_points,
-                   ProtocolVersion protocol_version,
+  ClusterConnector(const ContactPointList& contact_points, ProtocolVersion protocol_version,
                    const Callback& callback);
 
   /**
@@ -67,7 +69,7 @@ class ClusterConnector : public RefCounted<ClusterConnector> {
    * @param listener A listener that handles cluster events.
    * @return The connector to chain calls.
    */
-  ClusterConnector* with_listener(ClusterListener*  listener);
+  ClusterConnector* with_listener(ClusterListener* listener);
 
   /**
    * Set the random object to use for shuffling the contact points and load
@@ -87,7 +89,6 @@ class ClusterConnector : public RefCounted<ClusterConnector> {
    */
   ClusterConnector* with_metrics(Metrics* metrics);
 
-
   /**
    * Set the cluster and underlying control connection settings.
    *
@@ -177,6 +178,7 @@ class ClusterConnector : public RefCounted<ClusterConnector> {
   CassError ssl_error_code_;
 };
 
-} // namespace cass
+} // namespace core
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/collection.cpp b/src/collection.cpp
index 2fe6af848..8aa246a60 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -24,11 +24,13 @@
 
 #include <string.h>
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-CassCollection* cass_collection_new(CassCollectionType type,
-                                    size_t item_count) {
-  cass::Collection* collection = new cass::Collection(type, item_count);
+CassCollection* cass_collection_new(CassCollectionType type, size_t item_count) {
+  Collection* collection = new Collection(type, item_count);
   collection->inc_ref();
   return CassCollection::to(collection);
 }
@@ -38,27 +40,23 @@ CassCollection* cass_collection_new_from_data_type(const CassDataType* data_type
   if (!data_type->is_collection()) {
     return NULL;
   }
-  cass::Collection* collection
-      = new cass::Collection(cass::DataType::ConstPtr(data_type),
-                             item_count);
+  Collection* collection = new Collection(DataType::ConstPtr(data_type), item_count);
   collection->inc_ref();
   return CassCollection::to(collection);
 }
 
-void cass_collection_free(CassCollection* collection) {
-  collection->dec_ref();
-}
+void cass_collection_free(CassCollection* collection) { collection->dec_ref(); }
 
 const CassDataType* cass_collection_data_type(const CassCollection* collection) {
   return CassDataType::to(collection->data_type().get());
 }
 
-#define CASS_COLLECTION_APPEND(Name, Params, Value)                           \
- CassError cass_collection_append_##Name(CassCollection* collection Params) { \
-   return collection->append(Value);                                          \
- }
+#define CASS_COLLECTION_APPEND(Name, Params, Value)                            \
+  CassError cass_collection_append_##Name(CassCollection* collection Params) { \
+    return collection->append(Value);                                          \
+  }
 
-CASS_COLLECTION_APPEND(null, ZERO_PARAMS_(), cass::CassNull())
+CASS_COLLECTION_APPEND(null, ZERO_PARAMS_(), CassNull())
 CASS_COLLECTION_APPEND(int8, ONE_PARAM_(cass_int8_t value), value)
 CASS_COLLECTION_APPEND(int16, ONE_PARAM_(cass_int16_t value), value)
 CASS_COLLECTION_APPEND(int32, ONE_PARAM_(cass_int32_t value), value)
@@ -72,50 +70,40 @@ CASS_COLLECTION_APPEND(inet, ONE_PARAM_(CassInet value), value)
 CASS_COLLECTION_APPEND(collection, ONE_PARAM_(const CassCollection* value), value)
 CASS_COLLECTION_APPEND(tuple, ONE_PARAM_(const CassTuple* value), value)
 CASS_COLLECTION_APPEND(user_type, ONE_PARAM_(const CassUserType* value), value)
-CASS_COLLECTION_APPEND(bytes,
-                       TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
-                       cass::CassBytes(value, value_size))
+CASS_COLLECTION_APPEND(bytes, TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
+                       CassBytes(value, value_size))
 CASS_COLLECTION_APPEND(decimal,
                        THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
-                       cass::CassDecimal(varint, varint_size, scale))
+                       CassDecimal(varint, varint_size, scale))
 CASS_COLLECTION_APPEND(duration,
                        THREE_PARAMS_(cass_int32_t months, cass_int32_t days, cass_int64_t nanos),
-                       cass::CassDuration(months, days, nanos))
+                       CassDuration(months, days, nanos))
 
 #undef CASS_COLLECTION_APPEND
 
-CassError cass_collection_append_string(CassCollection* collection,
-                                        const char* value) {
-  return collection->append(cass::CassString(value, SAFE_STRLEN(value)));
+CassError cass_collection_append_string(CassCollection* collection, const char* value) {
+  return collection->append(CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_collection_append_string_n(CassCollection* collection,
-                                          const char* value,
+CassError cass_collection_append_string_n(CassCollection* collection, const char* value,
                                           size_t value_length) {
-  return collection->append(cass::CassString(value, value_length));
+  return collection->append(CassString(value, value_length));
 }
 
-CassError cass_collection_append_custom(CassCollection* collection,
-                                        const char* class_name,
-                                        const cass_byte_t* value,
-                                        size_t value_size) {
-  return collection->append(cass::CassCustom(cass::StringRef(class_name),
-                                             value, value_size));
+CassError cass_collection_append_custom(CassCollection* collection, const char* class_name,
+                                        const cass_byte_t* value, size_t value_size) {
+  return collection->append(CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_collection_append_custom_n(CassCollection* collection,
-                                          const char* class_name,
-                                          size_t class_name_length,
-                                          const cass_byte_t* value,
+CassError cass_collection_append_custom_n(CassCollection* collection, const char* class_name,
+                                          size_t class_name_length, const cass_byte_t* value,
                                           size_t value_size) {
-  return collection->append(cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                             value, value_size));
+  return collection->append(
+      CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
 } // extern "C"
 
-namespace cass {
-
 CassError Collection::append(CassNull value) {
   CASS_COLLECTION_CHECK_TYPE(value);
   items_.push_back(Buffer());
@@ -142,8 +130,7 @@ CassError Collection::append(const UserTypeValue* value) {
 
 size_t Collection::get_items_size() const {
   size_t size = 0;
-  for (BufferVec::const_iterator i = items_.begin(),
-       end = items_.end(); i != end; ++i) {
+  for (BufferVec::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) {
     size += sizeof(int32_t);
     size += i->size();
   }
@@ -151,8 +138,7 @@ size_t Collection::get_items_size() const {
 }
 
 void Collection::encode_items(char* buf) const {
-  for (BufferVec::const_iterator i = items_.begin(),
-       end = items_.end(); i != end; ++i) {
+  for (BufferVec::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) {
     encode_int32(buf, i->size());
     buf += sizeof(int32_t);
     memcpy(buf, i->data(), i->size());
@@ -160,13 +146,9 @@ void Collection::encode_items(char* buf) const {
   }
 }
 
-size_t Collection::get_size() const {
-  return sizeof(int32_t) + get_items_size();
-}
+size_t Collection::get_size() const { return sizeof(int32_t) + get_items_size(); }
 
-size_t Collection::get_size_with_length() const {
-  return sizeof(int32_t) + get_size();
-}
+size_t Collection::get_size_with_length() const { return sizeof(int32_t) + get_size(); }
 
 Buffer Collection::encode() const {
   Buffer buf(get_size());
@@ -183,5 +165,3 @@ Buffer Collection::encode_with_length() const {
   encode_items(buf.data() + pos);
   return buf;
 }
-
-}  // namespace cass
diff --git a/src/collection.hpp b/src/collection.hpp
index 21e5e646d..0637ad92f 100644
--- a/src/collection.hpp
+++ b/src/collection.hpp
@@ -14,37 +14,36 @@
   limitations under the License.
 */
 
-#ifndef __CASS_COLLECTION_HPP_INCLUDED__
-#define __CASS_COLLECTION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_COLLECTION_HPP
+#define DATASTAX_INTERNAL_COLLECTION_HPP
 
+#include "buffer.hpp"
 #include "cassandra.h"
 #include "data_type.hpp"
 #include "encode.hpp"
 #include "external.hpp"
-#include "buffer.hpp"
 #include "ref_counted.hpp"
 #include "types.hpp"
 
-#define CASS_COLLECTION_CHECK_TYPE(Value) do { \
-  CassError rc = check(Value);                 \
-  if (rc != CASS_OK) return rc;                \
-} while(0)
+#define CASS_COLLECTION_CHECK_TYPE(Value) \
+  do {                                    \
+    CassError rc = check(Value);          \
+    if (rc != CASS_OK) return rc;         \
+  } while (0)
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class UserTypeValue;
 
 class Collection : public RefCounted<Collection> {
 public:
-  Collection(CassCollectionType type,
-             size_t item_count)
-    : data_type_(new CollectionType(static_cast<CassValueType>(type), false)) {
+  Collection(CassCollectionType type, size_t item_count)
+      : data_type_(new CollectionType(static_cast<CassValueType>(type), false)) {
     items_.reserve(item_count);
   }
 
-  Collection(const CollectionType::ConstPtr& data_type,
-             size_t item_count)
-    : data_type_(data_type) {
+  Collection(const CollectionType::ConstPtr& data_type, size_t item_count)
+      : data_type_(data_type) {
     items_.reserve(item_count);
   }
 
@@ -58,7 +57,7 @@ class Collection : public RefCounted<Collection> {
 #define APPEND_TYPE(Type)                  \
   CassError append(const Type value) {     \
     CASS_COLLECTION_CHECK_TYPE(value);     \
-    items_.push_back(cass::encode(value)); \
+    items_.push_back(core::encode(value)); \
     return CASS_OK;                        \
   }
 
@@ -94,9 +93,7 @@ class Collection : public RefCounted<Collection> {
   Buffer encode() const;
   Buffer encode_with_length() const;
 
-  void clear() {
-    items_.clear();
-  }
+  void clear() { items_.clear(); }
 
 private:
   template <class T>
@@ -104,7 +101,7 @@ class Collection : public RefCounted<Collection> {
     IsValidDataType<T> is_valid_type;
     size_t index = items_.size();
 
-    switch(type()) {
+    switch (type()) {
       case CASS_COLLECTION_TYPE_MAP:
         if (data_type_->types().size() == 2 &&
             !is_valid_type(value, data_type_->types()[index % 2])) {
@@ -114,8 +111,7 @@ class Collection : public RefCounted<Collection> {
 
       case CASS_COLLECTION_TYPE_LIST:
       case CASS_COLLECTION_TYPE_SET:
-        if (data_type_->types().size() == 1 &&
-            !is_valid_type(value, data_type_->types()[0])) {
+        if (data_type_->types().size() == 1 && !is_valid_type(value, data_type_->types()[0])) {
           return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
         }
         break;
@@ -135,9 +131,8 @@ class Collection : public RefCounted<Collection> {
   DISALLOW_COPY_AND_ASSIGN(Collection);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Collection, CassCollection)
+EXTERNAL_TYPE(datastax::internal::core::Collection, CassCollection)
 
 #endif
-
diff --git a/src/collection_iterator.cpp b/src/collection_iterator.cpp
index 4a4c634d0..02a55dcfa 100644
--- a/src/collection_iterator.cpp
+++ b/src/collection_iterator.cpp
@@ -16,7 +16,7 @@
 
 #include "collection_iterator.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool CollectionIterator::next() {
   if (index_ + 1 >= count_) {
@@ -29,8 +29,8 @@ bool CollectionIterator::next() {
 bool CollectionIterator::decode_value() {
   DataType::ConstPtr data_type;
   if (collection_->value_type() == CASS_VALUE_TYPE_MAP) {
-    data_type = (index_ % 2 == 0) ? collection_->primary_data_type()
-                                  : collection_->secondary_data_type();
+    data_type =
+        (index_ % 2 == 0) ? collection_->primary_data_type() : collection_->secondary_data_type();
   } else {
     data_type = collection_->primary_data_type();
   }
@@ -45,5 +45,3 @@ bool TupleIterator::next() {
   current_ = next_++;
   return decoder_.decode_value(*current_, value_);
 }
-
-} // namespace cass
diff --git a/src/collection_iterator.hpp b/src/collection_iterator.hpp
index df17b084b..81ae86b95 100644
--- a/src/collection_iterator.hpp
+++ b/src/collection_iterator.hpp
@@ -14,25 +14,23 @@
   limitations under the License.
 */
 
-#ifndef __CASS_VALUE_ITERATOR_HPP_INCLUDED__
-#define __CASS_VALUE_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_VALUE_ITERATOR_HPP
+#define DATASTAX_INTERNAL_VALUE_ITERATOR_HPP
 
 #include "cassandra.h"
 #include "iterator.hpp"
 #include "serialization.hpp"
 #include "value.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ValueIterator : public Iterator {
 public:
   ValueIterator(CassIteratorType type, Decoder decoder)
-    : Iterator(type)
-    , decoder_(decoder) { }
+      : Iterator(type)
+      , decoder_(decoder) {}
 
-  const Value* value() const {
-    return &value_;
-  }
+  const Value* value() const { return &value_; }
 
 protected:
   Decoder decoder_;
@@ -45,9 +43,8 @@ class CollectionIterator : public ValueIterator {
       : ValueIterator(CASS_ITERATOR_TYPE_COLLECTION, collection->decoder())
       , collection_(collection)
       , index_(-1)
-      , count_(collection_->value_type() == CASS_VALUE_TYPE_MAP
-                   ? (2 * collection_->count())
-                   : collection->count()) {}
+      , count_(collection_->value_type() == CASS_VALUE_TYPE_MAP ? (2 * collection_->count())
+                                                                : collection->count()) {}
 
   virtual bool next();
 
@@ -78,6 +75,6 @@ class TupleIterator : public ValueIterator {
   DataType::Vec::const_iterator end_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/config.cpp b/src/config.cpp
index 6942221d2..86924ee23 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -16,12 +16,11 @@
 
 #include "config.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 void Config::init_profiles() {
   // Initialize the profile settings (if needed)
-  for (ExecutionProfile::Map::iterator it = profiles_.begin();
-        it != profiles_.end(); ++it) {
+  for (ExecutionProfile::Map::iterator it = profiles_.begin(); it != profiles_.end(); ++it) {
     if (it->second.consistency() == CASS_CONSISTENCY_UNKNOWN) {
       it->second.set_consistency(default_profile_.consistency());
     }
@@ -39,9 +38,8 @@ void Config::init_profiles() {
     }
 
     if (!it->second.speculative_execution_policy()) {
-      it->second.set_speculative_execution_policy(default_profile_.speculative_execution_policy()->new_instance());
+      it->second.set_speculative_execution_policy(
+          default_profile_.speculative_execution_policy()->new_instance());
     }
   }
 }
-
-} // namespace cass
diff --git a/src/config.hpp b/src/config.hpp
index f38b6efee..5265f05ee 100644
--- a/src/config.hpp
+++ b/src/config.hpp
@@ -14,22 +14,23 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONFIG_HPP_INCLUDED__
-#define __CASS_CONFIG_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONFIG_HPP
+#define DATASTAX_INTERNAL_CONFIG_HPP
 
 #include "auth.hpp"
 #include "cassandra.h"
 #include "constants.hpp"
 #include "execution_profile.hpp"
 #include "protocol.hpp"
-#include "ssl.hpp"
-#include "timestamp_generator.hpp"
+#include "reconnection_policy.hpp"
 #include "speculative_execution.hpp"
+#include "ssl.hpp"
 #include "string.hpp"
+#include "timestamp_generator.hpp"
 
 #include <climits>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 void stderr_log_callback(const CassLogMessage* message, void* data);
 
@@ -42,7 +43,7 @@ class Config {
       , thread_count_io_(CASS_DEFAULT_THREAD_COUNT_IO)
       , queue_size_io_(CASS_DEFAULT_QUEUE_SIZE_IO)
       , core_connections_per_host_(CASS_DEFAULT_NUM_CONNECTIONS_PER_HOST)
-      , reconnect_wait_time_ms_(CASS_DEFAULT_RECONNECT_WAIT_TIME_MS)
+      , reconnection_policy_(new ExponentialReconnectionPolicy())
       , connect_timeout_ms_(CASS_DEFAULT_CONNECT_TIMEOUT_MS)
       , resolve_timeout_ms_(CASS_DEFAULT_RESOLVE_TIMEOUT_MS)
       , max_schema_wait_time_ms_(CASS_DEFAULT_MAX_SCHEMA_WAIT_TIME_MS)
@@ -86,7 +87,8 @@ class Config {
     Config config = *this;
     config.default_profile_.build_load_balancing_policy();
     config.init_profiles(); // Initializes the profiles from default (if needed)
-    config.set_speculative_execution_policy(default_profile_.speculative_execution_policy()->new_instance());
+    config.set_speculative_execution_policy(
+        default_profile_.speculative_execution_policy()->new_instance());
 
     return config;
   }
@@ -103,71 +105,55 @@ class Config {
 
   unsigned thread_count_io() const { return thread_count_io_; }
 
-  void set_thread_count_io(unsigned num_threads) {
-    thread_count_io_ = num_threads;
-  }
+  void set_thread_count_io(unsigned num_threads) { thread_count_io_ = num_threads; }
 
   unsigned queue_size_io() const { return queue_size_io_; }
 
-  void set_queue_size_io(unsigned queue_size) {
-    queue_size_io_ = queue_size;
-  }
+  void set_queue_size_io(unsigned queue_size) { queue_size_io_ = queue_size; }
 
-  unsigned core_connections_per_host() const {
-    return core_connections_per_host_;
-  }
+  unsigned core_connections_per_host() const { return core_connections_per_host_; }
 
   void set_core_connections_per_host(unsigned num_connections) {
     core_connections_per_host_ = num_connections;
   }
 
-  unsigned reconnect_wait_time_ms() const { return reconnect_wait_time_ms_; }
+  ReconnectionPolicy::Ptr reconnection_policy() const { return reconnection_policy_; }
 
-  void set_reconnect_wait_time(unsigned wait_time_ms) {
-    reconnect_wait_time_ms_ = wait_time_ms;
+  void set_constant_reconnect(uint64_t wait_time_ms) {
+    reconnection_policy_.reset(new ConstantReconnectionPolicy(wait_time_ms));
+  }
+
+  void set_exponential_reconnect(uint64_t base_delay_ms, uint64_t max_delay_ms) {
+    reconnection_policy_.reset(new ExponentialReconnectionPolicy(base_delay_ms, max_delay_ms));
   }
 
   unsigned connect_timeout_ms() const { return connect_timeout_ms_; }
 
-  void set_connect_timeout(unsigned timeout_ms) {
-    connect_timeout_ms_ = timeout_ms;
-  }
+  void set_connect_timeout(unsigned timeout_ms) { connect_timeout_ms_ = timeout_ms; }
 
   unsigned max_schema_wait_time_ms() const { return max_schema_wait_time_ms_; }
 
-  void set_max_schema_wait_time_ms(unsigned time_ms) {
-    max_schema_wait_time_ms_ = time_ms;
-  }
+  void set_max_schema_wait_time_ms(unsigned time_ms) { max_schema_wait_time_ms_ = time_ms; }
 
   unsigned max_tracing_wait_time_ms() const { return max_tracing_wait_time_ms_; }
 
-  void set_max_tracing_wait_time_ms(unsigned time_ms) {
-    max_tracing_wait_time_ms_ = time_ms;
-  }
+  void set_max_tracing_wait_time_ms(unsigned time_ms) { max_tracing_wait_time_ms_ = time_ms; }
 
   unsigned retry_tracing_wait_time_ms() const { return retry_tracing_wait_time_ms_; }
 
-  void set_retry_tracing_wait_time_ms(unsigned time_ms) {
-    retry_tracing_wait_time_ms_ = time_ms;
-  }
+  void set_retry_tracing_wait_time_ms(unsigned time_ms) { retry_tracing_wait_time_ms_ = time_ms; }
 
   CassConsistency tracing_consistency() const { return tracing_consistency_; }
 
-  void set_tracing_consistency(CassConsistency consistency) {
-    tracing_consistency_ = consistency;
-  }
+  void set_tracing_consistency(CassConsistency consistency) { tracing_consistency_ = consistency; }
 
   uint64_t coalesce_delay_us() const { return coalesce_delay_us_; }
 
-  void set_coalesce_delay_us(uint64_t delay_us) {
-    coalesce_delay_us_ = delay_us;
-  }
+  void set_coalesce_delay_us(uint64_t delay_us) { coalesce_delay_us_ = delay_us; }
 
   int new_request_ratio() const { return new_request_ratio_; }
 
-  void set_new_request_ratio(int ratio) {
-    new_request_ratio_ = ratio;
-  }
+  void set_new_request_ratio(int ratio) { new_request_ratio_ = ratio; }
 
   unsigned request_timeout() { return default_profile_.request_timeout_ms(); }
   void set_request_timeout(unsigned timeout_ms) {
@@ -176,43 +162,27 @@ class Config {
 
   unsigned resolve_timeout_ms() const { return resolve_timeout_ms_; }
 
-  void set_resolve_timeout(unsigned timeout_ms) {
-    resolve_timeout_ms_ = timeout_ms;
-  }
+  void set_resolve_timeout(unsigned timeout_ms) { resolve_timeout_ms_ = timeout_ms; }
 
-  const ContactPointList& contact_points() const {
-    return contact_points_;
-  }
+  const ContactPointList& contact_points() const { return contact_points_; }
 
-  ContactPointList& contact_points() {
-    return contact_points_;
-  }
+  ContactPointList& contact_points() { return contact_points_; }
 
   int port() const { return port_; }
 
-  void set_port(int port) {
-    port_ = port;
-  }
+  void set_port(int port) { port_ = port; }
 
   ProtocolVersion protocol_version() const { return protocol_version_; }
 
-  void set_protocol_version(ProtocolVersion version) {
-    protocol_version_ = version;
-  }
+  void set_protocol_version(ProtocolVersion version) { protocol_version_ = version; }
 
-  bool use_beta_protocol_version() const {
-    return use_beta_protocol_version_;
-  }
+  bool use_beta_protocol_version() const { return use_beta_protocol_version_; }
 
-  void set_use_beta_protocol_version(bool enable) {
-    use_beta_protocol_version_ = enable;
-  }
+  void set_use_beta_protocol_version(bool enable) { use_beta_protocol_version_ = enable; }
 
   CassLogLevel log_level() const { return log_level_; }
 
-  void set_log_level(CassLogLevel log_level) {
-    log_level_ = log_level;
-  }
+  void set_log_level(CassLogLevel log_level) { log_level_ = log_level; }
 
   void* log_data() const { return log_data_; }
 
@@ -239,8 +209,8 @@ class Config {
 
   LoadBalancingPolicy::Vec load_balancing_policies() const {
     LoadBalancingPolicy::Vec policies;
-    for (ExecutionProfile::Map::const_iterator it = profiles_.begin(),
-         end = profiles_.end(); it != end; ++it) {
+    for (ExecutionProfile::Map::const_iterator it = profiles_.begin(), end = profiles_.end();
+         it != end; ++it) {
       if (it->second.load_balancing_policy()) {
         policies.push_back(it->second.load_balancing_policy());
       }
@@ -258,13 +228,9 @@ class Config {
 
   const SslContext::Ptr& ssl_context() const { return ssl_context_; }
 
-  void set_ssl_context(SslContext* ssl_context) {
-    ssl_context_.reset(ssl_context);
-  }
+  void set_ssl_context(SslContext* ssl_context) { ssl_context_.reset(ssl_context); }
 
-  bool token_aware_routing() const {
-    return default_profile().token_aware_routing();
-  }
+  bool token_aware_routing() const { return default_profile().token_aware_routing(); }
 
   void set_token_aware_routing(bool is_token_aware) {
     default_profile_.set_token_aware_routing(is_token_aware);
@@ -288,9 +254,7 @@ class Config {
 
   bool tcp_nodelay_enable() const { return tcp_nodelay_enable_; }
 
-  void set_tcp_nodelay(bool enable) {
-    tcp_nodelay_enable_ = enable;
-  }
+  void set_tcp_nodelay(bool enable) { tcp_nodelay_enable_ = enable; }
 
   bool tcp_keepalive_enable() const { return tcp_keepalive_enable_; }
   unsigned tcp_keepalive_delay_secs() const { return tcp_keepalive_delay_secs_; }
@@ -300,9 +264,7 @@ class Config {
     tcp_keepalive_delay_secs_ = delay_secs;
   }
 
-  unsigned connection_idle_timeout_secs() const {
-    return connection_idle_timeout_secs_;
-  }
+  unsigned connection_idle_timeout_secs() const { return connection_idle_timeout_secs_; }
 
   void set_connection_idle_timeout_secs(unsigned timeout_secs) {
     connection_idle_timeout_secs_ = timeout_secs;
@@ -316,9 +278,7 @@ class Config {
     connection_heartbeat_interval_secs_ = interval_secs;
   }
 
-  TimestampGenerator* timestamp_gen() const {
-    return timestamp_gen_.get();
-  }
+  TimestampGenerator* timestamp_gen() const { return timestamp_gen_.get(); }
 
   void set_timestamp_gen(TimestampGenerator* timestamp_gen) {
     if (timestamp_gen == NULL) return;
@@ -330,37 +290,26 @@ class Config {
   }
 
   bool use_schema() const { return use_schema_; }
-  void set_use_schema(bool enable) {
-    use_schema_ = enable;
-  }
+  void set_use_schema(bool enable) { use_schema_ = enable; }
 
   bool use_hostname_resolution() const { return use_hostname_resolution_; }
-  void set_use_hostname_resolution(bool enable) {
-    use_hostname_resolution_ = enable;
-  }
+  void set_use_hostname_resolution(bool enable) { use_hostname_resolution_ = enable; }
 
   bool use_randomized_contact_points() const { return use_randomized_contact_points_; }
-  void set_use_randomized_contact_points(bool enable) {
-    use_randomized_contact_points_ = enable;
-  }
+  void set_use_randomized_contact_points(bool enable) { use_randomized_contact_points_ = enable; }
 
   unsigned max_reusable_write_objects() const { return max_reusable_write_objects_; }
-  void set_max_reusable_write_objects(unsigned max_reusable_write_objects) { max_reusable_write_objects_ = max_reusable_write_objects; }
-
-  const ExecutionProfile& default_profile() const {
-    return default_profile_;
+  void set_max_reusable_write_objects(unsigned max_reusable_write_objects) {
+    max_reusable_write_objects_ = max_reusable_write_objects;
   }
 
-  ExecutionProfile& default_profile() {
-    return default_profile_;
-  }
+  const ExecutionProfile& default_profile() const { return default_profile_; }
 
-  const ExecutionProfile::Map& profiles() const {
-    return profiles_;
-  }
+  ExecutionProfile& default_profile() { return default_profile_; }
 
-  void set_execution_profile(const String& name,
-                             const ExecutionProfile* profile) {
+  const ExecutionProfile::Map& profiles() const { return profiles_; }
+
+  void set_execution_profile(const String& name, const ExecutionProfile* profile) {
     // Assign the host targeting profile based on the cluster profile
     // This is required as their is no exposed API to set this chained policy
     ExecutionProfile copy = *profile;
@@ -375,21 +324,15 @@ class Config {
 
   bool prepare_on_up_or_add_host() const { return prepare_on_up_or_add_host_; }
 
-  void set_prepare_on_up_or_add_host(bool enabled) {
-    prepare_on_up_or_add_host_ = enabled;
-  }
+  void set_prepare_on_up_or_add_host(bool enabled) { prepare_on_up_or_add_host_ = enabled; }
 
   const Address& local_address() const { return local_address_; }
 
-  void set_local_address(const Address& address) {
-    local_address_ = address;
-  }
+  void set_local_address(const Address& address) { local_address_ = address; }
 
   bool no_compact() const { return no_compact_; }
 
-  void set_no_compact(bool enabled) {
-    no_compact_ = enabled;
-  }
+  void set_no_compact(bool enabled) { no_compact_ = enabled; }
 
   const String& application_name() const { return application_name_; }
 
@@ -437,7 +380,7 @@ class Config {
   unsigned thread_count_io_;
   unsigned queue_size_io_;
   unsigned core_connections_per_host_;
-  unsigned reconnect_wait_time_ms_;
+  SharedRefPtr<ReconnectionPolicy> reconnection_policy_;
   unsigned connect_timeout_ms_;
   unsigned resolve_timeout_ms_;
   unsigned max_schema_wait_time_ms_;
@@ -475,6 +418,6 @@ class Config {
   unsigned monitor_reporting_interval_secs_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connection.cpp b/src/connection.cpp
index e5ff80285..c26d9dec2 100644
--- a/src/connection.cpp
+++ b/src/connection.cpp
@@ -21,7 +21,10 @@
 #include "request.hpp"
 #include "result_response.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A request callback that handles heartbeats.
@@ -40,19 +43,17 @@ class HeartbeatCallback : public SimpleRequestCallback {
 };
 
 HeartbeatCallback::HeartbeatCallback(Connection* connection)
-  : SimpleRequestCallback(Request::ConstPtr(new OptionsRequest()))
-  , connection_(connection) { }
+    : SimpleRequestCallback(Request::ConstPtr(new OptionsRequest()))
+    , connection_(connection) {}
 
 void HeartbeatCallback::on_internal_set(ResponseMessage* response) {
-  LOG_TRACE("Heartbeat completed on host %s",
-            connection_->socket_->address_string().c_str());
+  LOG_TRACE("Heartbeat completed on host %s", connection_->socket_->address_string().c_str());
   connection_->heartbeat_outstanding_ = false;
 }
 
 void HeartbeatCallback::on_internal_error(CassError code, const String& message) {
   LOG_WARN("An error occurred on host %s during a heartbeat request: %s",
-           connection_->socket_->address_string().c_str(),
-           message.c_str());
+           connection_->socket_->address_string().c_str(), message.c_str());
   connection_->heartbeat_outstanding_ = false;
 }
 
@@ -66,7 +67,7 @@ void HeartbeatCallback::on_internal_timeout() {
  * A no operation connection listener. This is used if a listener is not set.
  */
 class NopConnectionListener : public ConnectionListener {
-  virtual void on_close(Connection* connection) { }
+  virtual void on_close(Connection* connection) {}
 };
 
 static NopConnectionListener nop_listener__;
@@ -80,9 +81,7 @@ void ConnectionHandler::on_write(Socket* socket, int status, SocketRequest* requ
   connection_->on_write(status, static_cast<RequestCallback*>(request));
 }
 
-void ConnectionHandler::on_close() {
-  connection_->on_close();
-}
+void ConnectionHandler::on_close() { connection_->on_close(); }
 
 void SslConnectionHandler::on_ssl_read(Socket* socket, char* buf, size_t size) {
   connection_->on_read(buf, size);
@@ -92,41 +91,37 @@ void SslConnectionHandler::on_write(Socket* socket, int status, SocketRequest* r
   connection_->on_write(status, static_cast<RequestCallback*>(request));
 }
 
-void SslConnectionHandler::on_close() {
-  connection_->on_close();
-}
+void SslConnectionHandler::on_close() { connection_->on_close(); }
+
+}}} // namespace datastax::internal::core
 
 void RecordingConnectionListener::process_events(const EventResponse::Vec& events,
                                                  ConnectionListener* listener) {
-  for (EventResponse::Vec::const_iterator it = events.begin(),
-       end = events.end(); it != end; ++it) {
+  for (EventResponse::Vec::const_iterator it = events.begin(), end = events.end(); it != end;
+       ++it) {
     listener->on_event(*it);
   }
 }
 
-Connection::Connection(const Socket::Ptr& socket,
-                       const Host::Ptr& host,
-                       ProtocolVersion protocol_version,
-                       unsigned int idle_timeout_secs,
+Connection::Connection(const Socket::Ptr& socket, const Host::Ptr& host,
+                       ProtocolVersion protocol_version, unsigned int idle_timeout_secs,
                        unsigned int heartbeat_interval_secs)
-  : socket_(socket)
-  , host_(host)
-  , inflight_request_count_(0)
-  , response_(new ResponseMessage())
-  , listener_(&nop_listener__)
-  , protocol_version_(protocol_version)
-  , idle_timeout_secs_(idle_timeout_secs)
-  , heartbeat_interval_secs_(heartbeat_interval_secs)
-  , heartbeat_outstanding_(false) {
+    : socket_(socket)
+    , host_(host)
+    , inflight_request_count_(0)
+    , response_(new ResponseMessage())
+    , listener_(&nop_listener__)
+    , protocol_version_(protocol_version)
+    , idle_timeout_secs_(idle_timeout_secs)
+    , heartbeat_interval_secs_(heartbeat_interval_secs)
+    , heartbeat_outstanding_(false) {
   inc_ref(); // For the event loop
 
   assert(host_->address() == socket_->address() && "Host doesn't match socket address");
   host_->increment_connection_count();
 }
 
-Connection::~Connection() {
-  host_->decrement_connection_count();
-}
+Connection::~Connection() { host_->decrement_connection_count(); }
 
 int32_t Connection::write(const RequestCallback::Ptr& callback) {
   int stream = stream_manager_.acquire(callback);
@@ -143,8 +138,7 @@ int32_t Connection::write(const RequestCallback::Ptr& callback) {
 
     switch (request_size) {
       case SocketRequest::SOCKET_REQUEST_ERROR_CLOSED:
-        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR,
-                           "Unable to write to close socket");
+        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR, "Unable to write to close socket");
         break;
 
       case SocketRequest::SOCKET_REQUEST_ERROR_NO_HANDLER:
@@ -163,8 +157,7 @@ int32_t Connection::write(const RequestCallback::Ptr& callback) {
         break;
 
       default:
-        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR,
-                           "Unspecified write error occurred");
+        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR, "Unspecified write error occurred");
         break;
     }
 
@@ -175,8 +168,7 @@ int32_t Connection::write(const RequestCallback::Ptr& callback) {
   inflight_request_count_.fetch_add(1);
 
   LOG_TRACE("Sending message type %s with stream %d on host %s",
-            opcode_to_string(callback->request()->opcode()).c_str(),
-            stream,
+            opcode_to_string(callback->request()->opcode()).c_str(), stream,
             socket_->address_string().c_str());
 
   callback->set_state(RequestCallback::REQUEST_STATE_WRITING);
@@ -192,17 +184,11 @@ int32_t Connection::write_and_flush(const RequestCallback::Ptr& callback) {
   return result;
 }
 
-size_t Connection::flush() {
-  return socket_->flush();
-}
+size_t Connection::flush() { return socket_->flush(); }
 
-void Connection::close() {
-  socket_->close();
-}
+void Connection::close() { socket_->close(); }
 
-void Connection::defunct() {
-  socket_->defunct();
-}
+void Connection::defunct() { socket_->defunct(); }
 
 void Connection::set_listener(ConnectionListener* listener) {
   listener_ = listener ? listener : &nop_listener__;
@@ -215,8 +201,7 @@ void Connection::start_heartbeats() {
 
 void Connection::maybe_set_keyspace(ResponseMessage* response) {
   if (response->opcode() == CQL_OPCODE_RESULT) {
-    ResultResponse* result =
-        static_cast<ResultResponse*>(response->response_body().get());
+    ResultResponse* result = static_cast<ResultResponse*>(response->response_body().get());
     if (result->kind() == CASS_RESULT_KIND_SET_KEYSPACE) {
       keyspace_ = result->keyspace().to_string();
     }
@@ -244,8 +229,7 @@ void Connection::on_write(int status, RequestCallback* request) {
         stream_manager_.release(callback->stream());
         inflight_request_count_.fetch_sub(1);
         callback->set_state(RequestCallback::REQUEST_STATE_FINISHED);
-        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR,
-                           "Unable to write to socket");
+        callback->on_error(CASS_ERROR_LIB_WRITE_ERROR, "Unable to write to socket");
       }
       break;
 
@@ -288,10 +272,8 @@ void Connection::on_read(const char* buf, size_t size) {
       response_.reset(new ResponseMessage());
 
       LOG_TRACE("Consumed message type %s with stream %d, input %u, remaining %u on host %s",
-                opcode_to_string(response->opcode()).c_str(),
-                static_cast<int>(response->stream()),
-                static_cast<unsigned int>(size),
-                static_cast<unsigned int>(remaining),
+                opcode_to_string(response->opcode()).c_str(), static_cast<int>(response->stream()),
+                static_cast<unsigned int>(size), static_cast<unsigned int>(remaining),
                 socket_->address_string().c_str());
 
       if (response->stream() < 0) {
@@ -379,8 +361,7 @@ void Connection::on_heartbeat(Timer* timer) {
 void Connection::restart_terminate_timer() {
   // The terminate timer shouldn't be started without having heartbeats enabled,
   // otherwise connections would be terminated in periods of request inactivity.
-  if (!is_closing() && heartbeat_interval_secs_ > 0 &&
-      idle_timeout_secs_ > 0) {
+  if (!is_closing() && heartbeat_interval_secs_ > 0 && idle_timeout_secs_ > 0) {
     terminate_timer_.start(socket_->loop(), 1000 * idle_timeout_secs_,
                            bind_callback(&Connection::on_terminate, this));
   }
@@ -391,5 +372,3 @@ void Connection::on_terminate(Timer* timer) {
             "Terminating connection...");
   defunct();
 }
-
-} // namespace cass
diff --git a/src/connection.hpp b/src/connection.hpp
index 675705e1c..84ecc33c7 100644
--- a/src/connection.hpp
+++ b/src/connection.hpp
@@ -19,10 +19,10 @@
 #include "socket.hpp"
 #include "stream_manager.hpp"
 
-#ifndef __CASS_CONNECTION_HPP_INCLUDED__
-#define __CASS_CONNECTION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_HPP
+#define DATASTAX_INTERNAL_CONNECTION_HPP
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ResponseMessage;
 class EventResponse;
@@ -34,7 +34,7 @@ class Connection;
 class ConnectionHandler : public SocketHandler {
 public:
   ConnectionHandler(Connection* connection)
-    : connection_(connection) { }
+      : connection_(connection) {}
 
   virtual void on_read(Socket* socket, ssize_t nread, const uv_buf_t* buf);
   virtual void on_write(Socket* socket, int status, SocketRequest* request);
@@ -50,8 +50,8 @@ class ConnectionHandler : public SocketHandler {
 class SslConnectionHandler : public SslSocketHandler {
 public:
   SslConnectionHandler(SslSession* ssl_session, Connection* connection)
-    : SslSocketHandler(ssl_session)
-    , connection_(connection) { }
+      : SslSocketHandler(ssl_session)
+      , connection_(connection) {}
 
   virtual void on_ssl_read(Socket* socket, char* buf, size_t size);
   virtual void on_write(Socket* socket, int status, SocketRequest* request);
@@ -66,7 +66,7 @@ class SslConnectionHandler : public SslSocketHandler {
  */
 class ConnectionListener {
 public:
-  virtual ~ConnectionListener() { }
+  virtual ~ConnectionListener() {}
 
   /**
    * A callback that's called when the connection receives an event. The
@@ -74,11 +74,11 @@ class ConnectionListener {
    *
    * @param response The event response data sent from the server.
    */
-  virtual void on_event(const EventResponse::Ptr& response) { }
+  virtual void on_event(const EventResponse::Ptr& response) {}
 
-  virtual void on_read() { }
+  virtual void on_read() {}
 
-  virtual void on_write() { }
+  virtual void on_write() {}
 
   /**
    * A callback that's called when the connection closes.
@@ -95,9 +95,7 @@ class RecordingConnectionListener : public ConnectionListener {
 public:
   const EventResponse::Vec& events() const { return events_; }
 
-  virtual void on_event(const EventResponse::Ptr& response) {
-    events_.push_back(response);
-  }
+  virtual void on_event(const EventResponse::Ptr& response) { events_.push_back(response); }
 
   virtual void on_close(Connection* connection) = 0;
 
@@ -107,8 +105,7 @@ class RecordingConnectionListener : public ConnectionListener {
    * @param events The events to replay.
    * @param listener The listener that will receive the events.
    */
-  static void process_events(const EventResponse::Vec& events,
-                             ConnectionListener* listener);
+  static void process_events(const EventResponse::Vec& events, ConnectionListener* listener);
 
 private:
   EventResponse::Vec events_;
@@ -141,11 +138,8 @@ class Connection : public RefCounted<Connection> {
    * where the connection is considered idle and is terminated.
    * @param heartbeat_interval_secs The interval (in seconds) to send a heartbeat.
    */
-  Connection(const Socket::Ptr& socket,
-             const Host::Ptr& host,
-             ProtocolVersion protocol_version,
-             unsigned int idle_timeout_secs,
-             unsigned int heartbeat_interval_secs);
+  Connection(const Socket::Ptr& socket, const Host::Ptr& host, ProtocolVersion protocol_version,
+             unsigned int idle_timeout_secs, unsigned int heartbeat_interval_secs);
   ~Connection();
 
   /**
@@ -216,9 +210,7 @@ class Connection : public RefCounted<Connection> {
   uv_loop_t* loop() { return socket_->loop(); }
   const uv_tcp_t* handle() const { return socket_->handle(); }
 
-  int inflight_request_count() const {
-    return inflight_request_count_.load(MEMORY_ORDER_RELAXED);
-  }
+  int inflight_request_count() const { return inflight_request_count_.load(MEMORY_ORDER_RELAXED); }
 
 private:
   void maybe_set_keyspace(ResponseMessage* response);
@@ -255,6 +247,6 @@ class Connection : public RefCounted<Connection> {
   Timer terminate_timer_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connection_pool.cpp b/src/connection_pool.cpp
index 37fc3e877..a6908cbdf 100644
--- a/src/connection_pool.cpp
+++ b/src/connection_pool.cpp
@@ -23,64 +23,58 @@
 
 #include <algorithm>
 
+using namespace datastax;
+using namespace datastax::internal::core;
 
-namespace cass {
-
-static inline bool least_busy_comp(const PooledConnection::Ptr& a,
-                                   const PooledConnection::Ptr& b) {
+static inline bool least_busy_comp(const PooledConnection::Ptr& a, const PooledConnection::Ptr& b) {
   return a->inflight_request_count() < b->inflight_request_count();
 }
 
 ConnectionPoolSettings::ConnectionPoolSettings()
-  : num_connections_per_host(CASS_DEFAULT_NUM_CONNECTIONS_PER_HOST)
-  , reconnect_wait_time_ms(CASS_DEFAULT_RECONNECT_WAIT_TIME_MS) { }
+    : num_connections_per_host(CASS_DEFAULT_NUM_CONNECTIONS_PER_HOST)
+    , reconnection_policy(new ExponentialReconnectionPolicy()) {}
 
 ConnectionPoolSettings::ConnectionPoolSettings(const Config& config)
-  : connection_settings(config)
-  , num_connections_per_host(config.core_connections_per_host())
-  , reconnect_wait_time_ms(config.reconnect_wait_time_ms()) { }
+    : connection_settings(config)
+    , num_connections_per_host(config.core_connections_per_host())
+    , reconnection_policy(config.reconnection_policy()) {}
 
 class NopConnectionPoolListener : public ConnectionPoolListener {
 public:
-  virtual void on_pool_up(const Address& address) { }
+  virtual void on_pool_up(const Address& address) {}
 
-  virtual void on_pool_down(const Address& address) { }
+  virtual void on_pool_down(const Address& address) {}
 
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
-                                      const String& message) { }
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message) {}
 
-  virtual void on_close(ConnectionPool* pool) { }
+  virtual void on_close(ConnectionPool* pool) {}
 };
 
 NopConnectionPoolListener nop_connection_pool_listener__;
 
-ConnectionPool::ConnectionPool(const Connection::Vec& connections,
-                               ConnectionPoolListener* listener,
-                               const String& keyspace,
-                               uv_loop_t* loop,
-                               const Host::Ptr& host,
+ConnectionPool::ConnectionPool(const Connection::Vec& connections, ConnectionPoolListener* listener,
+                               const String& keyspace, uv_loop_t* loop, const Host::Ptr& host,
                                ProtocolVersion protocol_version,
-                               const ConnectionPoolSettings& settings,
-                               Metrics* metrics)
-  : listener_(listener ? listener : &nop_connection_pool_listener__)
-  , keyspace_(keyspace)
-  , loop_(loop)
-  , host_(host)
-  , protocol_version_(protocol_version)
-  , settings_(settings)
-  , metrics_(metrics)
-  , close_state_(CLOSE_STATE_OPEN)
-  , notify_state_(NOTIFY_STATE_NEW) {
+                               const ConnectionPoolSettings& settings, Metrics* metrics)
+    : listener_(listener ? listener : &nop_connection_pool_listener__)
+    , keyspace_(keyspace)
+    , loop_(loop)
+    , host_(host)
+    , protocol_version_(protocol_version)
+    , settings_(settings)
+    , metrics_(metrics)
+    , close_state_(CLOSE_STATE_OPEN)
+    , notify_state_(NOTIFY_STATE_NEW) {
   inc_ref(); // Reference for the lifetime of the pooled connections
+  set_pointer_keys(reconnection_schedules_);
   set_pointer_keys(to_flush_);
 
-  for (Connection::Vec::const_iterator it = connections.begin(),
-       end = connections.end(); it != end; ++it) {
+  for (Connection::Vec::const_iterator it = connections.begin(), end = connections.end(); it != end;
+       ++it) {
     const Connection::Ptr& connection(*it);
     if (!connection->is_closing()) {
-      add_connection(PooledConnection::Ptr(
-                       new PooledConnection(this, connection)));
+      add_connection(PooledConnection::Ptr(new PooledConnection(this, connection)));
     }
   }
 
@@ -98,29 +92,26 @@ PooledConnection::Ptr ConnectionPool::find_least_busy() const {
   if (connections_.empty()) {
     return PooledConnection::Ptr();
   }
-  return *std::min_element(connections_.begin(),
-                           connections_.end(), least_busy_comp);
+  return *std::min_element(connections_.begin(), connections_.end(), least_busy_comp);
 }
 
-bool ConnectionPool::has_connections() const {
-  return !connections_.empty();
-}
+bool ConnectionPool::has_connections() const { return !connections_.empty(); }
 
 void ConnectionPool::flush() {
   for (DenseHashSet<PooledConnection*>::const_iterator it = to_flush_.begin(),
-       end = to_flush_.end(); it != end; ++it) {
+                                                       end = to_flush_.end();
+       it != end; ++it) {
     (*it)->flush();
   }
   to_flush_.clear();
 }
 
-void ConnectionPool::close() {
-  internal_close();
-}
+void ConnectionPool::close() { internal_close(); }
 
 void ConnectionPool::attempt_immediate_connect() {
   for (DelayedConnector::Vec::iterator it = pending_connections_.begin(),
-       end = pending_connections_.end(); it != end; ++it) {
+                                       end = pending_connections_.end();
+       it != end; ++it) {
     (*it)->attempt_immediate_connect();
   }
 }
@@ -129,9 +120,7 @@ void ConnectionPool::set_listener(ConnectionPoolListener* listener) {
   listener_ = listener ? listener : &nop_connection_pool_listener__;
 }
 
-void ConnectionPool::set_keyspace(const String& keyspace) {
-  keyspace_ = keyspace;
-}
+void ConnectionPool::set_keyspace(const String& keyspace) { keyspace_ = keyspace; }
 
 void ConnectionPool::requires_flush(PooledConnection* connection, ConnectionPool::Protected) {
   if (to_flush_.empty()) {
@@ -178,29 +167,32 @@ void ConnectionPool::notify_up_or_down() {
   }
 }
 
-void ConnectionPool::notify_critical_error(Connector::ConnectionError code,
-                                           const String& message) {
+void ConnectionPool::notify_critical_error(Connector::ConnectionError code, const String& message) {
   if (notify_state_ != NOTIFY_STATE_CRITICAL) {
     notify_state_ = NOTIFY_STATE_CRITICAL;
     listener_->on_pool_critical_error(host_->address(), code, message);
   }
 }
 
-void ConnectionPool::schedule_reconnect() {
-  LOG_INFO("Scheduling reconnect for host %s in %llu ms on connection pool (%p)",
-           host_->address().to_string().c_str(),
-           static_cast<unsigned long long>(settings_.reconnect_wait_time_ms),
-           static_cast<void*>(this));
-  DelayedConnector::Ptr connector(
-        new DelayedConnector(host_,
-                             protocol_version_,
-                             bind_callback(&ConnectionPool::on_reconnect, this)));
+void ConnectionPool::schedule_reconnect(ReconnectionSchedule* schedule) {
+  DelayedConnector::Ptr connector(new DelayedConnector(
+      host_, protocol_version_, bind_callback(&ConnectionPool::on_reconnect, this)));
+
+  if (!schedule) {
+    schedule = settings_.reconnection_policy->new_reconnection_schedule();
+  }
+  reconnection_schedules_[connector.get()] = schedule;
+
+  uint64_t delay_ms = schedule->next_delay_ms();
+  LOG_INFO("Scheduling %s reconnect for host %s in %llums on connection pool (%p) ",
+           settings_.reconnection_policy->name(), host_->address().to_string().c_str(),
+           static_cast<unsigned long long>(delay_ms), static_cast<void*>(this));
+
   pending_connections_.push_back(connector);
-  connector
-      ->with_keyspace(keyspace())
+  connector->with_keyspace(keyspace())
       ->with_metrics(metrics_)
       ->with_settings(settings_.connection_settings)
-      ->delayed_connect(loop_, settings_.reconnect_wait_time_ms);
+      ->delayed_connect(loop_, delay_ms);
 }
 
 void ConnectionPool::internal_close() {
@@ -211,14 +203,15 @@ void ConnectionPool::internal_close() {
     // invalidation.
 
     PooledConnection::Vec connections(connections_);
-    for (PooledConnection::Vec::iterator it = connections.begin(),
-         end = connections.end(); it != end; ++it) {
+    for (PooledConnection::Vec::iterator it = connections.begin(), end = connections.end();
+         it != end; ++it) {
       (*it)->close();
     }
 
     DelayedConnector::Vec pending_connections(pending_connections_);
     for (DelayedConnector::Vec::iterator it = pending_connections.begin(),
-         end = pending_connections.end(); it != end; ++it) {
+                                         end = pending_connections.end();
+         it != end; ++it) {
       (*it)->cancel();
     }
 
@@ -230,8 +223,7 @@ void ConnectionPool::internal_close() {
 void ConnectionPool::maybe_closed() {
   // Remove the pool once all current connections and pending connections
   // are terminated.
-  if (close_state_ == CLOSE_STATE_WAITING_FOR_CONNECTIONS &&
-      connections_.empty() &&
+  if (close_state_ == CLOSE_STATE_WAITING_FOR_CONNECTIONS && connections_.empty() &&
       pending_connections_.empty()) {
     close_state_ = CLOSE_STATE_CLOSED;
     // Only mark DOWN if it's UP otherwise we might get multiple DOWN events
@@ -245,8 +237,16 @@ void ConnectionPool::maybe_closed() {
 }
 
 void ConnectionPool::on_reconnect(DelayedConnector* connector) {
-  pending_connections_.erase(std::remove(pending_connections_.begin(), pending_connections_.end(), connector),
-                             pending_connections_.end());
+  pending_connections_.erase(
+      std::remove(pending_connections_.begin(), pending_connections_.end(), connector),
+      pending_connections_.end());
+
+  ReconnectionSchedules::iterator it = reconnection_schedules_.find(connector);
+  assert(it != reconnection_schedules_.end() &&
+         "No reconnection schedule associated with connector");
+
+  ScopedPtr<ReconnectionSchedule> schedule(it->second);
+  reconnection_schedules_.erase(it);
 
   if (close_state_ != CLOSE_STATE_OPEN) {
     maybe_closed();
@@ -255,24 +255,19 @@ void ConnectionPool::on_reconnect(DelayedConnector* connector) {
 
   if (connector->is_ok()) {
     add_connection(
-          PooledConnection::Ptr(
-            new PooledConnection(this, connector->release_connection())));
+        PooledConnection::Ptr(new PooledConnection(this, connector->release_connection())));
     notify_up_or_down();
   } else if (!connector->is_canceled()) {
-    if(connector->is_critical_error()) {
+    if (connector->is_critical_error()) {
       LOG_ERROR("Closing established connection pool to host %s because of the following error: %s",
-                address().to_string().c_str(),
-                connector->error_message().c_str());
-      notify_critical_error(connector->error_code(),
-                            connector->error_message());
+                address().to_string().c_str(), connector->error_message().c_str());
+      notify_critical_error(connector->error_code(), connector->error_message());
       internal_close();
     } else {
-      LOG_WARN("Connection pool was unable to reconnect to host %s because of the following error: %s",
-               address().to_string().c_str(),
-               connector->error_message().c_str());
-      schedule_reconnect();
+      LOG_WARN(
+          "Connection pool was unable to reconnect to host %s because of the following error: %s",
+          address().to_string().c_str(), connector->error_message().c_str());
+      schedule_reconnect(schedule.release());
     }
   }
 }
-
-} // namespace cass
diff --git a/src/connection_pool.hpp b/src/connection_pool.hpp
index 9749a16a4..116b22e50 100644
--- a/src/connection_pool.hpp
+++ b/src/connection_pool.hpp
@@ -14,16 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONNECTION_POOL_HPP_INCLUDED__
-#define __CASS_CONNECTION_POOL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_POOL_HPP
+#define DATASTAX_INTERNAL_CONNECTION_POOL_HPP
 
 #include "address.hpp"
 #include "delayed_connector.hpp"
+#include "dense_hash_map.hpp"
 #include "pooled_connection.hpp"
+#include "reconnection_policy.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ConnectionPool;
 class ConnectionPoolConnector;
@@ -32,7 +34,7 @@ class EventLoop;
 
 class ConnectionPoolStateListener {
 public:
-  virtual ~ConnectionPoolStateListener() { }
+  virtual ~ConnectionPoolStateListener() {}
 
   /**
    * A callback that's called when a host is up.
@@ -62,15 +64,13 @@ class ConnectionPoolStateListener {
    * @param code The code of the critical error.
    * @param message The message of the critical error.
    */
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
                                       const String& message) = 0;
 };
 
-
 class ConnectionPoolListener : public ConnectionPoolStateListener {
 public:
-  virtual void on_requires_flush(ConnectionPool* pool) { }
+  virtual void on_requires_flush(ConnectionPool* pool) {}
 
   virtual void on_close(ConnectionPool* pool) = 0;
 };
@@ -93,7 +93,7 @@ struct ConnectionPoolSettings {
 
   ConnectionSettings connection_settings;
   size_t num_connections_per_host;
-  uint64_t reconnect_wait_time_ms;
+  ReconnectionPolicy::Ptr reconnection_policy;
 };
 
 /**
@@ -102,6 +102,7 @@ struct ConnectionPoolSettings {
 class ConnectionPool : public RefCounted<ConnectionPool> {
 public:
   typedef SharedRefPtr<ConnectionPool> Ptr;
+  typedef DenseHashMap<DelayedConnector*, ReconnectionSchedule*> ReconnectionSchedules;
 
   class Map : public DenseHashMap<Address, Ptr, AddressHash> {
   public:
@@ -123,13 +124,9 @@ class ConnectionPool : public RefCounted<ConnectionPool> {
    * @param settings
    * @param metrics
    */
-  ConnectionPool(const Connection::Vec& connections,
-                 ConnectionPoolListener* listener,
-                 const String& keyspace,
-                 uv_loop_t* loop,
-                 const Host::Ptr& host,
-                 ProtocolVersion protocol_version,
-                 const ConnectionPoolSettings& settings,
+  ConnectionPool(const Connection::Vec& connections, ConnectionPoolListener* listener,
+                 const String& keyspace, uv_loop_t* loop, const Host::Ptr& host,
+                 ProtocolVersion protocol_version, const ConnectionPoolSettings& settings,
                  Metrics* metrics);
 
   /**
@@ -181,8 +178,8 @@ class ConnectionPool : public RefCounted<ConnectionPool> {
   class Protected {
     friend class PooledConnection;
     friend class ConnectionPoolConnector;
-    Protected() { }
-    Protected(Protected const&) { }
+    Protected() {}
+    Protected(Protected const&) {}
   };
 
   /**
@@ -208,22 +205,16 @@ class ConnectionPool : public RefCounted<ConnectionPool> {
     CLOSE_STATE_CLOSED
   };
 
-  enum NotifyState {
-    NOTIFY_STATE_NEW,
-    NOTIFY_STATE_UP,
-    NOTIFY_STATE_DOWN,
-    NOTIFY_STATE_CRITICAL
-  };
+  enum NotifyState { NOTIFY_STATE_NEW, NOTIFY_STATE_UP, NOTIFY_STATE_DOWN, NOTIFY_STATE_CRITICAL };
 
 private:
   friend class NotifyDownOnRemovePoolOp;
 
 private:
   void notify_up_or_down();
-  void notify_critical_error(Connector::ConnectionError code,
-                             const String& message);
+  void notify_critical_error(Connector::ConnectionError code, const String& message);
   void add_connection(const PooledConnection::Ptr& connection);
-  void schedule_reconnect();
+  void schedule_reconnect(ReconnectionSchedule* schedule = NULL);
   void internal_close();
   void maybe_closed();
 
@@ -237,6 +228,7 @@ class ConnectionPool : public RefCounted<ConnectionPool> {
   const ProtocolVersion protocol_version_;
   const ConnectionPoolSettings settings_;
   Metrics* const metrics_;
+  ReconnectionSchedules reconnection_schedules_;
 
   CloseState close_state_;
   NotifyState notify_state_;
@@ -245,6 +237,6 @@ class ConnectionPool : public RefCounted<ConnectionPool> {
   DenseHashSet<PooledConnection*> to_flush_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connection_pool_connector.cpp b/src/connection_pool_connector.cpp
index 9546adf3b..0129f8027 100644
--- a/src/connection_pool_connector.cpp
+++ b/src/connection_pool_connector.cpp
@@ -19,19 +19,20 @@
 #include "event_loop.hpp"
 #include "metrics.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 ConnectionPoolConnector::ConnectionPoolConnector(const Host::Ptr& host,
                                                  ProtocolVersion protocol_version,
                                                  const Callback& callback)
-  : loop_(NULL)
-  , callback_(callback)
-  , is_canceled_(false)
-  , remaining_(0)
-  , host_(host)
-  , protocol_version_(protocol_version)
-  , listener_(NULL)
-  , metrics_(NULL) { }
+    : loop_(NULL)
+    , callback_(callback)
+    , is_canceled_(false)
+    , remaining_(0)
+    , host_(host)
+    , protocol_version_(protocol_version)
+    , listener_(NULL)
+    , metrics_(NULL) {}
 
 ConnectionPoolConnector* ConnectionPoolConnector::with_listener(ConnectionPoolListener* listener) {
   listener_ = listener;
@@ -48,23 +49,21 @@ ConnectionPoolConnector* ConnectionPoolConnector::with_metrics(Metrics* metrics)
   return this;
 }
 
-ConnectionPoolConnector* ConnectionPoolConnector::with_settings(const ConnectionPoolSettings& settings) {
+ConnectionPoolConnector*
+ConnectionPoolConnector::with_settings(const ConnectionPoolSettings& settings) {
   settings_ = settings;
   return this;
 }
 
-void ConnectionPoolConnector::connect(uv_loop_t*  loop) {
+void ConnectionPoolConnector::connect(uv_loop_t* loop) {
   inc_ref();
   loop_ = loop;
   remaining_ = settings_.num_connections_per_host;
   for (size_t i = 0; i < settings_.num_connections_per_host; ++i) {
-    Connector::Ptr connector(
-          new Connector(host_,
-                        protocol_version_,
-                        bind_callback(&ConnectionPoolConnector::on_connect, this)));
+    Connector::Ptr connector(new Connector(
+        host_, protocol_version_, bind_callback(&ConnectionPoolConnector::on_connect, this)));
     pending_connections_.push_back(connector);
-    connector
-        ->with_keyspace(keyspace_)
+    connector->with_keyspace(keyspace_)
         ->with_metrics(metrics_)
         ->with_settings(settings_.connection_settings)
         ->connect(loop);
@@ -75,13 +74,14 @@ void ConnectionPoolConnector::cancel() {
   is_canceled_ = true;
   if (pool_) {
     pool_->close();
-  } else  {
+  } else {
     for (Connector::Vec::iterator it = pending_connections_.begin(),
-         end = pending_connections_.end(); it != end; ++it) {
+                                  end = pending_connections_.end();
+         it != end; ++it) {
       (*it)->cancel();
     }
-    for (Connection::Vec::iterator it = connections_.begin(),
-         end = connections_.end(); it != end; ++it) {
+    for (Connection::Vec::iterator it = connections_.begin(), end = connections_.end(); it != end;
+         ++it) {
       (*it)->close();
     }
   }
@@ -94,20 +94,17 @@ ConnectionPool::Ptr ConnectionPoolConnector::release_pool() {
 }
 
 Connector::ConnectionError ConnectionPoolConnector::error_code() const {
-  return critical_error_connector_ ?  critical_error_connector_->error_code() : Connector::CONNECTION_OK;
+  return critical_error_connector_ ? critical_error_connector_->error_code()
+                                   : Connector::CONNECTION_OK;
 }
 
 String ConnectionPoolConnector::error_message() const {
   return critical_error_connector_ ? critical_error_connector_->error_message() : "";
 }
 
-bool ConnectionPoolConnector::is_ok() const {
-  return !is_critical_error();
-}
+bool ConnectionPoolConnector::is_ok() const { return !is_critical_error(); }
 
-bool ConnectionPoolConnector::is_critical_error() const {
-  return critical_error_connector_;
-}
+bool ConnectionPoolConnector::is_critical_error() const { return critical_error_connector_; }
 
 bool ConnectionPoolConnector::is_keyspace_error() const {
   if (critical_error_connector_) {
@@ -117,21 +114,22 @@ bool ConnectionPoolConnector::is_keyspace_error() const {
 }
 
 void ConnectionPoolConnector::on_connect(Connector* connector) {
-  pending_connections_.erase(std::remove(pending_connections_.begin(), pending_connections_.end(), connector),
-                             pending_connections_.end());
+  pending_connections_.erase(
+      std::remove(pending_connections_.begin(), pending_connections_.end(), connector),
+      pending_connections_.end());
 
   if (connector->is_ok()) {
     connections_.push_back(connector->release_connection());
-  } else if (!connector->is_canceled()){
+  } else if (!connector->is_canceled()) {
     LOG_ERROR("Connection pool was unable to connect to host %s because of the following error: %s",
-              host_->address().to_string().c_str(),
-              connector->error_message().c_str());
+              host_->address().to_string().c_str(), connector->error_message().c_str());
 
-    if (connector->is_critical_error())  {
+    if (connector->is_critical_error()) {
       if (!critical_error_connector_) {
         critical_error_connector_.reset(connector);
         for (Connector::Vec::iterator it = pending_connections_.begin(),
-             end = pending_connections_.end(); it != end; ++it) {
+                                      end = pending_connections_.end();
+             it != end; ++it) {
           (*it)->cancel();
         }
       }
@@ -141,14 +139,8 @@ void ConnectionPoolConnector::on_connect(Connector* connector) {
   if (--remaining_ == 0) {
     if (!is_canceled_) {
       if (!critical_error_connector_) {
-        pool_.reset(new ConnectionPool(connections_,
-                                       listener_,
-                                       keyspace_,
-                                       loop_,
-                                       host_,
-                                       protocol_version_,
-                                       settings_,
-                                       metrics_));
+        pool_.reset(new ConnectionPool(connections_, listener_, keyspace_, loop_, host_,
+                                       protocol_version_, settings_, metrics_));
       } else {
         if (listener_) {
           listener_->on_pool_critical_error(host_->address(),
@@ -168,5 +160,3 @@ void ConnectionPoolConnector::on_connect(Connector* connector) {
     dec_ref();
   }
 }
-
-} // namespace cass
diff --git a/src/connection_pool_connector.hpp b/src/connection_pool_connector.hpp
index 02bfbd531..28a0999a3 100644
--- a/src/connection_pool_connector.hpp
+++ b/src/connection_pool_connector.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONNECTION_POOL_CONNECTOR_HPP_INCLUDED__
-#define __CASS_CONNECTION_POOL_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_POOL_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_CONNECTION_POOL_CONNECTOR_HPP
 
 #include "address.hpp"
 #include "atomic.hpp"
@@ -28,7 +28,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ConnectionPoolManager;
 
@@ -41,7 +41,7 @@ class ConnectionPoolConnector : public RefCounted<ConnectionPoolConnector> {
   typedef SharedRefPtr<ConnectionPoolConnector> Ptr;
   typedef Vector<Ptr> Vec;
 
-  typedef cass::Callback<void, ConnectionPoolConnector*> Callback;
+  typedef internal::Callback<void, ConnectionPoolConnector*> Callback;
 
   /**
    * Constructor
@@ -51,8 +51,7 @@ class ConnectionPoolConnector : public RefCounted<ConnectionPoolConnector> {
    * @param callback A callback that is called when the connection is connected or
    * if an error occurred.
    */
-  ConnectionPoolConnector(const Host::Ptr& host,
-                          ProtocolVersion protocol_version,
+  ConnectionPoolConnector(const Host::Ptr& host, ProtocolVersion protocol_version,
                           const Callback& callback);
 
   /**
@@ -139,6 +138,6 @@ class ConnectionPoolConnector : public RefCounted<ConnectionPoolConnector> {
   Metrics* metrics_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connection_pool_manager.cpp b/src/connection_pool_manager.cpp
index 78ede8736..74c50243f 100644
--- a/src/connection_pool_manager.cpp
+++ b/src/connection_pool_manager.cpp
@@ -19,46 +19,44 @@
 #include "scoped_lock.hpp"
 #include "utils.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 class NopConnectionPoolManagerListener : public ConnectionPoolManagerListener {
 public:
-  virtual void on_pool_up(const Address& address) { }
+  virtual void on_pool_up(const Address& address) {}
 
-  virtual void on_pool_down(const Address& address) { }
+  virtual void on_pool_down(const Address& address) {}
 
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
-                                      const String& message) { }
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message) {}
 
-  virtual void on_close(ConnectionPoolManager* manager) { }
+  virtual void on_close(ConnectionPoolManager* manager) {}
 };
 
 static NopConnectionPoolManagerListener nop_connection_pool_manager_listener__;
 
-ConnectionPoolManager::ConnectionPoolManager(const ConnectionPool::Map& pools,
-                                             uv_loop_t* loop,
+ConnectionPoolManager::ConnectionPoolManager(const ConnectionPool::Map& pools, uv_loop_t* loop,
                                              ProtocolVersion protocol_version,
                                              const String& keyspace,
                                              ConnectionPoolManagerListener* listener,
                                              Metrics* metrics,
                                              const ConnectionPoolSettings& settings)
-  : loop_(loop)
-  , protocol_version_(protocol_version)
-  , settings_(settings)
-  , listener_(listener ? listener : &nop_connection_pool_manager_listener__)
-  , close_state_(CLOSE_STATE_OPEN)
-  , keyspace_(keyspace)
-  , metrics_(metrics)
-  #ifdef CASS_INTERNAL_DIAGNOSTICS
-  , flush_bytes_("flushed")
-  #endif
+    : loop_(loop)
+    , protocol_version_(protocol_version)
+    , settings_(settings)
+    , listener_(listener ? listener : &nop_connection_pool_manager_listener__)
+    , close_state_(CLOSE_STATE_OPEN)
+    , keyspace_(keyspace)
+    , metrics_(metrics)
+#ifdef CASS_INTERNAL_DIAGNOSTICS
+    , flush_bytes_("flushed")
+#endif
 {
   inc_ref(); // Reference for the lifetime of the connection pools
   set_pointer_keys(to_flush_);
 
-  for (ConnectionPool::Map::const_iterator it = pools.begin(),
-       end= pools.end(); it != end; ++it) {
+  for (ConnectionPool::Map::const_iterator it = pools.begin(), end = pools.end(); it != end; ++it) {
     it->second->set_listener(this);
     add_pool(it->second);
   }
@@ -78,19 +76,18 @@ bool ConnectionPoolManager::has_connections(const Address& address) const {
 }
 
 void ConnectionPoolManager::flush() {
-  for (DenseHashSet<ConnectionPool*>::const_iterator it = to_flush_.begin(),
-       end = to_flush_.end(); it != end; ++it) {
+  for (DenseHashSet<ConnectionPool*>::const_iterator it = to_flush_.begin(), end = to_flush_.end();
+       it != end; ++it) {
     (*it)->flush();
   }
   to_flush_.clear();
-
 }
 
 AddressVec ConnectionPoolManager::available() const {
   AddressVec result;
   result.reserve(pools_.size());
-  for (ConnectionPool::Map::const_iterator it = pools_.begin(),
-       end = pools_.end(); it != end; ++it) {
+  for (ConnectionPool::Map::const_iterator it = pools_.begin(), end = pools_.end(); it != end;
+       ++it) {
     result.push_back(it->first);
   }
   return result;
@@ -101,17 +98,15 @@ void ConnectionPoolManager::add(const Host::Ptr& host) {
   if (it != pools_.end()) return;
 
   for (ConnectionPoolConnector::Vec::iterator it = pending_pools_.begin(),
-       end = pending_pools_.end(); it != end; ++it) {
+                                              end = pending_pools_.end();
+       it != end; ++it) {
     if ((*it)->address() == host->address()) return;
   }
 
-  ConnectionPoolConnector::Ptr connector(
-        new ConnectionPoolConnector(host,
-                                    protocol_version_,
-                                    bind_callback(&ConnectionPoolManager::on_connect, this)));
+  ConnectionPoolConnector::Ptr connector(new ConnectionPoolConnector(
+      host, protocol_version_, bind_callback(&ConnectionPoolManager::on_connect, this)));
   pending_pools_.push_back(connector);
-  connector
-      ->with_listener(this)
+  connector->with_listener(this)
       ->with_keyspace(keyspace_)
       ->with_metrics(metrics_)
       ->with_settings(settings_)
@@ -134,14 +129,14 @@ void ConnectionPoolManager::close() {
     // invalidation.
 
     ConnectionPool::Map pools(pools_);
-    for (ConnectionPool::Map::iterator it = pools.begin(),
-         end = pools.end(); it != end; ++it) {
+    for (ConnectionPool::Map::iterator it = pools.begin(), end = pools.end(); it != end; ++it) {
       it->second->close();
     }
 
     ConnectionPoolConnector::Vec pending_pools(pending_pools_);
     for (ConnectionPoolConnector::Vec::iterator it = pending_pools.begin(),
-         end = pending_pools.end(); it != end; ++it) {
+                                                end = pending_pools.end();
+         it != end; ++it) {
       (*it)->cancel();
     }
 
@@ -162,15 +157,12 @@ void ConnectionPoolManager::set_listener(ConnectionPoolManagerListener* listener
 
 void ConnectionPoolManager::set_keyspace(const String& keyspace) {
   keyspace_ = keyspace;
-  for (ConnectionPool::Map::iterator it = pools_.begin(),
-       end = pools_.end(); it != end; ++it) {
+  for (ConnectionPool::Map::iterator it = pools_.begin(), end = pools_.end(); it != end; ++it) {
     it->second->set_keyspace(keyspace);
   }
 }
 
-void ConnectionPoolManager::on_pool_up(const Address& address) {
-  listener_->on_pool_up(address);
-}
+void ConnectionPoolManager::on_pool_up(const Address& address) { listener_->on_pool_up(address); }
 
 void ConnectionPoolManager::on_pool_down(const Address& address) {
   listener_->on_pool_down(address);
@@ -223,10 +215,7 @@ void ConnectionPoolManager::on_connect(ConnectionPoolConnector* pool_connector)
   if (pool_connector->is_ok()) {
     add_pool(pool_connector->release_pool());
   } else {
-    listener_->on_pool_critical_error(pool_connector->address(),
-                                      pool_connector->error_code(),
+    listener_->on_pool_critical_error(pool_connector->address(), pool_connector->error_code(),
                                       pool_connector->error_message());
   }
 }
-
-} // namespace cass
diff --git a/src/connection_pool_manager.hpp b/src/connection_pool_manager.hpp
index caf2a8f3f..1633e1cde 100644
--- a/src/connection_pool_manager.hpp
+++ b/src/connection_pool_manager.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONNECTION_POOL_MANAGER_HPP_INCLUDED__
-#define __CASS_CONNECTION_POOL_MANAGER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_POOL_MANAGER_HPP
+#define DATASTAX_INTERNAL_CONNECTION_POOL_MANAGER_HPP
 
 #include "address.hpp"
 #include "atomic.hpp"
@@ -27,7 +27,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class EventLoop;
 
@@ -36,13 +36,13 @@ class EventLoop;
  */
 class ConnectionPoolManagerListener : public ConnectionPoolStateListener {
 public:
-  virtual ~ConnectionPoolManagerListener() { }
+  virtual ~ConnectionPoolManagerListener() {}
 
   /**
    * A callback that's called when one of the manager's connections requires a
    * flush. It's only called once on the first write to the connection.
    */
-  virtual void on_requires_flush() { }
+  virtual void on_requires_flush() {}
 
   /**
    * A callback that's called when a manager is closed.
@@ -72,12 +72,9 @@ class ConnectionPoolManager
    * @param metrics An object for recording metrics.
    * @param settings Settings for the manager and its connections.
    */
-  ConnectionPoolManager(const ConnectionPool::Map& pools,
-                        uv_loop_t* loop,
-                        ProtocolVersion protocol_version,
-                        const String& keyspace,
-                        ConnectionPoolManagerListener* listener,
-                        Metrics* metrics,
+  ConnectionPoolManager(const ConnectionPool::Map& pools, uv_loop_t* loop,
+                        ProtocolVersion protocol_version, const String& keyspace,
+                        ConnectionPoolManagerListener* listener, Metrics* metrics,
                         const ConnectionPoolSettings& settings);
 
   /**
@@ -89,7 +86,6 @@ class ConnectionPoolManager
    */
   PooledConnection::Ptr find_least_busy(const Address& address) const;
 
-
   /**
    * Determine if a pool has any valid connections.
    *
@@ -165,9 +161,8 @@ class ConnectionPoolManager
 
   virtual void on_pool_down(const Address& address);
 
-  virtual void on_pool_critical_error(const Address& address,
-                                 Connector::ConnectionError code,
-                                 const String& message);
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message);
 
   virtual void on_requires_flush(ConnectionPool* pool);
 
@@ -209,6 +204,6 @@ class ConnectionPoolManager
 #endif
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connection_pool_manager_initializer.cpp b/src/connection_pool_manager_initializer.cpp
index a91925aa4..e6503294e 100644
--- a/src/connection_pool_manager_initializer.cpp
+++ b/src/connection_pool_manager_initializer.cpp
@@ -16,31 +16,28 @@
 
 #include "connection_pool_manager_initializer.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 ConnectionPoolManagerInitializer::ConnectionPoolManagerInitializer(ProtocolVersion protocol_version,
                                                                    const Callback& callback)
-  : callback_(callback)
-  , is_canceled_(false)
-  , remaining_(0)
-  , protocol_version_(protocol_version)
-  , listener_(NULL)
-  , metrics_(NULL) { }
-
-void ConnectionPoolManagerInitializer::initialize(uv_loop_t* loop,
-                                                  const HostMap& hosts) {
+    : callback_(callback)
+    , is_canceled_(false)
+    , remaining_(0)
+    , protocol_version_(protocol_version)
+    , listener_(NULL)
+    , metrics_(NULL) {}
+
+void ConnectionPoolManagerInitializer::initialize(uv_loop_t* loop, const HostMap& hosts) {
   inc_ref();
   loop_ = loop;
   remaining_ = hosts.size();
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
-    ConnectionPoolConnector::Ptr pool_connector(
-          new ConnectionPoolConnector(it->second,
-                                      protocol_version_,
-                                      bind_callback(&ConnectionPoolManagerInitializer::on_connect, this)));
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
+    ConnectionPoolConnector::Ptr pool_connector(new ConnectionPoolConnector(
+        it->second, protocol_version_,
+        bind_callback(&ConnectionPoolManagerInitializer::on_connect, this)));
     pending_pools_.push_back(pool_connector);
-    pool_connector
-        ->with_listener(this)
+    pool_connector->with_listener(this)
         ->with_keyspace(keyspace_)
         ->with_metrics(metrics_)
         ->with_settings(settings_)
@@ -54,22 +51,24 @@ void ConnectionPoolManagerInitializer::cancel() {
     manager_->close();
   } else {
     for (ConnectionPoolConnector::Vec::const_iterator it = pending_pools_.begin(),
-         end = pending_pools_.end(); it != end; ++it) {
+                                                      end = pending_pools_.end();
+         it != end; ++it) {
       (*it)->cancel();
     }
-    for (ConnectionPool::Map::iterator it = pools_.begin(),
-         end= pools_.end(); it != end; ++it) {
+    for (ConnectionPool::Map::iterator it = pools_.begin(), end = pools_.end(); it != end; ++it) {
       it->second->close();
     }
   }
 }
 
-ConnectionPoolManagerInitializer* ConnectionPoolManagerInitializer::with_keyspace(const String& keyspace) {
+ConnectionPoolManagerInitializer*
+ConnectionPoolManagerInitializer::with_keyspace(const String& keyspace) {
   keyspace_ = keyspace;
   return this;
 }
 
-ConnectionPoolManagerInitializer* ConnectionPoolManagerInitializer::with_listener(ConnectionPoolManagerListener* listener) {
+ConnectionPoolManagerInitializer*
+ConnectionPoolManagerInitializer::with_listener(ConnectionPoolManagerListener* listener) {
   listener_ = listener;
   return this;
 }
@@ -79,7 +78,8 @@ ConnectionPoolManagerInitializer* ConnectionPoolManagerInitializer::with_metrics
   return this;
 }
 
-ConnectionPoolManagerInitializer* ConnectionPoolManagerInitializer::with_settings(const ConnectionPoolSettings& settings) {
+ConnectionPoolManagerInitializer*
+ConnectionPoolManagerInitializer::with_settings(const ConnectionPoolSettings& settings) {
   settings_ = settings;
   return this;
 }
@@ -127,17 +127,12 @@ void ConnectionPoolManagerInitializer::on_connect(ConnectionPoolConnector* pool_
 
   if (--remaining_ == 0) {
     if (!is_canceled_) {
-      manager_.reset(new ConnectionPoolManager(pools_,
-                                               loop_,
-                                               protocol_version_,
-                                               keyspace_,
-                                               listener_,
-                                               metrics_,
-                                               settings_));
+      manager_.reset(new ConnectionPoolManager(pools_, loop_, protocol_version_, keyspace_,
+                                               listener_, metrics_, settings_));
     }
     callback_(this);
     // If the manager hasn't been released then close it.
-    if (manager_)  {
+    if (manager_) {
       // If the callback doesn't take possession of the manager then we should
       // also clear the listener.
       manager_->set_listener();
@@ -146,5 +141,3 @@ void ConnectionPoolManagerInitializer::on_connect(ConnectionPoolConnector* pool_
     dec_ref();
   }
 }
-
-} // namespace cass
diff --git a/src/connection_pool_manager_initializer.hpp b/src/connection_pool_manager_initializer.hpp
index a29b2f57e..fe4bd4679 100644
--- a/src/connection_pool_manager_initializer.hpp
+++ b/src/connection_pool_manager_initializer.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONNECTION_POOL_MANAGER_INITIALIZER_HPP_INCLUDED__
-#define __CASS_CONNECTION_POOL_MANAGER_INITIALIZER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_POOL_MANAGER_INITIALIZER_HPP
+#define DATASTAX_INTERNAL_CONNECTION_POOL_MANAGER_INITIALIZER_HPP
 
 #include "address.hpp"
 #include "atomic.hpp"
@@ -27,7 +27,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 class Metrics;
@@ -42,7 +42,7 @@ class ConnectionPoolManagerInitializer
 public:
   typedef SharedRefPtr<ConnectionPoolManagerInitializer> Ptr;
 
-  typedef cass::Callback<void, ConnectionPoolManagerInitializer*> Callback;
+  typedef internal::Callback<void, ConnectionPoolManagerInitializer*> Callback;
 
   /**
    * Constructor
@@ -51,8 +51,7 @@ class ConnectionPoolManagerInitializer
    * @param callback A callback that is called when the manager is connected or
    * if an error occurred.
    */
-  ConnectionPoolManagerInitializer(ProtocolVersion protocol_version,
-                                   const Callback& callback);
+  ConnectionPoolManagerInitializer(ProtocolVersion protocol_version, const Callback& callback);
 
   /**
    * Initialize a connection pool manager use the given hosts.
@@ -91,7 +90,6 @@ class ConnectionPoolManagerInitializer
    */
   ConnectionPoolManagerInitializer* with_metrics(Metrics* metrics);
 
-
   /**
    * Set settings to use for the manager and its connections.
    *
@@ -100,7 +98,6 @@ class ConnectionPoolManagerInitializer
    */
   ConnectionPoolManagerInitializer* with_settings(const ConnectionPoolSettings& settings);
 
-
   /**
    * Critical failures that happened during the connection process.
    *
@@ -128,9 +125,8 @@ class ConnectionPoolManagerInitializer
 
   virtual void on_pool_down(const Address& address);
 
-  virtual void on_pool_critical_error(const Address& address,
-                                 Connector::ConnectionError code,
-                                 const String& message);
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message);
 
   virtual void on_close(ConnectionPool* pool);
 
@@ -155,6 +151,6 @@ class ConnectionPoolManagerInitializer
   ConnectionPoolSettings settings_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/connector.cpp b/src/connector.cpp
index 897fd4315..c58959a47 100644
--- a/src/connector.cpp
+++ b/src/connector.cpp
@@ -24,11 +24,11 @@
 #include "serialization.hpp"
 #include "supported_response.hpp"
 
-#include "request.hpp"
 #include "auth_requests.hpp"
 #include "options_request.hpp"
 #include "query_request.hpp"
 #include "register_request.hpp"
+#include "request.hpp"
 #include "startup_request.hpp"
 
 #include "response.hpp"
@@ -36,15 +36,17 @@
 
 #include <iomanip>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A proxy request callback that handles the connection process.
  */
 class StartupCallback : public SimpleRequestCallback {
 public:
-  StartupCallback(Connector* connector,
-                  const Request::ConstPtr& request);
+  StartupCallback(Connector* connector, const Request::ConstPtr& request);
 
 private:
   virtual void on_internal_set(ResponseMessage* response);
@@ -57,9 +59,11 @@ class StartupCallback : public SimpleRequestCallback {
   Connector* connector_;
 };
 
+}}} // namespace datastax::internal::core
+
 StartupCallback::StartupCallback(Connector* connector, const Request::ConstPtr& request)
-  : SimpleRequestCallback(request, connector->settings_.connect_timeout_ms)
-  , connector_(connector) { }
+    : SimpleRequestCallback(request, connector->settings_.connect_timeout_ms)
+    , connector_(connector) {}
 
 void StartupCallback::on_internal_set(ResponseMessage* response) {
   switch (response->opcode()) {
@@ -70,8 +74,7 @@ void StartupCallback::on_internal_set(ResponseMessage* response) {
 #endif
 
     case CQL_OPCODE_ERROR: {
-      ErrorResponse* error
-          = static_cast<ErrorResponse*>(response->response_body().get());
+      ErrorResponse* error = static_cast<ErrorResponse*>(response->response_body().get());
       Connector::ConnectionError error_code = Connector::CONNECTION_ERROR_RESPONSE;
       if (error->code() == CQL_ERROR_PROTOCOL_ERROR &&
           error->message().find("Invalid or unsupported protocol version") != StringRef::npos) {
@@ -88,22 +91,22 @@ void StartupCallback::on_internal_set(ResponseMessage* response) {
     }
 
     case CQL_OPCODE_AUTHENTICATE: {
-      AuthenticateResponse* auth
-          = static_cast<AuthenticateResponse*>(response->response_body().get());
+      AuthenticateResponse* auth =
+          static_cast<AuthenticateResponse*>(response->response_body().get());
       connector_->on_authenticate(auth->class_name());
       break;
     }
 
     case CQL_OPCODE_AUTH_CHALLENGE:
       connector_->on_auth_challenge(
-            static_cast<const AuthResponseRequest*>(request()),
-            static_cast<AuthChallengeResponse*>(response->response_body().get())->token());
+          static_cast<const AuthResponseRequest*>(request()),
+          static_cast<AuthChallengeResponse*>(response->response_body().get())->token());
       break;
 
     case CQL_OPCODE_AUTH_SUCCESS:
       connector_->on_auth_success(
-            static_cast<const AuthResponseRequest*>(request()),
-            static_cast<AuthSuccessResponse*>(response->response_body().get())->token());
+          static_cast<const AuthResponseRequest*>(request()),
+          static_cast<AuthSuccessResponse*>(response->response_body().get())->token());
       break;
 
     case CQL_OPCODE_READY:
@@ -122,13 +125,12 @@ void StartupCallback::on_internal_set(ResponseMessage* response) {
 
 void StartupCallback::on_internal_error(CassError code, const String& message) {
   // Ignore timeouts caused by the connection closing
-  if (connector_->connection_->is_closing() &&
-      code == CASS_ERROR_LIB_REQUEST_TIMED_OUT) {
+  if (connector_->connection_->is_closing() && code == CASS_ERROR_LIB_REQUEST_TIMED_OUT) {
     return;
   }
   OStringStream ss;
-  ss << "Error: '" << message
-     << "' (0x" << std::hex << std::uppercase << std::setw(8) << std::setfill('0') << code << ")";
+  ss << "Error: '" << message << "' (0x" << std::hex << std::uppercase << std::setw(8)
+     << std::setfill('0') << code << ")";
   connector_->on_error(Connector::CONNECTION_ERROR_INTERNAL, ss.str());
 }
 
@@ -137,8 +139,7 @@ void StartupCallback::on_internal_timeout() {
 }
 
 void StartupCallback::on_result_response(ResponseMessage* response) {
-  ResultResponse* result =
-      static_cast<ResultResponse*>(response->response_body().get());
+  ResultResponse* result = static_cast<ResultResponse*>(response->response_body().get());
   switch (result->kind()) {
     case CASS_RESULT_KIND_SET_KEYSPACE:
       connector_->finish();
@@ -151,36 +152,34 @@ void StartupCallback::on_result_response(ResponseMessage* response) {
 }
 
 ConnectionSettings::ConnectionSettings()
-  : connect_timeout_ms(CASS_DEFAULT_CONNECT_TIMEOUT_MS)
-  , auth_provider(new AuthProvider())
-  , idle_timeout_secs(CASS_DEFAULT_IDLE_TIMEOUT_SECS)
-  , heartbeat_interval_secs(CASS_DEFAULT_HEARTBEAT_INTERVAL_SECS)
-  , no_compact(CASS_DEFAULT_NO_COMPACT) { }
+    : connect_timeout_ms(CASS_DEFAULT_CONNECT_TIMEOUT_MS)
+    , auth_provider(new AuthProvider())
+    , idle_timeout_secs(CASS_DEFAULT_IDLE_TIMEOUT_SECS)
+    , heartbeat_interval_secs(CASS_DEFAULT_HEARTBEAT_INTERVAL_SECS)
+    , no_compact(CASS_DEFAULT_NO_COMPACT) {}
 
 ConnectionSettings::ConnectionSettings(const Config& config)
-  : socket_settings(config)
-  , connect_timeout_ms(config.connect_timeout_ms())
-  , auth_provider(config.auth_provider())
-  , idle_timeout_secs(config.connection_idle_timeout_secs())
-  , heartbeat_interval_secs(config.connection_heartbeat_interval_secs())
-  , no_compact(config.no_compact())
-  , application_name(config.application_name())
-  , application_version(config.application_version()) { }
-
-Connector::Connector(const Host::Ptr& host,
-                     ProtocolVersion protocol_version,
+    : socket_settings(config)
+    , connect_timeout_ms(config.connect_timeout_ms())
+    , auth_provider(config.auth_provider())
+    , idle_timeout_secs(config.connection_idle_timeout_secs())
+    , heartbeat_interval_secs(config.connection_heartbeat_interval_secs())
+    , no_compact(config.no_compact())
+    , application_name(config.application_name())
+    , application_version(config.application_version()) {}
+
+Connector::Connector(const Host::Ptr& host, ProtocolVersion protocol_version,
                      const Callback& callback)
-  : callback_(callback)
-  , loop_(NULL)
-  , host_(host)
-  , socket_connector_(
-      new SocketConnector(host->address(),
-                          bind_callback(&Connector::on_connect, this)))
-  , error_code_(CONNECTION_OK)
-  , protocol_version_(protocol_version)
-  , event_types_(0)
-  , listener_(NULL)
-  , metrics_(NULL) { }
+    : callback_(callback)
+    , loop_(NULL)
+    , host_(host)
+    , socket_connector_(
+          new SocketConnector(host->address(), bind_callback(&Connector::on_connect, this)))
+    , error_code_(CONNECTION_OK)
+    , protocol_version_(protocol_version)
+    , event_types_(0)
+    , listener_(NULL)
+    , metrics_(NULL) {}
 
 Connector* Connector::with_keyspace(const String& keyspace) {
   keyspace_ = keyspace;
@@ -206,21 +205,18 @@ Connector* Connector::with_settings(const ConnectionSettings& settings) {
   settings_ = settings;
   // Only use hostname resolution if actually required for SSL or
   // authentication.
-  settings_.socket_settings.hostname_resolution_enabled
-      = settings.socket_settings.hostname_resolution_enabled &&
-        (settings.auth_provider || settings.socket_settings.ssl_context);
+  settings_.socket_settings.hostname_resolution_enabled =
+      settings.socket_settings.hostname_resolution_enabled &&
+      (settings.auth_provider || settings.socket_settings.ssl_context);
   return this;
 }
 
 void Connector::connect(uv_loop_t* loop) {
   inc_ref(); // For the event loop
   loop_ = loop;
-  socket_connector_
-      ->with_settings(settings_.socket_settings)
-      ->connect(loop);
+  socket_connector_->with_settings(settings_.socket_settings)->connect(loop);
   if (settings_.connect_timeout_ms > 0) {
-    timer_.start(loop, settings_.connect_timeout_ms,
-                 bind_callback(&Connector::on_timeout, this));
+    timer_.start(loop, settings_.connect_timeout_ms, bind_callback(&Connector::on_timeout, this));
   }
 }
 
@@ -254,8 +250,7 @@ void Connector::finish() {
 void Connector::on_error(ConnectionError code, const String& message) {
   assert(code != CONNECTION_OK && "Notified error without an error");
   LOG_DEBUG("Unable to connect to host %s because of the following error: %s",
-            address().to_string().c_str(),
-            message.c_str());
+            address().to_string().c_str(), message.c_str());
   if (error_code_ == CONNECTION_OK) { // Only perform this once
     error_message_ = message;
     error_code_ = code;
@@ -268,21 +263,15 @@ void Connector::on_ready_or_set_keyspace() {
   if (keyspace_.empty()) {
     finish();
   } else {
-    connection_->write_and_flush(
-          RequestCallback::Ptr(
-            new StartupCallback(this,
-                                Request::ConstPtr(
-                                  new QueryRequest("USE " + keyspace_)))));
+    connection_->write_and_flush(RequestCallback::Ptr(
+        new StartupCallback(this, Request::ConstPtr(new QueryRequest("USE " + keyspace_)))));
   }
 }
 
 void Connector::on_ready_or_register_for_events() {
   if (event_types_ != 0) {
-    connection_->write_and_flush(
-          RequestCallback::Ptr(
-            new StartupCallback(this,
-                                Request::ConstPtr(
-                                  new RegisterRequest(event_types_)))));
+    connection_->write_and_flush(RequestCallback::Ptr(
+        new StartupCallback(this, Request::ConstPtr(new RegisterRequest(event_types_)))));
     // REGISTER requests also returns a READY response so this needs to be reset
     // to prevent a loop.
     event_types_ = 0;
@@ -296,27 +285,21 @@ void Connector::on_ready_or_register_for_events() {
 // options for at least compression, but likely other things too.
 #ifdef CASS_USE_OPTIONS
 void ConnectionConnector::on_supported(ResponseMessage* response) {
-  SupportedResponse* supported =
-      static_cast<SupportedResponse*>(response->response_body().get());
+  SupportedResponse* supported = static_cast<SupportedResponse*>(response->response_body().get());
 
   // TODO: Do something with the supported info
   (void)supported;
 
-  connection_->write_and_flush(
-        RequestCallback::Ptr(
-          new StartupCallback(this,
-                              Request::ConstPtr(
-                                new StartupRequest(settings_.application_name,
-                                                   settings_.application_version,
-                                                   settings_.client_id,
-                                                   settings_.no_compact)))));
+  connection_->write_and_flush(RequestCallback::Ptr(new StartupCallback(
+      this, Request::ConstPtr(new StartupRequest(settings_.application_name,
+                                                 settings_.application_version, settings_.client_id,
+                                                 settings_.no_compact)))));
 }
 #endif
 
 void Connector::on_authenticate(const String& class_name) {
-  Authenticator::Ptr auth(settings_.auth_provider->new_authenticator(socket_connector_->address(),
-                                                                     socket_connector_->hostname(),
-                                                                     class_name));
+  Authenticator::Ptr auth(settings_.auth_provider->new_authenticator(
+      socket_connector_->address(), socket_connector_->hostname(), class_name));
   if (!auth) {
     on_error(CONNECTION_ERROR_AUTH, "Authentication required but no auth provider set");
   } else {
@@ -325,25 +308,20 @@ void Connector::on_authenticate(const String& class_name) {
       on_error(CONNECTION_ERROR_AUTH, "Failed creating initial response token: " + auth->error());
       return;
     }
-    connection_->write_and_flush(
-          RequestCallback::Ptr(
-            new StartupCallback(this,
-                                Request::ConstPtr(
-                                  new AuthResponseRequest(response, auth)))));
+    connection_->write_and_flush(RequestCallback::Ptr(
+        new StartupCallback(this, Request::ConstPtr(new AuthResponseRequest(response, auth)))));
   }
 }
 
 void Connector::on_auth_challenge(const AuthResponseRequest* request, const String& token) {
   String response;
   if (!request->auth()->evaluate_challenge(token, &response)) {
-    on_error(CONNECTION_ERROR_AUTH, "Failed evaluating challenge token: " + request->auth()->error());
+    on_error(CONNECTION_ERROR_AUTH,
+             "Failed evaluating challenge token: " + request->auth()->error());
     return;
   }
-  connection_->write_and_flush(
-        RequestCallback::Ptr(
-          new StartupCallback(this,
-                              Request::ConstPtr(
-                                new AuthResponseRequest(response, request->auth())))));
+  connection_->write_and_flush(RequestCallback::Ptr(new StartupCallback(
+      this, Request::ConstPtr(new AuthResponseRequest(response, request->auth())))));
 }
 
 void Connector::on_auth_success(const AuthResponseRequest* request, const String& token) {
@@ -366,38 +344,25 @@ void Connector::on_connect(SocketConnector* socket_connector) {
   if (socket_connector->is_ok()) {
     Socket::Ptr socket(socket_connector->release_socket());
 
-    connection_.reset(new Connection(socket,
-                                     host_,
-                                     protocol_version_,
-                                     settings_.idle_timeout_secs,
+    connection_.reset(new Connection(socket, host_, protocol_version_, settings_.idle_timeout_secs,
                                      settings_.heartbeat_interval_secs));
     connection_->set_listener(this);
 
     if (socket_connector->ssl_session()) {
       socket->set_handler(
-            new SslConnectionHandler(
-              socket_connector->ssl_session().release(),
-              connection_.get()));
+          new SslConnectionHandler(socket_connector->ssl_session().release(), connection_.get()));
     } else {
-      socket->set_handler(
-            new ConnectionHandler(connection_.get()));
+      socket->set_handler(new ConnectionHandler(connection_.get()));
     }
 
 #ifdef CASS_USE_OPTIONS
     connection_->write_and_flush(
-          RequestCallback::Ptr(
-            new StartupCallback(this,
-                                Request::ConstPtr(
-                                  new OptionsRequest()))));
+        RequestCallback::Ptr(new StartupCallback(this, Request::ConstPtr(new OptionsRequest()))));
 #else
-    connection_->write_and_flush(
-          RequestCallback::Ptr(
-            new StartupCallback(this,
-                                Request::ConstPtr(
-                                  new StartupRequest(settings_.application_name,
-                                                     settings_.application_version,
-                                                     settings_.client_id,
-                                                     settings_.no_compact)))));
+    connection_->write_and_flush(RequestCallback::Ptr(new StartupCallback(
+        this, Request::ConstPtr(new StartupRequest(settings_.application_name,
+                                                   settings_.application_version,
+                                                   settings_.client_id, settings_.no_compact)))));
 #endif
   } else if (socket_connector->is_canceled() || is_timeout_error()) {
     finish();
@@ -424,5 +389,3 @@ void Connector::on_timeout(Timer* timer) {
   socket_connector_->cancel();
   if (connection_) connection_->close();
 }
-
-} // namespace cass
diff --git a/src/connector.hpp b/src/connector.hpp
index bc8d1ef5e..28cbf30a8 100644
--- a/src/connector.hpp
+++ b/src/connector.hpp
@@ -19,10 +19,10 @@
 #include "connection.hpp"
 #include "socket_connector.hpp"
 
-#ifndef __CASS_CONNECTION_CONNECTOR_HPP_INCLUDED__
-#define __CASS_CONNECTION_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTION_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_CONNECTION_CONNECTOR_HPP
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class AuthResponseRequest;
 class Config;
@@ -69,7 +69,7 @@ class Connector
   typedef SharedRefPtr<Connector> Ptr;
   typedef Vector<Ptr> Vec;
 
-  typedef cass::Callback<void, Connector*> Callback;
+  typedef internal::Callback<void, Connector*> Callback;
 
   enum ConnectionError {
     CONNECTION_OK,
@@ -97,9 +97,7 @@ class Connector
    * @param callback A callback that is called when the connection is connected or
    * if an error occurred.
    */
-  Connector(const Host::Ptr& host,
-            ProtocolVersion protocol_version,
-            const Callback& callback);
+  Connector(const Host::Ptr& host, ProtocolVersion protocol_version, const Callback& callback);
 
   /**
    * Set the keyspace to connect with. Calls "USE <keyspace>" after
@@ -169,32 +167,18 @@ class Connector
   const Address& address() const { return socket_connector_->address(); }
   const ProtocolVersion protocol_version() const { return protocol_version_; }
 
-
-  bool is_ok() const {
-    return error_code_ == CONNECTION_OK;
-  }
-  bool is_canceled() const {
-    return error_code_ == CONNECTION_CANCELED;
-  }
-  bool is_invalid_protocol() const {
-    return error_code_ == CONNECTION_ERROR_INVALID_PROTOCOL;
-  }
-  bool is_auth_error() const {
-    return error_code_ == CONNECTION_ERROR_AUTH;
-  }
+  bool is_ok() const { return error_code_ == CONNECTION_OK; }
+  bool is_canceled() const { return error_code_ == CONNECTION_CANCELED; }
+  bool is_invalid_protocol() const { return error_code_ == CONNECTION_ERROR_INVALID_PROTOCOL; }
+  bool is_auth_error() const { return error_code_ == CONNECTION_ERROR_AUTH; }
   bool is_ssl_error() const {
     return error_code_ == CONNECTION_ERROR_SSL_HANDSHAKE ||
-        error_code_ == CONNECTION_ERROR_SSL_VERIFY;
-  }
-  bool is_timeout_error() const {
-    return error_code_ == CONNECTION_ERROR_TIMEOUT;
-  }
-  bool is_keyspace_error() const {
-    return error_code_ == CONNECTION_ERROR_KEYSPACE;
+           error_code_ == CONNECTION_ERROR_SSL_VERIFY;
   }
+  bool is_timeout_error() const { return error_code_ == CONNECTION_ERROR_TIMEOUT; }
+  bool is_keyspace_error() const { return error_code_ == CONNECTION_ERROR_KEYSPACE; }
   bool is_critical_error() const {
-    return is_auth_error() || is_ssl_error() ||
-        is_invalid_protocol() || is_keyspace_error();
+    return is_auth_error() || is_ssl_error() || is_invalid_protocol() || is_keyspace_error();
   }
 
   ConnectionError error_code() { return error_code_; }
@@ -241,6 +225,6 @@ class Connector
   ConnectionSettings settings_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/constants.hpp b/src/constants.hpp
index f4157bb90..84293368a 100644
--- a/src/constants.hpp
+++ b/src/constants.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONSTANTS_HPP_INCLUDED__
-#define __CASS_CONSTANTS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONSTANTS_HPP
+#define DATASTAX_INTERNAL_CONSTANTS_HPP
 
 #define CASS_UINT32_MAX 4294967295UL
 
@@ -121,7 +121,10 @@
 #define CASS_DEFAULT_PREPARE_ON_UP_OR_ADD_HOST true
 #define CASS_DEFAULT_PORT 9042
 #define CASS_DEFAULT_QUEUE_SIZE_IO 8192
-#define CASS_DEFAULT_RECONNECT_WAIT_TIME_MS 2000
+#define CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS 2000u
+#define CASS_DEFAULT_EXPONENTIAL_RECONNECT_BASE_DELAY_MS \
+  CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS
+#define CASS_DEFAULT_EXPONENTIAL_RECONNECT_MAX_DELAY_MS 600000u // 10 minutes
 #define CASS_DEFAULT_RESOLVE_TIMEOUT_MS 5000
 #define CASS_DEFAULT_TCP_KEEPALIVE_DELAY_SECS 0
 #define CASS_DEFAULT_TCP_KEEPALIVE_ENABLED true
diff --git a/src/control_connection.cpp b/src/control_connection.cpp
index f3f380d92..c2f1c46e5 100644
--- a/src/control_connection.cpp
+++ b/src/control_connection.cpp
@@ -18,13 +18,13 @@
 
 #include "collection_iterator.hpp"
 #include "constants.hpp"
+#include "error_response.hpp"
 #include "event_response.hpp"
 #include "load_balancing.hpp"
 #include "logger.hpp"
 #include "metadata.hpp"
 #include "query_request.hpp"
 #include "result_iterator.hpp"
-#include "error_response.hpp"
 #include "result_response.hpp"
 #include "session.hpp"
 #include "timer.hpp"
@@ -35,7 +35,10 @@
 #include <iomanip>
 #include <iterator>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A class for handling a single query on behalf of the control connection.
@@ -52,12 +55,11 @@ class ControlRequestCallback : public SimpleRequestCallback {
    * @param control_connection The control connection the query is run on.
    * @param callback A callback that handles a successful query.
    */
-  ControlRequestCallback(const String& query,
-                         ControlConnection* control_connection,
+  ControlRequestCallback(const String& query, ControlConnection* control_connection,
                          Callback callback)
-    : SimpleRequestCallback(query)
-    , control_connection_(control_connection)
-    , callback_(callback) { }
+      : SimpleRequestCallback(query)
+      , control_connection_(control_connection)
+      , callback_(callback) {}
 
   /**
    * Constructor. Initialize with a request object.
@@ -66,12 +68,11 @@ class ControlRequestCallback : public SimpleRequestCallback {
    * @param control_connection The control connection the request is run on.
    * @param callback A callback that handles a successful request.
    */
-  ControlRequestCallback(const Request::ConstPtr& request,
-                         ControlConnection* control_connection,
+  ControlRequestCallback(const Request::ConstPtr& request, ControlConnection* control_connection,
                          Callback callback)
-    : SimpleRequestCallback(request)
-    , control_connection_(control_connection)
-    , callback_(callback) { }
+      : SimpleRequestCallback(request)
+      , control_connection_(control_connection)
+      , callback_(callback) {}
 
   virtual void on_internal_set(ResponseMessage* response) {
     if (response->opcode() != CQL_OPCODE_RESULT) {
@@ -86,9 +87,7 @@ class ControlRequestCallback : public SimpleRequestCallback {
     control_connection_->defunct();
   }
 
-  virtual void on_internal_timeout() {
-    control_connection_->defunct();
-  }
+  virtual void on_internal_timeout() { control_connection_->defunct(); }
 
   ControlConnection* control_connection() { return control_connection_; }
   const ResultResponse::Ptr& result() const { return result_; }
@@ -117,15 +116,13 @@ class ChainedControlRequestCallback : public ChainedRequestCallback {
    * @param callback The callback for a successful run of all the queries.
    */
   ChainedControlRequestCallback(const String& key, const String& query,
-                                ControlConnection* control_connection,
-                                Callback callback)
-    : ChainedRequestCallback(key, query)
-    , control_connection_(control_connection)
-    , callback_(callback) { }
+                                ControlConnection* control_connection, Callback callback)
+      : ChainedRequestCallback(key, query)
+      , control_connection_(control_connection)
+      , callback_(callback) {}
 
   virtual void on_chain_set() {
-    for (Map::const_iterator it = responses().begin(),
-         end = responses().end(); it != end; ++it) {
+    for (Map::const_iterator it = responses().begin(), end = responses().end(); it != end; ++it) {
       if (it->second->opcode() != CQL_OPCODE_RESULT) {
         control_connection_->defunct();
         return;
@@ -138,9 +135,7 @@ class ChainedControlRequestCallback : public ChainedRequestCallback {
     control_connection_->defunct();
   }
 
-  virtual void on_chain_timeout() {
-    control_connection_->defunct();
-  }
+  virtual void on_chain_timeout() { control_connection_->defunct(); }
 
   ControlConnection* control_connection() { return control_connection_; }
 
@@ -149,7 +144,6 @@ class ChainedControlRequestCallback : public ChainedRequestCallback {
   Callback callback_;
 };
 
-
 /**
  * A specialized request callback for handling node queries. This is needed for
  * new node and node moved events.
@@ -166,17 +160,12 @@ class RefreshNodeCallback : public ControlRequestCallback {
    * @param query The query to run for the node change.
    * @param control_connection The control connection the query is run on.
    */
-  RefreshNodeCallback(const Address& address,
-                      ControlConnection::RefreshNodeType type,
-                      bool is_all_peers,
-                      const String& query,
-                      ControlConnection* control_connection)
-    : ControlRequestCallback(query,
-                             control_connection,
-                             ControlConnection::on_refresh_node)
-    , address(address)
-    , type(type)
-    , is_all_peers(is_all_peers) { }
+  RefreshNodeCallback(const Address& address, ControlConnection::RefreshNodeType type,
+                      bool is_all_peers, const String& query, ControlConnection* control_connection)
+      : ControlRequestCallback(query, control_connection, ControlConnection::on_refresh_node)
+      , address(address)
+      , type(type)
+      , is_all_peers(is_all_peers) {}
 
   const Address address;
   const ControlConnection::RefreshNodeType type;
@@ -196,13 +185,10 @@ class RefreshKeyspaceCallback : public ControlRequestCallback {
    * @param query The query to run for the keyspace change.
    * @param control_connection The control connection the query is run on.
    */
-  RefreshKeyspaceCallback(const String& keyspace_name,
-                          const String& query,
+  RefreshKeyspaceCallback(const String& keyspace_name, const String& query,
                           ControlConnection* control_connection)
-    : ControlRequestCallback(query,
-                             control_connection,
-                             ControlConnection::on_refresh_keyspace)
-    , keyspace_name(keyspace_name) { }
+      : ControlRequestCallback(query, control_connection, ControlConnection::on_refresh_keyspace)
+      , keyspace_name(keyspace_name) {}
 
   const String keyspace_name;
 };
@@ -227,11 +213,10 @@ class RefreshTableCallback : public ChainedControlRequestCallback {
   RefreshTableCallback(const String& keyspace_name, const String& table_or_view_name,
                        const String& key, const String& query,
                        ControlConnection* control_connection)
-    : ChainedControlRequestCallback(key, query,
-                                    control_connection,
-                                    ControlConnection::on_refresh_table_or_view)
-    , keyspace_name(keyspace_name)
-    , table_or_view_name(table_or_view_name) { }
+      : ChainedControlRequestCallback(key, query, control_connection,
+                                      ControlConnection::on_refresh_table_or_view)
+      , keyspace_name(keyspace_name)
+      , table_or_view_name(table_or_view_name) {}
 
   const String keyspace_name;
   const String table_or_view_name;
@@ -251,14 +236,11 @@ class RefreshTypeCallback : public ControlRequestCallback {
    * @param query The query to run for the type change.
    * @param control_connection The control connection to run the query on.
    */
-  RefreshTypeCallback(const String& keyspace_name, const String& type_name,
-                      const String& query,
+  RefreshTypeCallback(const String& keyspace_name, const String& type_name, const String& query,
                       ControlConnection* control_connection)
-    : ControlRequestCallback(query,
-                             control_connection,
-                             ControlConnection::on_refresh_type)
-    , keyspace_name(keyspace_name)
-    , type_name(type_name) { }
+      : ControlRequestCallback(query, control_connection, ControlConnection::on_refresh_type)
+      , keyspace_name(keyspace_name)
+      , type_name(type_name) {}
 
   const String keyspace_name;
   const String type_name;
@@ -284,15 +266,12 @@ class RefreshFunctionCallback : public ControlRequestCallback {
    */
   RefreshFunctionCallback(const String& keyspace_name, const String& function_name,
                           const StringVec& arg_types, bool is_aggregate,
-                          const Request::ConstPtr& request,
-                          ControlConnection* control_connection)
-    : ControlRequestCallback(request,
-                             control_connection,
-                             ControlConnection::on_refresh_function)
-    , keyspace_name(keyspace_name)
-    , function_name(function_name)
-    , arg_types(arg_types)
-    , is_aggregate(is_aggregate) { }
+                          const Request::ConstPtr& request, ControlConnection* control_connection)
+      : ControlRequestCallback(request, control_connection, ControlConnection::on_refresh_function)
+      , keyspace_name(keyspace_name)
+      , function_name(function_name)
+      , arg_types(arg_types)
+      , is_aggregate(is_aggregate) {}
 
   const String keyspace_name;
   const String function_name;
@@ -304,43 +283,39 @@ class RefreshFunctionCallback : public ControlRequestCallback {
  * A no operation control connection listener. This is used if no listener
  * is set.
  */
-class NopControlConnectionListener
-    : public ControlConnectionListener {
+class NopControlConnectionListener : public ControlConnectionListener {
 public:
-  virtual void on_up(const Address& address)  { }
-  virtual void on_down(const Address& address)  { }
+  virtual void on_up(const Address& address) {}
+  virtual void on_down(const Address& address) {}
 
-  virtual void on_add(const Host::Ptr& host)  { }
-  virtual void on_remove(const Address& address)  { }
+  virtual void on_add(const Host::Ptr& host) {}
+  virtual void on_remove(const Address& address) {}
 
-  virtual void on_update_schema(SchemaType type,
-                                const ResultResponse::Ptr& result,
-                                const String& keyspace_name,
-                                const String& target_name)  { }
+  virtual void on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                                const String& keyspace_name, const String& target_name) {}
 
-  virtual void on_drop_schema(SchemaType type,
-                              const String& keyspace_name,
-                              const String& target_name) { }
+  virtual void on_drop_schema(SchemaType type, const String& keyspace_name,
+                              const String& target_name) {}
 
-  virtual void on_close(ControlConnection* connection) { }
+  virtual void on_close(ControlConnection* connection) {}
 };
 
+}}} // namespace datastax::internal::core
+
 static NopControlConnectionListener nop_listener__;
 
 ControlConnection::ControlConnection(const Connection::Ptr& connection,
-                                     ControlConnectionListener* listener,
-                                     bool use_schema,
-                                     bool token_aware_routing,
-                                     const VersionNumber& server_version,
+                                     ControlConnectionListener* listener, bool use_schema,
+                                     bool token_aware_routing, const VersionNumber& server_version,
                                      const VersionNumber& dse_server_version,
                                      ListenAddressMap listen_addresses)
-  : connection_(connection)
-  , use_schema_(use_schema)
-  , token_aware_routing_(token_aware_routing)
-  , server_version_(server_version)
-  , dse_server_version_(dse_server_version)
-  , listen_addresses_(listen_addresses)
-  , listener_(listener ? listener : &nop_listener__) {
+    : connection_(connection)
+    , use_schema_(use_schema)
+    , token_aware_routing_(token_aware_routing)
+    , server_version_(server_version)
+    , dse_server_version_(dse_server_version)
+    , listen_addresses_(listen_addresses)
+    , listener_(listener ? listener : &nop_listener__) {
   connection_->set_listener(this);
   inc_ref();
 }
@@ -353,13 +328,9 @@ int32_t ControlConnection::write_and_flush(const RequestCallback::Ptr& callback)
   return connection_->write_and_flush(callback);
 }
 
-void ControlConnection::close() {
-  connection_->close();
-}
+void ControlConnection::close() { connection_->close(); }
 
-void ControlConnection::defunct() {
-  connection_->defunct();
-}
+void ControlConnection::defunct() { connection_->defunct(); }
 
 void ControlConnection::set_listener(ControlConnectionListener* listener) {
   listener_ = listener ? listener : &nop_listener__;
@@ -388,8 +359,7 @@ void ControlConnection::refresh_node(RefreshNodeType type, const Address& addres
   LOG_DEBUG("Refresh node: %s", query.c_str());
 
   if (write_and_flush(RequestCallback::Ptr(
-                        new RefreshNodeCallback(
-                          address, type, is_all_peers, query, this))) < 0) {
+          new RefreshNodeCallback(address, type, is_all_peers, query, this))) < 0) {
     LOG_ERROR("No more stream available while attempting to refresh node info");
     defunct();
   }
@@ -407,32 +377,26 @@ void ControlConnection::handle_refresh_node(RefreshNodeCallback* callback) {
     String address_str = callback->address.to_string();
     LOG_ERROR("No row found for host %s in %s's local/peers system table. "
               "%s will be ignored.",
-              address_str.c_str(),
-              address_string().c_str(),
-              address_str.c_str());
+              address_str.c_str(), address_string().c_str(), address_str.c_str());
     return;
   }
 
   Host::Ptr host(new Host(callback->address));
   if (!callback->is_all_peers) {
     host->set(&result->first_row(), token_aware_routing_);
-    listen_addresses_[callback->address]
-        = determine_listen_address(callback->address, &result->first_row());
+    listen_addresses_[callback->address] =
+        determine_listen_address(callback->address, &result->first_row());
   } else {
     ResultIterator rows(result.get());
     bool found_host = false;
     while (rows.next()) {
       const Row* row = rows.row();
       Address address;
-      bool is_valid_address
-          = determine_address_for_peer_host(this->address(),
-                                            row->get_by_name("peer"),
-                                            row->get_by_name("rpc_address"),
-                                            &address);
+      bool is_valid_address = determine_address_for_peer_host(
+          this->address(), row->get_by_name("peer"), row->get_by_name("rpc_address"), &address);
       if (is_valid_address && callback->address == address) {
         host->set(row, token_aware_routing_);
-        listen_addresses_[callback->address]
-            = determine_listen_address(callback->address, row);
+        listen_addresses_[callback->address] = determine_listen_address(callback->address, row);
         found_host = true;
         break;
       }
@@ -441,9 +405,7 @@ void ControlConnection::handle_refresh_node(RefreshNodeCallback* callback) {
       String address_str = callback->address.to_string();
       LOG_ERROR("No row found for host %s in %s's peers system table. "
                 "%s will be ignored.",
-                address_str.c_str(),
-                address_string().c_str(),
-                address_str.c_str());
+                address_str.c_str(), address_string().c_str(), address_str.c_str());
       return;
     }
   }
@@ -467,7 +429,7 @@ void ControlConnection::refresh_keyspace(const StringRef& keyspace_name) {
 
   if (server_version_ >= VersionNumber(3, 0, 0)) {
     query.assign(SELECT_KEYSPACES_30);
-  }  else {
+  } else {
     query.assign(SELECT_KEYSPACES_20);
   }
   query.append(" WHERE keyspace_name='")
@@ -476,10 +438,8 @@ void ControlConnection::refresh_keyspace(const StringRef& keyspace_name) {
 
   LOG_DEBUG("Refreshing keyspace %s", query.c_str());
 
-  if (write_and_flush(
-        RequestCallback::Ptr(
-          new RefreshKeyspaceCallback(
-            keyspace_name.to_string(), query, this))) < 0) {
+  if (write_and_flush(RequestCallback::Ptr(
+          new RefreshKeyspaceCallback(keyspace_name.to_string(), query, this))) < 0) {
     LOG_ERROR("No more stream available while attempting to refresh keyspace info");
     defunct();
   }
@@ -497,8 +457,7 @@ void ControlConnection::handle_refresh_keyspace(RefreshKeyspaceCallback* callbac
               callback->keyspace_name.c_str());
     return;
   }
-  listener_->on_update_schema(ControlConnectionListener::KEYSPACE,  result,
-                              callback->keyspace_name);
+  listener_->on_update_schema(ControlConnectionListener::KEYSPACE, result, callback->keyspace_name);
 }
 
 void ControlConnection::refresh_table_or_view(const StringRef& keyspace_name,
@@ -510,39 +469,55 @@ void ControlConnection::refresh_table_or_view(const StringRef& keyspace_name,
 
   if (server_version_ >= VersionNumber(3, 0, 0)) {
     table_query.assign(SELECT_TABLES_30);
-    table_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND table_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    table_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND table_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     view_query.assign(SELECT_VIEWS_30);
-    view_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND view_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    view_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND view_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     column_query.assign(SELECT_COLUMNS_30);
-    column_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND table_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    column_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND table_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     index_query.assign(SELECT_INDEXES_30);
-    index_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND table_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    index_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND table_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     LOG_DEBUG("Refreshing table/view %s; %s; %s; %s", table_query.c_str(), view_query.c_str(),
               column_query.c_str(), index_query.c_str());
   } else {
     table_query.assign(SELECT_COLUMN_FAMILIES_20);
-    table_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND columnfamily_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    table_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND columnfamily_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     column_query.assign(SELECT_COLUMNS_20);
-    column_query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-        .append("' AND columnfamily_name='").append(table_or_view_name.data(), table_or_view_name.size()).append("'");
+    column_query.append(" WHERE keyspace_name='")
+        .append(keyspace_name.data(), keyspace_name.size())
+        .append("' AND columnfamily_name='")
+        .append(table_or_view_name.data(), table_or_view_name.size())
+        .append("'");
 
     LOG_DEBUG("Refreshing table %s; %s", table_query.c_str(), column_query.c_str());
   }
 
-  ChainedRequestCallback::Ptr callback(
-        new RefreshTableCallback(
-          keyspace_name.to_string(), table_or_view_name.to_string(),
-          "tables", table_query, this));
+  ChainedRequestCallback::Ptr callback(new RefreshTableCallback(
+      keyspace_name.to_string(), table_or_view_name.to_string(), "tables", table_query, this));
 
   callback = callback->chain("columns", column_query);
 
@@ -570,8 +545,7 @@ void ControlConnection::handle_refresh_table_or_view(RefreshTableCallback* callb
     ResultResponse::Ptr views_result(callback->result("views"));
     if (!views_result || views_result->row_count() == 0) {
       LOG_ERROR("No row found for table (or view) %s.%s in system schema tables.",
-                callback->keyspace_name.c_str(),
-                callback->table_or_view_name.c_str());
+                callback->keyspace_name.c_str(), callback->table_or_view_name.c_str());
       return;
     }
     listener_->on_update_schema(ControlConnectionListener::VIEW, views_result,
@@ -594,8 +568,7 @@ void ControlConnection::handle_refresh_table_or_view(RefreshTableCallback* callb
   }
 }
 
-void ControlConnection::refresh_type(const StringRef& keyspace_name,
-                                     const StringRef& type_name) {
+void ControlConnection::refresh_type(const StringRef& keyspace_name, const StringRef& type_name) {
   String query;
   if (server_version_ >= VersionNumber(3, 0, 0)) {
     query.assign(SELECT_USERTYPES_30);
@@ -603,16 +576,16 @@ void ControlConnection::refresh_type(const StringRef& keyspace_name,
     query.assign(SELECT_USERTYPES_21);
   }
 
-  query.append(" WHERE keyspace_name='").append(keyspace_name.data(), keyspace_name.size())
-      .append("' AND type_name='").append(type_name.data(), type_name.size()).append("'");
+  query.append(" WHERE keyspace_name='")
+      .append(keyspace_name.data(), keyspace_name.size())
+      .append("' AND type_name='")
+      .append(type_name.data(), type_name.size())
+      .append("'");
 
   LOG_DEBUG("Refreshing type %s", query.c_str());
 
-  if (!write_and_flush(
-        RequestCallback::Ptr(
-          new RefreshTypeCallback(
-            keyspace_name.to_string(), type_name.to_string(),
-            query, this)))) {
+  if (!write_and_flush(RequestCallback::Ptr(new RefreshTypeCallback(
+          keyspace_name.to_string(), type_name.to_string(), query, this)))) {
     LOG_ERROR("No more stream available while attempting to refresh type info");
     defunct();
   }
@@ -627,18 +600,16 @@ void ControlConnection::handle_refresh_type(RefreshTypeCallback* callback) {
   const ResultResponse::Ptr result = callback->result();
   if (result->row_count() == 0) {
     LOG_ERROR("No row found for keyspace %s and type %s in system schema.",
-              callback->keyspace_name.c_str(),
-              callback->type_name.c_str());
+              callback->keyspace_name.c_str(), callback->type_name.c_str());
     return;
   }
-  listener_->on_update_schema(ControlConnectionListener::USER_TYPE, result,
-                              callback->keyspace_name, callback->type_name);
+  listener_->on_update_schema(ControlConnectionListener::USER_TYPE, result, callback->keyspace_name,
+                              callback->type_name);
 }
 
 void ControlConnection::refresh_function(const StringRef& keyspace_name,
                                          const StringRef& function_name,
-                                         const StringRefVec& arg_types,
-                                         bool is_aggregate) {
+                                         const StringRefVec& arg_types, bool is_aggregate) {
   String query;
   if (server_version_ >= VersionNumber(3, 0, 0)) {
     if (is_aggregate) {
@@ -658,18 +629,14 @@ void ControlConnection::refresh_function(const StringRef& keyspace_name,
     }
   }
 
-  LOG_DEBUG("Refreshing %s %s in keyspace %s",
-            is_aggregate ? "aggregate" : "function",
+  LOG_DEBUG("Refreshing %s %s in keyspace %s", is_aggregate ? "aggregate" : "function",
             Metadata::full_function_name(function_name.to_string(), to_strings(arg_types)).c_str(),
             String(keyspace_name.data(), keyspace_name.length()).c_str());
 
   SharedRefPtr<QueryRequest> request(new QueryRequest(query, 3));
   SharedRefPtr<Collection> signature(new Collection(CASS_COLLECTION_TYPE_LIST, arg_types.size()));
 
-  for (StringRefVec::const_iterator i = arg_types.begin(),
-       end = arg_types.end();
-       i != end;
-       ++i) {
+  for (StringRefVec::const_iterator i = arg_types.begin(), end = arg_types.end(); i != end; ++i) {
     signature->append(CassString(i->data(), i->size()));
   }
 
@@ -677,12 +644,9 @@ void ControlConnection::refresh_function(const StringRef& keyspace_name,
   request->set(1, CassString(function_name.data(), function_name.size()));
   request->set(2, signature.get());
 
-  if (!write_and_flush(
-        RequestCallback::Ptr(
-          new RefreshFunctionCallback(
-            keyspace_name.to_string(), function_name.to_string(),
-            to_strings(arg_types), is_aggregate,
-            request, this)))) {
+  if (!write_and_flush(RequestCallback::Ptr(
+          new RefreshFunctionCallback(keyspace_name.to_string(), function_name.to_string(),
+                                      to_strings(arg_types), is_aggregate, request, this)))) {
     LOG_ERROR("No more stream available while attempting to refresh function info");
     defunct();
   }
@@ -696,20 +660,17 @@ void ControlConnection::on_refresh_function(ControlRequestCallback* callback) {
 void ControlConnection::handle_refresh_function(RefreshFunctionCallback* callback) {
   const ResultResponse::Ptr result = callback->result();
   if (result->row_count() == 0) {
-    LOG_ERROR("No row found for keyspace %s and %s %s",
-              callback->keyspace_name.c_str(),
+    LOG_ERROR("No row found for keyspace %s and %s %s", callback->keyspace_name.c_str(),
               callback->is_aggregate ? "aggregate" : "function",
-              Metadata::full_function_name(callback->function_name,
-                                           callback->arg_types).c_str());
+              Metadata::full_function_name(callback->function_name, callback->arg_types).c_str());
     return;
   }
 
-  listener_->on_update_schema(callback->is_aggregate ? ControlConnectionListener::AGGREGATE
-                                                     : ControlConnectionListener::FUNCTION,
-                              result,
-                              callback->keyspace_name,
-                              Metadata::full_function_name(callback->function_name,
-                                                           callback->arg_types));
+  listener_->on_update_schema(
+      callback->is_aggregate ? ControlConnectionListener::AGGREGATE
+                             : ControlConnectionListener::FUNCTION,
+      result, callback->keyspace_name,
+      Metadata::full_function_name(callback->function_name, callback->arg_types));
 }
 
 void ControlConnection::on_close(Connection* connection) {
@@ -763,13 +724,11 @@ void ControlConnection::on_event(const EventResponse::Ptr& response) {
 
     case CASS_EVENT_SCHEMA_CHANGE:
       // Only handle keyspace events when using token-aware routing
-      if (!use_schema_ &&
-          response->schema_change_target() != EventResponse::KEYSPACE) {
+      if (!use_schema_ && response->schema_change_target() != EventResponse::KEYSPACE) {
         return;
       }
 
-      LOG_DEBUG("Schema change (%d): %.*s %.*s",
-                response->schema_change(),
+      LOG_DEBUG("Schema change (%d): %.*s %.*s", response->schema_change(),
                 (int)response->keyspace().size(), response->keyspace().data(),
                 (int)response->target().size(), response->target().data());
 
@@ -788,9 +747,7 @@ void ControlConnection::on_event(const EventResponse::Ptr& response) {
               break;
             case EventResponse::FUNCTION:
             case EventResponse::AGGREGATE:
-              refresh_function(response->keyspace(),
-                               response->target(),
-                               response->arg_types(),
+              refresh_function(response->keyspace(), response->target(), response->arg_types(),
                                response->schema_change_target() == EventResponse::AGGREGATE);
               break;
           }
@@ -814,20 +771,19 @@ void ControlConnection::on_event(const EventResponse::Ptr& response) {
                                         response->target().to_string());
               break;
             case EventResponse::FUNCTION:
-              listener_->on_drop_schema(ControlConnectionListener::FUNCTION,
-                                        response->keyspace().to_string(),
-                                        Metadata::full_function_name(response->target().to_string(),
-                                                                     to_strings(response->arg_types())));
+              listener_->on_drop_schema(
+                  ControlConnectionListener::FUNCTION, response->keyspace().to_string(),
+                  Metadata::full_function_name(response->target().to_string(),
+                                               to_strings(response->arg_types())));
               break;
             case EventResponse::AGGREGATE:
-              listener_->on_drop_schema(ControlConnectionListener::AGGREGATE,
-                                        response->keyspace().to_string(),
-                                        Metadata::full_function_name(response->target().to_string(),
-                                                                     to_strings(response->arg_types())));
+              listener_->on_drop_schema(
+                  ControlConnectionListener::AGGREGATE, response->keyspace().to_string(),
+                  Metadata::full_function_name(response->target().to_string(),
+                                               to_strings(response->arg_types())));
               break;
           }
           break;
-
       }
       break;
 
@@ -836,5 +792,3 @@ void ControlConnection::on_event(const EventResponse::Ptr& response) {
       break;
   }
 }
-
-} // namespace cass
diff --git a/src/control_connection.hpp b/src/control_connection.hpp
index 6ddbc335c..ce27e894e 100644
--- a/src/control_connection.hpp
+++ b/src/control_connection.hpp
@@ -14,18 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONTROL_CONNECTION_HPP_INCLUDED__
-#define __CASS_CONTROL_CONNECTION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONTROL_CONNECTION_HPP
+#define DATASTAX_INTERNAL_CONTROL_CONNECTION_HPP
 
 #include "address.hpp"
 #include "config.hpp"
 #include "connection.hpp"
 #include "connector.hpp"
 #include "dense_hash_map.hpp"
-#include "request_callback.hpp"
 #include "host.hpp"
 #include "load_balancing.hpp"
 #include "macros.hpp"
+#include "request_callback.hpp"
 #include "response.hpp"
 #include "scoped_ptr.hpp"
 #include "token_map.hpp"
@@ -55,7 +55,7 @@
 #define SELECT_VIRTUAL_TABLES_40 "SELECT * FROM system_virtual_schema.tables"
 #define SELECT_VIRTUAL_COLUMNS_40 "SELECT * FROM system_virtual_schema.columns"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ChainedControlRequestCallback;
 class ControlRequestCallback;
@@ -73,18 +73,9 @@ class RefreshFunctionCallback;
  */
 class ControlConnectionListener {
 public:
-  enum SchemaType {
-    KEYSPACE,
-    TABLE,
-    VIEW,
-    COLUMN,
-    INDEX,
-    USER_TYPE,
-    FUNCTION,
-    AGGREGATE
-  };
-
-  virtual ~ControlConnectionListener() { }
+  enum SchemaType { KEYSPACE, TABLE, VIEW, COLUMN, INDEX, USER_TYPE, FUNCTION, AGGREGATE };
+
+  virtual ~ControlConnectionListener() {}
 
   /**
    * A callback that's called when a host is marked as being UP.
@@ -124,10 +115,8 @@ class ControlConnectionListener {
    * @param result A result response with the row data associated with the
    * schema change.
    */
-  virtual void on_update_schema(SchemaType type,
-                                const ResultResponse::Ptr& result,
-                                const String& keyspace_name,
-                                const String& target_name = "") = 0;
+  virtual void on_update_schema(SchemaType type, const ResultResponse::Ptr& result,
+                                const String& keyspace_name, const String& target_name = "") = 0;
 
   /**
    * A callback that's called when schema is dropped.
@@ -137,8 +126,7 @@ class ControlConnectionListener {
    * @param target_name The name of the table, user type, function, or
    * aggregate dropped. This is the empty string for dropped keyspaces.
    */
-  virtual void on_drop_schema(SchemaType type,
-                              const String& keyspace_name,
+  virtual void on_drop_schema(SchemaType type, const String& keyspace_name,
                               const String& target_name = "") = 0;
 
   /**
@@ -167,15 +155,13 @@ class ListenAddressMap : public DenseHashMap<Address, String, AddressHash> {
  * by running queries on the control connection to get additional information
  * then passing that data to the listener.
  */
-class ControlConnection : public RefCounted<ControlConnection>
-                        , public ConnectionListener {
+class ControlConnection
+    : public RefCounted<ControlConnection>
+    , public ConnectionListener {
 public:
   typedef SharedRefPtr<ControlConnection> Ptr;
 
-  enum RefreshNodeType {
-    NEW_NODE,
-    MOVED_NODE
-  };
+  enum RefreshNodeType { NEW_NODE, MOVED_NODE };
 
   /**
    * Constructor. Don't use directly.
@@ -190,13 +176,9 @@ class ControlConnection : public RefCounted<ControlConnection>
    * @param dse_server_version The version number of the DSE server implementation.
    * @param listen_addresses The current state of the listen addresses map.
    */
-  ControlConnection(const Connection::Ptr& connection,
-                    ControlConnectionListener* listener,
-                    bool use_schema,
-                    bool token_aware_routing,
-                    const VersionNumber& server_version,
-                    const VersionNumber& dse_server_version,
-                    ListenAddressMap listen_addresses);
+  ControlConnection(const Connection::Ptr& connection, ControlConnectionListener* listener,
+                    bool use_schema, bool token_aware_routing, const VersionNumber& server_version,
+                    const VersionNumber& dse_server_version, ListenAddressMap listen_addresses);
 
   /**
    * Write a request and flush immediately.
@@ -225,25 +207,15 @@ class ControlConnection : public RefCounted<ControlConnection>
   void set_listener(ControlConnectionListener* listener = NULL);
 
 public:
-  const Address& address() const {
-    return connection_->address();
-  }
+  const Address& address() const { return connection_->address(); }
 
-  const String& address_string() const {
-    return connection_->address_string();
-  }
+  const String& address_string() const { return connection_->address_string(); }
 
-  ProtocolVersion protocol_version() const {
-    return connection_->protocol_version();
-  }
+  ProtocolVersion protocol_version() const { return connection_->protocol_version(); }
 
-  const VersionNumber& server_version() {
-    return server_version_;
-  }
+  const VersionNumber& server_version() { return server_version_; }
 
-  const VersionNumber& dse_server_version() {
-    return dse_server_version_;
-  }
+  const VersionNumber& dse_server_version() { return dse_server_version_; }
 
   uv_loop_t* loop() { return connection_->loop(); }
   const Connection::Ptr& connection() const { return connection_; }
@@ -265,20 +237,16 @@ class ControlConnection : public RefCounted<ControlConnection>
   static void on_refresh_keyspace(ControlRequestCallback* callback);
   void handle_refresh_keyspace(RefreshKeyspaceCallback* callback);
 
-  void refresh_table_or_view(const StringRef& keyspace_name,
-                             const StringRef& table_or_view_name);
+  void refresh_table_or_view(const StringRef& keyspace_name, const StringRef& table_or_view_name);
   static void on_refresh_table_or_view(ChainedControlRequestCallback* callback);
   void handle_refresh_table_or_view(RefreshTableCallback* callback);
 
-  void refresh_type(const StringRef& keyspace_name,
-                    const StringRef& type_name);
+  void refresh_type(const StringRef& keyspace_name, const StringRef& type_name);
   static void on_refresh_type(ControlRequestCallback* callback);
   void handle_refresh_type(RefreshTypeCallback* callback);
 
-  void refresh_function(const StringRef& keyspace_name,
-                        const StringRef& function_name,
-                        const StringRefVec& arg_types,
-                        bool is_aggregate);
+  void refresh_function(const StringRef& keyspace_name, const StringRef& function_name,
+                        const StringRefVec& arg_types, bool is_aggregate);
   static void on_refresh_function(ControlRequestCallback* callback);
   void handle_refresh_function(RefreshFunctionCallback* callback);
 
@@ -296,6 +264,6 @@ class ControlConnection : public RefCounted<ControlConnection>
   ControlConnectionListener* listener_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/control_connector.cpp b/src/control_connector.cpp
index cba5e0a50..03b9d7867 100644
--- a/src/control_connector.cpp
+++ b/src/control_connector.cpp
@@ -17,7 +17,10 @@
 #include "control_connector.hpp"
 #include "result_iterator.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A chained request callback that gets the cluster's hosts from the
@@ -27,14 +30,11 @@ class HostsConnectorRequestCallback : public ChainedRequestCallback {
 public:
   typedef SharedRefPtr<HostsConnectorRequestCallback> Ptr;
 
-  HostsConnectorRequestCallback(const String& key, const String& query,
-                                ControlConnector* connector)
-    : ChainedRequestCallback(key, query)
-    , connector_(connector) { }
+  HostsConnectorRequestCallback(const String& key, const String& query, ControlConnector* connector)
+      : ChainedRequestCallback(key, query)
+      , connector_(connector) {}
 
-  virtual void on_chain_set() {
-    connector_->handle_query_hosts(this);
-  }
+  virtual void on_chain_set() { connector_->handle_query_hosts(this); }
 
   virtual void on_chain_error(CassError code, const String& message) {
     connector_->on_error(ControlConnector::CONTROL_CONNECTION_ERROR_HOSTS,
@@ -59,12 +59,10 @@ class SchemaConnectorRequestCallback : public ChainedRequestCallback {
 
   SchemaConnectorRequestCallback(const String& key, const String& query,
                                  ControlConnector* connector)
-    : ChainedRequestCallback(key, query)
-    , connector_(connector) { }
+      : ChainedRequestCallback(key, query)
+      , connector_(connector) {}
 
-  virtual void on_chain_set() {
-    connector_->handle_query_schema(this);
-  }
+  virtual void on_chain_set() { connector_->handle_query_schema(this); }
 
   virtual void on_chain_error(CassError code, const String& message) {
     connector_->on_error(ControlConnector::CONTROL_CONNECTION_ERROR_SCHEMA,
@@ -80,25 +78,25 @@ class SchemaConnectorRequestCallback : public ChainedRequestCallback {
   ControlConnector* connector_;
 };
 
+}}} // namespace datastax::internal::core
+
 ControlConnectionSettings::ControlConnectionSettings()
-  : use_schema(CASS_DEFAULT_USE_SCHEMA)
-  , token_aware_routing(CASS_DEFAULT_TOKEN_AWARE_ROUTING) { }
+    : use_schema(CASS_DEFAULT_USE_SCHEMA)
+    , token_aware_routing(CASS_DEFAULT_TOKEN_AWARE_ROUTING) {}
 
 ControlConnectionSettings::ControlConnectionSettings(const Config& config)
-  : connection_settings(config)
-  , use_schema(config.use_schema())
-  , token_aware_routing(config.token_aware_routing()) { }
+    : connection_settings(config)
+    , use_schema(config.use_schema())
+    , token_aware_routing(config.token_aware_routing()) {}
 
-ControlConnector::ControlConnector(const Host::Ptr& host,
-                                   ProtocolVersion protocol_version,
+ControlConnector::ControlConnector(const Host::Ptr& host, ProtocolVersion protocol_version,
                                    const Callback& callback)
-  : connector_(new Connector(host,
-                             protocol_version,
-                             bind_callback(&ControlConnector::on_connect, this)))
-  , callback_(callback)
-  , error_code_(CONTROL_CONNECTION_OK)
-  , listener_(NULL)
-  , metrics_(NULL) { }
+    : connector_(
+          new Connector(host, protocol_version, bind_callback(&ControlConnector::on_connect, this)))
+    , callback_(callback)
+    , error_code_(CONTROL_CONNECTION_OK)
+    , listener_(NULL)
+    , metrics_(NULL) {}
 
 ControlConnector* ControlConnector::with_listener(ControlConnectionListener* listener) {
   listener_ = listener;
@@ -119,13 +117,11 @@ void ControlConnector::connect(uv_loop_t* loop) {
   inc_ref();
   int event_types = 0;
   if (settings_.use_schema || settings_.token_aware_routing) {
-    event_types = CASS_EVENT_TOPOLOGY_CHANGE | CASS_EVENT_STATUS_CHANGE |
-                  CASS_EVENT_SCHEMA_CHANGE;
+    event_types = CASS_EVENT_TOPOLOGY_CHANGE | CASS_EVENT_STATUS_CHANGE | CASS_EVENT_SCHEMA_CHANGE;
   } else {
     event_types = CASS_EVENT_TOPOLOGY_CHANGE | CASS_EVENT_STATUS_CHANGE;
   }
-  connector_
-      ->with_metrics(metrics_)
+  connector_->with_metrics(metrics_)
       ->with_settings(settings_.connection_settings)
       ->with_event_types(event_types)
       ->connect(loop);
@@ -165,14 +161,9 @@ void ControlConnector::on_success() {
   }
 
   // Transfer ownership of the connection to the control connection.
-  control_connection_.reset(
-        new ControlConnection(connection_,
-                              listener_,
-                              settings_.use_schema,
-                              settings_.token_aware_routing,
-                              server_version_,
-                              dse_server_version_,
-                              listen_addresses_));
+  control_connection_.reset(new ControlConnection(connection_, listener_, settings_.use_schema,
+                                                  settings_.token_aware_routing, server_version_,
+                                                  dse_server_version_, listen_addresses_));
 
   control_connection_->set_listener(listener_);
 
@@ -222,13 +213,11 @@ void ControlConnector::query_hosts() {
   // a valid server version because this version determines which follow up
   // schema metadata queries are executed.
   ChainedRequestCallback::Ptr callback(
-        new HostsConnectorRequestCallback(
-          "local", SELECT_LOCAL, this));
+      new HostsConnectorRequestCallback("local", SELECT_LOCAL, this));
   callback = callback->chain("peers", SELECT_PEERS);
 
   if (connection_->write_and_flush(callback) < 0) {
-    on_error(CONTROL_CONNECTION_ERROR_HOSTS,
-             "Unable able to write hosts query to connection");
+    on_error(CONTROL_CONNECTION_ERROR_HOSTS, "Unable able to write hosts query to connection");
   }
 }
 
@@ -252,10 +241,8 @@ void ControlConnector::handle_query_hosts(HostsConnectorRequestCallback* callbac
     while (rows.next()) {
       Address address;
       const Row* row = rows.row();
-      if (!determine_address_for_peer_host(connection_->address(),
-                                           row->get_by_name("peer"),
-                                           row->get_by_name("rpc_address"),
-                                           &address)) {
+      if (!determine_address_for_peer_host(connection_->address(), row->get_by_name("peer"),
+                                           row->get_by_name("rpc_address"), &address)) {
         continue;
       }
 
@@ -278,48 +265,42 @@ void ControlConnector::query_schema() {
   ChainedRequestCallback::Ptr callback;
 
   if (server_version_ >= VersionNumber(3, 0, 0)) {
-    callback = ChainedRequestCallback::Ptr(new SchemaConnectorRequestCallback(
-                                             "keyspaces", SELECT_KEYSPACES_30, this));
+    callback = ChainedRequestCallback::Ptr(
+        new SchemaConnectorRequestCallback("keyspaces", SELECT_KEYSPACES_30, this));
     if (settings_.use_schema) {
-      callback = callback
-                 ->chain("tables", SELECT_TABLES_30)
-                 ->chain("views", SELECT_VIEWS_30)
-                 ->chain("columns", SELECT_COLUMNS_30)
-                 ->chain("indexes", SELECT_INDEXES_30)
-                 ->chain("user_types", SELECT_USERTYPES_30)
-                 ->chain("functions", SELECT_FUNCTIONS_30)
-                 ->chain("aggregates", SELECT_AGGREGATES_30);
+      callback = callback->chain("tables", SELECT_TABLES_30)
+                     ->chain("views", SELECT_VIEWS_30)
+                     ->chain("columns", SELECT_COLUMNS_30)
+                     ->chain("indexes", SELECT_INDEXES_30)
+                     ->chain("user_types", SELECT_USERTYPES_30)
+                     ->chain("functions", SELECT_FUNCTIONS_30)
+                     ->chain("aggregates", SELECT_AGGREGATES_30);
 
       if (server_version_ >= VersionNumber(4, 0, 0)) {
-        callback = callback
-                   ->chain("virtual_keyspaces", SELECT_VIRTUAL_KEYSPACES_40)
-                   ->chain("virtual_tables", SELECT_VIRTUAL_TABLES_40)
-                   ->chain("virtual_columns", SELECT_VIRTUAL_COLUMNS_40);
+        callback = callback->chain("virtual_keyspaces", SELECT_VIRTUAL_KEYSPACES_40)
+                       ->chain("virtual_tables", SELECT_VIRTUAL_TABLES_40)
+                       ->chain("virtual_columns", SELECT_VIRTUAL_COLUMNS_40);
       }
     }
   } else {
-    callback = ChainedRequestCallback::Ptr(new SchemaConnectorRequestCallback(
-                                             "keyspaces", SELECT_KEYSPACES_20, this));
+    callback = ChainedRequestCallback::Ptr(
+        new SchemaConnectorRequestCallback("keyspaces", SELECT_KEYSPACES_20, this));
     if (settings_.use_schema) {
-      callback = callback
-                 ->chain("tables", SELECT_COLUMN_FAMILIES_20)
-                 ->chain("columns", SELECT_COLUMNS_20);
-
+      callback =
+          callback->chain("tables", SELECT_COLUMN_FAMILIES_20)->chain("columns", SELECT_COLUMNS_20);
 
       if (server_version_ >= VersionNumber(2, 1, 0)) {
         callback = callback->chain("user_types", SELECT_USERTYPES_21);
       }
       if (server_version_ >= VersionNumber(2, 2, 0)) {
-        callback = callback
-                   ->chain("functions", SELECT_FUNCTIONS_22)
-                   ->chain("aggregates", SELECT_AGGREGATES_22);
+        callback = callback->chain("functions", SELECT_FUNCTIONS_22)
+                       ->chain("aggregates", SELECT_AGGREGATES_22);
       }
     }
   }
 
   if (connection_->write_and_flush(callback) < 0) {
-    on_error(CONTROL_CONNECTION_ERROR_SCHEMA,
-             "Unable able to write schema query to connection");
+    on_error(CONTROL_CONNECTION_ERROR_SCHEMA, "Unable able to write schema query to connection");
   }
 }
 
@@ -343,9 +324,6 @@ void ControlConnector::on_close(Connection* connection) {
   if (is_canceled()) {
     finish();
   } else {
-    on_error(CONTROL_CONNECTION_ERROR_CLOSE,
-             "Control connection closed prematurely");
+    on_error(CONTROL_CONNECTION_ERROR_CLOSE, "Control connection closed prematurely");
   }
 }
-
-} // namespace cass
diff --git a/src/control_connector.hpp b/src/control_connector.hpp
index bcee23854..c1610b842 100644
--- a/src/control_connector.hpp
+++ b/src/control_connector.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONTROL_CONNECTOR_HPP_INCLUDED__
-#define __CASS_CONTROL_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONTROL_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_CONTROL_CONNECTOR_HPP
 
 #include "callback.hpp"
 #include "control_connection.hpp"
-#include "ref_counted.hpp"
 #include "event_response.hpp"
+#include "ref_counted.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class HostsConnectorRequestCallback;
 class Metrics;
@@ -84,12 +84,13 @@ struct ControlConnectionSchema {
  * version, and registers for cluster events (topology and schema changes). It
  * also retrieves the initial host and schema metadata for the cluster.
  */
-class ControlConnector : public RefCounted<ControlConnector>
-                       , public RecordingConnectionListener {
+class ControlConnector
+    : public RefCounted<ControlConnector>
+    , public RecordingConnectionListener {
 public:
   typedef SharedRefPtr<ControlConnector> Ptr;
   typedef Vector<Ptr> Vec;
-  typedef cass::Callback<void, ControlConnector*> Callback;
+  typedef internal::Callback<void, ControlConnector*> Callback;
 
   enum ControlConnectionError {
     CONTROL_CONNECTION_OK,
@@ -108,8 +109,7 @@ class ControlConnector : public RefCounted<ControlConnector>
    * connection.
    * @param callback
    */
-  ControlConnector(const Host::Ptr& host,
-                   ProtocolVersion protocol_version,
+  ControlConnector(const Host::Ptr& host, ProtocolVersion protocol_version,
                    const Callback& callback);
 
   /**
@@ -182,27 +182,20 @@ class ControlConnector : public RefCounted<ControlConnector>
   const ControlConnectionSchema& schema() const { return schema_; }
 
 public:
-  const Address& address() const {
-    return connector_->address();
-  }
+  const Address& address() const { return connector_->address(); }
 
-  const ProtocolVersion protocol_version() const {
-    return connector_->protocol_version();
-  }
+  const ProtocolVersion protocol_version() const { return connector_->protocol_version(); }
 
   bool is_ok() const { return error_code_ == CONTROL_CONNECTION_OK; }
   bool is_canceled() const { return error_code_ == CONTROL_CONNECTION_CANCELED; }
   bool is_invalid_protocol() const {
-    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION &&
-        connector_->is_invalid_protocol();
+    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION && connector_->is_invalid_protocol();
   }
   bool is_ssl_error() const {
-    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION &&
-        connector_->is_ssl_error();
+    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION && connector_->is_ssl_error();
   }
   bool is_auth_error() const {
-    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION &&
-        connector_->is_auth_error();
+    return error_code_ == CONTROL_CONNECTION_ERROR_CONNECTION && connector_->is_auth_error();
   }
 
   ControlConnectionError error_code() const { return error_code_; }
@@ -262,6 +255,6 @@ class ControlConnector : public RefCounted<ControlConnector>
   ControlConnectionSettings settings_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/copy_on_write_ptr.hpp b/src/copy_on_write_ptr.hpp
index 0b33d6512..fb92d8d95 100644
--- a/src/copy_on_write_ptr.hpp
+++ b/src/copy_on_write_ptr.hpp
@@ -16,24 +16,24 @@
 
 #include "ref_counted.hpp"
 
-#ifndef __CASS_COPY_ON_WRITE_PTR_HPP_INCLUDED__
-#define __CASS_COPY_ON_WRITE_PTR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_COPY_ON_WRITE_PTR_HPP
+#define DATASTAX_INTERNAL_COPY_ON_WRITE_PTR_HPP
 
 #include <stdio.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 template <class T>
 class CopyOnWritePtr {
 public:
   CopyOnWritePtr(T* t)
-    : ptr_(new Referenced(t)) {}
+      : ptr_(new Referenced(t)) {}
 
   CopyOnWritePtr(const SharedRefPtr<T>& shared)
-    : ptr_(shared) {}
+      : ptr_(shared) {}
 
   CopyOnWritePtr(const CopyOnWritePtr<T>& cow)
-    : ptr_(cow.ptr_) {}
+      : ptr_(cow.ptr_) {}
 
   CopyOnWritePtr<T>& operator=(const SharedRefPtr<T>& rhs) {
     ptr_ = rhs;
@@ -45,22 +45,16 @@ class CopyOnWritePtr {
     return *this;
   }
 
-  operator bool() const {
-    return ptr_->ref != NULL;
-  }
+  operator bool() const { return ptr_->ref != NULL; }
 
-  const T& operator*() const {
-    return *(ptr_->ref);
-  }
+  const T& operator*() const { return *(ptr_->ref); }
 
   T& operator*() {
     detach();
     return *(ptr_->ref);
   }
 
-  const T* operator->() const {
-    return ptr_->ref;
-  }
+  const T* operator->() const { return ptr_->ref; }
 
   T* operator->() {
     detach();
@@ -79,11 +73,9 @@ class CopyOnWritePtr {
   class Referenced : public RefCounted<Referenced> {
   public:
     Referenced(T* ref)
-      : ref(ref) {}
+        : ref(ref) {}
 
-    ~Referenced() {
-      delete ref;
-    }
+    ~Referenced() { delete ref; }
 
     T* ref;
   };
@@ -91,6 +83,6 @@ class CopyOnWritePtr {
   SharedRefPtr<Referenced> ptr_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/data_type.cpp b/src/data_type.cpp
index bd318ba2f..67fb5e496 100644
--- a/src/data_type.cpp
+++ b/src/data_type.cpp
@@ -20,31 +20,34 @@
 #include "external.hpp"
 #include "tuple.hpp"
 #include "types.hpp"
-#include "utils.hpp"
 #include "user_type_value.hpp"
+#include "utils.hpp"
 
 #include <string.h>
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassDataType* cass_data_type_new(CassValueType type) {
-  cass::DataType* data_type = NULL;
+  DataType* data_type = NULL;
   switch (type) {
     case CASS_VALUE_TYPE_LIST:
     case CASS_VALUE_TYPE_SET:
     case CASS_VALUE_TYPE_TUPLE:
     case CASS_VALUE_TYPE_MAP:
-      data_type = new cass::CollectionType(type, false);
+      data_type = new CollectionType(type, false);
       data_type->inc_ref();
       break;
 
     case CASS_VALUE_TYPE_UDT:
-      data_type = new cass::UserType(false);
+      data_type = new UserType(false);
       data_type->inc_ref();
       break;
 
     case CASS_VALUE_TYPE_CUSTOM:
-      data_type = new cass::CustomType();
+      data_type = new CustomType();
       data_type->inc_ref();
       break;
 
@@ -54,7 +57,7 @@ CassDataType* cass_data_type_new(CassValueType type) {
 
     default:
       if (type < CASS_VALUE_TYPE_LAST_ENTRY) {
-        data_type = new cass::DataType(type);
+        data_type = new DataType(type);
         data_type->inc_ref();
       }
       break;
@@ -63,36 +66,32 @@ CassDataType* cass_data_type_new(CassValueType type) {
 }
 
 CassDataType* cass_data_type_new_from_existing(const CassDataType* data_type) {
-  cass::DataType::Ptr copy = data_type->copy();
+  DataType::Ptr copy = data_type->copy();
   copy->inc_ref();
   return CassDataType::to(copy.get());
 }
 
 CassDataType* cass_data_type_new_tuple(size_t item_count) {
-  cass::DataType* data_type
-      = new cass::CollectionType(CASS_VALUE_TYPE_TUPLE, item_count);
+  DataType* data_type = new CollectionType(CASS_VALUE_TYPE_TUPLE, item_count);
   data_type->inc_ref();
   return CassDataType::to(data_type);
 }
 
 CassDataType* cass_data_type_new_udt(size_t field_count) {
-  cass::DataType* data_type = new cass::UserType(field_count);
+  DataType* data_type = new UserType(field_count);
   data_type->inc_ref();
   return CassDataType::to(data_type);
 }
 
-const CassDataType* cass_data_type_sub_data_type(const CassDataType* data_type,
-                                                 size_t index) {
-  const cass::DataType* sub_type = NULL;
+const CassDataType* cass_data_type_sub_data_type(const CassDataType* data_type, size_t index) {
+  const DataType* sub_type = NULL;
   if (data_type->is_collection() || data_type->is_tuple()) {
-    const cass::CompositeType* composite_type
-        = static_cast<const cass::CompositeType*>(data_type->from());
+    const CompositeType* composite_type = static_cast<const CompositeType*>(data_type->from());
     if (index < composite_type->types().size()) {
       sub_type = composite_type->types()[index].get();
     }
   } else if (data_type->is_user_type()) {
-    const cass::UserType* user_type
-        = static_cast<const cass::UserType*>(data_type->from());
+    const UserType* user_type = static_cast<const UserType*>(data_type->from());
     if (index < user_type->fields().size()) {
       sub_type = user_type->fields()[index].type.get();
     }
@@ -102,45 +101,38 @@ const CassDataType* cass_data_type_sub_data_type(const CassDataType* data_type,
 
 const CassDataType* cass_data_type_sub_data_type_by_name(const CassDataType* data_type,
                                                          const char* name) {
-  return cass_data_type_sub_data_type_by_name_n(data_type,
-                                                name, SAFE_STRLEN(name));
+  return cass_data_type_sub_data_type_by_name_n(data_type, name, SAFE_STRLEN(name));
 }
 
 const CassDataType* cass_data_type_sub_data_type_by_name_n(const CassDataType* data_type,
-                                                           const char* name,
-                                                           size_t name_length) {
+                                                           const char* name, size_t name_length) {
   if (!data_type->is_user_type()) {
     return NULL;
   }
 
-  const cass::UserType* user_type
-      = static_cast<const cass::UserType*>(data_type->from());
+  const UserType* user_type = static_cast<const UserType*>(data_type->from());
 
-  cass::IndexVec indices;
-  if (user_type->get_indices(cass::StringRef(name, name_length), &indices) == 0) {
+  IndexVec indices;
+  if (user_type->get_indices(StringRef(name, name_length), &indices) == 0) {
     return NULL;
   }
 
   return CassDataType::to(user_type->fields()[indices.front()].type.get());
 }
 
-CassValueType cass_data_type_type(const CassDataType* data_type) {
-  return data_type->value_type();
-}
+CassValueType cass_data_type_type(const CassDataType* data_type) { return data_type->value_type(); }
 
 cass_bool_t cass_data_type_is_frozen(const CassDataType* data_type) {
   return data_type->is_frozen() ? cass_true : cass_false;
 }
 
-CassError cass_data_type_type_name(const CassDataType* data_type,
-                                   const char** name,
+CassError cass_data_type_type_name(const CassDataType* data_type, const char** name,
                                    size_t* name_length) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  const cass::UserType* user_type
-      = static_cast<const cass::UserType*>(data_type->from());
+  const UserType* user_type = static_cast<const UserType*>(data_type->from());
 
   *name = user_type->type_name().data();
   *name_length = user_type->type_name().size();
@@ -148,36 +140,30 @@ CassError cass_data_type_type_name(const CassDataType* data_type,
   return CASS_OK;
 }
 
-CassError cass_data_type_set_type_name(CassDataType* data_type,
-                                       const char* type_name) {
-  return cass_data_type_set_type_name_n(data_type,
-                                        type_name, SAFE_STRLEN(type_name));
+CassError cass_data_type_set_type_name(CassDataType* data_type, const char* type_name) {
+  return cass_data_type_set_type_name_n(data_type, type_name, SAFE_STRLEN(type_name));
 }
 
-CassError cass_data_type_set_type_name_n(CassDataType* data_type,
-                                         const char* type_name,
+CassError cass_data_type_set_type_name_n(CassDataType* data_type, const char* type_name,
                                          size_t type_name_length) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  cass::UserType* user_type
-      = static_cast<cass::UserType*>(data_type->from());
+  UserType* user_type = static_cast<UserType*>(data_type->from());
 
-  user_type->set_type_name(cass::String(type_name, type_name_length));
+  user_type->set_type_name(String(type_name, type_name_length));
 
   return CASS_OK;
 }
 
-CassError cass_data_type_keyspace(const CassDataType* data_type,
-                                  const char** keyspace,
+CassError cass_data_type_keyspace(const CassDataType* data_type, const char** keyspace,
                                   size_t* keyspace_length) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  const cass::UserType* user_type
-      = static_cast<const cass::UserType*>(data_type->from());
+  const UserType* user_type = static_cast<const UserType*>(data_type->from());
 
   *keyspace = user_type->keyspace().data();
   *keyspace_length = user_type->keyspace().size();
@@ -185,36 +171,30 @@ CassError cass_data_type_keyspace(const CassDataType* data_type,
   return CASS_OK;
 }
 
-CassError cass_data_type_set_keyspace(CassDataType* data_type,
-                                      const char* keyspace) {
-  return cass_data_type_set_keyspace_n(data_type,
-                                       keyspace, SAFE_STRLEN(keyspace));
+CassError cass_data_type_set_keyspace(CassDataType* data_type, const char* keyspace) {
+  return cass_data_type_set_keyspace_n(data_type, keyspace, SAFE_STRLEN(keyspace));
 }
 
-CassError cass_data_type_set_keyspace_n(CassDataType* data_type,
-                                        const char* keyspace,
+CassError cass_data_type_set_keyspace_n(CassDataType* data_type, const char* keyspace,
                                         size_t keyspace_length) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  cass::UserType* user_type
-      = static_cast<cass::UserType*>(data_type->from());
+  UserType* user_type = static_cast<UserType*>(data_type->from());
 
-  user_type->set_keyspace(cass::String(keyspace, keyspace_length));
+  user_type->set_keyspace(String(keyspace, keyspace_length));
 
   return CASS_OK;
 }
 
-CassError cass_data_type_class_name(const CassDataType* data_type,
-                                    const char** class_name,
+CassError cass_data_type_class_name(const CassDataType* data_type, const char** class_name,
                                     size_t* class_name_length) {
   if (!data_type->is_custom()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  const cass::CustomType* custom_type
-      = static_cast<const cass::CustomType*>(data_type->from());
+  const CustomType* custom_type = static_cast<const CustomType*>(data_type->from());
 
   *class_name = custom_type->class_name().data();
   *class_name_length = custom_type->class_name().size();
@@ -222,23 +202,19 @@ CassError cass_data_type_class_name(const CassDataType* data_type,
   return CASS_OK;
 }
 
-CassError cass_data_type_set_class_name(CassDataType* data_type,
-                                        const char* class_name) {
-  return cass_data_type_set_class_name_n(data_type,
-                                         class_name, SAFE_STRLEN(class_name));
+CassError cass_data_type_set_class_name(CassDataType* data_type, const char* class_name) {
+  return cass_data_type_set_class_name_n(data_type, class_name, SAFE_STRLEN(class_name));
 }
 
-CassError cass_data_type_set_class_name_n(CassDataType* data_type,
-                                          const char* class_name,
+CassError cass_data_type_set_class_name_n(CassDataType* data_type, const char* class_name,
                                           size_t class_name_length) {
   if (!data_type->is_custom()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  cass::CustomType* custom_type
-      = static_cast<cass::CustomType*>(data_type->from());
+  CustomType* custom_type = static_cast<CustomType*>(data_type->from());
 
-  custom_type->set_class_name(cass::String(class_name, class_name_length));
+  custom_type->set_class_name(String(class_name, class_name_length));
 
   return CASS_OK;
 }
@@ -249,33 +225,28 @@ size_t cass_data_sub_type_count(const CassDataType* data_type) {
 
 size_t cass_data_type_sub_type_count(const CassDataType* data_type) {
   if (data_type->is_collection() || data_type->is_tuple()) {
-    const cass::CompositeType* composite_type
-        = static_cast<const cass::CompositeType*>(data_type->from());
+    const CompositeType* composite_type = static_cast<const CompositeType*>(data_type->from());
     return composite_type->types().size();
   } else if (data_type->is_user_type()) {
-    const cass::UserType* user_type
-        = static_cast<const cass::UserType*>(data_type->from());
+    const UserType* user_type = static_cast<const UserType*>(data_type->from());
     return user_type->fields().size();
   }
   return 0;
 }
 
-CassError cass_data_type_sub_type_name(const CassDataType* data_type,
-                                       size_t index,
-                                       const char** name,
-                                       size_t* name_length) {
+CassError cass_data_type_sub_type_name(const CassDataType* data_type, size_t index,
+                                       const char** name, size_t* name_length) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  const cass::UserType* user_type
-      = static_cast<const cass::UserType*>(data_type->from());
+  const UserType* user_type = static_cast<const UserType*>(data_type->from());
 
   if (index >= user_type->fields().size()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
 
-  cass::StringRef field_name = user_type->fields()[index].name;
+  StringRef field_name = user_type->fields()[index].name;
 
   *name = field_name.data();
   *name_length = field_name.size();
@@ -283,14 +254,12 @@ CassError cass_data_type_sub_type_name(const CassDataType* data_type,
   return CASS_OK;
 }
 
-CassError cass_data_type_add_sub_type(CassDataType* data_type,
-                                      const CassDataType* sub_data_type) {
+CassError cass_data_type_add_sub_type(CassDataType* data_type, const CassDataType* sub_data_type) {
   if (!data_type->is_collection() && !data_type->is_tuple()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  cass::CompositeType* composite_type
-      = static_cast<cass::CompositeType*>(data_type->from());
+  CompositeType* composite_type = static_cast<CompositeType*>(data_type->from());
 
   switch (composite_type->value_type()) {
     case CASS_VALUE_TYPE_LIST:
@@ -298,18 +267,18 @@ CassError cass_data_type_add_sub_type(CassDataType* data_type,
       if (composite_type->types().size() >= 1) {
         return CASS_ERROR_LIB_BAD_PARAMS;
       }
-      composite_type->types().push_back(cass::DataType::ConstPtr(sub_data_type));
+      composite_type->types().push_back(DataType::ConstPtr(sub_data_type));
       break;
 
     case CASS_VALUE_TYPE_MAP:
       if (composite_type->types().size() >= 2) {
         return CASS_ERROR_LIB_BAD_PARAMS;
       }
-      composite_type->types().push_back(cass::DataType::ConstPtr(sub_data_type));
+      composite_type->types().push_back(DataType::ConstPtr(sub_data_type));
       break;
 
     case CASS_VALUE_TYPE_TUPLE:
-      composite_type->types().push_back(cass::DataType::ConstPtr(sub_data_type));
+      composite_type->types().push_back(DataType::ConstPtr(sub_data_type));
       break;
 
     default:
@@ -320,68 +289,49 @@ CassError cass_data_type_add_sub_type(CassDataType* data_type,
   return CASS_OK;
 }
 
-CassError cass_data_type_add_sub_type_by_name(CassDataType* data_type,
-                                              const char* name,
+CassError cass_data_type_add_sub_type_by_name(CassDataType* data_type, const char* name,
                                               const CassDataType* sub_data_type) {
-  return cass_data_type_add_sub_type_by_name_n(data_type,
-                                               name, SAFE_STRLEN(name),
-                                               sub_data_type);
+  return cass_data_type_add_sub_type_by_name_n(data_type, name, SAFE_STRLEN(name), sub_data_type);
 }
 
-CassError cass_data_type_add_sub_type_by_name_n(CassDataType* data_type,
-                                                const char* name,
+CassError cass_data_type_add_sub_type_by_name_n(CassDataType* data_type, const char* name,
                                                 size_t name_length,
                                                 const CassDataType* sub_data_type) {
   if (!data_type->is_user_type()) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
 
-  cass::UserType* user_type
-      = static_cast<cass::UserType*>(data_type->from());
+  UserType* user_type = static_cast<UserType*>(data_type->from());
 
-  user_type->add_field(cass::String(name, name_length),
-                       cass::DataType::ConstPtr(sub_data_type));
+  user_type->add_field(String(name, name_length), DataType::ConstPtr(sub_data_type));
 
   return CASS_OK;
-
 }
 
-CassError cass_data_type_add_sub_value_type(CassDataType* data_type,
-                                            CassValueType sub_value_type) {
-  cass::DataType::ConstPtr sub_data_type(
-        new cass::DataType(sub_value_type));
-  return cass_data_type_add_sub_type(data_type,
-                                     CassDataType::to(sub_data_type.get()));
+CassError cass_data_type_add_sub_value_type(CassDataType* data_type, CassValueType sub_value_type) {
+  DataType::ConstPtr sub_data_type(new DataType(sub_value_type));
+  return cass_data_type_add_sub_type(data_type, CassDataType::to(sub_data_type.get()));
 }
 
-
-CassError cass_data_type_add_sub_value_type_by_name(CassDataType* data_type,
-                                                    const char* name,
+CassError cass_data_type_add_sub_value_type_by_name(CassDataType* data_type, const char* name,
                                                     CassValueType sub_value_type) {
-  cass::DataType::ConstPtr sub_data_type(
-        new cass::DataType(sub_value_type));
+  DataType::ConstPtr sub_data_type(new DataType(sub_value_type));
   return cass_data_type_add_sub_type_by_name(data_type, name,
                                              CassDataType::to(sub_data_type.get()));
 }
 
-CassError cass_data_type_add_sub_value_type_by_name_n(CassDataType* data_type,
-                                                      const char* name,
+CassError cass_data_type_add_sub_value_type_by_name_n(CassDataType* data_type, const char* name,
                                                       size_t name_length,
                                                       CassValueType sub_value_type) {
-  cass::DataType::ConstPtr sub_data_type(
-        new cass::DataType(sub_value_type));
+  DataType::ConstPtr sub_data_type(new DataType(sub_value_type));
   return cass_data_type_add_sub_type_by_name_n(data_type, name, name_length,
                                                CassDataType::to(sub_data_type.get()));
 }
 
-void cass_data_type_free(CassDataType* data_type) {
-  data_type->dec_ref();
-}
+void cass_data_type_free(CassDataType* data_type) { data_type->dec_ref(); }
 
 } // extern "C"
 
-namespace cass {
-
 const DataType::ConstPtr DataType::NIL;
 
 DataType::ConstPtr DataType::create_by_class(StringRef name) {
@@ -409,12 +359,12 @@ ValueTypes::ValueTypes() {
   value_types_by_class_.set_empty_key("");
   value_types_by_cql_.set_empty_key("");
 
-#define XX_VALUE_TYPE(name, type, cql, klass)                   \
+#define XX_VALUE_TYPE(name, type, cql, klass)                     \
   if (sizeof(klass) - 1 > 0) value_types_by_class_[klass] = name; \
   if (sizeof(cql) - 1 > 0) value_types_by_cql_[cql] = name;
 
   CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
-    #undef XX_VALUE_TYPE
+#undef XX_VALUE_TYPE
 }
 
 CassValueType ValueTypes::by_class(StringRef name) {
@@ -434,37 +384,30 @@ CassValueType ValueTypes::by_cql(StringRef name) {
 }
 
 const DataType::ConstPtr& SimpleDataTypeCache::by_value_type(uint16_t value_type) {
-  if (value_type == CASS_VALUE_TYPE_UNKNOWN ||
-      value_type == CASS_VALUE_TYPE_CUSTOM ||
-      value_type == CASS_VALUE_TYPE_LIST ||
-      value_type == CASS_VALUE_TYPE_MAP ||
-      value_type == CASS_VALUE_TYPE_SET ||
-      value_type == CASS_VALUE_TYPE_UDT ||
-      value_type == CASS_VALUE_TYPE_TUPLE ||
-      value_type >= CASS_VALUE_TYPE_LAST_ENTRY) {
+  if (value_type == CASS_VALUE_TYPE_UNKNOWN || value_type == CASS_VALUE_TYPE_CUSTOM ||
+      value_type == CASS_VALUE_TYPE_LIST || value_type == CASS_VALUE_TYPE_MAP ||
+      value_type == CASS_VALUE_TYPE_SET || value_type == CASS_VALUE_TYPE_UDT ||
+      value_type == CASS_VALUE_TYPE_TUPLE || value_type >= CASS_VALUE_TYPE_LAST_ENTRY) {
     return DataType::NIL;
   }
   DataType::ConstPtr& data_type = cache_[value_type];
   if (!data_type) {
-    data_type = DataType::ConstPtr(
-                  new DataType(static_cast<CassValueType>(value_type)));
+    data_type = DataType::ConstPtr(new DataType(static_cast<CassValueType>(value_type)));
   }
   return data_type;
 }
 
-bool cass::IsValidDataType<const Collection*>::operator()(const Collection* value,
-                                                          const DataType::ConstPtr& data_type) const {
+bool IsValidDataType<const Collection*>::operator()(const Collection* value,
+                                                    const DataType::ConstPtr& data_type) const {
   return value->data_type()->equals(data_type);
 }
 
-bool cass::IsValidDataType<const Tuple*>::operator()(const Tuple* value,
-                                                     const DataType::ConstPtr& data_type) const {
+bool IsValidDataType<const Tuple*>::operator()(const Tuple* value,
+                                               const DataType::ConstPtr& data_type) const {
   return value->data_type()->equals(data_type);
 }
 
-bool cass::IsValidDataType<const UserTypeValue*>::operator()(const UserTypeValue* value,
-                                                             const DataType::ConstPtr& data_type) const {
+bool IsValidDataType<const UserTypeValue*>::operator()(const UserTypeValue* value,
+                                                       const DataType::ConstPtr& data_type) const {
   return value->data_type()->equals(data_type);
 }
-
-} // namespace cass
diff --git a/src/data_type.hpp b/src/data_type.hpp
index 6d008068e..fe829a429 100644
--- a/src/data_type.hpp
+++ b/src/data_type.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_DATA_TYPE_HPP_INCLUDED__
-#define __CASS_DATA_TYPE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DATA_TYPE_HPP
+#define DATASTAX_INTERNAL_DATA_TYPE_HPP
 
 #include "cassandra.h"
 #include "external.hpp"
@@ -28,39 +28,33 @@
 #include "types.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Collection;
 class Tuple;
 class UserTypeValue;
 
 inline bool is_int64_type(CassValueType value_type) {
-  return value_type == CASS_VALUE_TYPE_BIGINT ||
-      value_type == CASS_VALUE_TYPE_COUNTER ||
-      value_type == CASS_VALUE_TYPE_TIMESTAMP ||
-      value_type == CASS_VALUE_TYPE_TIME;
+  return value_type == CASS_VALUE_TYPE_BIGINT || value_type == CASS_VALUE_TYPE_COUNTER ||
+         value_type == CASS_VALUE_TYPE_TIMESTAMP || value_type == CASS_VALUE_TYPE_TIME;
 }
 
 inline bool is_string_type(CassValueType value_type) {
-  return value_type == CASS_VALUE_TYPE_ASCII ||
-      value_type == CASS_VALUE_TYPE_TEXT ||
-      value_type == CASS_VALUE_TYPE_VARCHAR;
+  return value_type == CASS_VALUE_TYPE_ASCII || value_type == CASS_VALUE_TYPE_TEXT ||
+         value_type == CASS_VALUE_TYPE_VARCHAR;
 }
 
 inline bool is_bytes_type(CassValueType value_type) {
-  return value_type == CASS_VALUE_TYPE_BLOB ||
-      value_type == CASS_VALUE_TYPE_VARINT ||
-      value_type == CASS_VALUE_TYPE_CUSTOM;
+  return value_type == CASS_VALUE_TYPE_BLOB || value_type == CASS_VALUE_TYPE_VARINT ||
+         value_type == CASS_VALUE_TYPE_CUSTOM;
 }
 
 inline bool is_uuid_type(CassValueType value_type) {
-  return value_type == CASS_VALUE_TYPE_TIMEUUID ||
-      value_type == CASS_VALUE_TYPE_UUID;
+  return value_type == CASS_VALUE_TYPE_TIMEUUID || value_type == CASS_VALUE_TYPE_UUID;
 }
 
 // Only compare when both arguments are not empty
-inline bool equals_both_not_empty(const String& s1,
-                                  const String& s2) {
+inline bool equals_both_not_empty(const String& s1, const String& s2) {
   return s1.empty() || s2.empty() || s1 == s2;
 }
 
@@ -75,22 +69,20 @@ class DataType : public RefCounted<DataType> {
   static ConstPtr create_by_class(StringRef name);
   static ConstPtr create_by_cql(StringRef name);
 
-  DataType(CassValueType value_type = CASS_VALUE_TYPE_UNKNOWN,
-           bool is_frozen = false)
-    : value_type_(value_type)
-    , is_frozen_(is_frozen) { }
+  DataType(CassValueType value_type = CASS_VALUE_TYPE_UNKNOWN, bool is_frozen = false)
+      : value_type_(value_type)
+      , is_frozen_(is_frozen) {}
 
-  virtual ~DataType() { }
+  virtual ~DataType() {}
 
   CassValueType value_type() const { return value_type_; }
 
-  bool is_collection() const  {
-    return value_type_ == CASS_VALUE_TYPE_LIST ||
-        value_type_ == CASS_VALUE_TYPE_MAP ||
-        value_type_ == CASS_VALUE_TYPE_SET;
+  bool is_collection() const {
+    return value_type_ == CASS_VALUE_TYPE_LIST || value_type_ == CASS_VALUE_TYPE_MAP ||
+           value_type_ == CASS_VALUE_TYPE_SET;
   }
 
-  bool is_map() const  { return value_type_ == CASS_VALUE_TYPE_MAP; }
+  bool is_map() const { return value_type_ == CASS_VALUE_TYPE_MAP; }
   bool is_tuple() const { return value_type_ == CASS_VALUE_TYPE_TUPLE; }
   bool is_user_type() const { return value_type_ == CASS_VALUE_TYPE_UDT; }
   bool is_custom() const { return value_type_ == CASS_VALUE_TYPE_CUSTOM; }
@@ -103,22 +95,23 @@ class DataType : public RefCounted<DataType> {
       case CASS_VALUE_TYPE_TEXT:
       case CASS_VALUE_TYPE_VARCHAR:
         return data_type->value_type_ == CASS_VALUE_TYPE_TEXT ||
-            data_type->value_type_ == CASS_VALUE_TYPE_VARCHAR;
+               data_type->value_type_ == CASS_VALUE_TYPE_VARCHAR;
       default:
         return value_type_ == data_type->value_type_;
     }
   }
 
-  virtual DataType::Ptr copy() const {
-    return Ptr(new DataType(value_type_));
-  }
+  virtual DataType::Ptr copy() const { return Ptr(new DataType(value_type_)); }
 
   virtual String to_string() const {
     switch (value_type_) {
-#define XX_VALUE_TYPE(name, type, cql, klass) case name: return cql;
-  CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
+#define XX_VALUE_TYPE(name, type, cql, klass) \
+  case name:                                  \
+    return cql;
+      CASS_VALUE_TYPE_MAPPING(XX_VALUE_TYPE)
 #undef XX_VALUE_TYPE
-      default: return "";
+      default:
+        return "";
     }
   }
 
@@ -127,7 +120,7 @@ class DataType : public RefCounted<DataType> {
   bool is_frozen_;
 
 private:
- DISALLOW_COPY_AND_ASSIGN(DataType);
+  DISALLOW_COPY_AND_ASSIGN(DataType);
 };
 
 class CustomType : public DataType {
@@ -135,17 +128,15 @@ class CustomType : public DataType {
   typedef SharedRefPtr<const CustomType> ConstPtr;
 
   CustomType()
-    : DataType(CASS_VALUE_TYPE_CUSTOM) { }
+      : DataType(CASS_VALUE_TYPE_CUSTOM) {}
 
   CustomType(const String& class_name)
-    : DataType(CASS_VALUE_TYPE_CUSTOM)
-    , class_name_(class_name) { }
+      : DataType(CASS_VALUE_TYPE_CUSTOM)
+      , class_name_(class_name) {}
 
   const String& class_name() const { return class_name_; }
 
-  void set_class_name(const String& class_name) {
-    class_name_ = class_name;
-  }
+  void set_class_name(const String& class_name) { class_name_ = class_name; }
 
   virtual bool equals(const DataType::ConstPtr& data_type) const {
     assert(value_type() == CASS_VALUE_TYPE_CUSTOM);
@@ -156,13 +147,9 @@ class CustomType : public DataType {
     return equals_both_not_empty(class_name_, custom_type->class_name_);
   }
 
-  virtual DataType::Ptr copy() const {
-    return DataType::Ptr(new CustomType(class_name_));
-  }
+  virtual DataType::Ptr copy() const { return DataType::Ptr(new CustomType(class_name_)); }
 
-  virtual String to_string() const {
-    return class_name_;
-  }
+  virtual String to_string() const { return class_name_; }
 
 private:
   String class_name_;
@@ -171,11 +158,11 @@ class CustomType : public DataType {
 class CompositeType : public DataType {
 public:
   CompositeType(CassValueType type, bool is_frozen)
-   : DataType(type, is_frozen) { }
+      : DataType(type, is_frozen) {}
 
   CompositeType(CassValueType type, const DataType::Vec& types, bool is_frozen)
-    : DataType(type, is_frozen)
-    , types_(types) { }
+      : DataType(type, is_frozen)
+      , types_(types) {}
 
   DataType::Vec& types() { return types_; }
   const DataType::Vec& types() const { return types_; }
@@ -185,9 +172,7 @@ class CompositeType : public DataType {
     if (is_frozen()) str.append("frozen<");
     str.append(DataType::to_string());
     str.push_back('<');
-    for (DataType::Vec::const_iterator i = types_.begin(),
-         end = types_.end();
-         i != end; ++i) {
+    for (DataType::Vec::const_iterator i = types_.begin(), end = types_.end(); i != end; ++i) {
       if (i != types_.begin()) str.append(", ");
       str.append((*i)->to_string());
     }
@@ -208,25 +193,19 @@ class CollectionType : public CompositeType {
   typedef SharedRefPtr<const CollectionType> ConstPtr;
 
   CollectionType(CassValueType collection_type, bool is_frozen)
-    : CompositeType(collection_type, is_frozen) { }
+      : CompositeType(collection_type, is_frozen) {}
 
-  CollectionType(CassValueType collection_type,
-                 size_t types_count,
-                 bool is_frozen)
-    : CompositeType(collection_type, is_frozen) {
+  CollectionType(CassValueType collection_type, size_t types_count, bool is_frozen)
+      : CompositeType(collection_type, is_frozen) {
     types_.reserve(types_count);
   }
 
-  CollectionType(CassValueType collection_type,
-                 const DataType::Vec& types,
-                 bool is_frozen)
-    : CompositeType(collection_type, types, is_frozen) { }
+  CollectionType(CassValueType collection_type, const DataType::Vec& types, bool is_frozen)
+      : CompositeType(collection_type, types, is_frozen) {}
 
   virtual bool equals(const DataType::ConstPtr& data_type) const {
-    assert(value_type() == CASS_VALUE_TYPE_LIST ||
-           value_type() == CASS_VALUE_TYPE_SET ||
-           value_type() == CASS_VALUE_TYPE_MAP ||
-           value_type() == CASS_VALUE_TYPE_TUPLE);
+    assert(value_type() == CASS_VALUE_TYPE_LIST || value_type() == CASS_VALUE_TYPE_SET ||
+           value_type() == CASS_VALUE_TYPE_MAP || value_type() == CASS_VALUE_TYPE_TUPLE);
 
     if (value_type() != data_type->value_type()) {
       return false;
@@ -235,12 +214,12 @@ class CollectionType : public CompositeType {
     const CollectionType::ConstPtr& collection_type(data_type);
 
     // Only compare sub-types if both have sub-types
-    if(!types_.empty() && !collection_type->types_.empty()) {
+    if (!types_.empty() && !collection_type->types_.empty()) {
       if (types_.size() != collection_type->types_.size()) {
         return false;
       }
       for (size_t i = 0; i < types_.size(); ++i) {
-        if(!types_[i]->equals(collection_type->types_[i])) {
+        if (!types_[i]->equals(collection_type->types_[i])) {
           return false;
         }
       }
@@ -254,22 +233,19 @@ class CollectionType : public CompositeType {
   }
 
 public:
-  static DataType::ConstPtr list(DataType::ConstPtr element_type,
-                                 bool is_frozen) {
+  static DataType::ConstPtr list(DataType::ConstPtr element_type, bool is_frozen) {
     DataType::Vec types;
     types.push_back(element_type);
     return DataType::ConstPtr(new CollectionType(CASS_VALUE_TYPE_LIST, types, is_frozen));
   }
 
-  static DataType::ConstPtr set(DataType::ConstPtr element_type,
-                                bool is_frozen) {
+  static DataType::ConstPtr set(DataType::ConstPtr element_type, bool is_frozen) {
     DataType::Vec types;
     types.push_back(element_type);
     return DataType::ConstPtr(new CollectionType(CASS_VALUE_TYPE_SET, types, is_frozen));
   }
 
-  static DataType::ConstPtr map(DataType::ConstPtr key_type,
-                                DataType::ConstPtr value_type,
+  static DataType::ConstPtr map(DataType::ConstPtr key_type, DataType::ConstPtr value_type,
                                 bool is_frozen) {
     DataType::Vec types;
     types.push_back(key_type);
@@ -283,11 +259,10 @@ class TupleType : public CompositeType {
   typedef SharedRefPtr<const TupleType> ConstPtr;
 
   TupleType(bool is_frozen)
-    : CompositeType(CASS_VALUE_TYPE_TUPLE, is_frozen) { }
+      : CompositeType(CASS_VALUE_TYPE_TUPLE, is_frozen) {}
 
-  TupleType(const DataType::Vec& types,
-            bool is_frozen)
-    : CompositeType(CASS_VALUE_TYPE_TUPLE, types, is_frozen) { }
+  TupleType(const DataType::Vec& types, bool is_frozen)
+      : CompositeType(CASS_VALUE_TYPE_TUPLE, types, is_frozen) {}
 
   virtual bool equals(const DataType::ConstPtr& data_type) const {
     assert(value_type() == CASS_VALUE_TYPE_TUPLE);
@@ -299,12 +274,12 @@ class TupleType : public CompositeType {
     const ConstPtr& tuple_type(data_type);
 
     // Only compare sub-types if both have sub-types
-    if(!types_.empty() && !tuple_type->types_.empty()) {
+    if (!types_.empty() && !tuple_type->types_.empty()) {
       if (types_.size() != tuple_type->types_.size()) {
         return false;
       }
       for (size_t i = 0; i < types_.size(); ++i) {
-        if(!types_[i]->equals(tuple_type->types_[i])) {
+        if (!types_[i]->equals(tuple_type->types_[i])) {
           return false;
         }
       }
@@ -313,9 +288,7 @@ class TupleType : public CompositeType {
     return true;
   }
 
-  virtual DataType::Ptr copy() const {
-    return DataType::Ptr(new TupleType(types_, is_frozen()));
-  }
+  virtual DataType::Ptr copy() const { return DataType::Ptr(new TupleType(types_, is_frozen())); }
 };
 
 class UserType : public DataType {
@@ -324,13 +297,12 @@ class UserType : public DataType {
 public:
   typedef SharedRefPtr<UserType> Ptr;
   typedef SharedRefPtr<const UserType> ConstPtr;
-  typedef cass::Map<String, UserType::Ptr > Map;
+  typedef internal::Map<String, UserType::Ptr> Map;
 
   struct Field : public HashTableEntry<Field> {
-    Field(const String& field_name,
-          const DataType::ConstPtr& type)
-      : name(field_name)
-      , type(type) { }
+    Field(const String& field_name, const DataType::ConstPtr& type)
+        : name(field_name)
+        , type(type) {}
 
     String name;
     DataType::ConstPtr type;
@@ -339,39 +311,30 @@ class UserType : public DataType {
   typedef CaseInsensitiveHashTable<Field>::EntryVec FieldVec;
 
   UserType(bool is_frozen)
-    : DataType(CASS_VALUE_TYPE_UDT, is_frozen) { }
+      : DataType(CASS_VALUE_TYPE_UDT, is_frozen) {}
 
   UserType(size_t field_count, bool is_frozen)
-    : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
-    , fields_(field_count) { }
-
-  UserType(const String& keyspace,
-           const String& type_name,
-           bool is_frozen)
-    : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
-    , keyspace_(keyspace)
-    , type_name_(type_name) { }
-
-  UserType(const String& keyspace,
-           const String& type_name,
-           const FieldVec& fields,
-           bool is_frozen)
-    : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
-    , keyspace_(keyspace)
-    , type_name_(type_name)
-    , fields_(fields) { }
+      : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
+      , fields_(field_count) {}
+
+  UserType(const String& keyspace, const String& type_name, bool is_frozen)
+      : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
+      , keyspace_(keyspace)
+      , type_name_(type_name) {}
+
+  UserType(const String& keyspace, const String& type_name, const FieldVec& fields, bool is_frozen)
+      : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
+      , keyspace_(keyspace)
+      , type_name_(type_name)
+      , fields_(fields) {}
 
   const String& keyspace() const { return keyspace_; }
 
-  void set_keyspace(const String& keyspace) {
-    keyspace_ = keyspace;
-  }
+  void set_keyspace(const String& keyspace) { keyspace_ = keyspace; }
 
   const String& type_name() const { return type_name_; }
 
-  void set_type_name(const String& type_name) {
-    type_name_ = type_name;
-  }
+  void set_type_name(const String& type_name) { type_name_ = type_name; }
 
   const FieldVec& fields() const { return fields_.entries(); }
 
@@ -383,9 +346,7 @@ class UserType : public DataType {
     fields_.add(Field(name, data_type));
   }
 
-  void set_fields(const FieldVec& fields) {
-    fields_.set_entries(fields);
-  }
+  void set_fields(const FieldVec& fields) { fields_.set_entries(fields); }
 
   virtual bool equals(const DataType::ConstPtr& data_type) const {
     assert(value_type() == CASS_VALUE_TYPE_UDT);
@@ -445,8 +406,8 @@ class ValueTypes {
 private:
   typedef SmallDenseHashMap<StringRef, CassValueType,
                             CASS_VALUE_TYPE_LAST_ENTRY, // Max size
-                            StringRefIHash,
-                            StringRefIEquals> HashMap;
+                            StringRefIHash, StringRefIEquals>
+      HashMap;
 
   static HashMap value_types_by_class_;
   static HashMap value_types_by_cql_;
@@ -468,73 +429,71 @@ class SimpleDataTypeCache {
   DataType::ConstPtr cache_[CASS_VALUE_TYPE_LAST_ENTRY];
 };
 
-template<class T>
+template <class T>
 struct IsValidDataType;
 
-template<>
+template <>
 struct IsValidDataType<CassNull> {
-  bool operator()(CassNull, const DataType::ConstPtr& data_type) const {
-    return true;
-  }
+  bool operator()(CassNull, const DataType::ConstPtr& data_type) const { return true; }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_int8_t> {
   bool operator()(cass_int8_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_TINY_INT;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_int16_t> {
   bool operator()(cass_int16_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_SMALL_INT;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_int32_t> {
   bool operator()(cass_int32_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_INT;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_uint32_t> {
   bool operator()(cass_uint32_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_DATE;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_int64_t> {
   bool operator()(cass_int64_t, const DataType::ConstPtr& data_type) const {
     return is_int64_type(data_type->value_type());
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_float_t> {
   bool operator()(cass_float_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_FLOAT;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_double_t> {
   bool operator()(cass_double_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_DOUBLE;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<cass_bool_t> {
   bool operator()(cass_bool_t, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_BOOLEAN;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassString> {
   bool operator()(CassString, const DataType::ConstPtr& data_type) const {
     // Also allow "bytes" types to be bound as "string" types
@@ -542,14 +501,14 @@ struct IsValidDataType<CassString> {
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassBytes> {
   bool operator()(CassBytes, const DataType::ConstPtr& data_type) const {
     return is_bytes_type(data_type->value_type());
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassCustom> {
   bool operator()(const CassCustom& custom, const DataType::ConstPtr& data_type) const {
     if (!data_type->is_custom()) return false;
@@ -558,51 +517,51 @@ struct IsValidDataType<CassCustom> {
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassUuid> {
   bool operator()(CassUuid, const DataType::ConstPtr& data_type) const {
     return is_uuid_type(data_type->value_type());
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassInet> {
   bool operator()(CassInet, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_INET;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassDecimal> {
   bool operator()(CassDecimal, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_DECIMAL;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<CassDuration> {
   bool operator()(CassDuration, const DataType::ConstPtr& data_type) const {
     return data_type->value_type() == CASS_VALUE_TYPE_DURATION;
   }
 };
 
-template<>
+template <>
 struct IsValidDataType<const Collection*> {
   bool operator()(const Collection* value, const DataType::ConstPtr& data_type) const;
 };
 
-template<>
+template <>
 struct IsValidDataType<const Tuple*> {
   bool operator()(const Tuple* value, const DataType::ConstPtr& data_type) const;
 };
 
-template<>
+template <>
 struct IsValidDataType<const UserTypeValue*> {
   bool operator()(const UserTypeValue* value, const DataType::ConstPtr& data_type) const;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::DataType, CassDataType)
+EXTERNAL_TYPE(datastax::internal::core::DataType, CassDataType)
 
 #endif
diff --git a/src/data_type_parser.cpp b/src/data_type_parser.cpp
index dd3260f5b..fe98f9698 100644
--- a/src/data_type_parser.cpp
+++ b/src/data_type_parser.cpp
@@ -16,10 +16,10 @@
 
 #include "data_type_parser.hpp"
 
-#include "utils.hpp"
 #include "logger.hpp"
 #include "scoped_ptr.hpp"
 #include "string_ref.hpp"
+#include "utils.hpp"
 
 #define REVERSED_TYPE "org.apache.cassandra.db.marshal.ReversedType"
 #define FROZEN_TYPE "org.apache.cassandra.db.marshal.FrozenType"
@@ -32,7 +32,8 @@
 #define UDT_TYPE "org.apache.cassandra.db.marshal.UserType"
 #define TUPLE_TYPE "org.apache.cassandra.db.marshal.TupleType"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 int hex_value(int c) {
   if (c >= '0' && c <= '9') {
@@ -57,15 +58,14 @@ bool from_hex(const String& hex, String* result) {
     if (half0 < 0 || half1 < 0) {
       return false;
     }
-    (*result)[i] = static_cast<char>((static_cast<uint8_t>(half0) << 4) | static_cast<uint8_t>(half1));
+    (*result)[i] =
+        static_cast<char>((static_cast<uint8_t>(half0) << 4) | static_cast<uint8_t>(half1));
   }
   return true;
 }
 
-DataType::ConstPtr DataTypeCqlNameParser::parse(const String& type,
-                                                SimpleDataTypeCache& cache,
-                                                KeyspaceMetadata* keyspace,
-                                                bool is_frozen) {
+DataType::ConstPtr DataTypeCqlNameParser::parse(const String& type, SimpleDataTypeCache& cache,
+                                                KeyspaceMetadata* keyspace, bool is_frozen) {
   Parser parser(type, 0);
   String type_name;
   Parser::TypeParamsVec params;
@@ -115,9 +115,7 @@ DataType::ConstPtr DataTypeCqlNameParser::parse(const String& type,
       return DataType::NIL;
     }
     DataType::Vec types;
-    for (Parser::TypeParamsVec::iterator i = params.begin(),
-         end = params.end();
-         i != end;  ++i) {
+    for (Parser::TypeParamsVec::iterator i = params.begin(), end = params.end(); i != end; ++i) {
       types.push_back(parse(*i, cache, keyspace));
     }
     return DataType::ConstPtr(new TupleType(types, is_frozen));
@@ -148,10 +146,8 @@ DataType::ConstPtr DataTypeCqlNameParser::parse(const String& type,
   UserType::ConstPtr user_type(keyspace->get_or_create_user_type(type_name, is_frozen));
 
   if (user_type->is_frozen() != is_frozen) {
-    return UserType::Ptr(new UserType(user_type->keyspace(),
-                                      user_type->type_name(),
-                                      user_type->fields(),
-                                      is_frozen));
+    return UserType::Ptr(new UserType(user_type->keyspace(), user_type->type_name(),
+                                      user_type->fields(), is_frozen));
   }
 
   return user_type;
@@ -170,8 +166,8 @@ void DataTypeCqlNameParser::Parser::parse_type_parameters(TypeParamsVec* params)
   skip_blank_and_comma();
 
   if (str_[index_] != '<') {
-    LOG_ERROR("Expecting char %u of %s to be '<' but '%c' found",
-              (unsigned int)index_, str_.c_str(), str_[index_]);
+    LOG_ERROR("Expecting char %u of %s to be '<' but '%c' found", (unsigned int)index_,
+              str_.c_str(), str_[index_]);
     return;
   }
 
@@ -185,8 +181,7 @@ void DataTypeCqlNameParser::Parser::parse_type_parameters(TypeParamsVec* params)
       return;
     }
     parse_type_name(&name);
-    if (!read_raw_type_parameters(&args))
-      return;
+    if (!read_raw_type_parameters(&args)) return;
     params->push_back(name + args);
   }
 }
@@ -199,7 +194,7 @@ void DataTypeCqlNameParser::Parser::read_next_identifier(String* name) {
       bool is_quote = str_[index_] == '"';
       ++index_;
       if (is_quote) {
-        if  (!is_eos() && str_[index_] == '"') {
+        if (!is_eos() && str_[index_] == '"') {
           ++index_;
         } else {
           break;
@@ -208,7 +203,8 @@ void DataTypeCqlNameParser::Parser::read_next_identifier(String* name) {
     }
   } else if (str_[start_index] == '\'') {
     ++index_;
-    while (!is_eos() && str_[index_++] != '\'') { }
+    while (!is_eos() && str_[index_++] != '\'') {
+    }
   } else {
     while (!is_eos() && (is_identifier_char(str_[index_]) || str_[index_] == '"')) {
       ++index_;
@@ -225,8 +221,8 @@ bool DataTypeCqlNameParser::Parser::read_raw_type_parameters(String* params) {
   if (is_eos() || str_[index_] == '>' || str_[index_] == ',') return true;
 
   if (str_[index_] != '<') {
-    LOG_ERROR("Expecting char %u of %s to be '<' but '%c' found",
-              (unsigned int)index_, str_.c_str(), str_[index_]);
+    LOG_ERROR("Expecting char %u of %s to be '<' but '%c' found", (unsigned int)index_,
+              str_.c_str(), str_[index_]);
     return false;
   }
 
@@ -283,7 +279,8 @@ bool DataTypeClassNameParser::is_tuple_type(const String& type) {
   return starts_with(type, TUPLE_TYPE);
 }
 
-DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, SimpleDataTypeCache& cache) {
+DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type,
+                                                      SimpleDataTypeCache& cache) {
   bool is_frozen = DataTypeClassNameParser::is_frozen(type);
 
   String class_name;
@@ -311,7 +308,7 @@ DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, Simple
       return DataType::ConstPtr();
     }
     return CollectionType::list(element_type, is_frozen);
-  } else if(starts_with(next, SET_TYPE)) {
+  } else if (starts_with(next, SET_TYPE)) {
     TypeParamsVec params;
     if (!parser.get_type_params(&params) || params.empty()) {
       return DataType::ConstPtr();
@@ -321,7 +318,7 @@ DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, Simple
       return DataType::ConstPtr();
     }
     return CollectionType::set(element_type, is_frozen);
-  } else if(starts_with(next, MAP_TYPE)) {
+  } else if (starts_with(next, MAP_TYPE)) {
     TypeParamsVec params;
     if (!parser.get_type_params(&params) || params.size() < 2) {
       return DataType::ConstPtr();
@@ -371,8 +368,8 @@ DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, Simple
     }
 
     UserType::FieldVec fields;
-    for (NameAndTypeParamsVec::const_iterator i = raw_fields.begin(),
-         end = raw_fields.end(); i != end; ++i) {
+    for (NameAndTypeParamsVec::const_iterator i = raw_fields.begin(), end = raw_fields.end();
+         i != end; ++i) {
       DataType::ConstPtr data_type = parse_one(i->second, cache);
       if (!data_type) {
         return DataType::ConstPtr();
@@ -390,8 +387,8 @@ DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, Simple
     }
 
     DataType::Vec types;
-    for (TypeParamsVec::const_iterator i = raw_types.begin(),
-         end = raw_types.end(); i != end; ++i) {
+    for (TypeParamsVec::const_iterator i = raw_types.begin(), end = raw_types.end(); i != end;
+         ++i) {
       DataType::ConstPtr data_type = parse_one(*i, cache);
       if (!data_type) {
         return DataType::ConstPtr();
@@ -410,7 +407,8 @@ DataType::ConstPtr DataTypeClassNameParser::parse_one(const String& type, Simple
   return DataType::ConstPtr(new CustomType(next));
 }
 
-ParseResult::Ptr DataTypeClassNameParser::parse_with_composite(const String& type, SimpleDataTypeCache& cache) {
+ParseResult::Ptr DataTypeClassNameParser::parse_with_composite(const String& type,
+                                                               SimpleDataTypeCache& cache) {
   Parser parser(type, 0);
 
   String next;
@@ -448,8 +446,8 @@ ParseResult::Ptr DataTypeClassNameParser::parse_with_composite(const String& typ
       return ParseResult::Ptr();
     }
 
-    for (NameAndTypeParamsVec::const_iterator i = params.begin(),
-         end = params.end(); i != end; ++i) {
+    for (NameAndTypeParamsVec::const_iterator i = params.begin(), end = params.end(); i != end;
+         ++i) {
       DataType::ConstPtr data_type = parse_one(i->second, cache);
       if (!data_type) {
         return ParseResult::Ptr();
@@ -507,7 +505,7 @@ bool DataTypeClassNameParser::Parser::get_type_params(TypeParamsVec* params) {
   }
 
   if (str_[index_] != '(') {
-    parse_error(str_, index_,  "Expected '(' before type parameters");
+    parse_error(str_, index_, "Expected '(' before type parameters");
     return false;
   }
 
@@ -526,7 +524,7 @@ bool DataTypeClassNameParser::Parser::get_type_params(TypeParamsVec* params) {
     params->push_back(param);
   }
 
-  parse_error(str_, index_,  "Unexpected end of string");
+  parse_error(str_, index_, "Unexpected end of string");
   return false;
 }
 
@@ -549,7 +547,7 @@ bool DataTypeClassNameParser::Parser::get_name_and_type_params(NameAndTypeParams
     skip_blank();
 
     if (str_[index_] != ':') {
-      parse_error(str_, index_,  "Expected ':'");
+      parse_error(str_, index_, "Expected ':'");
       return false;
     }
 
@@ -565,7 +563,7 @@ bool DataTypeClassNameParser::Parser::get_name_and_type_params(NameAndTypeParams
     params->push_back(std::make_pair(name, type));
   }
 
-  parse_error(str_, index_,  "Unexpected end of string");
+  parse_error(str_, index_, "Unexpected end of string");
   return false;
 }
 
@@ -576,7 +574,7 @@ bool DataTypeClassNameParser::Parser::get_collection_params(NameAndTypeParamsVec
   }
 
   if (str_[index_] != '(') {
-    parse_error(str_, index_,  "Expected '(' before collection parameters");
+    parse_error(str_, index_, "Expected '(' before collection parameters");
     return false;
   }
 
@@ -627,19 +625,14 @@ void DataTypeClassNameParser::Parser::read_next_identifier(String* name) {
   if (name != NULL) {
     if (index_ > i) {
       *name = str_.substr(i, index_ - i);
-    } else{
+    } else {
       name->clear();
     }
   }
 }
 
-void DataTypeClassNameParser::Parser::parse_error(const String& str,
-                                                  size_t index,
+void DataTypeClassNameParser::Parser::parse_error(const String& str, size_t index,
                                                   const char* error) {
-  LOG_ERROR("Error parsing '%s' at %u index: %s",
-            str.c_str(),
-            static_cast<unsigned int>(index),
+  LOG_ERROR("Error parsing '%s' at %u index: %s", str.c_str(), static_cast<unsigned int>(index),
             error);
 }
-
-} // namespace cass
diff --git a/src/data_type_parser.hpp b/src/data_type_parser.hpp
index 9f71824d0..ac402c1a3 100644
--- a/src/data_type_parser.hpp
+++ b/src/data_type_parser.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TYPE_PARSER_HPP_INCLUDED__
-#define __CASS_TYPE_PARSER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TYPE_PARSER_HPP
+#define DATASTAX_INTERNAL_TYPE_PARSER_HPP
 
 #include "cassandra.h"
 #include "data_type.hpp"
@@ -28,53 +28,48 @@
 
 #define EMPTY_TYPE "org.apache.cassandra.db.marshal.EmptyType"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ParserBase {
 public:
   ParserBase(const String& str, size_t index)
-    : str_(str)
-    , index_(index) { }
+      : str_(str)
+      , index_(index) {}
 
-    void skip() { ++index_; }
+  void skip() { ++index_; }
 
-    void skip_blank() {
-      while (!is_eos() && is_blank(str_[index_])) {
-        ++index_;
-      }
+  void skip_blank() {
+    while (!is_eos() && is_blank(str_[index_])) {
+      ++index_;
     }
+  }
 
-    bool skip_blank_and_comma() {
-      bool comma_found = false;
-      while (!is_eos()) {
-        int c = str_[index_];
-        if (c == ',') {
-          if (comma_found) {
-            return true;
-          } else {
-            comma_found = true;
-          }
-        } else if (!is_blank(c)) {
+  bool skip_blank_and_comma() {
+    bool comma_found = false;
+    while (!is_eos()) {
+      int c = str_[index_];
+      if (c == ',') {
+        if (comma_found) {
           return true;
+        } else {
+          comma_found = true;
         }
-        ++index_;
+      } else if (!is_blank(c)) {
+        return true;
       }
-      return false;
+      ++index_;
     }
+    return false;
+  }
 
-    bool is_eos() const {
-      return index_ >= str_.length();
-    }
+  bool is_eos() const { return index_ >= str_.length(); }
 
-    static bool is_identifier_char(int c) {
-      return (c >= '0' && c <= '9')
-          || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-          || c == '-' || c == '+' || c == '.' || c == '_' || c == '&';
-    }
+  static bool is_identifier_char(int c) {
+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '-' ||
+           c == '+' || c == '.' || c == '_' || c == '&';
+  }
 
-    static bool is_blank(int c) {
-      return c == ' ' || c == '\t' || c == '\n';
-    }
+  static bool is_blank(int c) { return c == ' ' || c == '\t' || c == '\n'; }
 
 protected:
   const String str_;
@@ -83,10 +78,8 @@ class ParserBase {
 
 class DataTypeCqlNameParser {
 public:
-  static DataType::ConstPtr parse(const String& type,
-                                  SimpleDataTypeCache& cache,
-                                  KeyspaceMetadata* keyspace,
-                                  bool is_frozen = false);
+  static DataType::ConstPtr parse(const String& type, SimpleDataTypeCache& cache,
+                                  KeyspaceMetadata* keyspace, bool is_frozen = false);
 
 private:
   class Parser : public ParserBase {
@@ -94,7 +87,7 @@ class DataTypeCqlNameParser {
     typedef Vector<String> TypeParamsVec;
 
     Parser(const String& str, size_t index)
-      : ParserBase(str, index) { }
+        : ParserBase(str, index) {}
 
     void parse_type_name(String* name);
     void parse_type_parameters(TypeParamsVec* params);
@@ -112,24 +105,22 @@ class ParseResult : public RefCounted<ParseResult> {
   typedef Map<String, DataType::ConstPtr> CollectionMap;
 
   ParseResult(DataType::ConstPtr type, bool reversed)
-    : is_composite_(false) {
+      : is_composite_(false) {
     types_.push_back(type);
     reversed_.push_back(reversed);
   }
 
-  ParseResult(bool is_composite,
-              const DataType::Vec& types,
-              ReversedVec reversed,
+  ParseResult(bool is_composite, const DataType::Vec& types, ReversedVec reversed,
               CollectionMap collections)
-    : is_composite_(is_composite)
-    , types_(types)
-    , reversed_(reversed)
-    , collections_(collections) { }
+      : is_composite_(is_composite)
+      , types_(types)
+      , reversed_(reversed)
+      , collections_(collections) {}
 
   bool is_composite() const { return is_composite_; }
   const DataType::Vec& types() const { return types_; }
-  const ReversedVec& reversed() const  { return reversed_; }
-  const CollectionMap& collections() const  { return collections_; }
+  const ReversedVec& reversed() const { return reversed_; }
+  const CollectionMap& collections() const { return collections_; }
 
 private:
   bool is_composite_;
@@ -160,7 +151,7 @@ class DataTypeClassNameParser {
   class Parser : public ParserBase {
   public:
     Parser(const String& str, size_t index)
-      : ParserBase(str, index) { }
+        : ParserBase(str, index) {}
 
     bool read_one(String* name_and_args);
     void get_next_name(String* name = NULL);
@@ -172,14 +163,12 @@ class DataTypeClassNameParser {
     bool read_raw_arguments(String* args);
     void read_next_identifier(String* name);
 
-    static void parse_error(const String& str,
-                            size_t index,
-                            const char* error);
+    static void parse_error(const String& str, size_t index, const char* error);
   };
 
   DataTypeClassNameParser();
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/dc_aware_policy.cpp b/src/dc_aware_policy.cpp
index 3a4a26024..d5bedea56 100644
--- a/src/dc_aware_policy.cpp
+++ b/src/dc_aware_policy.cpp
@@ -22,16 +22,17 @@
 
 #include <algorithm>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-DCAwarePolicy::DCAwarePolicy(const String& local_dc,
-                             size_t used_hosts_per_remote_dc,
+DCAwarePolicy::DCAwarePolicy(const String& local_dc, size_t used_hosts_per_remote_dc,
                              bool skip_remote_dcs_for_local_cl)
-  : local_dc_(local_dc)
-  , used_hosts_per_remote_dc_(used_hosts_per_remote_dc)
-  , skip_remote_dcs_for_local_cl_(skip_remote_dcs_for_local_cl)
-  , local_dc_live_hosts_(new HostVec())
-  , index_(0) {
+    : local_dc_(local_dc)
+    , used_hosts_per_remote_dc_(used_hosts_per_remote_dc)
+    , skip_remote_dcs_for_local_cl_(skip_remote_dcs_for_local_cl)
+    , local_dc_live_hosts_(new HostVec())
+    , index_(0) {
   uv_rwlock_init(&available_rwlock_);
   if (used_hosts_per_remote_dc_ > 0 || !skip_remote_dcs_for_local_cl) {
     LOG_WARN("Remote multi-dc settings have been deprecated and will be removed"
@@ -39,13 +40,9 @@ DCAwarePolicy::DCAwarePolicy(const String& local_dc,
   }
 }
 
-DCAwarePolicy::~DCAwarePolicy() {
-  uv_rwlock_destroy(&available_rwlock_);
-}
+DCAwarePolicy::~DCAwarePolicy() { uv_rwlock_destroy(&available_rwlock_); }
 
-void DCAwarePolicy::init(const Host::Ptr& connected_host,
-                         const HostMap& hosts,
-                         Random* random) {
+void DCAwarePolicy::init(const Host::Ptr& connected_host, const HostMap& hosts, Random* random) {
   if (local_dc_.empty() && connected_host && !connected_host->dc().empty()) {
     LOG_INFO("Using '%s' for the local data center "
              "(if this is incorrect, please provide the correct data center)",
@@ -54,11 +51,10 @@ void DCAwarePolicy::init(const Host::Ptr& connected_host,
   }
 
   available_.resize(hosts.size());
-  std::transform(hosts.begin(), hosts.end(),
-                 std::inserter(available_, available_.begin()), GetAddress());
+  std::transform(hosts.begin(), hosts.end(), std::inserter(available_, available_.begin()),
+                 GetAddress());
 
-  for (HostMap::const_iterator i = hosts.begin(),
-       end = hosts.end(); i != end; ++i) {
+  for (HostMap::const_iterator i = hosts.begin(), end = hosts.end(); i != end; ++i) {
     on_host_added(i->second);
   }
   if (random != NULL) {
@@ -82,10 +78,10 @@ CassHostDistance DCAwarePolicy::distance(const Host::Ptr& host) const {
   return CASS_HOST_DISTANCE_IGNORE;
 }
 
-QueryPlan* DCAwarePolicy::new_query_plan(const String& keyspace,
-                                         RequestHandler* request_handler,
+QueryPlan* DCAwarePolicy::new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                          const TokenMap* token_map) {
-  CassConsistency cl = request_handler != NULL ? request_handler->consistency() : CASS_DEFAULT_CONSISTENCY;
+  CassConsistency cl =
+      request_handler != NULL ? request_handler->consistency() : CASS_DEFAULT_CONSISTENCY;
   return new DCAwareQueryPlan(this, cl, index_++);
 }
 
@@ -171,15 +167,14 @@ void DCAwarePolicy::PerDCHostMap::remove_host_from_dc(const String& dc, const Ho
   ScopedWriteLock wl(&rwlock_);
   Map::iterator i = map_.find(dc);
   if (i != map_.end()) {
-    cass::remove_host(i->second, host);
+    core::remove_host(i->second, host);
   }
 }
 
 bool DCAwarePolicy::PerDCHostMap::remove_host(const Address& address) {
   ScopedWriteLock wl(&rwlock_);
-  for (Map::iterator i = map_.begin(),
-       end = map_.end(); i != end; ++i) {
-    if (cass::remove_host(i->second, address)) {
+  for (Map::iterator i = map_.begin(), end = map_.end(); i != end; ++i) {
+    if (core::remove_host(i->second, address)) {
       return true;
     }
   }
@@ -196,8 +191,7 @@ const CopyOnWriteHostVec& DCAwarePolicy::PerDCHostMap::get_hosts(const String& d
 
 void DCAwarePolicy::PerDCHostMap::copy_dcs(KeySet* dcs) const {
   ScopedReadLock rl(&rwlock_);
-  for (Map::const_iterator i = map_.begin(),
-       end = map_.end(); i != end; ++i) {
+  for (Map::const_iterator i = map_.begin(), end = map_.end(); i != end; ++i) {
     dcs->insert(i->first);
   }
 }
@@ -208,24 +202,21 @@ static const Host::Ptr& get_next_host(const CopyOnWriteHostVec& hosts, size_t in
   return (*hosts)[index % hosts->size()];
 }
 
-static const Host::Ptr& get_next_host_bounded(const CopyOnWriteHostVec& hosts,
-                                              size_t index, size_t bound) {
+static const Host::Ptr& get_next_host_bounded(const CopyOnWriteHostVec& hosts, size_t index,
+                                              size_t bound) {
   return (*hosts)[index % std::min(hosts->size(), bound)];
 }
 
-static size_t get_hosts_size(const CopyOnWriteHostVec& hosts) {
-  return hosts->size();
-}
+static size_t get_hosts_size(const CopyOnWriteHostVec& hosts) { return hosts->size(); }
 
-DCAwarePolicy::DCAwareQueryPlan::DCAwareQueryPlan(const DCAwarePolicy* policy,
-                                                  CassConsistency cl,
+DCAwarePolicy::DCAwareQueryPlan::DCAwareQueryPlan(const DCAwarePolicy* policy, CassConsistency cl,
                                                   size_t start_index)
-  : policy_(policy)
-  , cl_(cl)
-  , hosts_(policy_->local_dc_live_hosts_)
-  , local_remaining_(get_hosts_size(hosts_))
-  , remote_remaining_(0)
-  , index_(start_index) { }
+    : policy_(policy)
+    , cl_(cl)
+    , hosts_(policy_->local_dc_live_hosts_)
+    , local_remaining_(get_hosts_size(hosts_))
+    , remote_remaining_(0)
+    , index_(start_index) {}
 
 Host::Ptr DCAwarePolicy::DCAwareQueryPlan::compute_next() {
   while (local_remaining_ > 0) {
@@ -248,9 +239,8 @@ Host::Ptr DCAwarePolicy::DCAwareQueryPlan::compute_next() {
   while (true) {
     while (remote_remaining_ > 0) {
       --remote_remaining_;
-      const Host::Ptr& host(get_next_host_bounded(hosts_,
-                                                  index_++,
-                                                  policy_->used_hosts_per_remote_dc_));
+      const Host::Ptr& host(
+          get_next_host_bounded(hosts_, index_++, policy_->used_hosts_per_remote_dc_));
       if (policy_->is_host_up(host->address())) {
         return host;
       }
@@ -268,5 +258,3 @@ Host::Ptr DCAwarePolicy::DCAwareQueryPlan::compute_next() {
 
   return Host::Ptr();
 }
-
-} // namespace cass
diff --git a/src/dc_aware_policy.hpp b/src/dc_aware_policy.hpp
index 4baf7a1eb..559585a54 100644
--- a/src/dc_aware_policy.hpp
+++ b/src/dc_aware_policy.hpp
@@ -14,25 +14,24 @@
   limitations under the License.
 */
 
-#ifndef __CASS_DC_AWARE_POLICY_HPP_INCLUDED__
-#define __CASS_DC_AWARE_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DC_AWARE_POLICY_HPP
+#define DATASTAX_INTERNAL_DC_AWARE_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
+#include "load_balancing.hpp"
 #include "map.hpp"
 #include "round_robin_policy.hpp"
-#include "scoped_ptr.hpp"
 #include "scoped_lock.hpp"
+#include "scoped_ptr.hpp"
 #include "set.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class DCAwarePolicy : public LoadBalancingPolicy {
 public:
-  DCAwarePolicy(const String& local_dc = "",
-                size_t used_hosts_per_remote_dc = 0,
+  DCAwarePolicy(const String& local_dc = "", size_t used_hosts_per_remote_dc = 0,
                 bool skip_remote_dcs_for_local_cl = true);
 
   ~DCAwarePolicy();
@@ -41,8 +40,7 @@ class DCAwarePolicy : public LoadBalancingPolicy {
 
   virtual CassHostDistance distance(const Host::Ptr& host) const;
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   virtual bool is_host_up(const Address& address) const;
@@ -57,18 +55,17 @@ class DCAwarePolicy : public LoadBalancingPolicy {
   virtual const String& local_dc() const;
 
   virtual LoadBalancingPolicy* new_instance() {
-    return new DCAwarePolicy(local_dc_,
-                             used_hosts_per_remote_dc_,
-                             skip_remote_dcs_for_local_cl_);
+    return new DCAwarePolicy(local_dc_, used_hosts_per_remote_dc_, skip_remote_dcs_for_local_cl_);
   }
 
 private:
   class PerDCHostMap {
   public:
-    typedef cass::Map<String, CopyOnWriteHostVec> Map;
+    typedef internal::Map<String, CopyOnWriteHostVec> Map;
     typedef Set<String> KeySet;
 
-    PerDCHostMap() : no_hosts_(new HostVec()) {
+    PerDCHostMap()
+        : no_hosts_(new HostVec()) {
       uv_rwlock_init(&rwlock_);
     }
     ~PerDCHostMap() { uv_rwlock_destroy(&rwlock_); }
@@ -94,9 +91,7 @@ class DCAwarePolicy : public LoadBalancingPolicy {
 public:
   class DCAwareQueryPlan : public QueryPlan {
   public:
-    DCAwareQueryPlan(const DCAwarePolicy* policy,
-                     CassConsistency cl,
-                     size_t start_index);
+    DCAwareQueryPlan(const DCAwarePolicy* policy, CassConsistency cl, size_t start_index);
 
     virtual Host::Ptr compute_next();
 
@@ -126,6 +121,6 @@ class DCAwarePolicy : public LoadBalancingPolicy {
   DISALLOW_COPY_AND_ASSIGN(DCAwarePolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/decoder.cpp b/src/decoder.cpp
index ba2fc0d7d..4ad7abc57 100644
--- a/src/decoder.cpp
+++ b/src/decoder.cpp
@@ -18,19 +18,19 @@
 #include "logger.hpp"
 #include "value.hpp"
 
-#define CHECK_REMAINING(SIZE, DETAIL) do { \
-  if (remaining_ <  static_cast<size_t>(SIZE)) { \
-    notify_error(DETAIL, SIZE); \
-    return false; \
-  } \
-} while (0)
+#define CHECK_REMAINING(SIZE, DETAIL)             \
+  do {                                            \
+    if (remaining_ < static_cast<size_t>(SIZE)) { \
+      notify_error(DETAIL, SIZE);                 \
+      return false;                               \
+    }                                             \
+  } while (0)
 
-namespace cass {
+using namespace datastax::internal::core;
 
 void Decoder::maybe_log_remaining() const {
   if (remaining_ > 0) {
-    LOG_TRACE("Data remaining in %s response: %u", type_,
-              static_cast<unsigned int>(remaining_));
+    LOG_TRACE("Data remaining in %s response: %u", type_, static_cast<unsigned int>(remaining_));
   }
 }
 
@@ -38,7 +38,7 @@ bool Decoder::decode_inet(Address* output) {
   CHECK_REMAINING(sizeof(uint8_t), "length of inet");
 
   uint8_t address_length = 0;
-  input_ = cass::decode_byte(input_, address_length);
+  input_ = internal::decode_byte(input_, address_length);
   remaining_ -= sizeof(uint8_t);
   if (address_length > CASS_INET_V6_LENGTH) {
     LOG_ERROR("Invalid inet address length of %d bytes", address_length);
@@ -53,7 +53,7 @@ bool Decoder::decode_inet(Address* output) {
 
   CHECK_REMAINING(sizeof(int32_t), "port");
   int32_t port = 0;
-  input_ = cass::decode_int32(input_, port);
+  input_ = internal::decode_int32(input_, port);
   remaining_ -= sizeof(int32_t);
 
   return Address::from_inet(address, address_length, port, output);
@@ -62,11 +62,10 @@ bool Decoder::decode_inet(Address* output) {
 bool Decoder::decode_inet(CassInet* output) {
   CHECK_REMAINING(sizeof(uint8_t), "length of inet");
 
-  input_ = cass::decode_byte(input_, output->address_length);
+  input_ = internal::decode_byte(input_, output->address_length);
   remaining_ -= sizeof(uint8_t);
   if (output->address_length > CASS_INET_V6_LENGTH) {
-    LOG_ERROR("Invalid inet address length of %d bytes",
-              output->address_length);
+    LOG_ERROR("Invalid inet address length of %d bytes", output->address_length);
     return false;
   }
 
@@ -80,8 +79,7 @@ bool Decoder::decode_inet(CassInet* output) {
 bool Decoder::as_inet(const int address_length, CassInet* output) const {
   output->address_length = address_length;
   if (output->address_length > CASS_INET_V6_LENGTH) {
-    LOG_ERROR("Invalid inet address length of %d bytes",
-              output->address_length);
+    LOG_ERROR("Invalid inet address length of %d bytes", output->address_length);
     return false;
   }
 
@@ -112,8 +110,7 @@ bool Decoder::decode_write_type(CassWriteType& output) {
   } else if (write_type == "CDC") {
     output = CASS_WRITE_TYPE_CDC;
   } else {
-    LOG_WARN("Invalid write type %.*s",
-             (int)write_type.size(), write_type.data());
+    LOG_WARN("Invalid write type %.*s", (int)write_type.size(), write_type.data());
     return false;
   }
 
@@ -126,7 +123,7 @@ bool Decoder::decode_warnings(WarningVec& output) {
     return false;
   }
   uint16_t count = 0;
-  input_ = cass::decode_uint16(input_, count);
+  input_ = internal::decode_uint16(input_, count);
   remaining_ -= sizeof(uint16_t);
 
   for (uint16_t i = 0; i < count; ++i) {
@@ -171,13 +168,10 @@ bool Decoder::decode_value(const DataType::ConstPtr& data_type, Value& output,
 
 void Decoder::notify_error(const char* detail, size_t bytes) const {
   if (strlen(type_) == 0) {
-    LOG_ERROR("Expected at least %u byte%s to decode %s value",
-              static_cast<unsigned int>(bytes), (bytes > 1 ? "s" : ""), detail);
+    LOG_ERROR("Expected at least %u byte%s to decode %s value", static_cast<unsigned int>(bytes),
+              (bytes > 1 ? "s" : ""), detail);
   } else {
     LOG_ERROR("Expected at least %u byte%s to decode %s %s response",
-              static_cast<unsigned int>(bytes), (bytes > 1 ? "s" : ""), detail,
-              type_);
+              static_cast<unsigned int>(bytes), (bytes > 1 ? "s" : ""), detail, type_);
   }
 }
-
-} // namespace cass
diff --git a/src/decoder.hpp b/src/decoder.hpp
index 31ee20955..3bfe2bc54 100644
--- a/src/decoder.hpp
+++ b/src/decoder.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_DECODER_HPP_INCLUDED__
-#define __CASS_DECODER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DECODER_HPP
+#define DATASTAX_INTERNAL_DECODER_HPP
 
 #include "constants.hpp"
 #include "data_type.hpp"
@@ -23,14 +23,15 @@
 #include "serialization.hpp"
 #include "small_vector.hpp"
 
-#define CHECK_REMAINING(SIZE, DETAIL) do { \
-  if (remaining_ <  static_cast<size_t>(SIZE)) { \
-    notify_error(DETAIL, SIZE); \
-    return false; \
-  } \
-} while (0)
+#define CHECK_REMAINING(SIZE, DETAIL)             \
+  do {                                            \
+    if (remaining_ < static_cast<size_t>(SIZE)) { \
+      notify_error(DETAIL, SIZE);                 \
+      return false;                               \
+    }                                             \
+  } while (0)
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 typedef Map<String, Vector<String> > StringMultimap;
 
@@ -43,7 +44,7 @@ typedef Vector<Failure> FailureVec;
 struct CustomPayloadItem {
   CustomPayloadItem(StringRef name, StringRef value)
       : name(name)
-      , value(value) { }
+      , value(value) {}
   StringRef name;
   StringRef value;
 };
@@ -57,13 +58,14 @@ class Value; // Forward declaration
  * Decoder class to validate server responses
  */
 class Decoder {
-friend class Value;
+  friend class Value;
+
 public:
   Decoder()
       : input_(NULL)
       , length_(0)
       , remaining_(0)
-      , type_("") { }
+      , type_("") {}
 
   Decoder(const char* input, size_t length,
           ProtocolVersion protocol_version = ProtocolVersion::highest_supported())
@@ -71,14 +73,12 @@ friend class Value;
       , input_(input)
       , length_(length)
       , remaining_(length)
-      , type_("") { }
+      , type_("") {}
 
   void maybe_log_remaining() const;
 
   inline String as_string() const { return String(input_, remaining_); }
-  inline StringRef as_string_ref() const {
-    return StringRef(input_, remaining_);
-  }
+  inline StringRef as_string_ref() const { return StringRef(input_, remaining_); }
 
   inline Vector<char> as_vector() const {
     Vector<char> buffer(remaining_ + 1);
@@ -89,14 +89,12 @@ friend class Value;
 
   inline ProtocolVersion protocol_version() const { return protocol_version_; }
 
-  inline void set_type(const char* type) {
-    type_ = type;
-  }
+  inline void set_type(const char* type) { type_ = type; }
 
   inline bool decode_byte(uint8_t& output) {
     CHECK_REMAINING(sizeof(uint8_t), "byte");
 
-    input_ = cass::decode_byte(input_, output);
+    input_ = internal::decode_byte(input_, output);
     remaining_ -= sizeof(uint8_t);
     return true;
   }
@@ -104,7 +102,7 @@ friend class Value;
   inline bool as_byte(uint8_t* output) const {
     CHECK_REMAINING(sizeof(uint8_t), "byte");
 
-    cass::decode_byte(input_, *output);
+    internal::decode_byte(input_, *output);
     return true;
   }
 
@@ -118,7 +116,7 @@ friend class Value;
   inline bool decode_int8(int8_t& output) {
     CHECK_REMAINING(sizeof(int8_t), "signed byte");
 
-    input_ = cass::decode_int8(input_, output);
+    input_ = internal::decode_int8(input_, output);
     remaining_ -= sizeof(int8_t);
     return true;
   }
@@ -126,14 +124,14 @@ friend class Value;
   inline bool as_int8(int8_t* output) const {
     CHECK_REMAINING(sizeof(int8_t), "signed byte");
 
-    cass::decode_int8(input_, *output);
+    internal::decode_int8(input_, *output);
     return true;
   }
 
   inline bool decode_uint16(uint16_t& output) {
     CHECK_REMAINING(sizeof(uint16_t), "unsigned short");
 
-    input_ = cass::decode_uint16(input_, output);
+    input_ = internal::decode_uint16(input_, output);
     remaining_ -= sizeof(uint16_t);
     return true;
   }
@@ -141,7 +139,7 @@ friend class Value;
   inline bool decode_int16(int16_t& output) {
     CHECK_REMAINING(sizeof(int16_t), "short");
 
-    input_ = cass::decode_int16(input_, output);
+    input_ = internal::decode_int16(input_, output);
     remaining_ -= sizeof(int16_t);
     return true;
   }
@@ -149,14 +147,14 @@ friend class Value;
   inline bool as_int16(int16_t* output) const {
     CHECK_REMAINING(sizeof(int16_t), "short");
 
-    cass::decode_int16(input_, *output);
+    internal::decode_int16(input_, *output);
     return true;
   }
 
   inline bool decode_uint32(uint32_t& output) {
     CHECK_REMAINING(sizeof(uint32_t), "unsigned int");
 
-    input_ = cass::decode_uint32(input_, output);
+    input_ = internal::decode_uint32(input_, output);
     remaining_ -= sizeof(uint32_t);
     return true;
   }
@@ -164,14 +162,14 @@ friend class Value;
   inline bool as_uint32(uint32_t* output) const {
     CHECK_REMAINING(sizeof(uint32_t), "unsigned int");
 
-    cass::decode_uint32(input_, *output);
+    internal::decode_uint32(input_, *output);
     return true;
   }
 
   inline bool decode_int32(int32_t& output) {
     CHECK_REMAINING(sizeof(int32_t), "int");
 
-    input_ = cass::decode_int32(input_, output);
+    input_ = internal::decode_int32(input_, output);
     remaining_ -= sizeof(int32_t);
     return true;
   }
@@ -179,14 +177,14 @@ friend class Value;
   inline bool as_int32(int32_t* output) const {
     CHECK_REMAINING(sizeof(int32_t), "int");
 
-    cass::decode_int32(input_, *output);
+    internal::decode_int32(input_, *output);
     return true;
   }
 
   inline bool decode_int64(int64_t& output) {
     CHECK_REMAINING(sizeof(int64_t), "long");
 
-    input_ = cass::decode_int64(input_, output);
+    input_ = internal::decode_int64(input_, output);
     remaining_ -= sizeof(int64_t);
     return true;
   }
@@ -194,14 +192,14 @@ friend class Value;
   inline bool as_int64(int64_t* output) const {
     CHECK_REMAINING(sizeof(int64_t), "long");
 
-    cass::decode_int64(input_, *output);
+    internal::decode_int64(input_, *output);
     return true;
   }
 
   inline bool decode_float(float& output) {
     CHECK_REMAINING(sizeof(int32_t), "float");
 
-    input_ = cass::decode_float(input_, output);
+    input_ = internal::decode_float(input_, output);
     remaining_ -= sizeof(int32_t);
     return true;
   }
@@ -209,14 +207,14 @@ friend class Value;
   inline bool as_float(float* output) const {
     CHECK_REMAINING(sizeof(int32_t), "float");
 
-    cass::decode_float(input_, *output);
+    internal::decode_float(input_, *output);
     return true;
   }
 
   inline bool decode_double(double& output) {
     CHECK_REMAINING(sizeof(int64_t), "double");
 
-    input_ = cass::decode_double(input_, output);
+    input_ = internal::decode_double(input_, output);
     remaining_ -= sizeof(int64_t);
     return true;
   }
@@ -224,7 +222,7 @@ friend class Value;
   inline bool as_double(double* output) const {
     CHECK_REMAINING(sizeof(int64_t), "double");
 
-    cass::decode_double(input_, *output);
+    internal::decode_double(input_, *output);
     return true;
   }
 
@@ -232,7 +230,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(uint16_t), "length of string");
 
     uint16_t string_size = 0;
-    input_ = cass::decode_uint16(input_, string_size);
+    input_ = internal::decode_uint16(input_, string_size);
     remaining_ -= sizeof(uint16_t);
 
     CHECK_REMAINING(string_size, "string");
@@ -256,7 +254,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(int32_t), "length of long string");
 
     int32_t string_size = 0;
-    input_ = cass::decode_int32(input_, string_size);
+    input_ = internal::decode_int32(input_, string_size);
     remaining_ -= sizeof(int32_t);
 
     CHECK_REMAINING(string_size, "string");
@@ -271,7 +269,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(int32_t), "length of bytes");
 
     int32_t bytes_size = 0;
-    input_ = cass::decode_int32(input_, bytes_size);
+    input_ = internal::decode_int32(input_, bytes_size);
     remaining_ -= sizeof(int32_t);
 
     if (bytes_size < 0) {
@@ -301,8 +299,7 @@ friend class Value;
   bool decode_inet(CassInet* output);
   bool as_inet(const int address_length, CassInet* output) const;
 
-  inline bool as_inet(const int address_length, const int port,
-                      Address* output) const {
+  inline bool as_inet(const int address_length, const int port, Address* output) const {
     CassInet inet;
     if (!as_inet(address_length, &inet)) return false;
     return Address::from_inet(&inet.address, inet.address_length, port, output);
@@ -312,7 +309,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(uint16_t), "size of string map");
 
     uint16_t pairs = 0;
-    input_ = cass::decode_uint16(input_, pairs);
+    input_ = internal::decode_uint16(input_, pairs);
     remaining_ -= sizeof(uint16_t);
 
     map.clear();
@@ -324,8 +321,7 @@ friend class Value;
 
       if (!decode_string(&key, key_size)) return false;
       if (!decode_string(&value, value_size)) return false;
-      map.insert(std::make_pair(String(key, key_size),
-                                String(value, value_size)));
+      map.insert(std::make_pair(String(key, key_size), String(value, value_size)));
     }
 
     return true;
@@ -335,7 +331,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(uint16_t), "count of stringlist");
 
     uint16_t count = 0;
-    input_ = cass::decode_uint16(input_, count);
+    input_ = internal::decode_uint16(input_, count);
     remaining_ -= sizeof(uint16_t);
 
     output.clear();
@@ -355,7 +351,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(uint16_t), "count of stringlist");
 
     uint16_t count = 0;
-    input_ = cass::decode_uint16(input_, count);
+    input_ = internal::decode_uint16(input_, count);
     remaining_ -= sizeof(uint16_t);
 
     output.clear();
@@ -374,7 +370,7 @@ friend class Value;
     size_t total_read = sizeof(uint16_t);
     CHECK_REMAINING(total_read, "count of stringlist");
     uint16_t count = 0;
-    const char* pos = cass::decode_uint16(input_, count);
+    const char* pos = internal::decode_uint16(input_, count);
 
     output.clear();
     output.reserve(count);
@@ -382,7 +378,7 @@ friend class Value;
       total_read += sizeof(uint16_t);
       CHECK_REMAINING(total_read, "length of string");
       uint16_t string_size = 0;
-      pos = cass::decode_uint16(pos, string_size);
+      pos = internal::decode_uint16(pos, string_size);
 
       total_read += string_size;
       CHECK_REMAINING(total_read, "string");
@@ -397,7 +393,7 @@ friend class Value;
     CHECK_REMAINING(sizeof(uint16_t), "pair(s) of string multimap");
 
     uint16_t pairs = 0;
-    input_ = cass::decode_uint16(input_, pairs);
+    input_ = internal::decode_uint16(input_, pairs);
     remaining_ -= sizeof(uint16_t);
 
     output.clear();
@@ -414,11 +410,10 @@ friend class Value;
     return true;
   }
 
-  inline bool decode_option(uint16_t& type, const char** class_name,
-                            size_t& class_name_size) {
+  inline bool decode_option(uint16_t& type, const char** class_name, size_t& class_name_size) {
     CHECK_REMAINING(sizeof(uint16_t), "option type");
 
-    input_ = cass::decode_uint16(input_, type);
+    input_ = internal::decode_uint16(input_, type);
     remaining_ -= sizeof(uint16_t);
 
     if (type == CASS_VALUE_TYPE_CUSTOM) {
@@ -432,7 +427,7 @@ friend class Value;
     size_t bytes = sizeof(uint8_t) * 16;
     CHECK_REMAINING(bytes, "UUID");
 
-    input_ = cass::decode_uuid(input_, output);
+    input_ = internal::decode_uuid(input_, output);
     remaining_ -= bytes;
     return true;
   }
@@ -440,7 +435,7 @@ friend class Value;
   inline bool as_uuid(CassUuid* output) const {
     CHECK_REMAINING(sizeof(uint8_t) * 16, "UUID");
 
-    cass::decode_uuid(input_, output);
+    internal::decode_uuid(input_, output);
     return true;
   }
 
@@ -462,9 +457,9 @@ friend class Value;
       // 3. We care about leading 0s in the byte, not int, so subtract out the
       //    appropriate number of extra bits (56 for a 64-bit int).
 
-      // We mask out high-order bits to prevent sign-extension as the value is placed in a 64-bit arg
-      // to the num_leading_zeros function.
-      int extra_bytes = cass::num_leading_zeros(~first_byte & 0xff) - 56;
+      // We mask out high-order bits to prevent sign-extension as the value is placed in a 64-bit
+      // arg to the num_leading_zeros function.
+      int extra_bytes = internal::num_leading_zeros(~first_byte & 0xff) - 56;
       CHECK_REMAINING(extra_bytes, "vint value");
 
       // Build up the vint value one byte at a time from the data bytes.
@@ -482,11 +477,10 @@ friend class Value;
     return true;
   }
 
-  inline bool as_decimal(const uint8_t** output, size_t* size,
-                         int32_t* scale) {
+  inline bool as_decimal(const uint8_t** output, size_t* size, int32_t* scale) {
     CHECK_REMAINING(sizeof(int32_t), "decimal scale");
 
-    const char* pos = cass::decode_int32(input_, *scale);
+    const char* pos = internal::decode_int32(input_, *scale);
 
     if (remaining_ - sizeof(int32_t) <= 0) {
       notify_error("decimal value", remaining_ - sizeof(int32_t));
@@ -497,19 +491,18 @@ friend class Value;
     return true;
   }
 
-  inline bool as_duration(int32_t* out_months, int32_t* out_days,
-                          int64_t* out_nanos) const {
+  inline bool as_duration(int32_t* out_months, int32_t* out_days, int64_t* out_nanos) const {
     Decoder decoder = Decoder(input_, remaining_, protocol_version_);
     uint64_t decoded = 0;
 
     if (!decoder.decode_vint(decoded)) return false;
-    *out_months = static_cast<int32_t>(cass::decode_zig_zag(decoded));
+    *out_months = static_cast<int32_t>(internal::decode_zig_zag(decoded));
 
     if (!decoder.decode_vint(decoded)) return false;
-    *out_days = static_cast<int32_t>(cass::decode_zig_zag(decoded));
+    *out_days = static_cast<int32_t>(internal::decode_zig_zag(decoded));
 
     if (!decoder.decode_vint(decoded)) return false;
-    *out_nanos = static_cast<int64_t>(cass::decode_zig_zag(decoded));
+    *out_nanos = static_cast<int64_t>(internal::decode_zig_zag(decoded));
 
     return true;
   }
@@ -520,7 +513,7 @@ friend class Value;
       return false;
     }
     uint16_t count = 0;
-    input_ = cass::decode_uint16(input_, count);
+    input_ = internal::decode_uint16(input_, count);
     remaining_ -= sizeof(uint16_t);
 
     for (uint16_t i = 0; i < count; ++i) {
@@ -540,7 +533,7 @@ friend class Value;
       notify_error("count of failures", sizeof(int32_t));
       return false;
     }
-    input_ = cass::decode_int32(input_, output_size);
+    input_ = internal::decode_int32(input_, output_size);
     remaining_ -= sizeof(int32_t);
 
     // Format: <endpoint><failurecode>
@@ -583,8 +576,8 @@ friend class Value;
   void notify_error(const char* detail, size_t bytes) const;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #undef CHECK_REMAINING
 
-#endif // __CASS_DECODER_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_DECODER_HPP
diff --git a/src/delayed_connector.cpp b/src/delayed_connector.cpp
index bb12ed675..a8110cd88 100644
--- a/src/delayed_connector.cpp
+++ b/src/delayed_connector.cpp
@@ -18,16 +18,15 @@
 
 #include "event_loop.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
-DelayedConnector::DelayedConnector(const Host::Ptr& host,
-                                   ProtocolVersion protocol_version,
+DelayedConnector::DelayedConnector(const Host::Ptr& host, ProtocolVersion protocol_version,
                                    const Callback& callback)
-  : connector_(new Connector(host,
-                             protocol_version,
-                             bind_callback(&DelayedConnector::on_connect, this)))
-  , callback_(callback)
-  , is_canceled_(false) { }
+    : connector_(
+          new Connector(host, protocol_version, bind_callback(&DelayedConnector::on_connect, this)))
+    , callback_(callback)
+    , is_canceled_(false) {}
 
 DelayedConnector* DelayedConnector::with_keyspace(const String& keyspace) {
   connector_->with_keyspace(keyspace);
@@ -72,17 +71,11 @@ void DelayedConnector::cancel() {
   }
 }
 
-Connection::Ptr DelayedConnector::release_connection() {
-  return connector_->release_connection();
-}
+Connection::Ptr DelayedConnector::release_connection() { return connector_->release_connection(); }
 
-bool DelayedConnector::is_canceled() const {
-  return is_canceled_;
-}
+bool DelayedConnector::is_canceled() const { return is_canceled_; }
 
-bool DelayedConnector::is_ok() const {
-  return !is_canceled() && connector_->is_ok();
-}
+bool DelayedConnector::is_ok() const { return !is_canceled() && connector_->is_ok(); }
 
 bool DelayedConnector::is_critical_error() const {
   return !is_canceled() && connector_->is_critical_error();
@@ -99,17 +92,11 @@ Connector::ConnectionError DelayedConnector::error_code() const {
   return connector_->error_code();
 }
 
-void DelayedConnector::internal_connect(uv_loop_t* loop) {
-  connector_->connect(loop);
-}
+void DelayedConnector::internal_connect(uv_loop_t* loop) { connector_->connect(loop); }
 
 void DelayedConnector::on_connect(Connector* connector) {
   callback_(this);
   dec_ref();
 }
 
-void DelayedConnector::on_delayed_connect(Timer* timer) {
-  internal_connect(timer->loop());
-}
-
-} // namespace cass
+void DelayedConnector::on_delayed_connect(Timer* timer) { internal_connect(timer->loop()); }
diff --git a/src/delayed_connector.hpp b/src/delayed_connector.hpp
index aa441d3fc..730aeee8f 100644
--- a/src/delayed_connector.hpp
+++ b/src/delayed_connector.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_DELAYED_CONNECTOR_HPP_INCLUDED__
-#define __CASS_DELAYED_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DELAYED_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_DELAYED_CONNECTOR_HPP
 
 #include "callback.hpp"
 #include "connector.hpp"
@@ -24,7 +24,7 @@
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ConnectionPool;
 class EventLoop;
@@ -37,7 +37,7 @@ class DelayedConnector : public RefCounted<DelayedConnector> {
   typedef SharedRefPtr<DelayedConnector> Ptr;
   typedef Vector<Ptr> Vec;
 
-  typedef cass::Callback<void, DelayedConnector*> Callback;
+  typedef internal::Callback<void, DelayedConnector*> Callback;
 
   /**
    * Constructor
@@ -47,8 +47,7 @@ class DelayedConnector : public RefCounted<DelayedConnector> {
    * @param callback A callback that is called when the connection is connected or
    * if an error occurred.
    */
-  DelayedConnector(const Host::Ptr& host,
-                   ProtocolVersion protocol_version,
+  DelayedConnector(const Host::Ptr& host, ProtocolVersion protocol_version,
                    const Callback& callback);
 
   /**
@@ -78,8 +77,8 @@ class DelayedConnector : public RefCounted<DelayedConnector> {
   /**
    * Connect to a host after a delay.
    *
+   * @param loop The event loop to run the timer and connection process.
    * @param wait_time_ms The amount of time to delay.
-   * @param A key to restrict access to the method.
    */
   void delayed_connect(uv_loop_t* loop, uint64_t wait_time_ms);
 
@@ -128,6 +127,6 @@ class DelayedConnector : public RefCounted<DelayedConnector> {
   bool is_canceled_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/dense_hash_map.hpp b/src/dense_hash_map.hpp
index be28641ae..a27769f50 100644
--- a/src/dense_hash_map.hpp
+++ b/src/dense_hash_map.hpp
@@ -5,45 +5,35 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_DENSE_HASH_MAP_HPP_INCLUDED__
-#define __DSE_DENSE_HASH_MAP_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DENSE_HASH_MAP_HPP
+#define DATASTAX_INTERNAL_DENSE_HASH_MAP_HPP
 
 #include "allocator.hpp"
 
 #include <sparsehash/dense_hash_map>
 
-namespace cass {
+namespace datastax { namespace internal {
 
-template <class K, class V,
-          class HashFcn = SPARSEHASH_HASH<K>,
-          class EqualKey = std::equal_to<K> >
+template <class K, class V, class HashFcn = SPARSEHASH_HASH<K>, class EqualKey = std::equal_to<K> >
 class DenseHashMap
-    : public sparsehash::dense_hash_map<
-      K, V,  HashFcn, EqualKey,
-      cass::Allocator<std::pair<const K, V> > > {
+    : public sparsehash::dense_hash_map<K, V, HashFcn, EqualKey,
+                                        internal::Allocator<std::pair<const K, V> > > {
 public:
-  typedef cass::Allocator<std::pair<const K, V> > Allocator;
+  typedef internal::Allocator<std::pair<const K, V> > Allocator;
 
-  explicit DenseHashMap(size_t expected_max_items_in_table = 0,
-                        const HashFcn& hf = HashFcn(),
-                        const EqualKey& eql = EqualKey(),
-                        const Allocator& alloc = Allocator())
-    : sparsehash::dense_hash_map<K, V, HashFcn, EqualKey, Allocator>(expected_max_items_in_table,
-                                                                     hf, eql, alloc) { }
+  explicit DenseHashMap(size_t expected_max_items_in_table = 0, const HashFcn& hf = HashFcn(),
+                        const EqualKey& eql = EqualKey(), const Allocator& alloc = Allocator())
+      : sparsehash::dense_hash_map<K, V, HashFcn, EqualKey, Allocator>(expected_max_items_in_table,
+                                                                       hf, eql, alloc) {}
 
   template <class InputIterator>
-  DenseHashMap(InputIterator first, InputIterator last,
-               const K& empty_key_val,
-               size_t expected_max_items_in_table = 0,
-               const HashFcn& hf = HashFcn(),
-               const EqualKey& eql = EqualKey(),
-               const Allocator& alloc = Allocator())
-    : sparsehash::dense_hash_map<K, V, HashFcn, EqualKey, Allocator>(first, last,
-                                                                     empty_key_val,
-                                                                     expected_max_items_in_table,
-                                                                     hf, eql, alloc) { }
+  DenseHashMap(InputIterator first, InputIterator last, const K& empty_key_val,
+               size_t expected_max_items_in_table = 0, const HashFcn& hf = HashFcn(),
+               const EqualKey& eql = EqualKey(), const Allocator& alloc = Allocator())
+      : sparsehash::dense_hash_map<K, V, HashFcn, EqualKey, Allocator>(
+            first, last, empty_key_val, expected_max_items_in_table, hf, eql, alloc) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/dense_hash_set.hpp b/src/dense_hash_set.hpp
index 1a8612ba3..c32e9aafb 100644
--- a/src/dense_hash_set.hpp
+++ b/src/dense_hash_set.hpp
@@ -5,45 +5,34 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_DENSE_HASH_SET_HPP_INCLUDED__
-#define __DSE_DENSE_HASH_SET_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DENSE_HASH_SET_HPP
+#define DATASTAX_INTERNAL_DENSE_HASH_SET_HPP
 
 #include "allocator.hpp"
 
 #include <sparsehash/dense_hash_set>
 
-namespace cass {
+namespace datastax { namespace internal {
 
-template <class T,
-          class HashFcn = SPARSEHASH_HASH<T>,
-          class EqualKey = std::equal_to<T> >
+template <class T, class HashFcn = SPARSEHASH_HASH<T>, class EqualKey = std::equal_to<T> >
 class DenseHashSet
-    : public sparsehash::dense_hash_set<
-      T,  HashFcn, EqualKey,
-      cass::Allocator<T> > {
+    : public sparsehash::dense_hash_set<T, HashFcn, EqualKey, internal::Allocator<T> > {
 public:
-  typedef cass::Allocator<T> Allocator;
+  typedef internal::Allocator<T> Allocator;
 
-  explicit DenseHashSet(size_t expected_max_items_in_table = 0,
-                        const HashFcn& hf = HashFcn(),
-                        const EqualKey& eql = EqualKey(),
-                        const Allocator& alloc = Allocator())
-    : sparsehash::dense_hash_set<T, HashFcn, EqualKey, Allocator>(expected_max_items_in_table,
-                                                                  hf, eql, alloc) { }
+  explicit DenseHashSet(size_t expected_max_items_in_table = 0, const HashFcn& hf = HashFcn(),
+                        const EqualKey& eql = EqualKey(), const Allocator& alloc = Allocator())
+      : sparsehash::dense_hash_set<T, HashFcn, EqualKey, Allocator>(expected_max_items_in_table, hf,
+                                                                    eql, alloc) {}
 
   template <class InputIterator>
-  DenseHashSet(InputIterator first, InputIterator last,
-               const T& empty_key_val,
-               size_t expected_max_items_in_table = 0,
-               const HashFcn& hf = HashFcn(),
-               const EqualKey& eql = EqualKey(),
-               const Allocator& alloc = Allocator())
-    : sparsehash::dense_hash_set<T, HashFcn, EqualKey, Allocator>(first, last,
-                                                                  empty_key_val,
-                                                                  expected_max_items_in_table,
-                                                                  hf, eql, alloc) { }
+  DenseHashSet(InputIterator first, InputIterator last, const T& empty_key_val,
+               size_t expected_max_items_in_table = 0, const HashFcn& hf = HashFcn(),
+               const EqualKey& eql = EqualKey(), const Allocator& alloc = Allocator())
+      : sparsehash::dense_hash_set<T, HashFcn, EqualKey, Allocator>(
+            first, last, empty_key_val, expected_max_items_in_table, hf, eql, alloc) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/deque.hpp b/src/deque.hpp
index a12542a9e..f4671f180 100644
--- a/src/deque.hpp
+++ b/src/deque.hpp
@@ -5,37 +5,34 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_DEQUE_HPP_INCLUDED__
-#define __DSE_DEQUE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DEQUE_HPP
+#define DATASTAX_INTERNAL_DEQUE_HPP
 
 #include "allocator.hpp"
 
 #include <deque>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
-class Deque : public std::deque<T, cass::Allocator<T> > {
+class Deque : public std::deque<T, internal::Allocator<T> > {
 public:
-  typedef cass::Allocator<T> Allocator;
+  typedef internal::Allocator<T> Allocator;
 
   explicit Deque(const Allocator& alloc = Allocator())
-    : std::deque<T, Allocator>(alloc) { }
+      : std::deque<T, Allocator>(alloc) {}
 
-  explicit Deque(size_t count,
-                 const T& value = T(),
-                 const Allocator& alloc = Allocator())
-    : std::deque<T, Allocator>(count, value, alloc) { }
+  explicit Deque(size_t count, const T& value = T(), const Allocator& alloc = Allocator())
+      : std::deque<T, Allocator>(count, value, alloc) {}
 
-  template<class InputIt>
-  Deque(InputIt first, InputIt last,
-        const Allocator& alloc = Allocator())
-    : std::deque<T, Allocator>(first, last, alloc) { }
+  template <class InputIt>
+  Deque(InputIt first, InputIt last, const Allocator& alloc = Allocator())
+      : std::deque<T, Allocator>(first, last, alloc) {}
 
   Deque(const Deque& other)
-    : std::deque<T, Allocator>(other) { }
+      : std::deque<T, Allocator>(other) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/driver_info.cpp b/src/driver_info.cpp
index 18094e81c..1dd1f0a7a 100644
--- a/src/driver_info.cpp
+++ b/src/driver_info.cpp
@@ -22,15 +22,11 @@
 #include <cstring>
 
 #define DRIVER_VERSION \
-  STRINGIFY(CASS_VERSION_MAJOR) "." \
-  STRINGIFY(CASS_VERSION_MINOR) "." \
-  STRINGIFY(CASS_VERSION_PATCH)
+  STRINGIFY(CASS_VERSION_MAJOR) "." STRINGIFY(CASS_VERSION_MINOR) "." STRINGIFY(CASS_VERSION_PATCH)
 
-namespace cass {
+namespace datastax { namespace internal {
 
-const char* driver_name() {
-  return "DataStax Apache Cassandra C/C++ Driver";
-}
+const char* driver_name() { return "DataStax Apache Cassandra C/C++ Driver"; }
 
 const char* driver_version() {
   if (strlen(CASS_VERSION_SUFFIX) == 0) {
@@ -40,4 +36,4 @@ const char* driver_version() {
   }
 }
 
-} // namespace cass
+}} // namespace datastax::internal
diff --git a/src/driver_info.hpp b/src/driver_info.hpp
index c4f365ac1..43a5c310b 100644
--- a/src/driver_info.hpp
+++ b/src/driver_info.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_DRIVER_INFO_HPP_INCLUDED__
-#define __CASS_DRIVER_INFO_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_DRIVER_INFO_HPP
+#define DATASTAX_INTERNAL_DRIVER_INFO_HPP
 
-namespace cass {
+namespace datastax { namespace internal {
 
 const char* driver_name();
 const char* driver_version();
 
-} // namespace cass
+}} // namespace datastax::internal
 
-#endif // __CASS_DRIVER_INFO_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_DRIVER_INFO_HPP
diff --git a/src/encode.cpp b/src/encode.cpp
index 586a43206..0d872a51f 100644
--- a/src/encode.cpp
+++ b/src/encode.cpp
@@ -18,7 +18,7 @@
 #include "serialization.hpp"
 #include "utils.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 static char* encode_vint(char* output, uint64_t value, size_t value_size) {
   if (value_size == 1) {
@@ -29,7 +29,7 @@ static char* encode_vint(char* output, uint64_t value, size_t value_size) {
 
   // Write the bytes of zigzag value to the output array with most significant byte
   // in first byte of buffer, and so on.
-  for (int j = value_size - 1 ; j >= 0 ; --j) {
+  for (int j = value_size - 1; j >= 0; --j) {
     *(output + j) = value & 0xff;
     value >>= 8;
   }
@@ -50,14 +50,14 @@ static Buffer encode_internal(CassDuration value, bool with_length) {
   // We need vint sizes for each attribute.
   size_t vint_sizes[3];
 
-  zigzag_values[0] = cass::encode_zig_zag(value.months);
-  zigzag_values[1] = cass::encode_zig_zag(value.days);
-  zigzag_values[2] = cass::encode_zig_zag(value.nanos);
+  zigzag_values[0] = encode_zig_zag(value.months);
+  zigzag_values[1] = encode_zig_zag(value.days);
+  zigzag_values[2] = encode_zig_zag(value.nanos);
 
   // We also need the total size of all three vint's.
   size_t data_size = 0;
   for (int i = 0; i < 3; ++i) {
-    vint_sizes[i] = cass::vint_size(zigzag_values[i]);
+    vint_sizes[i] = vint_size(zigzag_values[i]);
     data_size += vint_sizes[i];
   }
 
@@ -78,12 +78,8 @@ static Buffer encode_internal(CassDuration value, bool with_length) {
   return buf;
 }
 
-Buffer encode(CassDuration value) {
-  return encode_internal(value, false);
-}
+Buffer encode(CassDuration value) { return encode_internal(value, false); }
 
-Buffer encode_with_length(CassDuration value) {
-  return encode_internal(value, true);
-}
+Buffer encode_with_length(CassDuration value) { return encode_internal(value, true); }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
diff --git a/src/encode.hpp b/src/encode.hpp
index f01ecd8de..7e6ee8e50 100644
--- a/src/encode.hpp
+++ b/src/encode.hpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ENCODING_HPP_INCLUDED__
-#define __CASS_ENCODING_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ENCODING_HPP
+#define DATASTAX_INTERNAL_ENCODING_HPP
 
 #include "buffer.hpp"
 #include "types.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 inline Buffer encode_with_length(CassNull) {
   Buffer buf(sizeof(int32_t));
@@ -222,7 +222,6 @@ Buffer encode(CassDuration value);
 
 Buffer encode_with_length(CassDuration value);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
-
diff --git a/src/error_response.cpp b/src/error_response.cpp
index a7f3958e4..99e87a255 100644
--- a/src/error_response.cpp
+++ b/src/error_response.cpp
@@ -22,15 +22,16 @@
 
 #include <iomanip>
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-void cass_error_result_free(const CassErrorResult* error_result) {
-  error_result->dec_ref();
-}
+void cass_error_result_free(const CassErrorResult* error_result) { error_result->dec_ref(); }
 
 CassError cass_error_result_code(const CassErrorResult* error_result) {
-  return static_cast<CassError>(
-        CASS_ERROR(CASS_ERROR_SOURCE_SERVER, error_result->code()));
+  return static_cast<CassError>(CASS_ERROR(CASS_ERROR_SOURCE_SERVER, error_result->code()));
 }
 
 CassConsistency cass_error_result_consistency(const CassErrorResult* error_result) {
@@ -57,8 +58,7 @@ CassWriteType cass_error_result_write_type(const CassErrorResult* error_result)
   return error_result->write_type();
 }
 
-CassError cass_error_result_keyspace(const CassErrorResult* error_result,
-                                     const char** keyspace,
+CassError cass_error_result_keyspace(const CassErrorResult* error_result, const char** keyspace,
                                      size_t* keyspace_length) {
   if (error_result->code() != CASS_ERROR_SERVER_ALREADY_EXISTS ||
       error_result->code() != CASS_ERROR_SERVER_FUNCTION_FAILURE) {
@@ -69,8 +69,7 @@ CassError cass_error_result_keyspace(const CassErrorResult* error_result,
   return CASS_OK;
 }
 
-CassError cass_error_result_table(const CassErrorResult* error_result,
-                                  const char** table,
+CassError cass_error_result_table(const CassErrorResult* error_result, const char** table,
                                   size_t* table_length) {
   if (error_result->code() != CASS_ERROR_SERVER_ALREADY_EXISTS) {
     return CASS_ERROR_LIB_INVALID_ERROR_RESULT_TYPE;
@@ -80,8 +79,7 @@ CassError cass_error_result_table(const CassErrorResult* error_result,
   return CASS_OK;
 }
 
-CassError cass_error_result_function(const CassErrorResult* error_result,
-                                     const char** function,
+CassError cass_error_result_function(const CassErrorResult* error_result, const char** function,
                                      size_t* function_length) {
   if (error_result->code() != CASS_ERROR_SERVER_FUNCTION_FAILURE) {
     return CASS_ERROR_LIB_INVALID_ERROR_RESULT_TYPE;
@@ -95,17 +93,15 @@ size_t cass_error_num_arg_types(const CassErrorResult* error_result) {
   return error_result->arg_types().size();
 }
 
-CassError cass_error_result_arg_type(const CassErrorResult* error_result,
-                                     size_t index,
-                                     const char** arg_type,
-                                     size_t* arg_type_length) {
+CassError cass_error_result_arg_type(const CassErrorResult* error_result, size_t index,
+                                     const char** arg_type, size_t* arg_type_length) {
   if (error_result->code() != CASS_ERROR_SERVER_FUNCTION_FAILURE) {
     return CASS_ERROR_LIB_INVALID_ERROR_RESULT_TYPE;
   }
   if (index > error_result->arg_types().size()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
-  cass::StringRef arg_type_ref = error_result->arg_types()[index];
+  StringRef arg_type_ref = error_result->arg_types()[index];
   *arg_type = arg_type_ref.data();
   *arg_type_length = arg_type_ref.size();
   return CASS_OK;
@@ -113,8 +109,6 @@ CassError cass_error_result_arg_type(const CassErrorResult* error_result,
 
 } // extern "C"
 
-namespace cass {
-
 String ErrorResponse::error_message() const {
   OStringStream ss;
   ss << "'" << message().to_string() << "'"
@@ -189,13 +183,10 @@ bool check_error_or_invalid_response(const String& prefix, uint8_t expected_opco
     ss << prefix << ": Error response "
        << static_cast<const ErrorResponse*>(response)->error_message();
   } else {
-    ss << prefix << ": Unexpected opcode "
-       << opcode_to_string(response->opcode());
+    ss << prefix << ": Unexpected opcode " << opcode_to_string(response->opcode());
   }
 
   LOG_ERROR("%s", ss.str().c_str());
 
   return true;
 }
-
-} // namespace cass
diff --git a/src/error_response.hpp b/src/error_response.hpp
index 4d28a15fa..78df16a80 100644
--- a/src/error_response.hpp
+++ b/src/error_response.hpp
@@ -14,11 +14,11 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ERROR_RESPONSE_HPP_INCLUDED__
-#define __CASS_ERROR_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ERROR_RESPONSE_HPP
+#define DATASTAX_INTERNAL_ERROR_RESPONSE_HPP
 
-#include "external.hpp"
 #include "constants.hpp"
+#include "external.hpp"
 #include "response.hpp"
 #include "retry_policy.hpp"
 #include "scoped_ptr.hpp"
@@ -30,7 +30,7 @@
 
 #include <string.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ErrorResponse : public Response {
 public:
@@ -42,12 +42,12 @@ class ErrorResponse : public Response {
       , required_(-1)
       , num_failures_(-1)
       , data_present_(0)
-      , write_type_(CASS_WRITE_TYPE_UNKNOWN) { }
+      , write_type_(CASS_WRITE_TYPE_UNKNOWN) {}
 
   ErrorResponse(int32_t code, StringRef message)
-    : Response (CQL_OPCODE_ERROR)
-    , code_(code)
-    , message_(message) { }
+      : Response(CQL_OPCODE_ERROR)
+      , code_(code)
+      , message_(message) {}
 
   int32_t code() const { return code_; }
   StringRef message() const { return message_; }
@@ -87,8 +87,8 @@ class ErrorResponse : public Response {
 bool check_error_or_invalid_response(const String& prefix, uint8_t expected_opcode,
                                      const Response* response);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::ErrorResponse, CassErrorResult)
+EXTERNAL_TYPE(datastax::internal::core::ErrorResponse, CassErrorResult)
 
 #endif
diff --git a/src/event_loop.cpp b/src/event_loop.cpp
index 51ddfa4c0..8c0f1e257 100644
--- a/src/event_loop.cpp
+++ b/src/event_loop.cpp
@@ -21,7 +21,8 @@
 #include <signal.h>
 #endif
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 #if defined(HAVE_SIGTIMEDWAIT) && !defined(HAVE_NOSIGPIPE)
 static int block_sigpipe() {
@@ -44,11 +45,11 @@ static void consume_blocked_sigpipe() {
 #endif
 
 EventLoop::EventLoop()
-  : is_loop_initialized_(false)
-  , is_joinable_(false)
-  , is_closing_(false)
-  , io_time_start_(0)
-  , io_time_elapsed_(0) {
+    : is_loop_initialized_(false)
+    , is_joinable_(false)
+    , is_closing_(false)
+    , io_time_start_(0)
+    , io_time_elapsed_(0) {
   // Set user data for PooledConnection to start the I/O elapsed time.
   loop_.data = this;
 }
@@ -119,27 +120,22 @@ void EventLoop::maybe_start_io_time() {
   }
 }
 
-bool EventLoop::is_running_on() const {
-  return uv_thread_self() == thread_;
-}
+bool EventLoop::is_running_on() const { return uv_thread_self() == thread_; }
 
 void EventLoop::on_run() {
   if (name_.empty()) name_ = "Event Loop";
 #if defined(_MSC_VER)
   char temp[64];
-  sprintf(temp, "%s - %lu", name_.c_str(), static_cast<unsigned long>(GetThreadId(uv_thread_self())));
+  sprintf(temp, "%s - %lu", name_.c_str(),
+          static_cast<unsigned long>(GetThreadId(uv_thread_self())));
   name_ = temp;
 #endif
   set_thread_name(name_);
 }
 
-EventLoop::TaskQueue::TaskQueue() {
-  uv_mutex_init(&lock_);
-}
+EventLoop::TaskQueue::TaskQueue() { uv_mutex_init(&lock_); }
 
-EventLoop::TaskQueue::~TaskQueue() {
-  uv_mutex_destroy(&lock_);
-}
+EventLoop::TaskQueue::~TaskQueue() { uv_mutex_destroy(&lock_); }
 
 bool EventLoop::TaskQueue::enqueue(Task* task) {
   ScopedMutex l(&lock_);
@@ -174,7 +170,7 @@ void EventLoop::handle_run() {
   SslContextFactory::thread_cleanup();
 }
 
-void EventLoop::on_check(Check *check) {
+void EventLoop::on_check(Check* check) {
   uint64_t now = uv_hrtime();
   if (io_time_start_ > 0) {
     io_time_elapsed_ = now - io_time_start_;
@@ -205,9 +201,7 @@ void EventLoop::on_task(Async* async) {
 }
 
 #if defined(HAVE_SIGTIMEDWAIT) && !defined(HAVE_NOSIGPIPE)
-void EventLoop::on_prepare(uv_prepare_t* prepare) {
-  consume_blocked_sigpipe();
-}
+void EventLoop::on_prepare(uv_prepare_t* prepare) { consume_blocked_sigpipe(); }
 #endif
 
 int RoundRobinEventLoopGroup::init(const String& thread_name /*= ""*/) {
@@ -243,5 +237,3 @@ EventLoop* RoundRobinEventLoopGroup::add(Task* task) {
   event_loop->add(task);
   return event_loop;
 }
-
-} // namespace cass
diff --git a/src/event_loop.hpp b/src/event_loop.hpp
index 81633687c..425ca1552 100644
--- a/src/event_loop.hpp
+++ b/src/event_loop.hpp
@@ -14,17 +14,17 @@
   limitations under the License.
 */
 
-#ifndef __CASS_THREAD_HPP_INCLUDED__
-#define __CASS_THREAD_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_THREAD_HPP
+#define DATASTAX_INTERNAL_THREAD_HPP
 
 #include "allocated.hpp"
 #include "async.hpp"
 #include "atomic.hpp"
-#include "cassconfig.hpp"
 #include "deque.hpp"
+#include "driver_config.hpp"
 #include "logger.hpp"
-#include "macros.hpp"
 #include "loop_watcher.hpp"
+#include "macros.hpp"
 #include "scoped_lock.hpp"
 #include "scoped_ptr.hpp"
 #include "utils.hpp"
@@ -32,7 +32,7 @@
 #include <assert.h>
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class EventLoop;
 
@@ -41,7 +41,7 @@ class EventLoop;
  */
 class Task : public Allocated {
 public:
-  virtual ~Task() { }
+  virtual ~Task() {}
   virtual void run(EventLoop* event_loop) = 0;
 };
 
@@ -101,7 +101,6 @@ class EventLoop : public Allocated {
    */
   uint64_t io_time_elapsed() const { return io_time_elapsed_; }
 
-
   /**
    * Determines if we're running on this event loop.
    *
@@ -125,7 +124,7 @@ class EventLoop : public Allocated {
   /**
    * A callback that's run after the event loop exits.
    */
-  virtual void on_after_run() { }
+  virtual void on_after_run() {}
 
 private:
   class TaskQueue {
@@ -153,7 +152,7 @@ class EventLoop : public Allocated {
   bool is_loop_initialized_;
 
 #if defined(HAVE_SIGTIMEDWAIT) && !defined(HAVE_NOSIGPIPE)
-  static void on_prepare(uv_prepare_t *prepare);
+  static void on_prepare(uv_prepare_t* prepare);
 
   uv_prepare_t prepare_;
 #endif
@@ -177,7 +176,7 @@ class EventLoop : public Allocated {
  */
 class EventLoopGroup : public Allocated {
 public:
-  virtual ~EventLoopGroup() { }
+  virtual ~EventLoopGroup() {}
 
   /**
    * Queue a task on any available event loop thread.
@@ -210,9 +209,9 @@ class EventLoopGroup : public Allocated {
 class RoundRobinEventLoopGroup : public EventLoopGroup {
 public:
   RoundRobinEventLoopGroup(size_t num_threads)
-    : current_(0)
-    , threads_(new EventLoop[num_threads])
-    , num_threads_(num_threads) { }
+      : current_(0)
+      , threads_(new EventLoop[num_threads])
+      , num_threads_(num_threads) {}
 
   int init(const String& thread_name = "");
   int run();
@@ -229,6 +228,6 @@ class RoundRobinEventLoopGroup : public EventLoopGroup {
   size_t num_threads_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/event_response.cpp b/src/event_response.cpp
index c11d608a9..751a056ac 100644
--- a/src/event_response.cpp
+++ b/src/event_response.cpp
@@ -18,7 +18,7 @@
 
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool EventResponse::decode(Decoder& decoder) {
   decoder.set_type("event");
@@ -91,11 +91,9 @@ bool EventResponse::decode(Decoder& decoder) {
 
     CHECK_RESULT(decoder.decode_string(&keyspace_));
 
-    if (schema_change_target_ == TABLE ||
-        schema_change_target_ == TYPE) {
+    if (schema_change_target_ == TABLE || schema_change_target_ == TYPE) {
       CHECK_RESULT(decoder.decode_string(&target_));
-    } else if (schema_change_target_ == FUNCTION ||
-               schema_change_target_ == AGGREGATE) {
+    } else if (schema_change_target_ == FUNCTION || schema_change_target_ == AGGREGATE) {
       CHECK_RESULT(decoder.decode_string(&target_));
       CHECK_RESULT(decoder.decode_stringlist(arg_types_));
     }
@@ -106,5 +104,3 @@ bool EventResponse::decode(Decoder& decoder) {
   decoder.maybe_log_remaining();
   return true;
 }
-
-} // namespace cass
diff --git a/src/event_response.hpp b/src/event_response.hpp
index facc314a8..b5dde885d 100644
--- a/src/event_response.hpp
+++ b/src/event_response.hpp
@@ -14,47 +14,30 @@
   limitations under the License.
 */
 
-#ifndef __CASS_EVENT_RESPONSE_HPP_INCLUDED__
-#define __CASS_EVENT_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_EVENT_RESPONSE_HPP
+#define DATASTAX_INTERNAL_EVENT_RESPONSE_HPP
 
 #include "address.hpp"
-#include "response.hpp"
 #include "constants.hpp"
+#include "response.hpp"
 #include "scoped_ptr.hpp"
 #include "string_ref.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class EventResponse : public Response {
 public:
   typedef SharedRefPtr<EventResponse> Ptr;
   typedef Vector<Ptr> Vec;
 
-  enum TopologyChange {
-    NEW_NODE = 1,
-    REMOVED_NODE,
-    MOVED_NODE
-  };
-
-  enum StatusChange {
-    UP = 1,
-    DOWN
-  };
-
-  enum SchemaChange {
-    CREATED = 1,
-    UPDATED,
-    DROPPED
-  };
-
-  enum SchemaChangeTarget {
-    KEYSPACE = 1,
-    TABLE,
-    TYPE,
-    FUNCTION,
-    AGGREGATE
-  };
+  enum TopologyChange { NEW_NODE = 1, REMOVED_NODE, MOVED_NODE };
+
+  enum StatusChange { UP = 1, DOWN };
+
+  enum SchemaChange { CREATED = 1, UPDATED, DROPPED };
+
+  enum SchemaChangeTarget { KEYSPACE = 1, TABLE, TYPE, FUNCTION, AGGREGATE };
 
   EventResponse()
       : Response(CQL_OPCODE_EVENT)
@@ -62,7 +45,7 @@ class EventResponse : public Response {
       , topology_change_(0)
       , status_change_(0)
       , schema_change_(0)
-      , schema_change_target_(0) { }
+      , schema_change_target_(0) {}
 
   virtual bool decode(Decoder& decoder);
 
@@ -90,6 +73,6 @@ class EventResponse : public Response {
   StringRefVec arg_types_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/execute_request.cpp b/src/execute_request.cpp
index b148ed897..f9919d068 100644
--- a/src/execute_request.cpp
+++ b/src/execute_request.cpp
@@ -20,13 +20,14 @@
 #include "protocol.hpp"
 #include "request_callback.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 ExecuteRequest::ExecuteRequest(const Prepared* prepared)
-  : Statement(prepared)
-  , prepared_(prepared) { }
+    : Statement(prepared)
+    , prepared_(prepared) {}
 
-int ExecuteRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int ExecuteRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                           BufferVec* bufs) const {
   int32_t length = encode_query_or_id(bufs);
   if (version.supports_result_metadata_id()) {
     if (callback->prepared_metadata_entry()) {
@@ -46,5 +47,3 @@ int ExecuteRequest::encode(ProtocolVersion version, RequestCallback* callback, B
   length += encode_end(version, callback, bufs);
   return length;
 }
-
-} // namespace cass
diff --git a/src/execute_request.hpp b/src/execute_request.hpp
index 52fa21b5c..218e9ad48 100644
--- a/src/execute_request.hpp
+++ b/src/execute_request.hpp
@@ -14,17 +14,17 @@
   limitations under the License.
 */
 
-#ifndef __CASS_EXECUTE_REQUEST_HPP_INCLUDED__
-#define __CASS_EXECUTE_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_EXECUTE_REQUEST_HPP
+#define DATASTAX_INTERNAL_EXECUTE_REQUEST_HPP
 
-#include "statement.hpp"
 #include "constants.hpp"
 #include "prepared.hpp"
 #include "ref_counted.hpp"
+#include "statement.hpp"
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ExecuteRequest : public Statement {
 public:
@@ -34,7 +34,7 @@ class ExecuteRequest : public Statement {
 
   virtual int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
 
-  bool get_routing_key(String* routing_key)  const {
+  bool get_routing_key(String* routing_key) const {
     return calculate_routing_key(prepared_->key_indices(), routing_key);
   }
 
@@ -51,6 +51,6 @@ class ExecuteRequest : public Statement {
   Prepared::ConstPtr prepared_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/execution_profile.cpp b/src/execution_profile.cpp
index e17bdebf1..53799184e 100644
--- a/src/execution_profile.cpp
+++ b/src/execution_profile.cpp
@@ -7,17 +7,17 @@
 
 #include "execution_profile.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassExecProfile* cass_execution_profile_new() {
-  cass::ExecutionProfile* profile =
-      new cass::ExecutionProfile();
+  ExecutionProfile* profile = new ExecutionProfile();
   return CassExecProfile::to(profile);
 }
 
-void cass_execution_profile_free(CassExecProfile* profile) {
-  delete profile->from();
-}
+void cass_execution_profile_free(CassExecProfile* profile) { delete profile->from(); }
 
 CassError cass_execution_profile_set_request_timeout(CassExecProfile* profile,
                                                      cass_uint64_t timeout_ms) {
@@ -38,37 +38,30 @@ CassError cass_execution_profile_set_serial_consistency(CassExecProfile* profile
 }
 
 CassError cass_execution_profile_set_load_balance_round_robin(CassExecProfile* profile) {
-  profile->set_load_balancing_policy(
-        new cass::RoundRobinPolicy());
+  profile->set_load_balancing_policy(new RoundRobinPolicy());
   return CASS_OK;
 }
 
-CassError cass_execution_profile_set_load_balance_dc_aware(CassExecProfile* profile,
-                                                           const char* local_dc,
-                                                           unsigned used_hosts_per_remote_dc,
-                                                           cass_bool_t allow_remote_dcs_for_local_cl) {
+CassError
+cass_execution_profile_set_load_balance_dc_aware(CassExecProfile* profile, const char* local_dc,
+                                                 unsigned used_hosts_per_remote_dc,
+                                                 cass_bool_t allow_remote_dcs_for_local_cl) {
   if (local_dc == NULL) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  return cass_execution_profile_set_load_balance_dc_aware_n(profile,
-                                                            local_dc,
-                                                            SAFE_STRLEN(local_dc),
-                                                            used_hosts_per_remote_dc,
-                                                            allow_remote_dcs_for_local_cl);
-}
-
-CassError cass_execution_profile_set_load_balance_dc_aware_n(CassExecProfile* profile,
-                                                             const char* local_dc,
-                                                             size_t local_dc_length,
-                                                             unsigned used_hosts_per_remote_dc,
-                                                             cass_bool_t allow_remote_dcs_for_local_cl) {
+  return cass_execution_profile_set_load_balance_dc_aware_n(
+      profile, local_dc, SAFE_STRLEN(local_dc), used_hosts_per_remote_dc,
+      allow_remote_dcs_for_local_cl);
+}
+
+CassError cass_execution_profile_set_load_balance_dc_aware_n(
+    CassExecProfile* profile, const char* local_dc, size_t local_dc_length,
+    unsigned used_hosts_per_remote_dc, cass_bool_t allow_remote_dcs_for_local_cl) {
   if (local_dc == NULL || local_dc_length == 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  profile->set_load_balancing_policy(
-        new cass::DCAwarePolicy(cass::String(local_dc, local_dc_length),
-                                used_hosts_per_remote_dc,
-                                !allow_remote_dcs_for_local_cl));
+  profile->set_load_balancing_policy(new DCAwarePolicy(
+      String(local_dc, local_dc_length), used_hosts_per_remote_dc, !allow_remote_dcs_for_local_cl));
   return CASS_OK;
 }
 
@@ -90,13 +83,10 @@ CassError cass_execution_profile_set_latency_aware_routing(CassExecProfile* prof
   return CASS_OK;
 }
 
-CassError cass_execution_profile_set_latency_aware_routing_settings(CassExecProfile* profile,
-                                                                    cass_double_t exclusion_threshold,
-                                                                    cass_uint64_t scale_ms,
-                                                                    cass_uint64_t retry_period_ms,
-                                                                    cass_uint64_t update_rate_ms,
-                                                                    cass_uint64_t min_measured) {
-  cass::LatencyAwarePolicy::Settings settings;
+CassError cass_execution_profile_set_latency_aware_routing_settings(
+    CassExecProfile* profile, cass_double_t exclusion_threshold, cass_uint64_t scale_ms,
+    cass_uint64_t retry_period_ms, cass_uint64_t update_rate_ms, cass_uint64_t min_measured) {
+  LatencyAwarePolicy::Settings settings;
   settings.exclusion_threshold = exclusion_threshold;
   settings.scale_ns = scale_ms * 1000 * 1000;
   settings.retry_period_ns = retry_period_ms * 1000 * 1000;
@@ -108,77 +98,61 @@ CassError cass_execution_profile_set_latency_aware_routing_settings(CassExecProf
 
 CassError cass_execution_profile_set_whitelist_filtering(CassExecProfile* profile,
                                                          const char* hosts) {
-  return cass_execution_profile_set_whitelist_filtering_n(profile,
-                                                          hosts,
-                                                          SAFE_STRLEN(hosts));
+  return cass_execution_profile_set_whitelist_filtering_n(profile, hosts, SAFE_STRLEN(hosts));
   return CASS_OK;
 }
 
 CassError cass_execution_profile_set_whitelist_filtering_n(CassExecProfile* profile,
-                                                           const char* hosts,
-                                                           size_t hosts_length) {
+                                                           const char* hosts, size_t hosts_length) {
   if (hosts_length == 0) {
     profile->whitelist().clear();
   } else {
-    cass::explode(cass::String(hosts, hosts_length),
-                  profile->whitelist());
+    explode(String(hosts, hosts_length), profile->whitelist());
   }
   return CASS_OK;
 }
 
 CassError cass_execution_profile_set_blacklist_filtering(CassExecProfile* profile,
                                                          const char* hosts) {
-  return cass_execution_profile_set_blacklist_filtering_n(profile,
-                                                          hosts,
-                                                          SAFE_STRLEN(hosts));
+  return cass_execution_profile_set_blacklist_filtering_n(profile, hosts, SAFE_STRLEN(hosts));
 }
 
 CassError cass_execution_profile_set_blacklist_filtering_n(CassExecProfile* profile,
-                                                           const char* hosts,
-                                                           size_t hosts_length) {
+                                                           const char* hosts, size_t hosts_length) {
   if (hosts_length == 0) {
     profile->blacklist().clear();
   } else {
-    cass::explode(cass::String(hosts, hosts_length),
-                  profile->blacklist());
+    explode(String(hosts, hosts_length), profile->blacklist());
   }
   return CASS_OK;
 }
 
 CassError cass_execution_profile_set_whitelist_dc_filtering(CassExecProfile* profile,
                                                             const char* dcs) {
-  return cass_execution_profile_set_whitelist_dc_filtering_n(profile,
-                                                             dcs,
-                                                             SAFE_STRLEN(dcs));
+  return cass_execution_profile_set_whitelist_dc_filtering_n(profile, dcs, SAFE_STRLEN(dcs));
 }
 
 CassError cass_execution_profile_set_whitelist_dc_filtering_n(CassExecProfile* profile,
-                                                              const char* dcs,
-                                                              size_t dcs_length) {
+                                                              const char* dcs, size_t dcs_length) {
   if (dcs_length == 0) {
     profile->whitelist_dc().clear();
   } else {
-    cass::explode(cass::String(dcs, dcs_length),
-                  profile->whitelist_dc());
+    explode(String(dcs, dcs_length), profile->whitelist_dc());
   }
   return CASS_OK;
 }
 
 CassError cass_execution_profile_set_blacklist_dc_filtering(CassExecProfile* profile,
                                                             const char* dcs) {
-  return cass_execution_profile_set_blacklist_dc_filtering_n(profile,
-                                                             dcs,
-                                                             SAFE_STRLEN(dcs));
+  return cass_execution_profile_set_blacklist_dc_filtering_n(profile, dcs, SAFE_STRLEN(dcs));
 }
 
 CassError cass_execution_profile_set_blacklist_dc_filtering_n(CassExecProfile* profile,
-                                                              const char* dcs,
-                                                              size_t dcs_length) {
+                                                              const char* dcs, size_t dcs_length) {
   if (dcs_length == 0) {
     profile->blacklist_dc().clear();
   } else {
-    cass::explode(cass::String(dcs, dcs_length),
-                  profile->blacklist_dc());
+    explode(String(dcs, dcs_length), profile->blacklist_dc());
   }
   return CASS_OK;
 }
@@ -189,20 +163,18 @@ CassError cass_execution_profile_set_retry_policy(CassExecProfile* profile,
   return CASS_OK;
 }
 
-CassError cass_execution_profile_set_constant_speculative_execution_policy(CassExecProfile* profile,
-                                                                           cass_int64_t constant_delay_ms,
-                                                                           int max_speculative_executions) {
+CassError cass_execution_profile_set_constant_speculative_execution_policy(
+    CassExecProfile* profile, cass_int64_t constant_delay_ms, int max_speculative_executions) {
   if (constant_delay_ms < 0 || max_speculative_executions < 0) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
   profile->set_speculative_execution_policy(
-        new cass::ConstantSpeculativeExecutionPolicy(constant_delay_ms,
-                                                     max_speculative_executions));
+      new ConstantSpeculativeExecutionPolicy(constant_delay_ms, max_speculative_executions));
   return CASS_OK;
 }
 
 CassError cass_execution_profile_set_no_speculative_execution_policy(CassExecProfile* profile) {
-  profile->set_speculative_execution_policy(new cass::NoSpeculativeExecutionPolicy());
+  profile->set_speculative_execution_policy(new NoSpeculativeExecutionPolicy());
   return CASS_OK;
 }
 
diff --git a/src/execution_profile.hpp b/src/execution_profile.hpp
index 1382fddf5..57f3c1cb6 100644
--- a/src/execution_profile.hpp
+++ b/src/execution_profile.hpp
@@ -5,52 +5,48 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __CASS_EXECUTION_PROFILE_HPP_INCLUDED__
-#define __CASS_EXECUTION_PROFILE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_EXECUTION_PROFILE_HPP
+#define DATASTAX_INTERNAL_EXECUTION_PROFILE_HPP
 
 #include "allocated.hpp"
-#include "blacklist_policy.hpp"
 #include "blacklist_dc_policy.hpp"
+#include "blacklist_policy.hpp"
 #include "cassandra.h"
 #include "constants.hpp"
 #include "dc_aware_policy.hpp"
+#include "dense_hash_map.hpp"
 #include "host_targeting_policy.hpp"
 #include "latency_aware_policy.hpp"
-#include "dense_hash_map.hpp"
 #include "string.hpp"
 #include "token_aware_policy.hpp"
 #include "utils.hpp"
-#include "whitelist_policy.hpp"
 #include "whitelist_dc_policy.hpp"
+#include "whitelist_policy.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ExecutionProfile : public Allocated {
 public:
   typedef DenseHashMap<String, ExecutionProfile> Map;
 
   ExecutionProfile()
-    : request_timeout_ms_(CASS_UINT64_MAX)
-    , consistency_(CASS_CONSISTENCY_UNKNOWN)
-    , serial_consistency_(CASS_CONSISTENCY_UNKNOWN)
-    , host_targeting_(false)
-    , latency_aware_routing_(false)
-    , token_aware_routing_(true)
-    , token_aware_routing_shuffle_replicas_(true)
-    , load_balancing_policy_(NULL)
-    , retry_policy_(NULL) { }
-
-  uint64_t request_timeout_ms() const { return request_timeout_ms_;  }
-
-  void set_request_timeout(uint64_t timeout_ms) {
-    request_timeout_ms_ = timeout_ms;
-  }
+      : request_timeout_ms_(CASS_UINT64_MAX)
+      , consistency_(CASS_CONSISTENCY_UNKNOWN)
+      , serial_consistency_(CASS_CONSISTENCY_UNKNOWN)
+      , host_targeting_(false)
+      , latency_aware_routing_(false)
+      , token_aware_routing_(true)
+      , token_aware_routing_shuffle_replicas_(true)
+      , load_balancing_policy_(NULL)
+      , retry_policy_(NULL) {}
+
+  uint64_t request_timeout_ms() const { return request_timeout_ms_; }
+
+  void set_request_timeout(uint64_t timeout_ms) { request_timeout_ms_ = timeout_ms; }
 
   CassConsistency consistency() const { return consistency_; }
 
-  void set_consistency(CassConsistency consistency) {
-    consistency_ = consistency;
-  }
+  void set_consistency(CassConsistency consistency) { consistency_ = consistency; }
 
   CassConsistency serial_consistency() const { return serial_consistency_; }
 
@@ -58,25 +54,15 @@ class ExecutionProfile : public Allocated {
     serial_consistency_ = serial_consistency;
   }
 
-  ContactPointList& blacklist() {
-    return blacklist_;
-  }
-  const ContactPointList& blacklist() const {
-    return blacklist_;
-  }
+  ContactPointList& blacklist() { return blacklist_; }
+  const ContactPointList& blacklist() const { return blacklist_; }
 
-  DcList& blacklist_dc() {
-    return blacklist_dc_;
-  }
-  const DcList& blacklist_dc() const {
-    return blacklist_dc_;
-  }
+  DcList& blacklist_dc() { return blacklist_dc_; }
+  const DcList& blacklist_dc() const { return blacklist_dc_; }
 
   bool host_targeting() const { return host_targeting_; }
 
-  void set_host_targeting(bool is_host_targeting) {
-    host_targeting_ = is_host_targeting;
-  }
+  void set_host_targeting(bool is_host_targeting) { host_targeting_ = is_host_targeting; }
 
   bool latency_aware() const { return latency_aware_routing_; }
 
@@ -94,9 +80,7 @@ class ExecutionProfile : public Allocated {
 
   bool token_aware_routing() const { return token_aware_routing_; }
 
-  void set_token_aware_routing(bool is_token_aware) {
-    token_aware_routing_ = is_token_aware;
-  }
+  void set_token_aware_routing(bool is_token_aware) { token_aware_routing_ = is_token_aware; }
 
   void set_token_aware_routing_shuffle_replicas(bool shuffle_replicas) {
     token_aware_routing_shuffle_replicas_ = shuffle_replicas;
@@ -106,27 +90,15 @@ class ExecutionProfile : public Allocated {
     return token_aware_routing_shuffle_replicas_;
   }
 
-  ContactPointList& whitelist() {
-    return whitelist_;
-  }
-  const ContactPointList& whitelist() const {
-    return whitelist_;
-  }
+  ContactPointList& whitelist() { return whitelist_; }
+  const ContactPointList& whitelist() const { return whitelist_; }
 
-  DcList& whitelist_dc() {
-    return whitelist_dc_;
-  }
-  const DcList& whitelist_dc() const {
-    return whitelist_dc_;
-  }
+  DcList& whitelist_dc() { return whitelist_dc_; }
+  const DcList& whitelist_dc() const { return whitelist_dc_; }
 
-  const LoadBalancingPolicy::Ptr& load_balancing_policy() const {
-    return load_balancing_policy_;
-  }
+  const LoadBalancingPolicy::Ptr& load_balancing_policy() const { return load_balancing_policy_; }
 
-  void set_load_balancing_policy(LoadBalancingPolicy* lbp) {
-    load_balancing_policy_.reset(lbp);
-  }
+  void set_load_balancing_policy(LoadBalancingPolicy* lbp) { load_balancing_policy_.reset(lbp); }
 
   void build_load_balancing_policy() {
     // The base LBP can be augmented by special wrappers (whitelist,
@@ -147,12 +119,10 @@ class ExecutionProfile : public Allocated {
         chain = new WhitelistDCPolicy(chain, whitelist_dc_);
       }
       if (token_aware_routing()) {
-        chain = new TokenAwarePolicy(chain,
-                                     token_aware_routing_shuffle_replicas_);
+        chain = new TokenAwarePolicy(chain, token_aware_routing_shuffle_replicas_);
       }
       if (latency_aware()) {
-        chain = new LatencyAwarePolicy(chain,
-                                       latency_aware_routing_settings_);
+        chain = new LatencyAwarePolicy(chain, latency_aware_routing_settings_);
       }
       if (host_targeting()) {
         chain = new HostTargetingPolicy(chain);
@@ -162,13 +132,9 @@ class ExecutionProfile : public Allocated {
     }
   }
 
-  const RetryPolicy::Ptr& retry_policy() const {
-    return retry_policy_;
-  }
+  const RetryPolicy::Ptr& retry_policy() const { return retry_policy_; }
 
-  void set_retry_policy(RetryPolicy* retry_policy) {
-    retry_policy_.reset(retry_policy);
-  }
+  void set_retry_policy(RetryPolicy* retry_policy) { retry_policy_.reset(retry_policy); }
 
   const SpeculativeExecutionPolicy::Ptr& speculative_execution_policy() const {
     return speculative_execution_policy_;
@@ -197,8 +163,8 @@ class ExecutionProfile : public Allocated {
   SpeculativeExecutionPolicy::Ptr speculative_execution_policy_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::ExecutionProfile, CassExecProfile)
+EXTERNAL_TYPE(datastax::internal::core::ExecutionProfile, CassExecProfile)
 
-#endif // __CASS_EXECUTION_PROFILE_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_EXECUTION_PROFILE_HPP
diff --git a/src/external.cpp b/src/external.cpp
index c8b83149c..1d2045742 100644
--- a/src/external.cpp
+++ b/src/external.cpp
@@ -75,7 +75,6 @@ const char* cass_write_type_string(CassWriteType write_type) {
   }
 }
 
-
 CassInet cass_inet_init_v4(const cass_uint8_t* address) {
   CassInet inet;
   inet.address_length = CASS_INET_V4_LENGTH;
@@ -91,8 +90,7 @@ CassInet cass_inet_init_v6(const cass_uint8_t* address) {
 }
 
 void cass_inet_string(CassInet inet, char* output) {
-  uv_inet_ntop(inet.address_length == CASS_INET_V4_LENGTH ? AF_INET : AF_INET6,
-               inet.address,
+  uv_inet_ntop(inet.address_length == CASS_INET_V4_LENGTH ? AF_INET : AF_INET6, inet.address,
                output, CASS_INET_STRING_LENGTH);
 }
 
@@ -108,11 +106,9 @@ CassError cass_inet_from_string(const char* str, CassInet* output) {
   }
 }
 
-CassError cass_inet_from_string_n(const char* str,
-                                  size_t str_length,
-                                  CassInet* output) {
+CassError cass_inet_from_string_n(const char* str, size_t str_length, CassInet* output) {
   char buf[CASS_INET_STRING_LENGTH];
-   // Need space for null terminator
+  // Need space for null terminator
   if (str_length > CASS_INET_STRING_LENGTH - 1) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
@@ -126,13 +122,12 @@ cass_uint32_t cass_date_from_epoch(cass_int64_t epoch_secs) {
 }
 
 cass_int64_t cass_time_from_epoch(cass_int64_t epoch_secs) {
-  return  CASS_TIME_NANOSECONDS_PER_SECOND *
-      (epoch_secs % NUM_SECONDS_PER_DAY);
+  return CASS_TIME_NANOSECONDS_PER_SECOND * (epoch_secs % NUM_SECONDS_PER_DAY);
 }
 
 cass_int64_t cass_date_time_to_epoch(cass_uint32_t date, cass_int64_t time) {
   return (static_cast<cass_uint64_t>(date) - CASS_DATE_EPOCH) * NUM_SECONDS_PER_DAY +
-      time / CASS_TIME_NANOSECONDS_PER_SECOND;
+         time / CASS_TIME_NANOSECONDS_PER_SECOND;
 }
 
 } // extern "C"
diff --git a/src/external.hpp b/src/external.hpp
index 395cdba9d..b86889ae2 100644
--- a/src/external.hpp
+++ b/src/external.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_EXTERNAL_HPP_INCLUDED__
-#define __CASS_EXTERNAL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_EXTERNAL_HPP
+#define DATASTAX_INTERNAL_EXTERNAL_HPP
 
 // This abstraction allows us to separate internal types from the
 // external opaque pointers that we expose.
@@ -27,12 +27,12 @@ struct External : public In {
   static const Ex* to(const In* in) { return static_cast<const Ex*>(in); }
 };
 
-#define EXTERNAL_TYPE(InternalType, ExternalType)                          \
-  extern "C" {                                                             \
-    struct ExternalType##_ : public External<InternalType, ExternalType> { \
-      private:                                                             \
-        ~ExternalType##_() { }                                             \
-    };                                                                     \
+#define EXTERNAL_TYPE(InternalType, ExternalType)                        \
+  extern "C" {                                                           \
+  struct ExternalType##_ : public External<InternalType, ExternalType> { \
+  private:                                                               \
+    ~ExternalType##_() {}                                                \
+  };                                                                     \
   }
 
 #endif
diff --git a/src/fixed_allocator.hpp b/src/fixed_allocator.hpp
index fc6bdba5a..fe618615d 100644
--- a/src/fixed_allocator.hpp
+++ b/src/fixed_allocator.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_FIXED_ALLOCATOR_HPP_INCLUDED__
-#define __CASS_FIXED_ALLOCATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_FIXED_ALLOCATOR_HPP
+#define DATASTAX_INTERNAL_FIXED_ALLOCATOR_HPP
 
 #include "aligned_storage.hpp"
 #include "macros.hpp"
@@ -24,7 +24,7 @@
 #include <limits>
 #include <memory>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // This is an allocator that starts using a fixed size buffer that only
 // uses the heap when exceeded. The allocator can be
@@ -41,11 +41,14 @@ class FixedAllocator {
   typedef T& reference;
   typedef const T& const_reference;
 
-  template <class U> struct rebind { typedef FixedAllocator<U, N> other; };
+  template <class U>
+  struct rebind {
+    typedef FixedAllocator<U, N> other;
+  };
 
   struct Fixed {
     Fixed()
-      : is_used(false) {}
+        : is_used(false) {}
 
     // See aligned_storage.hpp for why this is required
     typedef AlignedStorage<N * sizeof(T), ALIGN_OF(T)> Storage;
@@ -55,28 +58,24 @@ class FixedAllocator {
   };
 
   FixedAllocator()
-    : fixed_(NULL) {}
+      : fixed_(NULL) {}
 
   FixedAllocator(Fixed* fixed)
-    : fixed_(fixed) {}
+      : fixed_(fixed) {}
 
   FixedAllocator(const FixedAllocator<T, N>& allocator)
-    : fixed_(allocator.fixed_) {}
+      : fixed_(allocator.fixed_) {}
 
-  template<class U, size_t M>
+  template <class U, size_t M>
   FixedAllocator(const FixedAllocator<U, M>& allocator)
-    : fixed_(NULL) {}
+      : fixed_(NULL) {}
 
   FixedAllocator(const std::allocator<T>& allocator)
-    : fixed_(NULL) {}
+      : fixed_(NULL) {}
 
-  pointer address(reference x) const {
-    return &x;
-  }
+  pointer address(reference x) const { return &x; }
 
-  const_pointer address(const_reference x) const {
-    return &x;
-  }
+  const_pointer address(const_reference x) const { return &x; }
 
   pointer allocate(size_type n, const_pointer hint = NULL) {
     if (fixed_ != NULL && !fixed_->is_used && n <= N) {
@@ -95,22 +94,16 @@ class FixedAllocator {
     }
   }
 
-  void construct(pointer p, const_reference x) {
-    new (p) value_type(x);
-  }
+  void construct(pointer p, const_reference x) { new (p) value_type(x); }
 
-  void destroy(pointer p) {
-    p->~value_type();
-  }
+  void destroy(pointer p) { p->~value_type(); }
 
-  size_type max_size() const throw() {
-    return std::numeric_limits<size_type>::max();
-  }
+  size_type max_size() const throw() { return std::numeric_limits<size_type>::max(); }
 
 private:
   Fixed* fixed_;
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/fixnl.sh b/src/fixnl.sh
new file mode 100755
index 000000000..9791c1b9e
--- /dev/null
+++ b/src/fixnl.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+function fixnl() {
+  echo "Fixing $1..."
+  awk '/^$/ {nlstack=nlstack "\n";next;} {printf "%s",nlstack; nlstack=""; print;}' $1 > $1.tmp && mv $1.tmp $1
+}
+
+shopt -s globstar
+
+for file in **/*.cpp; do fixnl "$file"; done
+for file in **/*.hpp; do fixnl "$file"; done
diff --git a/src/future.cpp b/src/future.cpp
index 6ee0b3f4b..9bb6c6ec0 100644
--- a/src/future.cpp
+++ b/src/future.cpp
@@ -22,6 +22,10 @@
 #include "result_response.hpp"
 #include "scoped_ptr.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 void cass_future_free(CassFuture* future) {
@@ -30,9 +34,7 @@ void cass_future_free(CassFuture* future) {
   future->dec_ref();
 }
 
-CassError cass_future_set_callback(CassFuture* future,
-                                   CassFutureCallback callback,
-                                   void* data) {
+CassError cass_future_set_callback(CassFuture* future, CassFutureCallback callback, void* data) {
   if (!future->set_callback(callback, data)) {
     return CASS_ERROR_LIB_CALLBACK_ALREADY_SET;
   }
@@ -43,67 +45,59 @@ cass_bool_t cass_future_ready(CassFuture* future) {
   return static_cast<cass_bool_t>(future->ready());
 }
 
-void cass_future_wait(CassFuture* future) {
-  future->wait();
-}
+void cass_future_wait(CassFuture* future) { future->wait(); }
 
 cass_bool_t cass_future_wait_timed(CassFuture* future, cass_duration_t wait_us) {
   return static_cast<cass_bool_t>(future->wait_for(wait_us));
 }
 
 const CassResult* cass_future_get_result(CassFuture* future) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return NULL;
   }
 
-  cass::Response::Ptr response(
-        static_cast<cass::ResponseFuture*>(future->from())->response());
+  Response::Ptr response(static_cast<ResponseFuture*>(future->from())->response());
   if (!response || response->opcode() == CQL_OPCODE_ERROR) {
     return NULL;
   }
 
   response->inc_ref();
-  return CassResult::to(
-        static_cast<cass::ResultResponse*>(response.get()));
+  return CassResult::to(static_cast<ResultResponse*>(response.get()));
 }
 
 const CassPrepared* cass_future_get_prepared(CassFuture* future) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return NULL;
   }
-  cass::ResponseFuture* response_future =
-      static_cast<cass::ResponseFuture*>(future->from());
+  ResponseFuture* response_future = static_cast<ResponseFuture*>(future->from());
 
-  cass::SharedRefPtr<cass::ResultResponse> result(response_future->response());
+  SharedRefPtr<ResultResponse> result(response_future->response());
   if (!result || result->kind() != CASS_RESULT_KIND_PREPARED) {
     return NULL;
   }
 
-  cass::Prepared* prepared = new cass::Prepared(result,
-                                                response_future->prepare_request,
-                                                *response_future->schema_metadata);
+  Prepared* prepared =
+      new Prepared(result, response_future->prepare_request, *response_future->schema_metadata);
   prepared->inc_ref();
   return CassPrepared::to(prepared);
 }
 
 const CassErrorResult* cass_future_get_error_result(CassFuture* future) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return NULL;
   }
 
-  cass::Response::Ptr response(
-        static_cast<cass::ResponseFuture*>(future->from())->response());
+  Response::Ptr response(static_cast<ResponseFuture*>(future->from())->response());
   if (!response || response->opcode() != CQL_OPCODE_ERROR) {
     return NULL;
   }
 
   response->inc_ref();
-  return CassErrorResult::to(
-        static_cast<cass::ErrorResponse*>(response.get()));
+  return CassErrorResult::to(static_cast<ErrorResponse*>(response.get()));
 }
 
 CassError cass_future_error_code(CassFuture* future) {
-  const cass::Future::Error* error = future->error();
+  const Future::Error* error = future->error();
   if (error != NULL) {
     return error->code;
   } else {
@@ -111,12 +105,10 @@ CassError cass_future_error_code(CassFuture* future) {
   }
 }
 
-void cass_future_error_message(CassFuture* future,
-                               const char** message,
-                               size_t* message_length) {
-  const cass::Future::Error* error = future->error();
+void cass_future_error_message(CassFuture* future, const char** message, size_t* message_length) {
+  const Future::Error* error = future->error();
   if (error != NULL) {
-    const cass::String& m = error->message;
+    const String& m = error->message;
     *message = m.data();
     *message_length = m.length();
   } else {
@@ -126,13 +118,12 @@ void cass_future_error_message(CassFuture* future,
 }
 
 CassError cass_future_tracing_id(CassFuture* future, CassUuid* tracing_id) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return CASS_ERROR_LIB_INVALID_FUTURE_TYPE;
   }
 
-  cass::Response::Ptr response(
-        static_cast<cass::ResponseFuture*>(future->from())->response());
-  if (!response || !response->has_tracing_id())  {
+  Response::Ptr response(static_cast<ResponseFuture*>(future->from())->response());
+  if (!response || !response->has_tracing_id()) {
     return CASS_ERROR_LIB_NO_TRACING_ID;
   }
 
@@ -142,35 +133,29 @@ CassError cass_future_tracing_id(CassFuture* future, CassUuid* tracing_id) {
 }
 
 size_t cass_future_custom_payload_item_count(CassFuture* future) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return 0;
   }
-  cass::Response::Ptr response(
-        static_cast<cass::ResponseFuture*>(future->from())->response());
+  Response::Ptr response(static_cast<ResponseFuture*>(future->from())->response());
   if (!response) return 0;
   return response->custom_payload().size();
 }
 
-CassError cass_future_custom_payload_item(CassFuture* future,
-                                          size_t index,
-                                          const char** name,
-                                          size_t* name_length,
-                                          const cass_byte_t** value,
+CassError cass_future_custom_payload_item(CassFuture* future, size_t index, const char** name,
+                                          size_t* name_length, const cass_byte_t** value,
                                           size_t* value_size) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return CASS_ERROR_LIB_INVALID_FUTURE_TYPE;
   }
-  cass::Response::Ptr response(
-        static_cast<cass::ResponseFuture*>(future->from())->response());
+  Response::Ptr response(static_cast<ResponseFuture*>(future->from())->response());
   if (!response) return CASS_ERROR_LIB_NO_CUSTOM_PAYLOAD;
 
-  const cass::CustomPayloadVec& custom_payload =
-      response->custom_payload();
+  const CustomPayloadVec& custom_payload = response->custom_payload();
   if (index >= custom_payload.size()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
 
-  const cass::CustomPayloadItem& item = custom_payload[index];
+  const CustomPayloadItem& item = custom_payload[index];
   *name = item.name.data();
   *name_length = item.name.size();
   *value = reinterpret_cast<const cass_byte_t*>(item.value.data());
@@ -180,8 +165,6 @@ CassError cass_future_custom_payload_item(CassFuture* future,
 
 } // extern "C"
 
-namespace cass {
-
 bool Future::set_callback(Future::Callback callback, void* data) {
   ScopedMutex lock(&mutex_);
   if (callback_) {
@@ -210,7 +193,3 @@ void Future::internal_set(ScopedMutex& lock) {
   // on this future see the side effects of the callback.
   uv_cond_broadcast(&cond_);
 }
-
-} // namespace cass
-
-
diff --git a/src/future.hpp b/src/future.hpp
index e4567d636..ba0646fe2 100644
--- a/src/future.hpp
+++ b/src/future.hpp
@@ -14,23 +14,23 @@
   limitations under the License.
 */
 
-#ifndef __CASS_FUTURE_HPP_INCLUDED__
-#define __CASS_FUTURE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_FUTURE_HPP
+#define DATASTAX_INTERNAL_FUTURE_HPP
 
 #include "atomic.hpp"
 #include "cassandra.h"
 #include "external.hpp"
 #include "host.hpp"
 #include "macros.hpp"
+#include "ref_counted.hpp"
 #include "scoped_lock.hpp"
 #include "scoped_ptr.hpp"
 #include "string.hpp"
-#include "ref_counted.hpp"
 
-#include <uv.h>
 #include <assert.h>
+#include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 struct Error;
 
@@ -39,11 +39,7 @@ class Future : public RefCounted<Future> {
   typedef SharedRefPtr<Future> Ptr;
   typedef void (*Callback)(CassFuture*, void*);
 
-  enum Type {
-    FUTURE_TYPE_GENERIC,
-    FUTURE_TYPE_SESSION,
-    FUTURE_TYPE_RESPONSE
-  };
+  enum Type { FUTURE_TYPE_GENERIC, FUTURE_TYPE_SESSION, FUTURE_TYPE_RESPONSE };
 
   struct Error : public Allocated {
     Error(CassError code, const String& message)
@@ -145,8 +141,8 @@ class Future : public RefCounted<Future> {
   DISALLOW_COPY_AND_ASSIGN(Future);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Future, CassFuture)
+EXTERNAL_TYPE(datastax::internal::core::Future, CassFuture)
 
 #endif
diff --git a/src/get_time-mac.cpp b/src/get_time-mac.cpp
index f6712e0db..59c003597 100644
--- a/src/get_time-mac.cpp
+++ b/src/get_time-mac.cpp
@@ -22,7 +22,7 @@
 #include <mach/mach_time.h>
 #include <sys/time.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // Information on converting the absolute time to nanoseconds can be found
 // here: https://developer.apple.com/library/content/qa/qa1398/_index.html.
@@ -48,8 +48,7 @@ static ClockInfo __clock_info__; // Initializer
 uint64_t get_time_since_epoch_us() {
   struct timeval tv;
   gettimeofday(&tv, NULL);
-  return static_cast<uint64_t>(tv.tv_sec) * 1000000 +
-         static_cast<uint64_t>(tv.tv_usec);
+  return static_cast<uint64_t>(tv.tv_sec) * 1000000 + static_cast<uint64_t>(tv.tv_usec);
 }
 
 uint64_t get_time_monotonic_ns() {
@@ -57,7 +56,6 @@ uint64_t get_time_monotonic_ns() {
   return time * ClockInfo::frequency();
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif // defined(__APPLE__) && defined(__MACH__)
-
diff --git a/src/get_time-unix.cpp b/src/get_time-unix.cpp
index 8b456ba64..bb4fef1f6 100644
--- a/src/get_time-unix.cpp
+++ b/src/get_time-unix.cpp
@@ -14,7 +14,6 @@
   limitations under the License.
 */
 
-
 #include <unistd.h>
 
 #if _POSIX_TIMERS > 0
@@ -23,15 +22,15 @@
 
 #include <time.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class ClockInfo {
 public:
   ClockInfo() {
     struct timespec res;
     struct timespec tp;
-    supports_monotonic_ = clock_getres(CLOCK_MONOTONIC, &res) == 0 &&
-                          clock_gettime(CLOCK_MONOTONIC, &tp) == 0;
+    supports_monotonic_ =
+        clock_getres(CLOCK_MONOTONIC, &res) == 0 && clock_gettime(CLOCK_MONOTONIC, &tp) == 0;
   }
 
   static bool supports_monotonic() { return supports_monotonic_; }
@@ -44,12 +43,10 @@ bool ClockInfo::supports_monotonic_;
 
 static ClockInfo __clock_info__; // Initializer
 
-
 uint64_t get_time_since_epoch_us() {
   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
-  return static_cast<uint64_t>(ts.tv_sec)  * 1000000 +
-         static_cast<uint64_t>(ts.tv_nsec) / 1000;
+  return static_cast<uint64_t>(ts.tv_sec) * 1000000 + static_cast<uint64_t>(ts.tv_nsec) / 1000;
 }
 
 uint64_t get_time_monotonic_ns() {
@@ -63,7 +60,6 @@ uint64_t get_time_monotonic_ns() {
   }
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
-
diff --git a/src/get_time-win.cpp b/src/get_time-win.cpp
index 8d1e7e59f..a8963a1fd 100644
--- a/src/get_time-win.cpp
+++ b/src/get_time-win.cpp
@@ -14,7 +14,6 @@
   limitations under the License.
 */
 
-
 #if defined(_WIN32)
 
 #ifndef _WINSOCKAPI_
@@ -25,7 +24,7 @@
 
 #include "get_time.hpp"
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // Information for using the query performance counter can be found here:
 // https://msdn.microsoft.com/en-us/library/dn553408(v=vs.85).aspx
@@ -50,11 +49,11 @@ static ClockInfo __clock_info__; // Initializer
 uint64_t get_time_since_epoch_us() {
   _FILETIME ft;
   GetSystemTimeAsFileTime(&ft);
-  uint64_t ns100 = (static_cast<uint64_t>(ft.dwHighDateTime) << 32 |
-                    static_cast<uint64_t>(ft.dwLowDateTime)) -
-                   116444736000000000LL; // 100 nanosecond increments between
-                                         // Jan. 1, 1601 - Jan. 1, 1970
-  return ns100 / 10;                     // 100 nanosecond increments to microseconds
+  uint64_t ns100 =
+      (static_cast<uint64_t>(ft.dwHighDateTime) << 32 | static_cast<uint64_t>(ft.dwLowDateTime)) -
+      116444736000000000LL; // 100 nanosecond increments between
+                            // Jan. 1, 1601 - Jan. 1, 1970
+  return ns100 / 10;        // 100 nanosecond increments to microseconds
 }
 
 uint64_t get_time_monotonic_ns() {
@@ -69,7 +68,6 @@ uint64_t get_time_monotonic_ns() {
   }
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif // defined(_WIN32)
-
diff --git a/src/get_time.hpp b/src/get_time.hpp
index 9c12c4ab8..28855c971 100644
--- a/src/get_time.hpp
+++ b/src/get_time.hpp
@@ -14,18 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_GET_TIME_HPP_INCLUDED__
-#define __CASS_GET_TIME_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_GET_TIME_HPP
+#define DATASTAX_INTERNAL_GET_TIME_HPP
 
 #include <uv.h>
 
-#define NANOSECONDS_PER_MICROSECOND  1000LL
-#define NANOSECONDS_PER_MILLISECOND  1000000LL
-#define NANOSECONDS_PER_SECOND       1000000000LL
+#define NANOSECONDS_PER_MICROSECOND 1000LL
+#define NANOSECONDS_PER_MILLISECOND 1000000LL
+#define NANOSECONDS_PER_SECOND 1000000000LL
 
 #define MICROSECONDS_PER_MILLISECOND 1000LL
 
-namespace cass {
+namespace datastax { namespace internal {
 
 uint64_t get_time_since_epoch_us();
 
@@ -38,6 +38,6 @@ inline uint64_t get_time_since_epoch_ms() {
 // `get_time_since_epoch_us()` will be used.
 uint64_t get_time_monotonic_ns();
 
-}
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/hash.hpp b/src/hash.hpp
index 03a646413..293e80067 100644
--- a/src/hash.hpp
+++ b/src/hash.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_HASH_HPP_INCLUDED__
-#define __CASS_HASH_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_HASH_HPP
+#define DATASTAX_INTERNAL_HASH_HPP
 
 #include <algorithm>
 #include <stdint.h>
 
-namespace cass { namespace hash {
+namespace datastax { namespace hash {
 
-typedef int (Op)(int);
+typedef int(Op)(int);
 
 inline int nop(int c) { return c; }
 
@@ -52,7 +52,6 @@ inline uint32_t fnv1a(const char* data, size_t length, Op op = nop) {
 }
 #endif
 
-} } // namespace cass::hash
-
+}} // namespace datastax::hash
 
 #endif
diff --git a/src/hash_table.hpp b/src/hash_table.hpp
index 2cc202411..140a19a84 100644
--- a/src/hash_table.hpp
+++ b/src/hash_table.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_HASH_INDEX_HPP_INCLUDED__
-#define __CASS_HASH_INDEX_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_HASH_INDEX_HPP
+#define DATASTAX_INTERNAL_HASH_INDEX_HPP
 
 #include "allocated.hpp"
 #include "hash.hpp"
@@ -30,22 +30,22 @@
 // additional memory.
 #define CASS_LOAD_FACTOR 0.75
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 typedef SmallVector<size_t, 4> IndexVec;
 
-template<class T>
+template <class T>
 struct HashTableEntry {
   HashTableEntry()
-    : index(0)
-    , next(NULL) { }
+      : index(0)
+      , next(NULL) {}
 
-  // Requires a "name" String or cass::StringRef field
+  // Requires a "name" String or datastax::StringRef field
   size_t index;
   T* next;
 };
 
-template<class T>
+template <class T>
 class CaseInsensitiveHashTable : public Allocated {
 public:
   typedef SmallVector<T, 16> EntryVec;
@@ -56,7 +56,7 @@ class CaseInsensitiveHashTable : public Allocated {
   T& operator[](size_t index) { return entries_[index]; }
   const T& operator[](size_t index) const { return entries_[index]; }
 
-  size_t get_indices(StringRef name, IndexVec* result) const ;
+  size_t get_indices(StringRef name, IndexVec* result) const;
   size_t add(const T& entry);
 
   const EntryVec& entries() const { return entries_; }
@@ -80,17 +80,17 @@ class CaseInsensitiveHashTable : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(CaseInsensitiveHashTable);
 };
 
-template<class T>
+template <class T>
 CaseInsensitiveHashTable<T>::CaseInsensitiveHashTable(size_t capacity) {
   reset(capacity);
 }
 
-template<class T>
+template <class T>
 CaseInsensitiveHashTable<T>::CaseInsensitiveHashTable(const EntryVec& entries) {
   set_entries(entries);
 }
 
-template<class T>
+template <class T>
 size_t CaseInsensitiveHashTable<T>::get_indices(StringRef name, IndexVec* result) const {
   result->clear();
   bool is_case_sensitive = false;
@@ -104,8 +104,7 @@ size_t CaseInsensitiveHashTable<T>::get_indices(StringRef name, IndexVec* result
     name = name.substr(1, name.size() - 2);
   }
 
-  size_t h = hash::fnv1a(name.data(),
-                         name.size(), ::tolower) & index_mask_;
+  size_t h = hash::fnv1a(name.data(), name.size(), ::tolower) & index_mask_;
 
   size_t start = h;
   while (index_[h] != NULL && !iequals(name, index_[h]->name)) {
@@ -138,7 +137,7 @@ size_t CaseInsensitiveHashTable<T>::get_indices(StringRef name, IndexVec* result
   return result->size();
 }
 
-template<class T>
+template <class T>
 size_t CaseInsensitiveHashTable<T>::add(const T& entry) {
   size_t index = entries_.size();
   size_t capacity = entries_.capacity();
@@ -152,8 +151,7 @@ size_t CaseInsensitiveHashTable<T>::add(const T& entry) {
   return index;
 }
 
-
-template<class T>
+template <class T>
 void CaseInsensitiveHashTable<T>::set_entries(const EntryVec& entries) {
   entries_.clear();
   reset(entries.size());
@@ -162,10 +160,9 @@ void CaseInsensitiveHashTable<T>::set_entries(const EntryVec& entries) {
   }
 }
 
-template<class T>
+template <class T>
 void CaseInsensitiveHashTable<T>::add_index(T* entry) {
-  size_t h = hash::fnv1a(entry->name.data(),
-                         entry->name.size(), ::tolower) & index_mask_;
+  size_t h = hash::fnv1a(entry->name.data(), entry->name.size(), ::tolower) & index_mask_;
 
   if (index_[h] == NULL) {
     index_[h] = entry;
@@ -190,7 +187,7 @@ void CaseInsensitiveHashTable<T>::add_index(T* entry) {
   }
 }
 
-template<class T>
+template <class T>
 void CaseInsensitiveHashTable<T>::reset(size_t capacity) {
   if (capacity < entries_.capacity()) {
     capacity = entries_.capacity();
@@ -202,13 +199,13 @@ void CaseInsensitiveHashTable<T>::reset(size_t capacity) {
   index_mask_ = index_capacity - 1;
 }
 
-template<class T>
+template <class T>
 void CaseInsensitiveHashTable<T>::resize(size_t new_capacity) {
   reset(new_capacity);
   reindex();
 }
 
-template<class T>
+template <class T>
 void CaseInsensitiveHashTable<T>::reindex() {
   for (size_t i = 0; i < entries_.size(); ++i) {
     T* entry = &entries_[i];
@@ -217,6 +214,6 @@ void CaseInsensitiveHashTable<T>::reindex() {
   }
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/histogram_wrapper.hpp b/src/histogram_wrapper.hpp
index 93f687f95..f1c862535 100644
--- a/src/histogram_wrapper.hpp
+++ b/src/histogram_wrapper.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_HISTOGRAM_WRAPPER_HPP_INCLUDED__
-#define __CASS_HISTOGRAM_WRAPPER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_HISTOGRAM_WRAPPER_HPP
+#define DATASTAX_INTERNAL_HISTOGRAM_WRAPPER_HPP
 
 #ifdef CASS_INTERNAL_DIAGNOSTICS
 #include "string.hpp"
@@ -23,15 +23,15 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class HistogramWrapper {
 public:
   static const int64_t HIGHEST_TRACKABLE_VALUE = 1000LL * 1000LL;
 
   HistogramWrapper(const String& name)
-    : thread_id_(0)
-    , name_(name) {
+      : thread_id_(0)
+      , name_(name) {
     hdr_init(1LL, HIGHEST_TRACKABLE_VALUE, 3, &histogram_);
   }
 
@@ -57,14 +57,16 @@ class HistogramWrapper {
             "%10llu, %10llu, %10llu, %10llu, "
             "%10llu, %10llu, %10llu, %10llu, "
             "%10llu\n",
-            "name", "thread", "min", "mean", "median", "75th",
-            "95th", "98th", "99th", "99.9th",
-            "max",
-            name_.c_str(), static_cast<unsigned long long int>(thread_id_),
-            (unsigned long long int)hdr_min(histogram_), (unsigned long long int)hdr_mean(histogram_),
-            (unsigned long long int)hdr_value_at_percentile(histogram_, 50.0), (unsigned long long int)hdr_value_at_percentile(histogram_, 75.0),
-            (unsigned long long int)hdr_value_at_percentile(histogram_, 95.0), (unsigned long long int)hdr_value_at_percentile(histogram_, 98.0),
-            (unsigned long long int)hdr_value_at_percentile(histogram_, 99.0), (unsigned long long int)hdr_value_at_percentile(histogram_, 99.9),
+            "name", "thread", "min", "mean", "median", "75th", "95th", "98th", "99th", "99.9th",
+            "max", name_.c_str(), static_cast<unsigned long long int>(thread_id_),
+            (unsigned long long int)hdr_min(histogram_),
+            (unsigned long long int)hdr_mean(histogram_),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 50.0),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 75.0),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 95.0),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 98.0),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 99.0),
+            (unsigned long long int)hdr_value_at_percentile(histogram_, 99.9),
             (unsigned long long int)hdr_max(histogram_));
   }
 
@@ -74,7 +76,7 @@ class HistogramWrapper {
   String name_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif // CASS_INTERNAL_DIAGNOSTICS
 
diff --git a/src/host.cpp b/src/host.cpp
index f484112d5..2a566acbd 100644
--- a/src/host.cpp
+++ b/src/host.cpp
@@ -16,11 +16,14 @@
 
 #include "host.hpp"
 
+#include "collection_iterator.hpp"
 #include "row.hpp"
 #include "value.hpp"
-#include "collection_iterator.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 void add_host(CopyOnWriteHostVec& hosts, const Host::Ptr& host) {
   HostVec::iterator i;
@@ -50,6 +53,8 @@ bool remove_host(CopyOnWriteHostVec& hosts, const Address& address) {
   return false;
 }
 
+}}} // namespace datastax::internal::core
+
 void Host::LatencyTracker::update(uint64_t latency_ns) {
   uint64_t now = uv_hrtime();
 
@@ -69,7 +74,8 @@ void Host::LatencyTracker::update(uint64_t latency_ns) {
 
     double scaled_delay = static_cast<double>(delay) / scale_ns_;
     double weight = log(scaled_delay + 1) / scaled_delay;
-    current_.average = static_cast<int64_t>((1.0 - weight) * latency_ns + weight * previous.average);
+    current_.average =
+        static_cast<int64_t>((1.0 - weight) * latency_ns + weight * previous.average);
   }
 
   current_.num_measured = previous.num_measured + 1;
@@ -77,7 +83,8 @@ void Host::LatencyTracker::update(uint64_t latency_ns) {
 }
 
 bool VersionNumber::parse(const String& version) {
-  return sscanf(version.c_str(), "%d.%d.%d", &major_version_, &minor_version_, &patch_version_) >= 2;
+  return sscanf(version.c_str(), "%d.%d.%d", &major_version_, &minor_version_, &patch_version_) >=
+         2;
 }
 
 void Host::set(const Row* row, bool use_tokens) {
@@ -99,8 +106,7 @@ void Host::set(const Row* row, bool use_tokens) {
   if (server_version.parse(release_version)) {
     server_version_ = server_version;
   } else {
-    LOG_WARN("Invalid release version string \"%s\" on host %s",
-             release_version.c_str(),
+    LOG_WARN("Invalid release version string \"%s\" on host %s", release_version.c_str(),
              address().to_string().c_str());
   }
 
@@ -118,8 +124,7 @@ void Host::set(const Row* row, bool use_tokens) {
         server_version_ = VersionNumber(3, 11, 0);
       }
     } else {
-      LOG_WARN("Invalid DSE version string \"%s\" on host %s",
-               dse_version_str.c_str(),
+      LOG_WARN("Invalid DSE version string \"%s\" on host %s", dse_version_str.c_str(),
                address().to_string().c_str());
     }
   }
@@ -137,10 +142,9 @@ void Host::set(const Row* row, bool use_tokens) {
   }
 }
 
-ExternalHostListener::ExternalHostListener(const CassHostListenerCallback callback,
-                                           void *data)
-  : callback_(callback)
-  , data_(data) { }
+ExternalHostListener::ExternalHostListener(const CassHostListenerCallback callback, void* data)
+    : callback_(callback)
+    , data_(data) {}
 
 void ExternalHostListener::on_host_up(const Host::Ptr& host) {
   CassInet address;
@@ -165,5 +169,3 @@ void ExternalHostListener::on_host_removed(const Host::Ptr& host) {
   address.address_length = host->address().to_inet(address.address);
   callback_(CASS_HOST_LISTENER_EVENT_REMOVE, address, data_);
 }
-
-} // namespace cass
diff --git a/src/host.hpp b/src/host.hpp
index 3adce5468..0bfc91daa 100644
--- a/src/host.hpp
+++ b/src/host.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_HOST_HPP_INCLUDED__
-#define __CASS_HOST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_HOST_HPP
+#define DATASTAX_INTERNAL_HOST_HPP
 
 #include "address.hpp"
 #include "allocated.hpp"
@@ -33,15 +33,15 @@
 #include <math.h>
 #include <stdint.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Row;
 
 struct TimestampedAverage {
   TimestampedAverage()
-    : average(-1)
-    , timestamp(0)
-    , num_measured(0) { }
+      : average(-1)
+      , timestamp(0)
+      , num_measured(0) {}
 
   int64_t average;
   uint64_t timestamp;
@@ -51,32 +51,28 @@ struct TimestampedAverage {
 class VersionNumber {
 public:
   VersionNumber()
-    : major_version_(0)
-    , minor_version_(0)
-    , patch_version_(0) { }
+      : major_version_(0)
+      , minor_version_(0)
+      , patch_version_(0) {}
 
   VersionNumber(int major_version, int minor_version, int patch_version)
-    : major_version_(major_version)
-    , minor_version_(minor_version)
-    , patch_version_(patch_version) { }
+      : major_version_(major_version)
+      , minor_version_(minor_version)
+      , patch_version_(patch_version) {}
 
-  bool operator >=(const VersionNumber& other) const {
-    return compare(other) >= 0;
-  }
+  bool operator>=(const VersionNumber& other) const { return compare(other) >= 0; }
 
-  bool operator <(const VersionNumber& other) const {
-    return compare(other) < 0;
-  }
+  bool operator<(const VersionNumber& other) const { return compare(other) < 0; }
 
   int compare(const VersionNumber& other) const {
     if (major_version_ < other.major_version_) return -1;
-    if (major_version_ > other.major_version_) return  1;
+    if (major_version_ > other.major_version_) return 1;
 
     if (minor_version_ < other.minor_version_) return -1;
-    if (minor_version_ > other.minor_version_) return  1;
+    if (minor_version_ > other.minor_version_) return 1;
 
     if (patch_version_ < other.patch_version_) return -1;
-    if (patch_version_ > other.patch_version_) return  1;
+    if (patch_version_ > other.patch_version_) return 1;
 
     return 0;
   }
@@ -104,7 +100,7 @@ class Host : public RefCounted<Host> {
       , dc_id_(0)
       , address_string_(address.to_string())
       , connection_count_(0)
-      , inflight_request_count_(0) { }
+      , inflight_request_count_(0) {}
 
   const Address& address() const { return address_; }
   const String& address_string() const { return address_string_; }
@@ -125,21 +121,13 @@ class Host : public RefCounted<Host> {
     dc_id_ = dc_id;
   }
 
-  const String& partitioner() const {
-    return partitioner_;
-  }
+  const String& partitioner() const { return partitioner_; }
 
-  const Vector<String>& tokens() const {
-    return tokens_;
-  }
+  const Vector<String>& tokens() const { return tokens_; }
 
-  const VersionNumber& server_version() const {
-    return server_version_;
-  }
+  const VersionNumber& server_version() const { return server_version_; }
 
-  const VersionNumber& dse_server_version() const {
-    return dse_server_version_;
-  }
+  const VersionNumber& dse_server_version() const { return dse_server_version_; }
 
   String to_string() const {
     OStringStream ss;
@@ -170,25 +158,15 @@ class Host : public RefCounted<Host> {
     return TimestampedAverage();
   }
 
-  void increment_connection_count() {
-    connection_count_.fetch_add(1, MEMORY_ORDER_RELAXED);
-  }
+  void increment_connection_count() { connection_count_.fetch_add(1, MEMORY_ORDER_RELAXED); }
 
-  void decrement_connection_count() {
-    connection_count_.fetch_sub(1, MEMORY_ORDER_RELAXED);
-  }
+  void decrement_connection_count() { connection_count_.fetch_sub(1, MEMORY_ORDER_RELAXED); }
 
-  int32_t connection_count() const {
-    return connection_count_.load(MEMORY_ORDER_RELAXED);
-  }
+  int32_t connection_count() const { return connection_count_.load(MEMORY_ORDER_RELAXED); }
 
-  void increment_inflight_requests() {
-    inflight_request_count_.fetch_add(1, MEMORY_ORDER_RELAXED);
-  }
+  void increment_inflight_requests() { inflight_request_count_.fetch_add(1, MEMORY_ORDER_RELAXED); }
 
-  void decrement_inflight_requests() {
-    inflight_request_count_.fetch_sub(1, MEMORY_ORDER_RELAXED);
-  }
+  void decrement_inflight_requests() { inflight_request_count_.fetch_sub(1, MEMORY_ORDER_RELAXED); }
 
   int32_t inflight_request_count() const {
     return inflight_request_count_.load(MEMORY_ORDER_RELAXED);
@@ -198,8 +176,8 @@ class Host : public RefCounted<Host> {
   class LatencyTracker : public Allocated {
   public:
     LatencyTracker(uint64_t scale_ns, uint64_t threshold_to_account)
-      : scale_ns_(scale_ns)
-      , threshold_to_account_(threshold_to_account) { }
+        : scale_ns_(scale_ns)
+        , threshold_to_account_(threshold_to_account) {}
 
     void update(uint64_t latency_ns);
 
@@ -242,7 +220,7 @@ class Host : public RefCounted<Host> {
  */
 class HostListener {
 public:
-  virtual ~HostListener() { }
+  virtual ~HostListener() {}
 
   /**
    * A callback that's called when a host is marked as being UP.
@@ -279,17 +257,16 @@ class DefaultHostListener
 public:
   typedef SharedRefPtr<DefaultHostListener> Ptr;
 
-  virtual void on_host_up(const Host::Ptr& host) { }
-  virtual void on_host_down(const Host::Ptr& host) { }
-  virtual void on_host_added(const Host::Ptr& host) { }
-  virtual void on_host_removed(const Host::Ptr& host) { }
+  virtual void on_host_up(const Host::Ptr& host) {}
+  virtual void on_host_down(const Host::Ptr& host) {}
+  virtual void on_host_added(const Host::Ptr& host) {}
+  virtual void on_host_removed(const Host::Ptr& host) {}
 };
 
-class ExternalHostListener : public DefaultHostListener  {
+class ExternalHostListener : public DefaultHostListener {
 public:
   typedef SharedRefPtr<ExternalHostListener> Ptr;
-  ExternalHostListener(const CassHostListenerCallback callback,
-                       void *data);
+  ExternalHostListener(const CassHostListenerCallback callback, void* data);
 
   virtual void on_host_up(const Host::Ptr& host);
   virtual void on_host_down(const Host::Ptr& host);
@@ -305,16 +282,12 @@ typedef Map<Address, Host::Ptr> HostMap;
 
 struct GetAddress {
   typedef std::pair<Address, Host::Ptr> Pair;
-  const Address& operator()(const Pair& pair) const {
-    return pair.first;
-  }
+  const Address& operator()(const Pair& pair) const { return pair.first; }
 };
 
 struct GetHost {
   typedef std::pair<Address, Host::Ptr> Pair;
-  Host::Ptr operator()(const Pair& pair) const {
-    return pair.second;
-  }
+  Host::Ptr operator()(const Pair& pair) const { return pair.second; }
 };
 
 typedef std::pair<Address, Host::Ptr> HostPair;
@@ -325,6 +298,6 @@ void add_host(CopyOnWriteHostVec& hosts, const Host::Ptr& host);
 void remove_host(CopyOnWriteHostVec& hosts, const Host::Ptr& host);
 bool remove_host(CopyOnWriteHostVec& hosts, const Address& address);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/host_targeting_policy.cpp b/src/host_targeting_policy.cpp
index c9a0ee17b..395337c84 100644
--- a/src/host_targeting_policy.cpp
+++ b/src/host_targeting_policy.cpp
@@ -16,13 +16,13 @@
 
 #include "host_targeting_policy.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-void HostTargetingPolicy::init(const SharedRefPtr<Host>& connected_host,
-                               const cass::HostMap& hosts,
+void HostTargetingPolicy::init(const SharedRefPtr<Host>& connected_host, const core::HostMap& hosts,
                                Random* random) {
-  for (cass::HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (core::HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     hosts_[it->first] = it->second;
   }
   ChainedLoadBalancingPolicy::init(connected_host, hosts, random);
@@ -31,11 +31,8 @@ void HostTargetingPolicy::init(const SharedRefPtr<Host>& connected_host,
 QueryPlan* HostTargetingPolicy::new_query_plan(const String& keyspace,
                                                RequestHandler* request_handler,
                                                const TokenMap* token_map) {
-  QueryPlan* child_plan = child_policy_->new_query_plan(keyspace,
-                                                        request_handler,
-                                                        token_map);
-  if (request_handler == NULL ||
-      !request_handler->preferred_address().is_valid()) {
+  QueryPlan* child_plan = child_policy_->new_query_plan(keyspace, request_handler, token_map);
+  if (request_handler == NULL || !request_handler->preferred_address().is_valid()) {
     return child_plan;
   }
 
@@ -69,5 +66,3 @@ SharedRefPtr<Host> HostTargetingPolicy::HostTargetingQueryPlan::compute_next() {
     return next;
   }
 }
-
-} // namespace cass
diff --git a/src/host_targeting_policy.hpp b/src/host_targeting_policy.hpp
index 2130f5a2d..fe8616f98 100644
--- a/src/host_targeting_policy.hpp
+++ b/src/host_targeting_policy.hpp
@@ -14,26 +14,24 @@
   limitations under the License.
 */
 
-#ifndef __CASS_HOST_TARGETING_POLICY_HPP_INCLUDED__
-#define __CASS_HOST_TARGETING_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_HOST_TARGETING_POLICY_HPP
+#define DATASTAX_INTERNAL_HOST_TARGETING_POLICY_HPP
 
 #include "address.hpp"
 #include "dense_hash_map.hpp"
 #include "load_balancing.hpp"
 #include "request_handler.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class HostTargetingPolicy : public ChainedLoadBalancingPolicy {
 public:
   HostTargetingPolicy(LoadBalancingPolicy* child_policy)
-    : ChainedLoadBalancingPolicy(child_policy) { }
+      : ChainedLoadBalancingPolicy(child_policy) {}
 
-  virtual void init(const SharedRefPtr<Host>& connected_host,
-                    const cass::HostMap& hosts, Random* random);
+  virtual void init(const SharedRefPtr<Host>& connected_host, const HostMap& hosts, Random* random);
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   virtual LoadBalancingPolicy* new_instance() {
@@ -47,9 +45,9 @@ class HostTargetingPolicy : public ChainedLoadBalancingPolicy {
   class HostTargetingQueryPlan : public QueryPlan {
   public:
     HostTargetingQueryPlan(const Host::Ptr& preferred_host, QueryPlan* child_plan)
-      : first_(true)
-      , preferred_host_(preferred_host)
-      , child_plan_(child_plan) { }
+        : first_(true)
+        , preferred_host_(preferred_host)
+        , child_plan_(child_plan) {}
 
     virtual SharedRefPtr<Host> compute_next();
 
@@ -70,6 +68,6 @@ class HostTargetingPolicy : public ChainedLoadBalancingPolicy {
   HostMap hosts_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/iterator.cpp b/src/iterator.cpp
index 5ccfcbb5c..eed0d853d 100644
--- a/src/iterator.cpp
+++ b/src/iterator.cpp
@@ -23,65 +23,61 @@
 #include "row_iterator.hpp"
 #include "user_type_field_iterator.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-void cass_iterator_free(CassIterator* iterator) {
-  delete iterator->from();
-}
+void cass_iterator_free(CassIterator* iterator) { delete iterator->from(); }
 
 cass_bool_t cass_iterator_next(CassIterator* iterator) {
   return static_cast<cass_bool_t>(iterator->from()->next());
 }
 
-CassIteratorType cass_iterator_type(CassIterator* iterator) {
-  return iterator->type();
-}
+CassIteratorType cass_iterator_type(CassIterator* iterator) { return iterator->type(); }
 
 CassIterator* cass_iterator_from_result(const CassResult* result) {
-  return CassIterator::to(new cass::ResultIterator(result));
+  return CassIterator::to(new ResultIterator(result));
 }
 
 CassIterator* cass_iterator_from_row(const CassRow* row) {
-  return CassIterator::to(new cass::RowIterator(row));
+  return CassIterator::to(new RowIterator(row));
 }
 
 CassIterator* cass_iterator_from_collection(const CassValue* value) {
   if (value->is_null() || !value->is_collection()) {
     return NULL;
   }
-  return CassIterator::to(new cass::CollectionIterator(value));
+  return CassIterator::to(new CollectionIterator(value));
 }
 
 CassIterator* cass_iterator_from_tuple(const CassValue* value) {
   if (value->is_null() || !value->is_tuple()) {
     return NULL;
   }
-  return CassIterator::to(new cass::TupleIterator(value));
+  return CassIterator::to(new TupleIterator(value));
 }
 
 CassIterator* cass_iterator_from_map(const CassValue* value) {
   if (value->is_null() || !value->is_map()) {
     return NULL;
   }
-  return CassIterator::to(new cass::MapIterator(value));
+  return CassIterator::to(new MapIterator(value));
 }
 
 CassIterator* cass_iterator_fields_from_user_type(const CassValue* value) {
   if (value->is_null() || !value->is_user_type()) {
     return NULL;
   }
-  return CassIterator::to(new cass::UserTypeFieldIterator(value));
+  return CassIterator::to(new UserTypeFieldIterator(value));
 }
 
-CassError cass_iterator_get_user_type_field_name(const CassIterator* iterator,
-                                                 const char** name,
+CassError cass_iterator_get_user_type_field_name(const CassIterator* iterator, const char** name,
                                                  size_t* name_length) {
   if (iterator->type() != CASS_ITERATOR_TYPE_USER_TYPE_FIELD) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  cass::StringRef field_name
-      = static_cast<const cass::UserTypeFieldIterator*>(
-          iterator->from())->field_name();
+  StringRef field_name = static_cast<const UserTypeFieldIterator*>(iterator->from())->field_name();
   *name = field_name.data();
   *name_length = field_name.size();
   return CASS_OK;
@@ -91,27 +87,21 @@ const CassValue* cass_iterator_get_user_type_field_value(const CassIterator* ite
   if (iterator->type() != CASS_ITERATOR_TYPE_USER_TYPE_FIELD) {
     return NULL;
   }
-  return CassValue::to(
-        static_cast<const cass::UserTypeFieldIterator*>(
-          iterator->from())->field_value());
+  return CassValue::to(static_cast<const UserTypeFieldIterator*>(iterator->from())->field_value());
 }
 
 const CassRow* cass_iterator_get_row(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_RESULT) {
     return NULL;
   }
-  return CassRow::to(
-        static_cast<const cass::ResultIterator*>(
-                       iterator->from())->row());
+  return CassRow::to(static_cast<const ResultIterator*>(iterator->from())->row());
 }
 
 const CassValue* cass_iterator_get_column(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_ROW) {
     return NULL;
   }
-  return CassValue::to(
-        static_cast<const cass::RowIterator*>(
-          iterator->from())->column());
+  return CassValue::to(static_cast<const RowIterator*>(iterator->from())->column());
 }
 
 const CassValue* cass_iterator_get_value(const CassIterator* iterator) {
@@ -119,27 +109,21 @@ const CassValue* cass_iterator_get_value(const CassIterator* iterator) {
       iterator->type() != CASS_ITERATOR_TYPE_TUPLE) {
     return NULL;
   }
-  return CassValue::to(
-        static_cast<const cass::ValueIterator*>(
-          iterator->from())->value());
+  return CassValue::to(static_cast<const ValueIterator*>(iterator->from())->value());
 }
 
 const CassValue* cass_iterator_get_map_key(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_MAP) {
     return NULL;
   }
-  return CassValue::to(
-        static_cast<const cass::MapIterator*>(
-          iterator->from())->key());
+  return CassValue::to(static_cast<const MapIterator*>(iterator->from())->key());
 }
 
 const CassValue* cass_iterator_get_map_value(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_MAP) {
     return NULL;
   }
-  return CassValue::to(
-        static_cast<const cass::MapIterator*>(
-          iterator->from())->value());
+  return CassValue::to(static_cast<const MapIterator*>(iterator->from())->value());
 }
 
 } // extern "C"
diff --git a/src/iterator.hpp b/src/iterator.hpp
index f46731702..8af2e098c 100644
--- a/src/iterator.hpp
+++ b/src/iterator.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ITERATOR_HPP_INCLUDED__
-#define __CASS_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ITERATOR_HPP
+#define DATASTAX_INTERNAL_ITERATOR_HPP
 
 #include "allocated.hpp"
 #include "cassandra.h"
 #include "external.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Iterator : public Allocated {
 public:
@@ -38,8 +38,8 @@ class Iterator : public Allocated {
   const CassIteratorType type_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Iterator, CassIterator)
+EXTERNAL_TYPE(datastax::internal::core::Iterator, CassIterator)
 
 #endif
diff --git a/src/json.hpp b/src/json.hpp
index 67dbd252e..665cdf583 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -14,13 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_JSON_HPP_INCLUDED__
-#define __CASS_JSON_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_JSON_HPP
+#define DATASTAX_INTERNAL_JSON_HPP
 
 #include "memory.hpp"
 
-namespace cass {
-namespace json {
+namespace datastax { namespace internal { namespace json {
 
 template <class T>
 static T* new_() {
@@ -37,58 +36,67 @@ static void delete_(T* ptr) {
   Memory::free(ptr);
 }
 
-} } // namespace cass::json
+}}} // namespace datastax::internal::json
 
-#define RAPIDJSON_NAMESPACE cass::rapidjson
-#define RAPIDJSON_NAMESPACE_BEGIN namespace cass { namespace rapidjson {
-#define RAPIDJSON_NAMESPACE_END } }
-#define RAPIDJSON_NEW(x) cass::json::new_<x>
-#define RAPIDJSON_DELETE(x) cass::json::delete_(x)
+#define RAPIDJSON_NAMESPACE datastax::rapidjson
+#define RAPIDJSON_NAMESPACE_BEGIN \
+  namespace datastax {            \
+  namespace rapidjson {
+#define RAPIDJSON_NAMESPACE_END \
+  }                             \
+  }
+#define RAPIDJSON_NEW(x) ::datastax::internal::json::new_<x>
+#define RAPIDJSON_DELETE(x) ::datastax::internal::json::delete_(x)
 
 #include "third_party/rapidjson/rapidjson/document.h"
 #include "third_party/rapidjson/rapidjson/stringbuffer.h"
 #ifndef JSON_DEBUG
-# include "third_party/rapidjson/rapidjson/writer.h"
-# define JSON_WRITE_TYPE Writer
+#include "third_party/rapidjson/rapidjson/writer.h"
+#define JSON_WRITE_TYPE Writer
 #else
-# include "third_party/rapidjson/rapidjson/prettywriter.h"
-# define JSON_WRITE_TYPE PrettyWriter
+#include "third_party/rapidjson/rapidjson/prettywriter.h"
+#define JSON_WRITE_TYPE PrettyWriter
 #endif
 
-namespace cass {
-namespace json {
+namespace datastax { namespace internal { namespace json {
 
 class Allocator {
 public:
-    static const bool kNeedFree = true;
-    void* Malloc(size_t size) {
-      return Memory::malloc(size);
-    }
-    void* Realloc(void* ptr, size_t original_size, size_t new_size) {
-      (void)original_size;
-      return Memory::realloc(ptr, new_size);
-    }
-    static void Free(void *ptr) {
-      Memory::free(ptr);
-    }
+  static const bool kNeedFree = true;
+  void* Malloc(size_t size) { return Memory::malloc(size); }
+  void* Realloc(void* ptr, size_t original_size, size_t new_size) {
+    (void)original_size;
+    return Memory::realloc(ptr, new_size);
+  }
+  static void Free(void* ptr) { Memory::free(ptr); }
 };
 
-typedef cass::rapidjson::GenericDocument<cass::rapidjson::UTF8<>, cass::rapidjson::MemoryPoolAllocator<json::Allocator>, json::Allocator> Document;
-typedef cass::rapidjson::GenericValue<cass::rapidjson::UTF8<>, cass::rapidjson::MemoryPoolAllocator<json::Allocator> > Value;
-typedef cass::rapidjson::GenericStringBuffer<cass::rapidjson::UTF8<>, json::Allocator> StringBuffer;
+typedef datastax::rapidjson::UTF8<> UTF8;
+typedef datastax::rapidjson::MemoryPoolAllocator<json::Allocator> MemoryPoolAllocator;
 
-template<typename OutputStream, typename SourceEncoding = cass::rapidjson::UTF8<>, typename TargetEncoding = cass::rapidjson::UTF8<>, typename StackAllocator = json::Allocator, unsigned writeFlags = cass::rapidjson::kWriteDefaultFlags>
-class Writer : public cass::rapidjson::JSON_WRITE_TYPE<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
+typedef datastax::rapidjson::GenericDocument<UTF8, MemoryPoolAllocator, json::Allocator> Document;
+typedef datastax::rapidjson::GenericValue<UTF8, MemoryPoolAllocator> Value;
+typedef datastax::rapidjson::GenericStringBuffer<UTF8, json::Allocator> StringBuffer;
+
+template <typename OutputStream, typename SourceEncoding = UTF8, typename TargetEncoding = UTF8,
+          typename StackAllocator = json::Allocator,
+          unsigned writeFlags = datastax::rapidjson::kWriteDefaultFlags>
+class Writer
+    : public datastax::rapidjson::JSON_WRITE_TYPE<OutputStream, SourceEncoding, TargetEncoding,
+                                                  StackAllocator, writeFlags> {
 public:
-    typedef cass::rapidjson::JSON_WRITE_TYPE<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Type;
+  typedef datastax::rapidjson::JSON_WRITE_TYPE<OutputStream, SourceEncoding, TargetEncoding,
+                                               StackAllocator, writeFlags>
+      Type;
 
-    explicit Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = Type::kDefaultLevelDepth) :
-        Type(os, stackAllocator, levelDepth) { }
+  explicit Writer(OutputStream& os, StackAllocator* stackAllocator = 0,
+                  size_t levelDepth = Type::kDefaultLevelDepth)
+      : Type(os, stackAllocator, levelDepth) {}
 
-    explicit Writer(StackAllocator* allocator = 0, size_t levelDepth = Type::kDefaultLevelDepth) :
-        Type(allocator, levelDepth) { }
+  explicit Writer(StackAllocator* allocator = 0, size_t levelDepth = Type::kDefaultLevelDepth)
+      : Type(allocator, levelDepth) {}
 };
 
-} } // namespace cass::json
+}}} // namespace datastax::internal::json
 
-#endif // __CASS_JSON_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_JSON_HPP
diff --git a/src/latency_aware_policy.cpp b/src/latency_aware_policy.cpp
index 0ea1bdff4..3db811a14 100644
--- a/src/latency_aware_policy.cpp
+++ b/src/latency_aware_policy.cpp
@@ -22,35 +22,29 @@
 #include <algorithm>
 #include <iterator>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-void LatencyAwarePolicy::init(const Host::Ptr& connected_host,
-                              const HostMap& hosts,
+void LatencyAwarePolicy::init(const Host::Ptr& connected_host, const HostMap& hosts,
                               Random* random) {
   hosts_->reserve(hosts.size());
   std::transform(hosts.begin(), hosts.end(), std::back_inserter(*hosts_), GetHost());
-  for (HostMap::const_iterator i = hosts.begin(),
-       end = hosts.end(); i != end; ++i) {
+  for (HostMap::const_iterator i = hosts.begin(), end = hosts.end(); i != end; ++i) {
     i->second->enable_latency_tracking(settings_.scale_ns, settings_.min_measured);
   }
   ChainedLoadBalancingPolicy::init(connected_host, hosts, random);
 }
 
-void LatencyAwarePolicy::register_handles(uv_loop_t* loop) {
-  start_timer(loop);
-}
+void LatencyAwarePolicy::register_handles(uv_loop_t* loop) { start_timer(loop); }
 
-void LatencyAwarePolicy::close_handles() {
-  timer_.stop();
-}
+void LatencyAwarePolicy::close_handles() { timer_.stop(); }
 
 QueryPlan* LatencyAwarePolicy::new_query_plan(const String& keyspace,
                                               RequestHandler* request_handler,
                                               const TokenMap* token_map) {
-  return new LatencyAwareQueryPlan(this,
-                                   child_policy_->new_query_plan(keyspace,
-                                                                 request_handler,
-                                                                 token_map));
+  return new LatencyAwareQueryPlan(
+      this, child_policy_->new_query_plan(keyspace, request_handler, token_map));
 }
 
 void LatencyAwarePolicy::on_host_added(const Host::Ptr& host) {
@@ -65,8 +59,7 @@ void LatencyAwarePolicy::on_host_removed(const Host::Ptr& host) {
 }
 
 void LatencyAwarePolicy::start_timer(uv_loop_t* loop) {
-  timer_.start(loop, settings_.update_rate_ms,
-               bind_callback(&LatencyAwarePolicy::on_timer, this));
+  timer_.start(loop, settings_.update_rate_ms, bind_callback(&LatencyAwarePolicy::on_timer, this));
 }
 
 void LatencyAwarePolicy::on_timer(Timer* timer) {
@@ -75,12 +68,10 @@ void LatencyAwarePolicy::on_timer(Timer* timer) {
   int64_t new_min_average = CASS_INT64_MAX;
   int64_t now = uv_hrtime();
 
-  for (HostVec::const_iterator i = hosts->begin(),
-       end = hosts->end(); i != end; ++i) {
+  for (HostVec::const_iterator i = hosts->begin(), end = hosts->end(); i != end; ++i) {
     TimestampedAverage latency = (*i)->get_current_average();
-    if (latency.average >= 0
-        && latency.num_measured >= settings_.min_measured
-        && (now - latency.timestamp) <= settings_.retry_period_ns) {
+    if (latency.average >= 0 && latency.num_measured >= settings_.min_measured &&
+        (now - latency.timestamp) <= settings_.retry_period_ns) {
       new_min_average = std::min(new_min_average, latency.average);
     }
   }
@@ -102,9 +93,7 @@ Host::Ptr LatencyAwarePolicy::LatencyAwareQueryPlan::compute_next() {
   while ((host = child_plan_->compute_next())) {
     TimestampedAverage latency = host->get_current_average();
 
-    if (min < 0 ||
-        latency.average < 0 ||
-        latency.num_measured < settings.min_measured ||
+    if (min < 0 || latency.average < 0 || latency.num_measured < settings.min_measured ||
         (now - latency.timestamp) > settings.retry_period_ns) {
       return host;
     }
@@ -122,5 +111,3 @@ Host::Ptr LatencyAwarePolicy::LatencyAwareQueryPlan::compute_next() {
 
   return Host::Ptr();
 }
-
-} // namespace cass
diff --git a/src/latency_aware_policy.hpp b/src/latency_aware_policy.hpp
index 39e5474e3..3506d8bf2 100644
--- a/src/latency_aware_policy.hpp
+++ b/src/latency_aware_policy.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LATENCY_AWARE_POLICY_HPP_INCLUDED__
-#define __CASS_LATENCY_AWARE_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LATENCY_AWARE_POLICY_HPP
+#define DATASTAX_INTERNAL_LATENCY_AWARE_POLICY_HPP
 
 #include "atomic.hpp"
 #include "load_balancing.hpp"
@@ -23,17 +23,17 @@
 #include "scoped_ptr.hpp"
 #include "timer.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
 public:
   struct Settings {
     Settings()
-      : exclusion_threshold(2.0)
-      , scale_ns(100LL * 1000LL * 1000LL)
-      , retry_period_ns(10LL * 1000LL * 1000LL * 1000LL)
-      , update_rate_ms(100LL)
-      , min_measured(50LL) {}
+        : exclusion_threshold(2.0)
+        , scale_ns(100LL * 1000LL * 1000LL)
+        , retry_period_ns(10LL * 1000LL * 1000LL * 1000LL)
+        , update_rate_ms(100LL)
+        , min_measured(50LL) {}
 
     double exclusion_threshold;
     uint64_t scale_ns;
@@ -43,10 +43,10 @@ class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
   };
 
   LatencyAwarePolicy(LoadBalancingPolicy* child_policy, const Settings& settings)
-    : ChainedLoadBalancingPolicy(child_policy)
-    , min_average_(-1)
-    , settings_(settings)
-    , hosts_(new HostVec()) {}
+      : ChainedLoadBalancingPolicy(child_policy)
+      , min_average_(-1)
+      , settings_(settings)
+      , hosts_(new HostVec()) {}
 
   virtual ~LatencyAwarePolicy() {}
 
@@ -55,8 +55,7 @@ class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
   virtual void register_handles(uv_loop_t* loop);
   virtual void close_handles();
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   virtual LoadBalancingPolicy* new_instance() {
@@ -68,9 +67,7 @@ class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
 
 public:
   // Testing only
-  int64_t min_average() const {
-    return min_average_.load();
-  }
+  int64_t min_average() const { return min_average_.load(); }
 
 private:
   void start_timer(uv_loop_t* loop);
@@ -79,9 +76,9 @@ class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
   class LatencyAwareQueryPlan : public QueryPlan {
   public:
     LatencyAwareQueryPlan(LatencyAwarePolicy* policy, QueryPlan* child_plan)
-      : policy_(policy)
-      , child_plan_(child_plan)
-      , skipped_index_(0) {}
+        : policy_(policy)
+        , child_plan_(child_plan)
+        , skipped_index_(0) {}
 
     Host::Ptr compute_next();
 
@@ -104,6 +101,6 @@ class LatencyAwarePolicy : public ChainedLoadBalancingPolicy {
   DISALLOW_COPY_AND_ASSIGN(LatencyAwarePolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/list.hpp b/src/list.hpp
index 77c1b8481..29f0540d9 100644
--- a/src/list.hpp
+++ b/src/list.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LIST_HPP_INCLUDED__
-#define __CASS_LIST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LIST_HPP
+#define DATASTAX_INTERNAL_LIST_HPP
 
 #include "macros.hpp"
 
 #include <stddef.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 class List {
@@ -82,8 +82,7 @@ class List {
 
   T* pop_front() {
     T* first = front();
-    if (first != NULL)
-      remove(first);
+    if (first != NULL) remove(first);
     return first;
   }
 
@@ -139,6 +138,6 @@ void List<T>::insert_before(Node* pos, Node* node) {
   pos->prev_ = node;
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/list_policy.cpp b/src/list_policy.cpp
index d86efa07a..85335b20f 100644
--- a/src/list_policy.cpp
+++ b/src/list_policy.cpp
@@ -18,14 +18,13 @@
 
 #include "logger.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-void ListPolicy::init(const Host::Ptr& connected_host,
-                      const HostMap& hosts,
-                      Random* random) {
+void ListPolicy::init(const Host::Ptr& connected_host, const HostMap& hosts, Random* random) {
   HostMap valid_hosts;
-  for (HostMap::const_iterator i = hosts.begin(),
-    end = hosts.end(); i != end; ++i) {
+  for (HostMap::const_iterator i = hosts.begin(), end = hosts.end(); i != end; ++i) {
     const Host::Ptr& host = i->second;
     if (is_valid_host(host)) {
       valid_hosts.insert(HostPair(i->first, host));
@@ -46,12 +45,9 @@ CassHostDistance ListPolicy::distance(const Host::Ptr& host) const {
   return CASS_HOST_DISTANCE_IGNORE;
 }
 
-QueryPlan* ListPolicy::new_query_plan(const String& keyspace,
-                                      RequestHandler* request_handler,
+QueryPlan* ListPolicy::new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                       const TokenMap* token_map) {
-  return child_policy_->new_query_plan(keyspace,
-                                       request_handler,
-                                       token_map);
+  return child_policy_->new_query_plan(keyspace, request_handler, token_map);
 }
 
 void ListPolicy::on_host_added(const Host::Ptr& host) {
@@ -65,5 +61,3 @@ void ListPolicy::on_host_removed(const Host::Ptr& host) {
     child_policy_->on_host_removed(host);
   }
 }
-
-} // namespace cass
diff --git a/src/list_policy.hpp b/src/list_policy.hpp
index 637d52093..72de4d972 100644
--- a/src/list_policy.hpp
+++ b/src/list_policy.hpp
@@ -14,19 +14,19 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LIST_POLICY_HPP_INCLUDED__
-#define __CASS_LIST_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LIST_POLICY_HPP
+#define DATASTAX_INTERNAL_LIST_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
+#include "load_balancing.hpp"
 #include "scoped_ptr.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ListPolicy : public ChainedLoadBalancingPolicy {
 public:
   ListPolicy(LoadBalancingPolicy* child_policy)
-    : ChainedLoadBalancingPolicy(child_policy) {}
+      : ChainedLoadBalancingPolicy(child_policy) {}
 
   virtual ~ListPolicy() {}
 
@@ -34,8 +34,7 @@ class ListPolicy : public ChainedLoadBalancingPolicy {
 
   virtual CassHostDistance distance(const Host::Ptr& host) const;
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   virtual void on_host_added(const Host::Ptr& host);
@@ -45,10 +44,8 @@ class ListPolicy : public ChainedLoadBalancingPolicy {
 
 private:
   virtual bool is_valid_host(const Host::Ptr& host) const = 0;
-
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
-
diff --git a/src/load_balancing.hpp b/src/load_balancing.hpp
index db7c8085d..38e1c8faa 100644
--- a/src/load_balancing.hpp
+++ b/src/load_balancing.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LOAD_BALANCING_HPP_INCLUDED__
-#define __CASS_LOAD_BALANCING_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LOAD_BALANCING_HPP
+#define DATASTAX_INTERNAL_LOAD_BALANCING_HPP
 
 #include "allocated.hpp"
 #include "cassandra.h"
@@ -48,9 +48,12 @@ typedef enum CassHostDistance_ {
 
 } // extern "C"
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Random;
+
+namespace core {
+
 class RequestHandler;
 class TokenMap;
 
@@ -73,14 +76,13 @@ class QueryPlan : public Allocated {
   }
 };
 
-class LoadBalancingPolicy
-    : public RefCounted<LoadBalancingPolicy> {
+class LoadBalancingPolicy : public RefCounted<LoadBalancingPolicy> {
 public:
   typedef SharedRefPtr<LoadBalancingPolicy> Ptr;
   typedef Vector<Ptr> Vec;
 
   LoadBalancingPolicy()
-    : RefCounted<LoadBalancingPolicy>() {}
+      : RefCounted<LoadBalancingPolicy>() {}
 
   virtual ~LoadBalancingPolicy() {}
 
@@ -97,17 +99,15 @@ class LoadBalancingPolicy
   virtual void on_host_up(const Host::Ptr& host) = 0;
   virtual void on_host_down(const Address& address) = 0;
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map) = 0;
 
   virtual LoadBalancingPolicy* new_instance() = 0;
 };
 
-inline bool is_host_ignored(const LoadBalancingPolicy::Vec& policies,
-                            const Host::Ptr& host) {
-  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(),
-       end = policies.end(); it != end; ++it) {
+inline bool is_host_ignored(const LoadBalancingPolicy::Vec& policies, const Host::Ptr& host) {
+  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(), end = policies.end();
+       it != end; ++it) {
     if ((*it)->distance(host) != CASS_HOST_DISTANCE_IGNORE) {
       return false;
     }
@@ -118,7 +118,7 @@ inline bool is_host_ignored(const LoadBalancingPolicy::Vec& policies,
 class ChainedLoadBalancingPolicy : public LoadBalancingPolicy {
 public:
   ChainedLoadBalancingPolicy(LoadBalancingPolicy* child_policy)
-    : child_policy_(child_policy) {}
+      : child_policy_(child_policy) {}
 
   virtual ~ChainedLoadBalancingPolicy() {}
 
@@ -126,9 +126,7 @@ class ChainedLoadBalancingPolicy : public LoadBalancingPolicy {
     return child_policy_->init(connected_host, hosts, random);
   }
 
-  virtual const LoadBalancingPolicy::Ptr& child_policy() const {
-    return child_policy_;
-  }
+  virtual const LoadBalancingPolicy::Ptr& child_policy() const { return child_policy_; }
 
   virtual CassHostDistance distance(const Host::Ptr& host) const {
     return child_policy_->distance(host);
@@ -147,7 +145,7 @@ class ChainedLoadBalancingPolicy : public LoadBalancingPolicy {
   LoadBalancingPolicy::Ptr child_policy_;
 };
 
-} // namespace cass
+} // namespace core
+}} // namespace datastax::internal
 
 #endif
-
diff --git a/src/logger.cpp b/src/logger.cpp
index 7f7cdda49..0861eb21e 100644
--- a/src/logger.cpp
+++ b/src/logger.cpp
@@ -16,19 +16,18 @@
 
 #include "logger.hpp"
 
+using namespace datastax::internal;
+
 extern "C" {
 
 void cass_log_cleanup() {
   // Deprecated
 }
 
-void cass_log_set_level(CassLogLevel log_level) {
-  cass::Logger::set_log_level(log_level);
-}
+void cass_log_set_level(CassLogLevel log_level) { Logger::set_log_level(log_level); }
 
-void cass_log_set_callback(CassLogCallback callback,
-                           void* data) {
-  cass::Logger::set_callback(callback, data);
+void cass_log_set_callback(CassLogCallback callback, void* data) {
+  Logger::set_callback(callback, data);
 }
 
 void cass_log_set_queue_size(size_t queue_size) {
@@ -37,42 +36,33 @@ void cass_log_set_queue_size(size_t queue_size) {
 
 } // extern "C"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 void stderr_log_callback(const CassLogMessage* message, void* data) {
-  fprintf(stderr, "%u.%03u [%s] (%s:%d:%s): %s\n",
-          static_cast<unsigned int>(message->time_ms / 1000),
-          static_cast<unsigned int>(message->time_ms % 1000),
-          cass_log_level_string(message->severity),
-          message->file, message->line, message->function,
-          message->message);
+  fprintf(
+      stderr, "%u.%03u [%s] (%s:%d:%s): %s\n", static_cast<unsigned int>(message->time_ms / 1000),
+      static_cast<unsigned int>(message->time_ms % 1000), cass_log_level_string(message->severity),
+      message->file, message->line, message->function, message->message);
 }
 
-void noop_log_callback(const CassLogMessage* message, void* data) { }
+}}} // namespace datastax::internal::core
+
+void noop_log_callback(const CassLogMessage* message, void* data) {}
 
 CassLogLevel Logger::log_level_ = CASS_LOG_WARN;
-CassLogCallback Logger::cb_ = stderr_log_callback;
+CassLogCallback Logger::cb_ = core::stderr_log_callback;
 void* Logger::data_ = NULL;
 
-void Logger::internal_log(CassLogLevel severity,
-                          const char* file, int line, const char* function,
+void Logger::internal_log(CassLogLevel severity, const char* file, int line, const char* function,
                           const char* format, va_list args) {
-  CassLogMessage message = {
-    get_time_since_epoch_ms(), severity,
-    file, line, function,
-    ""
-  };
+  CassLogMessage message = { get_time_since_epoch_ms(), severity, file, line, function, "" };
   vsnprintf(message.message, sizeof(message.message), format, args);
   Logger::cb_(&message, Logger::data_);
 }
 
-void Logger::set_log_level(CassLogLevel log_level) {
-  log_level_ = log_level;
-}
+void Logger::set_log_level(CassLogLevel log_level) { log_level_ = log_level; }
 
 void Logger::set_callback(CassLogCallback cb, void* data) {
   cb_ = cb == NULL ? noop_log_callback : cb;
   data_ = data;
 }
-
-} // namespace cass
diff --git a/src/logger.hpp b/src/logger.hpp
index 0f55a0638..8b64bf68f 100644
--- a/src/logger.hpp
+++ b/src/logger.hpp
@@ -14,17 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LOGGER_HPP_INCLUDED__
-#define __CASS_LOGGER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LOGGER_HPP
+#define DATASTAX_INTERNAL_LOGGER_HPP
 
 #include "cassandra.h"
 #include "get_time.hpp"
 #include "string.hpp"
 
+#include <cstring>
 #include <stdarg.h>
 #include <stdio.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Logger {
 public:
@@ -34,15 +35,14 @@ class Logger {
 #if defined(__GNUC__) || defined(__clang__)
 #define ATTR_FORMAT(string, first) __attribute__((__format__(__printf__, string, first)))
 #else
-#define ATTR_FORMAT(string , first)
+#define ATTR_FORMAT(string, first)
 #endif
 
   static CassLogLevel log_level() { return log_level_; }
 
   ATTR_FORMAT(5, 6)
-  static void log(CassLogLevel severity,
-                   const char* file, int line, const char* function,
-                   const char* format, ...) {
+  static void log(CassLogLevel severity, const char* file, int line, const char* function,
+                  const char* format, ...) {
     va_list args;
     va_start(args, format);
     internal_log(severity, file, line, function, format, args);
@@ -51,8 +51,7 @@ class Logger {
 
 private:
   ATTR_FORMAT(5, 0)
-  static void internal_log(CassLogLevel severity,
-                           const char* file, int line, const char* function,
+  static void internal_log(CassLogLevel severity, const char* file, int line, const char* function,
                            const char* format, va_list args);
 
 private:
@@ -63,7 +62,7 @@ class Logger {
   Logger(); // Keep this object from being created
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 // These macros allow the LOG_<level>() methods to accept one or more
 // arguments (including the format string). This needs to be extended
@@ -77,38 +76,44 @@ class Logger {
 #define LOG_REST_HELPER2_(num, ...) LOG_REST_HELPER_##num##_(__VA_ARGS__)
 #define LOG_REST_HELPER_ONE_(first)
 #define LOG_REST_HELPER_TWOORMORE_(first, ...) , __VA_ARGS__
-#define LOG_SELECT_20TH_(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, \
-  a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, ...) a20
-#define LOG_NUM_ARGS_(...) LOG_SELECT_20TH_(__VA_ARGS__, \
-  TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,            \
-  TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,            \
-  TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,            \
-  TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,            \
-  TWOORMORE, TWOORMORE, ONE, throwaway)
-
-// Using __FILE__ returns the whole absolute path of the file, this
-// allows something more concise to be used via -DLOG_FILE_=<path>
-#ifndef LOG_FILE_
-#define LOG_FILE_ __FILE__
+#define LOG_SELECT_20TH_(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, \
+                         a17, a18, a19, a20, ...)                                               \
+  a20
+#define LOG_NUM_ARGS_(...)                                                                        \
+  LOG_SELECT_20TH_(__VA_ARGS__, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, \
+                   TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,   \
+                   TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
+
+#ifdef WIN32
+#define LOG_FILE_SEPARATOR_STR_ "\\"
+#define LOG_FILE_SEPARATOR_CHAR_ '\\'
+#else
+#define LOG_FILE_SEPARATOR_STR_ "/"
+#define LOG_FILE_SEPARATOR_CHAR_ '/'
 #endif
 
+// Compiles away on most compilers (not MSVC, but it's still fast). This adds the seperator to the
+// front to guarantee a match is found, but it's then removed by moving the pointer to the next
+// position.
+#define LOG_FILE_ (strrchr(LOG_FILE_SEPARATOR_STR_ __FILE__, LOG_FILE_SEPARATOR_CHAR_) + 1)
+
 #if defined(_MSC_VER)
-#  define LOG_FUNCTION_ __FUNCSIG__
+#define LOG_FUNCTION_ __FUNCSIG__
 #elif defined(__clang__) || defined(__GNUC__) || defined(__INTEL_COMPILER)
-#  define LOG_FUNCTION_ __PRETTY_FUNCTION__
+#define LOG_FUNCTION_ __PRETTY_FUNCTION__
 #elif defined(__func__)
-#  define LOG_FUNCTION_ __func__
+#define LOG_FUNCTION_ __func__
 #else
-#  define LOG_FUNCTION_ ""
+#define LOG_FUNCTION_ ""
 #endif
 
-#define LOG_CHECK_LEVEL(severity, ...) do {                            \
-  if (severity <= cass::Logger::log_level()) {                         \
-    cass::Logger::log(severity,                                        \
-                      LOG_FILE_, __LINE__, LOG_FUNCTION_,              \
-                      LOG_FIRST_(__VA_ARGS__) LOG_REST_(__VA_ARGS__)); \
-  }                                                                    \
-} while(0)
+#define LOG_CHECK_LEVEL(severity, ...)                                                   \
+  do {                                                                                   \
+    if (severity <= ::datastax::internal::Logger::log_level()) {                         \
+      ::datastax::internal::Logger::log(severity, LOG_FILE_, __LINE__, LOG_FUNCTION_,    \
+                                        LOG_FIRST_(__VA_ARGS__) LOG_REST_(__VA_ARGS__)); \
+    }                                                                                    \
+  } while (0)
 
 #define LOG_CRITICAL(...) LOG_CHECK_LEVEL(CASS_LOG_CRITICAL, __VA_ARGS__)
 #define LOG_ERROR(...) LOG_CHECK_LEVEL(CASS_LOG_ERROR, __VA_ARGS__)
diff --git a/src/loop_watcher.hpp b/src/loop_watcher.hpp
index 16c1242bf..fb824f34c 100644
--- a/src/loop_watcher.hpp
+++ b/src/loop_watcher.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_LOOP_WATCHER_HPP_INCLUDED__
-#define __CASS_LOOP_WATCHER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_LOOP_WATCHER_HPP
+#define DATASTAX_INTERNAL_LOOP_WATCHER_HPP
 
 #include "allocated.hpp"
 #include "callback.hpp"
@@ -23,21 +23,19 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
-template<class Type, class HType>
+template <class Type, class HType>
 class LoopWatcher {
 public:
-  typedef cass::Callback<void, Type*> Callback;
+  typedef internal::Callback<void, Type*> Callback;
   typedef HType HandleType;
 
   LoopWatcher()
-    : handle_(NULL)
-    , state_(CLOSED) { }
+      : handle_(NULL)
+      , state_(CLOSED) {}
 
-  ~LoopWatcher() {
-    close_handle();
-  }
+  ~LoopWatcher() { close_handle(); }
 
   /**
    * Start the handle.
@@ -93,7 +91,7 @@ class LoopWatcher {
 
 public:
   bool is_running() const { return state_ == STARTED; }
-  uv_loop_t* loop() {  return handle_ ? handle_->loop : NULL;  }
+  uv_loop_t* loop() { return handle_ ? handle_->loop : NULL; }
 
 private:
   static void on_run(HandleType* handle) {
@@ -106,11 +104,7 @@ class LoopWatcher {
   }
 
 private:
-  enum State {
-    CLOSED,
-    STOPPED,
-    STARTED
-  };
+  enum State { CLOSED, STOPPED, STARTED };
 
 private:
   AllocatedT<HandleType>* handle_;
@@ -138,9 +132,7 @@ class Prepare : public LoopWatcher<Prepare, uv_prepare_t> {
     return uv_prepare_start(handle, callback);
   }
 
-  static void stop_handle(HandleType* handle) {
-    uv_prepare_stop(handle);
-  }
+  static void stop_handle(HandleType* handle) { uv_prepare_stop(handle); }
 };
 
 /**
@@ -160,11 +152,9 @@ class Check : public LoopWatcher<Check, uv_check_t> {
     return uv_check_start(handle, callback);
   }
 
-  static void stop_handle(HandleType* handle) {
-    uv_check_stop(handle);
-  }
+  static void stop_handle(HandleType* handle) { uv_check_stop(handle); }
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/macros.hpp b/src/macros.hpp
index e2b7a6faa..4b7e7bee1 100644
--- a/src/macros.hpp
+++ b/src/macros.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_MACROS_HPP_INCLUDED__
-#define __CASS_MACROS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MACROS_HPP
+#define DATASTAX_INTERNAL_MACROS_HPP
 
 #include <stddef.h>
 
@@ -30,48 +30,50 @@
 #define ZERO_PARAMS1_()
 #define ZERO_PARAMS_() ZERO_PARAMS1_()
 
-#define ONE_PARAM1_(A) ,A
+#define ONE_PARAM1_(A) , A
 #define ONE_PARAM_(A) ONE_PARAM1_(A)
 
-#define TWO_PARAMS1_(A, B)  ,A,B
+#define TWO_PARAMS1_(A, B) , A, B
 #define TWO_PARAMS_(A, B) TWO_PARAMS1_(A, B)
 
-#define THREE_PARAMS1_(A, B, C)  ,A,B,C
+#define THREE_PARAMS1_(A, B, C) , A, B, C
 #define THREE_PARAMS_(A, B, C) THREE_PARAMS1_(A, B, C)
 
 // Done this way so that macros like __LINE__ will expand before
 // being concatenated.
-#define STATIC_ASSERT_CONCAT(Arg1, Arg2)  STATIC_ASSERT_CONCAT1(Arg1, Arg2)
+#define STATIC_ASSERT_CONCAT(Arg1, Arg2) STATIC_ASSERT_CONCAT1(Arg1, Arg2)
 #define STATIC_ASSERT_CONCAT1(Arg1, Arg2) STATIC_ASSERT_CONCAT2(Arg1, Arg2)
 #define STATIC_ASSERT_CONCAT2(Arg1, Arg2) Arg1##Arg2
 
-#define STATIC_ASSERT(Expression) \
-  struct STATIC_ASSERT_CONCAT(__static_assertion_at_line_, __LINE__) \
-  { \
-    StaticAssert<static_cast<bool>(Expression)> \
-      STATIC_ASSERT_CONCAT(STATIC_ASSERTION_FAILED_AT_LINE_, __LINE__); \
-  }; \
+#define STATIC_ASSERT(Expression)                                                               \
+  struct STATIC_ASSERT_CONCAT(__static_assertion_at_line_, __LINE__) {                          \
+    StaticAssert<static_cast<bool>(Expression)>                                                 \
+        STATIC_ASSERT_CONCAT(STATIC_ASSERTION_FAILED_AT_LINE_, __LINE__);                       \
+  };                                                                                            \
   typedef StaticAssertTest<sizeof(STATIC_ASSERT_CONCAT(__static_assertion_at_line_, __LINE__))> \
-    STATIC_ASSERT_CONCAT(__static_assertion_test_at_line_, __LINE__)
+      STATIC_ASSERT_CONCAT(__static_assertion_test_at_line_, __LINE__)
 
-template <bool> struct StaticAssert;
-template <> struct StaticAssert<true> { };
-template<size_t s> struct StaticAssertTest { };
+template <bool>
+struct StaticAssert;
+template <>
+struct StaticAssert<true> {};
+template <size_t s>
+struct StaticAssertTest {};
 
 #define STATIC_NEXT_POW_2(N) StaticNextPow2<N>::value
 
 template <size_t C, size_t N>
 struct StaticNextPow2Helper {
-  enum { 
+  enum {
     value = static_cast<size_t>(StaticNextPow2Helper<C - 1, N>::value) < N
-          ? static_cast<size_t>(1) << C
-          : static_cast<size_t>(StaticNextPow2Helper<C - 1, N>::value)
+                ? static_cast<size_t>(1) << C
+                : static_cast<size_t>(StaticNextPow2Helper<C - 1, N>::value)
   };
 };
 
 template <size_t N>
-struct StaticNextPow2Helper<1, N> { 
-  enum { value = 2 }; 
+struct StaticNextPow2Helper<1, N> {
+  enum { value = 2 };
 };
 
 template <size_t N>
diff --git a/src/map.hpp b/src/map.hpp
index 1bc285c4a..679cdfa5c 100644
--- a/src/map.hpp
+++ b/src/map.hpp
@@ -5,37 +5,35 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_MAP_HPP_INCLUDED__
-#define __DSE_MAP_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MAP_HPP
+#define DATASTAX_INTERNAL_MAP_HPP
 
 #include "allocated.hpp"
 #include "allocator.hpp"
 
 #include <map>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class K, class V, class Compare = std::less<K> >
-class Map :
-    public Allocated,
-    public std::map<K, V, Compare, cass::Allocator<std::pair<const K, V> > > {
+class Map
+    : public Allocated
+    , public std::map<K, V, Compare, internal::Allocator<std::pair<const K, V> > > {
 public:
-  typedef cass::Allocator<std::pair<const K, V> > Allocator;
+  typedef internal::Allocator<std::pair<const K, V> > Allocator;
 
-  explicit Map(const Compare& compare = Compare(),
-               const Allocator& alloc = Allocator())
-    : std::map<K, V, Compare, Allocator>(compare, alloc) { }
+  explicit Map(const Compare& compare = Compare(), const Allocator& alloc = Allocator())
+      : std::map<K, V, Compare, Allocator>(compare, alloc) {}
 
   Map(const Map& other)
-    : std::map<K, V, Compare, Allocator>(other) { }
+      : std::map<K, V, Compare, Allocator>(other) {}
 
-  template<class InputIt>
-  Map(InputIt first, InputIt last,
-      const Compare& compare = Compare(),
+  template <class InputIt>
+  Map(InputIt first, InputIt last, const Compare& compare = Compare(),
       const Allocator& alloc = Allocator())
-    : std::map<K, V, Compare, Allocator>(first, last, compare, alloc) { }
+      : std::map<K, V, Compare, Allocator>(first, last, compare, alloc) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/map_iterator.cpp b/src/map_iterator.cpp
index 9ec497e39..1b1b25973 100644
--- a/src/map_iterator.cpp
+++ b/src/map_iterator.cpp
@@ -16,7 +16,7 @@
 
 #include "map_iterator.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool MapIterator::decode_pair() {
   if (!decoder_.decode_value(map_->primary_data_type(), key_, true)) return false;
@@ -30,5 +30,3 @@ bool MapIterator::next() {
   ++index_;
   return decode_pair();
 }
-
-} // namespace cass
diff --git a/src/map_iterator.hpp b/src/map_iterator.hpp
index 91d96f7cf..cb66e96b1 100644
--- a/src/map_iterator.hpp
+++ b/src/map_iterator.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_MAP_ITERATOR_HPP_INCLUDED__
-#define __CASS_MAP_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MAP_ITERATOR_HPP
+#define DATASTAX_INTERNAL_MAP_ITERATOR_HPP
 
 #include "cassandra.h"
 #include "iterator.hpp"
 #include "serialization.hpp"
 #include "value.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class MapIterator : public Iterator {
 public:
@@ -57,6 +57,6 @@ class MapIterator : public Iterator {
   const int32_t count_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/md5.cpp b/src/md5.cpp
index 62761bd0a..207b3cfb2 100644
--- a/src/md5.cpp
+++ b/src/md5.cpp
@@ -28,15 +28,15 @@
 // F and G are optimized compared to their RFC 1321 definitions for
 // architectures that lack an AND-NOT instruction, just like in Colin Plumb's
 // implementation.
-#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
-#define H(x, y, z)			((x) ^ (y) ^ (z))
-#define I(x, y, z)			((y) ^ ((x) | ~(z)))
+#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
 
 // The MD5 transformation for all four rounds.
-#define STEP(f, a, b, c, d, x, t, s) \
-  (a) += f((b), (c), (d)) + (x) + (t); \
-  (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+#define STEP(f, a, b, c, d, x, t, s)                       \
+  (a) += f((b), (c), (d)) + (x) + (t);                     \
+  (a) = (((a) << (s)) | (((a)&0xffffffff) >> (32 - (s)))); \
   (a) += (b);
 
 // SET reads 4 input bytes in little-endian byte order and stores them
@@ -46,35 +46,31 @@
 // memory accesses is just an optimization.  Nothing will break if it
 // doesn't work.
 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
-#define SET(n) \
-  (*(MD5_u32plus *)&ptr[(n) * 4])
-#define GET(n) \
-  SET(n)
+#define SET(n) (*(MD5_u32plus*)&ptr[(n)*4])
+#define GET(n) SET(n)
 #else
-#define SET(n) \
-  (block_[(n)] = \
-  (MD5_u32plus)ptr[(n) * 4] | \
-  ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
-  ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
-  ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
-#define GET(n) \
-  (block_[(n)])
+#define SET(n)                                                                  \
+  (block_[(n)] = (MD5_u32plus)ptr[(n)*4] | ((MD5_u32plus)ptr[(n)*4 + 1] << 8) | \
+                 ((MD5_u32plus)ptr[(n)*4 + 2] << 16) | ((MD5_u32plus)ptr[(n)*4 + 3] << 24))
+#define GET(n) (block_[(n)])
 #endif
 
-namespace cass {
+using namespace datastax::internal;
 
 Md5::Md5()
-  : lo_(0), hi_(0)
-  , a_(0x67452301), b_(0xefcdab89)
-  , c_(0x98badcfe), d_(0x10325476) {}
+    : lo_(0)
+    , hi_(0)
+    , a_(0x67452301)
+    , b_(0xefcdab89)
+    , c_(0x98badcfe)
+    , d_(0x10325476) {}
 
 void Md5::update(const uint8_t* data, size_t size) {
   MD5_u32plus saved_lo;
   size_t used, free;
 
   saved_lo = lo_;
-  if ((lo_ = (saved_lo + size) & 0x1fffffff) < saved_lo)
-    hi_++;
+  if ((lo_ = (saved_lo + size) & 0x1fffffff) < saved_lo) hi_++;
   hi_ += size >> 29;
 
   used = saved_lo & 0x3f;
@@ -88,7 +84,7 @@ void Md5::update(const uint8_t* data, size_t size) {
     }
 
     memcpy(&buffer_[used], data, free);
-    data = (unsigned char *)data + free;
+    data = (unsigned char*)data + free;
     size -= free;
     body(buffer_, 64);
   }
@@ -131,16 +127,16 @@ void Md5::final(uint8_t* result) {
 
   body(buffer_, 64);
 
-  result[0]  = a_;
-  result[1]  = a_ >> 8;
-  result[2]  = a_ >> 16;
-  result[3]  = a_ >> 24;
-  result[4]  = b_;
-  result[5]  = b_ >> 8;
-  result[6]  = b_ >> 16;
-  result[7]  = b_ >> 24;
-  result[8]  = c_;
-  result[9]  = c_ >> 8;
+  result[0] = a_;
+  result[1] = a_ >> 8;
+  result[2] = a_ >> 16;
+  result[3] = a_ >> 24;
+  result[4] = b_;
+  result[5] = b_ >> 8;
+  result[6] = b_ >> 16;
+  result[7] = b_ >> 24;
+  result[8] = c_;
+  result[9] = c_ >> 8;
   result[10] = c_ >> 16;
   result[11] = c_ >> 24;
   result[12] = d_;
@@ -153,8 +149,7 @@ void Md5::final(uint8_t* result) {
 
 // This processes one or more 64-byte data blocks, but does NOT update
 // the bit counters.  There are no alignment requirements.
-const uint8_t* Md5::body(const uint8_t* data, size_t size)
-{
+const uint8_t* Md5::body(const uint8_t* data, size_t size) {
   const uint8_t* ptr = data;
   MD5_u32plus a, b, c, d;
   MD5_u32plus saved_a, saved_b, saved_c, saved_d;
@@ -206,7 +201,7 @@ const uint8_t* Md5::body(const uint8_t* data, size_t size)
     STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
     STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
 
-     // Round 3
+    // Round 3
     STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
     STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
     STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
@@ -257,5 +252,3 @@ const uint8_t* Md5::body(const uint8_t* data, size_t size)
 
   return ptr;
 }
-
-} // namespace cass
diff --git a/src/md5.hpp b/src/md5.hpp
index c7e985304..328fc6800 100644
--- a/src/md5.hpp
+++ b/src/md5.hpp
@@ -17,15 +17,15 @@
 // Based on public domain source found here:
 // http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
 
-#ifndef __CASS_MD5_HPP_INCLUDED__
-#define __CASS_MD5_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MD5_HPP
+#define DATASTAX_INTERNAL_MD5_HPP
 
 #include "macros.hpp"
 
-#include <uv.h>
 #include <stdint.h>
+#include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Md5 {
 public:
@@ -49,7 +49,6 @@ class Md5 {
   DISALLOW_COPY_AND_ASSIGN(Md5);
 };
 
-
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/memory.cpp b/src/memory.cpp
index 4595fcf3f..c3e1494d0 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -13,12 +13,13 @@
 
 #include <uv.h>
 
+using namespace datastax::internal;
+
 extern "C" {
 
-void cass_alloc_set_functions(CassMallocFunction malloc_func,
-                              CassReallocFunction realloc_func,
+void cass_alloc_set_functions(CassMallocFunction malloc_func, CassReallocFunction realloc_func,
                               CassFreeFunction free_func) {
-  cass::Memory::set_functions(malloc_func, realloc_func, free_func);
+  Memory::set_functions(malloc_func, realloc_func, free_func);
 }
 
 } // extern "C"
@@ -45,8 +46,6 @@ void operator delete[](void* ptr) throw() {
 }
 #endif
 
-namespace cass {
-
 CassMallocFunction Memory::malloc_func_ = NULL;
 CassReallocFunction Memory::realloc_func_ = NULL;
 CassFreeFunction Memory::free_func_ = NULL;
@@ -61,12 +60,9 @@ static void* calloc_(size_t count, size_t size) {
 }
 #endif
 
-void Memory::set_functions(CassMallocFunction malloc_func,
-                           CassReallocFunction realloc_func,
+void Memory::set_functions(CassMallocFunction malloc_func, CassReallocFunction realloc_func,
                            CassFreeFunction free_func) {
-  if (malloc_func == NULL ||
-      realloc_func == NULL ||
-      free_func == NULL) {
+  if (malloc_func == NULL || realloc_func == NULL || free_func == NULL) {
     Memory::malloc_func_ = NULL;
     Memory::realloc_func_ = NULL;
     Memory::free_func_ = NULL;
@@ -79,6 +75,3 @@ void Memory::set_functions(CassMallocFunction malloc_func,
   uv_replace_allocator(Memory::malloc_func_, Memory::realloc_func_, calloc_, Memory::free_func_);
 #endif
 }
-
-} // namespace cass
-
diff --git a/src/memory.hpp b/src/memory.hpp
index 5f3bc6caa..7ace2b862 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -5,18 +5,17 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_MEMORY_HPP_INCLUDED__
-#define __DSE_MEMORY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MEMORY_HPP
+#define DATASTAX_INTERNAL_MEMORY_HPP
 
 #include "cassandra.h"
 #include <cstdlib>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Memory {
 public:
-  static void set_functions(CassMallocFunction malloc_func,
-                            CassReallocFunction realloc_func,
+  static void set_functions(CassMallocFunction malloc_func, CassReallocFunction realloc_func,
                             CassFreeFunction free_func);
 
   static CassMallocFunction malloc_func() { return malloc_func_; }
@@ -50,6 +49,6 @@ class Memory {
   static CassFreeFunction free_func_;
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/metadata.cpp b/src/metadata.cpp
index b8c95d672..4f4b5a2dc 100644
--- a/src/metadata.cpp
+++ b/src/metadata.cpp
@@ -19,6 +19,7 @@
 #include "buffer.hpp"
 #include "collection.hpp"
 #include "collection_iterator.hpp"
+#include "data_type_parser.hpp"
 #include "external.hpp"
 #include "iterator.hpp"
 #include "json.hpp"
@@ -29,7 +30,6 @@
 #include "row_iterator.hpp"
 #include "scoped_lock.hpp"
 #include "string.hpp"
-#include "data_type_parser.hpp"
 #include "utils.hpp"
 #include "value.hpp"
 
@@ -38,17 +38,19 @@
 #include <ctype.h>
 #include <iterator>
 
-static cass::String& append_arguments(cass::String& full_name,
-                                      const cass::String& arguments) {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+static String& append_arguments(String& full_name, const String& arguments) {
   full_name.push_back('(');
   bool first = true;
-  cass::IStringStream stream(arguments);
+  IStringStream stream(arguments);
   while (!stream.eof()) {
-    cass::String argument;
+    String argument;
     std::getline(stream, argument, ',');
     // Remove white-space
-    argument.erase(std::remove_if(argument.begin(), argument.end(), ::isspace),
-                   argument.end());
+    argument.erase(std::remove_if(argument.begin(), argument.end(), ::isspace), argument.end());
     if (!argument.empty()) {
       if (!first) full_name.push_back(',');
       full_name.append(argument);
@@ -61,9 +63,7 @@ static cass::String& append_arguments(cass::String& full_name,
 
 extern "C" {
 
-void cass_schema_meta_free(const CassSchemaMeta* schema_meta) {
-  delete schema_meta->from();
-}
+void cass_schema_meta_free(const CassSchemaMeta* schema_meta) { delete schema_meta->from(); }
 
 cass_uint32_t cass_schema_meta_snapshot_version(const CassSchemaMeta* schema_meta) {
   return schema_meta->version();
@@ -85,11 +85,11 @@ const CassKeyspaceMeta* cass_schema_meta_keyspace_by_name(const CassSchemaMeta*
 const CassKeyspaceMeta* cass_schema_meta_keyspace_by_name_n(const CassSchemaMeta* schema_meta,
                                                             const char* keyspace,
                                                             size_t keyspace_length) {
-  return CassKeyspaceMeta::to(schema_meta->get_keyspace(cass::String(keyspace, keyspace_length)));
+  return CassKeyspaceMeta::to(schema_meta->get_keyspace(String(keyspace, keyspace_length)));
 }
 
-void cass_keyspace_meta_name(const CassKeyspaceMeta* keyspace_meta,
-                             const char** name, size_t* name_length) {
+void cass_keyspace_meta_name(const CassKeyspaceMeta* keyspace_meta, const char** name,
+                             size_t* name_length) {
   *name = keyspace_meta->name().data();
   *name_length = keyspace_meta->name().size();
 }
@@ -104,22 +104,22 @@ const CassTableMeta* cass_keyspace_meta_table_by_name(const CassKeyspaceMeta* ke
 }
 
 const CassTableMeta* cass_keyspace_meta_table_by_name_n(const CassKeyspaceMeta* keyspace_meta,
-                                                        const char* table,
-                                                        size_t table_length) {
+                                                        const char* table, size_t table_length) {
 
-  return CassTableMeta::to(keyspace_meta->get_table(cass::String(table, table_length)));
+  return CassTableMeta::to(keyspace_meta->get_table(String(table, table_length)));
 }
 
-const CassMaterializedViewMeta* cass_keyspace_meta_materialized_view_by_name(const CassKeyspaceMeta* keyspace_meta,
-                                                                             const char* view) {
+const CassMaterializedViewMeta*
+cass_keyspace_meta_materialized_view_by_name(const CassKeyspaceMeta* keyspace_meta,
+                                             const char* view) {
   return cass_keyspace_meta_materialized_view_by_name_n(keyspace_meta, view, SAFE_STRLEN(view));
 }
 
-const CassMaterializedViewMeta* cass_keyspace_meta_materialized_view_by_name_n(const CassKeyspaceMeta* keyspace_meta,
-                                                                               const char* view,
-                                                                               size_t view_length) {
+const CassMaterializedViewMeta*
+cass_keyspace_meta_materialized_view_by_name_n(const CassKeyspaceMeta* keyspace_meta,
+                                               const char* view, size_t view_length) {
 
-  return CassMaterializedViewMeta::to(keyspace_meta->get_view(cass::String(view, view_length)));
+  return CassMaterializedViewMeta::to(keyspace_meta->get_view(String(view, view_length)));
 }
 
 const CassDataType* cass_keyspace_meta_user_type_by_name(const CassKeyspaceMeta* keyspace_meta,
@@ -128,46 +128,40 @@ const CassDataType* cass_keyspace_meta_user_type_by_name(const CassKeyspaceMeta*
 }
 
 const CassDataType* cass_keyspace_meta_user_type_by_name_n(const CassKeyspaceMeta* keyspace_meta,
-                                                           const char* type,
-                                                           size_t type_length) {
-  return CassDataType::to(keyspace_meta->get_user_type(cass::String(type, type_length)));
+                                                           const char* type, size_t type_length) {
+  return CassDataType::to(keyspace_meta->get_user_type(String(type, type_length)));
 }
 
 const CassFunctionMeta* cass_keyspace_meta_function_by_name(const CassKeyspaceMeta* keyspace_meta,
                                                             const char* name,
                                                             const char* arguments) {
-  return cass_keyspace_meta_function_by_name_n(keyspace_meta,
-                                               name, SAFE_STRLEN(name),
-                                               arguments, SAFE_STRLEN(arguments));
+  return cass_keyspace_meta_function_by_name_n(keyspace_meta, name, SAFE_STRLEN(name), arguments,
+                                               SAFE_STRLEN(arguments));
 }
 
-
 const CassFunctionMeta* cass_keyspace_meta_function_by_name_n(const CassKeyspaceMeta* keyspace_meta,
-                                                              const char* name,
-                                                              size_t name_length,
+                                                              const char* name, size_t name_length,
                                                               const char* arguments,
                                                               size_t arguments_length) {
-  cass::String full_function_name(name, name_length);
+  String full_function_name(name, name_length);
   return CassFunctionMeta::to(keyspace_meta->get_function(
-                                append_arguments(full_function_name, cass::String(arguments, arguments_length))));
+      append_arguments(full_function_name, String(arguments, arguments_length))));
 }
 
 const CassAggregateMeta* cass_keyspace_meta_aggregate_by_name(const CassKeyspaceMeta* keyspace_meta,
                                                               const char* name,
                                                               const char* arguments) {
-  return cass_keyspace_meta_aggregate_by_name_n(keyspace_meta,
-                                                name, SAFE_STRLEN(name),
-                                                arguments, SAFE_STRLEN(arguments));
+  return cass_keyspace_meta_aggregate_by_name_n(keyspace_meta, name, SAFE_STRLEN(name), arguments,
+                                                SAFE_STRLEN(arguments));
 }
 
-const CassAggregateMeta* cass_keyspace_meta_aggregate_by_name_n(const CassKeyspaceMeta* keyspace_meta,
-                                                                const char* name,
-                                                                size_t name_length,
-                                                                const char* arguments,
-                                                                size_t arguments_length) {
-  cass::String full_aggregate_name(name, name_length);
+const CassAggregateMeta*
+cass_keyspace_meta_aggregate_by_name_n(const CassKeyspaceMeta* keyspace_meta, const char* name,
+                                       size_t name_length, const char* arguments,
+                                       size_t arguments_length) {
+  String full_aggregate_name(name, name_length);
   return CassAggregateMeta::to(keyspace_meta->get_aggregate(
-                                 append_arguments(full_aggregate_name, cass::String(arguments, arguments_length))));
+      append_arguments(full_aggregate_name, String(arguments, arguments_length))));
 }
 
 const CassValue* cass_keyspace_meta_field_by_name(const CassKeyspaceMeta* keyspace_meta,
@@ -177,11 +171,10 @@ const CassValue* cass_keyspace_meta_field_by_name(const CassKeyspaceMeta* keyspa
 
 const CassValue* cass_keyspace_meta_field_by_name_n(const CassKeyspaceMeta* keyspace_meta,
                                                     const char* name, size_t name_length) {
-  return CassValue::to(keyspace_meta->get_field(cass::String(name, name_length)));
+  return CassValue::to(keyspace_meta->get_field(String(name, name_length)));
 }
 
-void cass_table_meta_name(const CassTableMeta* table_meta,
-                          const char** name, size_t* name_length) {
+void cass_table_meta_name(const CassTableMeta* table_meta, const char** name, size_t* name_length) {
   *name = table_meta->name().data();
   *name_length = table_meta->name().size();
 }
@@ -196,17 +189,15 @@ const CassColumnMeta* cass_table_meta_column_by_name(const CassTableMeta* table_
 }
 
 const CassColumnMeta* cass_table_meta_column_by_name_n(const CassTableMeta* table_meta,
-                                                       const char* column,
-                                                       size_t column_length) {
-  return CassColumnMeta::to(table_meta->get_column(cass::String(column, column_length)));
+                                                       const char* column, size_t column_length) {
+  return CassColumnMeta::to(table_meta->get_column(String(column, column_length)));
 }
 
 size_t cass_table_meta_column_count(const CassTableMeta* table_meta) {
   return table_meta->columns().size();
 }
 
-const CassColumnMeta* cass_table_meta_column(const CassTableMeta* table_meta,
-                                             size_t index) {
+const CassColumnMeta* cass_table_meta_column(const CassTableMeta* table_meta, size_t index) {
   if (index >= table_meta->columns().size()) {
     return NULL;
   }
@@ -219,32 +210,30 @@ const CassIndexMeta* cass_table_meta_index_by_name(const CassTableMeta* table_me
 }
 
 const CassIndexMeta* cass_table_meta_index_by_name_n(const CassTableMeta* table_meta,
-                                                     const char* index,
-                                                     size_t index_length) {
-  return CassIndexMeta::to(table_meta->get_index(cass::String(index, index_length)));
+                                                     const char* index, size_t index_length) {
+  return CassIndexMeta::to(table_meta->get_index(String(index, index_length)));
 }
 
 size_t cass_table_meta_index_count(const CassTableMeta* table_meta) {
   return table_meta->indexes().size();
 }
 
-const CassIndexMeta* cass_table_meta_index(const CassTableMeta* table_meta,
-                                           size_t index) {
+const CassIndexMeta* cass_table_meta_index(const CassTableMeta* table_meta, size_t index) {
   if (index >= table_meta->indexes().size()) {
     return NULL;
   }
   return CassIndexMeta::to(table_meta->indexes()[index].get());
 }
 
-const CassMaterializedViewMeta* cass_table_meta_materialized_view_by_name(const CassTableMeta* table_meta,
-                                                                          const char* view) {
+const CassMaterializedViewMeta*
+cass_table_meta_materialized_view_by_name(const CassTableMeta* table_meta, const char* view) {
   return cass_table_meta_materialized_view_by_name_n(table_meta, view, SAFE_STRLEN(view));
 }
 
-const CassMaterializedViewMeta* cass_table_meta_materialized_view_by_name_n(const CassTableMeta* table_meta,
-                                                                            const char* view,
-                                                                            size_t view_length) {
-  return CassMaterializedViewMeta::to(table_meta->get_view(cass::String(view, view_length)));
+const CassMaterializedViewMeta*
+cass_table_meta_materialized_view_by_name_n(const CassTableMeta* table_meta, const char* view,
+                                            size_t view_length) {
+  return CassMaterializedViewMeta::to(table_meta->get_view(String(view, view_length)));
 }
 
 size_t cass_table_meta_materialized_view_count(const CassTableMeta* table_meta) {
@@ -263,8 +252,7 @@ size_t cass_table_meta_partition_key_count(const CassTableMeta* table_meta) {
   return table_meta->partition_key().size();
 }
 
-const CassColumnMeta* cass_table_meta_partition_key(const CassTableMeta* table_meta,
-                                                    size_t index) {
+const CassColumnMeta* cass_table_meta_partition_key(const CassTableMeta* table_meta, size_t index) {
   if (index >= table_meta->partition_key().size()) {
     return NULL;
   }
@@ -291,48 +279,51 @@ CassClusteringOrder cass_table_meta_clustering_key_order(const CassTableMeta* ta
   return table_meta->clustering_key_order()[index];
 }
 
-const CassValue* cass_table_meta_field_by_name(const CassTableMeta* table_meta,
-                                               const char* name) {
+const CassValue* cass_table_meta_field_by_name(const CassTableMeta* table_meta, const char* name) {
   return cass_table_meta_field_by_name_n(table_meta, name, SAFE_STRLEN(name));
 }
 
-const CassValue* cass_table_meta_field_by_name_n(const CassTableMeta* table_meta,
-                                                 const char* name, size_t name_length) {
-  return CassValue::to(table_meta->get_field(cass::String(name, name_length)));
+const CassValue* cass_table_meta_field_by_name_n(const CassTableMeta* table_meta, const char* name,
+                                                 size_t name_length) {
+  return CassValue::to(table_meta->get_field(String(name, name_length)));
 }
 
-const CassColumnMeta* cass_materialized_view_meta_column_by_name(const CassMaterializedViewMeta* view_meta,
-                                                                 const char* column) {
+const CassColumnMeta*
+cass_materialized_view_meta_column_by_name(const CassMaterializedViewMeta* view_meta,
+                                           const char* column) {
   return cass_materialized_view_meta_column_by_name_n(view_meta, column, SAFE_STRLEN(column));
 }
 
-const CassColumnMeta* cass_materialized_view_meta_column_by_name_n(const CassMaterializedViewMeta* view_meta,
-                                                                   const char* column,
-                                                                   size_t column_length) {
-  return CassColumnMeta::to(view_meta->get_column(cass::String(column, column_length)));
+const CassColumnMeta*
+cass_materialized_view_meta_column_by_name_n(const CassMaterializedViewMeta* view_meta,
+                                             const char* column, size_t column_length) {
+  return CassColumnMeta::to(view_meta->get_column(String(column, column_length)));
 }
 
-void cass_materialized_view_meta_name(const CassMaterializedViewMeta* view_meta,
-                                      const char** name, size_t* name_length) {
+void cass_materialized_view_meta_name(const CassMaterializedViewMeta* view_meta, const char** name,
+                                      size_t* name_length) {
   *name = view_meta->name().data();
   *name_length = view_meta->name().size();
 }
 
-const CassTableMeta* cass_materialized_view_meta_base_table(const CassMaterializedViewMeta* view_meta) {
+const CassTableMeta*
+cass_materialized_view_meta_base_table(const CassMaterializedViewMeta* view_meta) {
   if (view_meta == NULL) { // Materialized views may be NULL (Cassandra < v3.0.0)
     return NULL;
   }
   return CassTableMeta::to(view_meta->base_table());
 }
 
-const CassValue* cass_materialized_view_meta_field_by_name(const CassMaterializedViewMeta* view_meta,
-                                                           const char* name) {
+const CassValue*
+cass_materialized_view_meta_field_by_name(const CassMaterializedViewMeta* view_meta,
+                                          const char* name) {
   return cass_materialized_view_meta_field_by_name_n(view_meta, name, SAFE_STRLEN(name));
 }
 
-const CassValue* cass_materialized_view_meta_field_by_name_n(const CassMaterializedViewMeta* view_meta,
-                                                             const char* name, size_t name_length) {
-  return CassValue::to(view_meta->get_field(cass::String(name, name_length)));
+const CassValue*
+cass_materialized_view_meta_field_by_name_n(const CassMaterializedViewMeta* view_meta,
+                                            const char* name, size_t name_length) {
+  return CassValue::to(view_meta->get_field(String(name, name_length)));
 }
 
 size_t cass_materialized_view_meta_column_count(const CassMaterializedViewMeta* view_meta) {
@@ -351,8 +342,8 @@ size_t cass_materialized_view_meta_partition_key_count(const CassMaterializedVie
   return view_meta->partition_key().size();
 }
 
-const CassColumnMeta* cass_materialized_view_meta_partition_key(const CassMaterializedViewMeta* view_meta,
-                                                                size_t index) {
+const CassColumnMeta*
+cass_materialized_view_meta_partition_key(const CassMaterializedViewMeta* view_meta, size_t index) {
   if (index >= view_meta->partition_key().size()) {
     return NULL;
   }
@@ -363,24 +354,26 @@ size_t cass_materialized_view_meta_clustering_key_count(const CassMaterializedVi
   return view_meta->clustering_key().size();
 }
 
-const CassColumnMeta* cass_materialized_view_meta_clustering_key(const CassMaterializedViewMeta* view_meta,
-                                                                 size_t index) {
+const CassColumnMeta*
+cass_materialized_view_meta_clustering_key(const CassMaterializedViewMeta* view_meta,
+                                           size_t index) {
   if (index >= view_meta->clustering_key().size()) {
     return NULL;
   }
   return CassColumnMeta::to(view_meta->clustering_key()[index].get());
 }
 
-CassClusteringOrder cass_materialized_view_meta_clustering_key_order(const CassMaterializedViewMeta* view_meta,
-                                                                     size_t index) {
+CassClusteringOrder
+cass_materialized_view_meta_clustering_key_order(const CassMaterializedViewMeta* view_meta,
+                                                 size_t index) {
   if (index >= view_meta->clustering_key_order().size()) {
     return CASS_CLUSTERING_ORDER_NONE;
   }
   return view_meta->clustering_key_order()[index];
 }
 
-void cass_column_meta_name(const CassColumnMeta* column_meta,
-                           const char** name, size_t* name_length) {
+void cass_column_meta_name(const CassColumnMeta* column_meta, const char** name,
+                           size_t* name_length) {
   *name = column_meta->name().data();
   *name_length = column_meta->name().size();
 }
@@ -393,30 +386,25 @@ const CassDataType* cass_column_meta_data_type(const CassColumnMeta* column_meta
   return CassDataType::to(column_meta->data_type().get());
 }
 
-const CassValue*
-cass_column_meta_field_by_name(const CassColumnMeta* column_meta,
-                               const char* name) {
+const CassValue* cass_column_meta_field_by_name(const CassColumnMeta* column_meta,
+                                                const char* name) {
   return cass_column_meta_field_by_name_n(column_meta, name, SAFE_STRLEN(name));
 }
 
-const CassValue*
-cass_column_meta_field_by_name_n(const CassColumnMeta* column_meta,
-                                 const char* name, size_t name_length) {
-  return CassValue::to(column_meta->get_field(cass::String(name, name_length)));
+const CassValue* cass_column_meta_field_by_name_n(const CassColumnMeta* column_meta,
+                                                  const char* name, size_t name_length) {
+  return CassValue::to(column_meta->get_field(String(name, name_length)));
 }
 
-void cass_index_meta_name(const CassIndexMeta* index_meta,
-                          const char** name, size_t* name_length) {
+void cass_index_meta_name(const CassIndexMeta* index_meta, const char** name, size_t* name_length) {
   *name = index_meta->name().data();
   *name_length = index_meta->name().size();
 }
 
-CassIndexType cass_index_meta_type(const CassIndexMeta* index_meta) {
-  return index_meta->type();
-}
+CassIndexType cass_index_meta_type(const CassIndexMeta* index_meta) { return index_meta->type(); }
 
-void cass_index_meta_target(const CassIndexMeta* index_meta,
-                            const char** target, size_t* target_length) {
+void cass_index_meta_target(const CassIndexMeta* index_meta, const char** target,
+                            size_t* target_length) {
   *target = index_meta->target().data();
   *target_length = index_meta->target().size();
 }
@@ -425,41 +413,34 @@ const CassValue* cass_index_meta_options(const CassIndexMeta* index_meta) {
   return CassValue::to(index_meta->options());
 }
 
-const CassValue*
-cass_index_meta_field_by_name(const CassIndexMeta* index_meta,
-                              const char* name) {
+const CassValue* cass_index_meta_field_by_name(const CassIndexMeta* index_meta, const char* name) {
   return cass_index_meta_field_by_name_n(index_meta, name, SAFE_STRLEN(name));
 }
 
-const CassValue*
-cass_index_meta_field_by_name_n(const CassIndexMeta* index_meta,
-                                const char* name, size_t name_length) {
-  return CassValue::to(index_meta->get_field(cass::String(name, name_length)));
+const CassValue* cass_index_meta_field_by_name_n(const CassIndexMeta* index_meta, const char* name,
+                                                 size_t name_length) {
+  return CassValue::to(index_meta->get_field(String(name, name_length)));
 }
 
-void cass_function_meta_name(const CassFunctionMeta* function_meta,
-                             const char** name,
+void cass_function_meta_name(const CassFunctionMeta* function_meta, const char** name,
                              size_t* name_length) {
   *name = function_meta->simple_name().data();
   *name_length = function_meta->simple_name().size();
 }
 
-void cass_function_meta_full_name(const CassFunctionMeta* function_meta,
-                                  const char** full_name,
+void cass_function_meta_full_name(const CassFunctionMeta* function_meta, const char** full_name,
                                   size_t* full_name_length) {
   *full_name = function_meta->name().data();
   *full_name_length = function_meta->name().size();
 }
 
-void cass_function_meta_body(const CassFunctionMeta* function_meta,
-                             const char** body,
+void cass_function_meta_body(const CassFunctionMeta* function_meta, const char** body,
                              size_t* body_length) {
   *body = function_meta->body().data();
   *body_length = function_meta->body().size();
 }
 
-void cass_function_meta_language(const CassFunctionMeta* function_meta,
-                                 const char** language,
+void cass_function_meta_language(const CassFunctionMeta* function_meta, const char** language,
                                  size_t* language_length) {
   *language = function_meta->language().data();
   *language_length = function_meta->language().size();
@@ -473,15 +454,13 @@ size_t cass_function_meta_argument_count(const CassFunctionMeta* function_meta)
   return function_meta->args().size();
 }
 
-CassError cass_function_meta_argument(const CassFunctionMeta* function_meta,
-                                      size_t index,
-                                      const char** name,
-                                      size_t* name_length,
+CassError cass_function_meta_argument(const CassFunctionMeta* function_meta, size_t index,
+                                      const char** name, size_t* name_length,
                                       const CassDataType** type) {
   if (index >= function_meta->args().size()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
-  const cass::FunctionMetadata::Argument& arg = function_meta->args()[index];
+  const FunctionMetadata::Argument& arg = function_meta->args()[index];
   *name = arg.name.data();
   *name_length = arg.name.size();
   *type = CassDataType::to(arg.type.get());
@@ -493,10 +472,10 @@ const CassDataType* cass_function_meta_argument_type_by_name(const CassFunctionM
   return cass_function_meta_argument_type_by_name_n(function_meta, name, SAFE_STRLEN(name));
 }
 
-const CassDataType* cass_function_meta_argument_type_by_name_n(const CassFunctionMeta* function_meta,
-                                                               const char* name,
-                                                               size_t name_length) {
-  return CassDataType::to(function_meta->get_arg_type(cass::StringRef(name, name_length)));
+const CassDataType*
+cass_function_meta_argument_type_by_name_n(const CassFunctionMeta* function_meta, const char* name,
+                                           size_t name_length) {
+  return CassDataType::to(function_meta->get_arg_type(StringRef(name, name_length)));
 }
 
 const CassDataType* cass_function_meta_return_type(const CassFunctionMeta* function_meta) {
@@ -509,20 +488,17 @@ const CassValue* cass_function_meta_field_by_name(const CassFunctionMeta* functi
 }
 
 const CassValue* cass_function_meta_field_by_name_n(const CassFunctionMeta* function_meta,
-                                                    const char* name,
-                                                    size_t name_length) {
-  return CassValue::to(function_meta->get_field(cass::String(name, name_length)));
+                                                    const char* name, size_t name_length) {
+  return CassValue::to(function_meta->get_field(String(name, name_length)));
 }
 
-void cass_aggregate_meta_name(const CassAggregateMeta* aggregate_meta,
-                              const char** name,
+void cass_aggregate_meta_name(const CassAggregateMeta* aggregate_meta, const char** name,
                               size_t* name_length) {
   *name = aggregate_meta->simple_name().data();
   *name_length = aggregate_meta->simple_name().size();
 }
 
-void cass_aggregate_meta_full_name(const CassAggregateMeta* aggregate_meta,
-                                   const char** full_name,
+void cass_aggregate_meta_full_name(const CassAggregateMeta* aggregate_meta, const char** full_name,
                                    size_t* full_name_length) {
   *full_name = aggregate_meta->name().data();
   *full_name_length = aggregate_meta->name().size();
@@ -566,9 +542,8 @@ const CassValue* cass_aggregate_meta_field_by_name(const CassAggregateMeta* aggr
 }
 
 const CassValue* cass_aggregate_meta_field_by_name_n(const CassAggregateMeta* aggregate_meta,
-                                                     const char* name,
-                                                     size_t name_length) {
-  return CassValue::to(aggregate_meta->get_field(cass::String(name, name_length)));
+                                                     const char* name, size_t name_length) {
+  return CassValue::to(aggregate_meta->get_field(String(name, name_length)));
 }
 
 CassIterator* cass_iterator_keyspaces_from_schema_meta(const CassSchemaMeta* schema_meta) {
@@ -579,7 +554,8 @@ CassIterator* cass_iterator_tables_from_keyspace_meta(const CassKeyspaceMeta* ke
   return CassIterator::to(keyspace_meta->iterator_tables());
 }
 
-CassIterator* cass_iterator_materialized_views_from_keyspace_meta(const CassKeyspaceMeta* keyspace_meta) {
+CassIterator*
+cass_iterator_materialized_views_from_keyspace_meta(const CassKeyspaceMeta* keyspace_meta) {
   return CassIterator::to(keyspace_meta->iterator_views());
 }
 
@@ -615,11 +591,13 @@ CassIterator* cass_iterator_fields_from_table_meta(const CassTableMeta* table_me
   return CassIterator::to(table_meta->iterator_fields());
 }
 
-CassIterator* cass_iterator_columns_from_materialized_view_meta(const CassMaterializedViewMeta* view_meta) {
+CassIterator*
+cass_iterator_columns_from_materialized_view_meta(const CassMaterializedViewMeta* view_meta) {
   return CassIterator::to(view_meta->iterator_columns());
 }
 
-CassIterator* cass_iterator_fields_from_materialized_view_meta(const CassMaterializedViewMeta* view_meta) {
+CassIterator*
+cass_iterator_fields_from_materialized_view_meta(const CassMaterializedViewMeta* view_meta) {
   return CassIterator::to(view_meta->iterator_fields());
 }
 
@@ -644,8 +622,7 @@ const CassKeyspaceMeta* cass_iterator_get_keyspace_meta(const CassIterator* iter
     return NULL;
   }
   return CassKeyspaceMeta::to(
-        static_cast<const cass::Metadata::KeyspaceIterator*>(
-          iterator->from())->keyspace());
+      static_cast<const Metadata::KeyspaceIterator*>(iterator->from())->keyspace());
 }
 
 const CassTableMeta* cass_iterator_get_table_meta(const CassIterator* iterator) {
@@ -653,17 +630,16 @@ const CassTableMeta* cass_iterator_get_table_meta(const CassIterator* iterator)
     return NULL;
   }
   return CassTableMeta::to(
-        static_cast<const cass::KeyspaceMetadata::TableIterator*>(
-          iterator->from())->table());
+      static_cast<const KeyspaceMetadata::TableIterator*>(iterator->from())->table());
 }
 
-const CassMaterializedViewMeta* cass_iterator_get_materialized_view_meta(const CassIterator* iterator) {
+const CassMaterializedViewMeta*
+cass_iterator_get_materialized_view_meta(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META) {
     return NULL;
   }
   return CassMaterializedViewMeta::to(
-        static_cast<const cass::ViewIteratorBase*>(
-          iterator->from())->view());
+      static_cast<const ViewIteratorBase*>(iterator->from())->view());
 }
 
 const CassDataType* cass_iterator_get_user_type(const CassIterator* iterator) {
@@ -671,8 +647,7 @@ const CassDataType* cass_iterator_get_user_type(const CassIterator* iterator) {
     return NULL;
   }
   return CassDataType::to(
-        static_cast<const cass::KeyspaceMetadata::TypeIterator*>(
-          iterator->from())->type());
+      static_cast<const KeyspaceMetadata::TypeIterator*>(iterator->from())->type());
 }
 
 const CassFunctionMeta* cass_iterator_get_function_meta(const CassIterator* iterator) {
@@ -680,17 +655,15 @@ const CassFunctionMeta* cass_iterator_get_function_meta(const CassIterator* iter
     return NULL;
   }
   return CassFunctionMeta::to(
-        static_cast<const cass::KeyspaceMetadata::FunctionIterator*>(
-          iterator->from())->function());
+      static_cast<const KeyspaceMetadata::FunctionIterator*>(iterator->from())->function());
 }
 
-const CassAggregateMeta* cass_iterator_get_aggregate_meta(const CassIterator* iterator){
+const CassAggregateMeta* cass_iterator_get_aggregate_meta(const CassIterator* iterator) {
   if (iterator->type() != CASS_ITERATOR_TYPE_AGGREGATE_META) {
     return NULL;
   }
   return CassAggregateMeta::to(
-        static_cast<const cass::KeyspaceMetadata::AggregateIterator*>(
-          iterator->from())->aggregate());
+      static_cast<const KeyspaceMetadata::AggregateIterator*>(iterator->from())->aggregate());
 }
 
 const CassColumnMeta* cass_iterator_get_column_meta(const CassIterator* iterator) {
@@ -698,8 +671,7 @@ const CassColumnMeta* cass_iterator_get_column_meta(const CassIterator* iterator
     return NULL;
   }
   return CassColumnMeta::to(
-        static_cast<const cass::TableMetadata::ColumnIterator*>(
-          iterator->from())->column());
+      static_cast<const TableMetadata::ColumnIterator*>(iterator->from())->column());
 }
 
 const CassIndexMeta* cass_iterator_get_index_meta(const CassIterator* iterator) {
@@ -707,18 +679,15 @@ const CassIndexMeta* cass_iterator_get_index_meta(const CassIterator* iterator)
     return NULL;
   }
   return CassIndexMeta::to(
-        static_cast<const cass::TableMetadata::IndexIterator*>(
-          iterator->from())->index());
+      static_cast<const TableMetadata::IndexIterator*>(iterator->from())->index());
 }
 
-CassError cass_iterator_get_meta_field_name(const CassIterator* iterator,
-                                            const char** name,
+CassError cass_iterator_get_meta_field_name(const CassIterator* iterator, const char** name,
                                             size_t* name_length) {
   if (iterator->type() != CASS_ITERATOR_TYPE_META_FIELD) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  const cass::MetadataField* field =
-      static_cast<const cass::MetadataFieldIterator*>(iterator->from())->field();
+  const MetadataField* field = static_cast<const MetadataFieldIterator*>(iterator->from())->field();
   *name = field->name().data();
   *name_length = field->name().size();
   return CASS_OK;
@@ -729,24 +698,23 @@ const CassValue* cass_iterator_get_meta_field_value(const CassIterator* iterator
     return NULL;
   }
   return CassValue::to(
-        static_cast<const cass::MetadataFieldIterator*>(
-          iterator->from())->field()->value());
+      static_cast<const MetadataFieldIterator*>(iterator->from())->field()->value());
 }
 
 } // extern "C"
 
-namespace cass {
-
-static const char* table_column_name(const cass::VersionNumber& server_version) {
+static const char* table_column_name(const VersionNumber& server_version) {
   return server_version >= VersionNumber(3, 0, 0) ? "table_name" : "columnfamily_name";
 }
 
-static const char* signature_column_name(const cass::VersionNumber& server_version) {
+static const char* signature_column_name(const VersionNumber& server_version) {
   return server_version >= VersionNumber(3, 0, 0) ? "argument_types" : "signature";
 }
 
 template <class T>
-const T& as_const(const T& x) { return x; }
+const T& as_const(const T& x) {
+  return x;
+}
 
 const KeyspaceMetadata* Metadata::SchemaSnapshot::get_keyspace(const String& name) const {
   KeyspaceMetadata::Map::const_iterator i = keyspaces_->find(name);
@@ -755,8 +723,7 @@ const KeyspaceMetadata* Metadata::SchemaSnapshot::get_keyspace(const String& nam
 }
 
 const UserType* Metadata::SchemaSnapshot::get_user_type(const String& keyspace_name,
-                                                        const String& type_name) const
-{
+                                                        const String& type_name) const {
   KeyspaceMetadata::Map::const_iterator i = keyspaces_->find(keyspace_name);
   if (i == keyspaces_->end()) {
     return NULL;
@@ -767,12 +734,10 @@ const UserType* Metadata::SchemaSnapshot::get_user_type(const String& keyspace_n
 String Metadata::full_function_name(const String& name, const StringVec& signature) {
   String full_function_name(name);
   full_function_name.push_back('(');
-  for (StringVec::const_iterator i = signature.begin(),
-       end = signature.end(); i != end; ++i) {
+  for (StringVec::const_iterator i = signature.begin(), end = signature.end(); i != end; ++i) {
     String argument(*i);
     // Remove white-space
-    argument.erase(std::remove_if(argument.begin(), argument.end(), ::isspace),
-                   argument.end());
+    argument.erase(std::remove_if(argument.begin(), argument.end(), ::isspace), argument.end());
     if (!argument.empty()) {
       if (i != signature.begin()) full_function_name.push_back(',');
       full_function_name.append(argument);
@@ -784,13 +749,10 @@ String Metadata::full_function_name(const String& name, const StringVec& signatu
 
 Metadata::SchemaSnapshot Metadata::schema_snapshot() const {
   ScopedMutex l(&mutex_);
-  return SchemaSnapshot(schema_snapshot_version_,
-                        server_version_,
-                        front_.keyspaces());
+  return SchemaSnapshot(schema_snapshot_version_, server_version_, front_.keyspaces());
 }
 
-void Metadata::update_keyspaces(const ResultResponse* result,
-                                bool is_virtual) {
+void Metadata::update_keyspaces(const ResultResponse* result, bool is_virtual) {
   schema_snapshot_version_++;
 
   if (is_front_buffer()) {
@@ -979,7 +941,8 @@ String MetadataBase::get_string_field(const String& name) const {
   return value->to_string();
 }
 
-const Value* MetadataBase::add_field(const RefBuffer::Ptr& buffer, const Row* row, const String& name) {
+const Value* MetadataBase::add_field(const RefBuffer::Ptr& buffer, const Row* row,
+                                     const String& name) {
   const Value* value = row->get_by_name(name);
   if (value == NULL) return NULL;
   if (value->is_null()) {
@@ -1018,10 +981,10 @@ void MetadataBase::add_json_list_field(const Row* row, const String& name) {
     return;
   }
 
-  Collection collection(CollectionType::list(DataType::Ptr(new DataType(CASS_VALUE_TYPE_TEXT)), false),
-                        d.Size());
+  Collection collection(
+      CollectionType::list(DataType::Ptr(new DataType(CASS_VALUE_TYPE_TEXT)), false), d.Size());
   for (json::Value::ConstValueIterator i = d.Begin(); i != d.End(); ++i) {
-    collection.append(cass::CassString(i->GetString(), i->GetStringLength()));
+    collection.append(CassString(i->GetString(), i->GetStringLength()));
   }
 
   size_t encoded_size = collection.get_items_size();
@@ -1029,10 +992,8 @@ void MetadataBase::add_json_list_field(const Row* row, const String& name) {
 
   collection.encode_items(encoded->data());
 
-  Value list(collection.data_type(),
-             d.Size(),
-             Decoder(encoded->data(), encoded_size,
-                     value->protocol_version()));
+  Value list(collection.data_type(), d.Size(),
+             Decoder(encoded->data(), encoded_size, value->protocol_version()));
   fields_[name] = MetadataField(name, list, encoded);
 }
 
@@ -1072,10 +1033,8 @@ const Value* MetadataBase::add_json_map_field(const Row* row, const String& name
 
   collection.encode_items(encoded->data());
 
-  Value map(collection.data_type(),
-            d.MemberCount(),
-            Decoder(encoded->data(), encoded_size,
-                    value->protocol_version()));
+  Value map(collection.data_type(), d.MemberCount(),
+            Decoder(encoded->data(), encoded_size, value->protocol_version()));
 
   return (fields_[name] = MetadataField(name, map, encoded)).value();
 }
@@ -1109,8 +1068,7 @@ void KeyspaceMetadata::add_table(const TableMetadata::Ptr& table) {
 void KeyspaceMetadata::internal_add_table(const TableMetadata::Ptr& table,
                                           const ViewMetadata::Vec& views) {
   // Copy all the views and update the table and keyspace views
-  for (ViewMetadata::Vec::const_iterator i = views.begin();
-       i != views.end(); ++i) {
+  for (ViewMetadata::Vec::const_iterator i = views.begin(); i != views.end(); ++i) {
     ViewMetadata::Ptr view(new ViewMetadata(**i, table.get()));
     table->add_view(view);
     (*views_)[view->name()] = view;
@@ -1130,9 +1088,7 @@ const ViewMetadata::Ptr& KeyspaceMetadata::get_view(const String& name) {
   return i->second;
 }
 
-void KeyspaceMetadata::add_view(const ViewMetadata::Ptr& view) {
-  (*views_)[view->name()] = view;
-}
+void KeyspaceMetadata::add_view(const ViewMetadata::Ptr& view) { (*views_)[view->name()] = view; }
 
 void KeyspaceMetadata::drop_table_or_view(const String& table_or_view_name) {
   TableMetadata::Map::iterator table_it = tables_->find(table_or_view_name);
@@ -1142,8 +1098,8 @@ void KeyspaceMetadata::drop_table_or_view(const String& table_or_view_name) {
     // Cassandra doesn't allow for tables to be dropped while it has active
     // views, but it could be possible for the drop events to arrive out of
     // order.
-    for (ViewMetadata::Vec::const_iterator i = table->views().begin(),
-         end = table->views().end(); i != end; ++i) {
+    for (ViewMetadata::Vec::const_iterator i = table->views().begin(), end = table->views().end();
+         i != end; ++i) {
       views_->erase((*i)->name());
     }
     tables_->erase(table_it);
@@ -1154,7 +1110,8 @@ void KeyspaceMetadata::drop_table_or_view(const String& table_or_view_name) {
 
       // Remove view from the base table's views
       ViewMetadata::Vec views(view->base_table()->views());
-      ViewMetadata::Vec::iterator i = std::lower_bound(views.begin(), views.end(), table_or_view_name);
+      ViewMetadata::Vec::iterator i =
+          std::lower_bound(views.begin(), views.end(), table_or_view_name);
       if (i != views.end() && (*i)->name() == table_or_view_name) {
         views.erase(i);
       }
@@ -1172,9 +1129,10 @@ void KeyspaceMetadata::drop_table_or_view(const String& table_or_view_name) {
 const UserType::Ptr& KeyspaceMetadata::get_or_create_user_type(const String& name, bool is_frozen) {
   UserType::Map::iterator i = user_types_->find(name);
   if (i == user_types_->end()) {
-    i = user_types_->insert(std::make_pair(name,
-                                           UserType::Ptr(new UserType(MetadataBase::name(), name,
-                                                                      is_frozen)))).first;
+    i = user_types_
+            ->insert(std::make_pair(
+                name, UserType::Ptr(new UserType(MetadataBase::name(), name, is_frozen))))
+            .first;
   }
   return i->second;
 }
@@ -1185,19 +1143,18 @@ const UserType* KeyspaceMetadata::get_user_type(const String& name) const {
   return i->second.get();
 }
 
-void KeyspaceMetadata::update(const VersionNumber& server_version, const RefBuffer::Ptr& buffer, const Row* row) {
+void KeyspaceMetadata::update(const VersionNumber& server_version, const RefBuffer::Ptr& buffer,
+                              const Row* row) {
   add_field(buffer, row, "keyspace_name");
   add_field(buffer, row, "durable_writes");
-  if (server_version >= VersionNumber(3, 0, 0))  {
+  if (server_version >= VersionNumber(3, 0, 0)) {
     const Value* map = add_field(buffer, row, "replication");
-    if (map != NULL &&
-        map->value_type() == CASS_VALUE_TYPE_MAP &&
-        is_string_type(map->primary_value_type()) &&
-        is_string_type(map->secondary_value_type())) {
+    if (map != NULL && map->value_type() == CASS_VALUE_TYPE_MAP &&
+        is_string_type(map->primary_value_type()) && is_string_type(map->secondary_value_type())) {
       MapIterator iterator(map);
       while (iterator.next()) {
         const Value* key = iterator.key();
-        const Value* value  = iterator.value();
+        const Value* value = iterator.value();
         if (key->to_string_ref() == "class") {
           strategy_class_ = value->to_string_ref();
         }
@@ -1206,8 +1163,7 @@ void KeyspaceMetadata::update(const VersionNumber& server_version, const RefBuff
     }
   } else {
     const Value* value = add_field(buffer, row, "strategy_class");
-    if (value != NULL &&
-        is_string_type(value->value_type())) {
+    if (value != NULL && is_string_type(value->value_type())) {
       strategy_class_ = value->to_string_ref();
     }
     const Value* map = add_json_map_field(row, "strategy_options");
@@ -1217,9 +1173,7 @@ void KeyspaceMetadata::update(const VersionNumber& server_version, const RefBuff
   }
 }
 
-void KeyspaceMetadata::drop_user_type(const String& type_name) {
-  user_types_->erase(type_name);
-}
+void KeyspaceMetadata::drop_user_type(const String& type_name) { user_types_->erase(type_name); }
 
 void KeyspaceMetadata::add_function(const FunctionMetadata::Ptr& function) {
   (*functions_)[function->name()] = function;
@@ -1249,11 +1203,10 @@ void KeyspaceMetadata::drop_aggregate(const String& full_aggregate_name) {
   aggregates_->erase(full_aggregate_name);
 }
 
-TableMetadataBase::TableMetadataBase(const VersionNumber& server_version,
-                                     const String& name, const RefBuffer::Ptr& buffer, const Row* row,
-                                     bool is_virtual)
-  : MetadataBase(name)
-  , is_virtual_(is_virtual) {
+TableMetadataBase::TableMetadataBase(const VersionNumber& server_version, const String& name,
+                                     const RefBuffer::Ptr& buffer, const Row* row, bool is_virtual)
+    : MetadataBase(name)
+    , is_virtual_(is_virtual) {
   add_field(buffer, row, "keyspace_name");
   add_field(buffer, row, "bloom_filter_fp_chance");
   add_field(buffer, row, "caching");
@@ -1307,7 +1260,8 @@ const ColumnMetadata* TableMetadataBase::get_column(const String& name) const {
   return i->second.get();
 }
 
-void TableMetadataBase::add_column(const VersionNumber& server_version, const ColumnMetadata::Ptr& column) {
+void TableMetadataBase::add_column(const VersionNumber& server_version,
+                                   const ColumnMetadata::Ptr& column) {
   if (columns_by_name_.insert(std::make_pair(column->name(), column)).second) {
     columns_.push_back(column);
   }
@@ -1322,14 +1276,15 @@ void TableMetadataBase::clear_columns() {
 
 size_t get_column_count(const ColumnMetadata::Vec& columns, CassColumnType type) {
   size_t count = 0;
-  for (ColumnMetadata::Vec::const_iterator i = columns.begin(),
-       end = columns.end(); i != end; ++i) {
+  for (ColumnMetadata::Vec::const_iterator i = columns.begin(), end = columns.end(); i != end;
+       ++i) {
     if ((*i)->type() == type) count++;
   }
   return count;
 }
 
-void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version, SimpleDataTypeCache& cache) {
+void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
+                                            SimpleDataTypeCache& cache) {
   // Also, Reorders columns so that the order is:
   // 1) Parition key
   // 2) Clustering keys
@@ -1339,30 +1294,30 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
     partition_key_.resize(get_column_count(columns_, CASS_COLUMN_TYPE_PARTITION_KEY));
     clustering_key_.resize(get_column_count(columns_, CASS_COLUMN_TYPE_CLUSTERING_KEY));
     clustering_key_order_.resize(clustering_key_.size(), CASS_CLUSTERING_ORDER_NONE);
-    for (ColumnMetadata::Vec::const_iterator i = columns_.begin(),
-         end = columns_.end(); i != end; ++i) {
+    for (ColumnMetadata::Vec::const_iterator i = columns_.begin(), end = columns_.end(); i != end;
+         ++i) {
       const ColumnMetadata::Ptr& column(*i);
-      if (column->type() == CASS_COLUMN_TYPE_PARTITION_KEY &&
-          column->position() >= 0 &&
+      if (column->type() == CASS_COLUMN_TYPE_PARTITION_KEY && column->position() >= 0 &&
           static_cast<size_t>(column->position()) < partition_key_.size()) {
         partition_key_[column->position()] = column;
-      } else if (column->type() == CASS_COLUMN_TYPE_CLUSTERING_KEY &&
-                 column->position() >= 0 &&
+      } else if (column->type() == CASS_COLUMN_TYPE_CLUSTERING_KEY && column->position() >= 0 &&
                  static_cast<size_t>(column->position()) < clustering_key_.size()) {
         clustering_key_[column->position()] = column;
-        clustering_key_order_[column->position()] = column->is_reversed() ? CASS_CLUSTERING_ORDER_DESC
-                                                                          : CASS_CLUSTERING_ORDER_ASC;
+        clustering_key_order_[column->position()] =
+            column->is_reversed() ? CASS_CLUSTERING_ORDER_DESC : CASS_CLUSTERING_ORDER_ASC;
       }
     }
 
     ColumnMetadata::Vec columns;
     columns.reserve(columns_.size());
 
-    std::copy(partition_key_.begin(), partition_key_.end(), std::back_inserter<ColumnMetadata::Vec>(columns));
-    std::copy(clustering_key_.begin(), clustering_key_.end(), std::back_inserter<ColumnMetadata::Vec>(columns));
+    std::copy(partition_key_.begin(), partition_key_.end(),
+              std::back_inserter<ColumnMetadata::Vec>(columns));
+    std::copy(clustering_key_.begin(), clustering_key_.end(),
+              std::back_inserter<ColumnMetadata::Vec>(columns));
 
-    for (ColumnMetadata::Vec::const_iterator i = columns_.begin(),
-         end = columns_.end(); i != end; ++i) {
+    for (ColumnMetadata::Vec::const_iterator i = columns_.begin(), end = columns_.end(); i != end;
+         ++i) {
       const ColumnMetadata::Ptr& column(*i);
       if (column->type() != CASS_COLUMN_TYPE_PARTITION_KEY &&
           column->type() != CASS_COLUMN_TYPE_CLUSTERING_KEY) {
@@ -1386,8 +1341,8 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
         }
       }
 
-      ParseResult::Ptr key_validator
-          = DataTypeClassNameParser::parse_with_composite(get_string_field("key_validator"), cache);
+      ParseResult::Ptr key_validator =
+          DataTypeClassNameParser::parse_with_composite(get_string_field("key_validator"), cache);
       size_t size = key_validator->types().size();
       partition_key_.reserve(size);
       for (size_t i = 0; i < size; ++i) {
@@ -1401,10 +1356,9 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
           }
           key_alias = ss.str();
         }
-        partition_key_.push_back(ColumnMetadata::Ptr(new ColumnMetadata(key_alias,
-                                                                        partition_key_.size(),
-                                                                        CASS_COLUMN_TYPE_PARTITION_KEY,
-                                                                        key_validator->types()[i])));
+        partition_key_.push_back(ColumnMetadata::Ptr(
+            new ColumnMetadata(key_alias, partition_key_.size(), CASS_COLUMN_TYPE_PARTITION_KEY,
+                               key_validator->types()[i])));
       }
     }
 
@@ -1420,12 +1374,13 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
       }
 
       // TODO: Figure out how to test these special cases and properly document them here
-      ParseResult::Ptr comparator
-          = DataTypeClassNameParser::parse_with_composite(get_string_field("comparator"), cache);
+      ParseResult::Ptr comparator =
+          DataTypeClassNameParser::parse_with_composite(get_string_field("comparator"), cache);
       size_t size = comparator->types().size();
       if (comparator->is_composite()) {
         if (!comparator->collections().empty() ||
-            (column_aliases.size() == size - 1 && comparator->types().back()->value_type() == CASS_VALUE_TYPE_TEXT)) {
+            (column_aliases.size() == size - 1 &&
+             comparator->types().back()->value_type() == CASS_VALUE_TYPE_TEXT)) {
           size = size - 1;
         }
       } else {
@@ -1443,10 +1398,9 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
           }
           column_alias = ss.str();
         }
-        clustering_key_.push_back(ColumnMetadata::Ptr(new ColumnMetadata(column_alias,
-                                                                         clustering_key_.size(),
-                                                                         CASS_COLUMN_TYPE_CLUSTERING_KEY,
-                                                                         comparator->types()[i])));
+        clustering_key_.push_back(ColumnMetadata::Ptr(
+            new ColumnMetadata(column_alias, clustering_key_.size(),
+                               CASS_COLUMN_TYPE_CLUSTERING_KEY, comparator->types()[i])));
         clustering_key_order_.push_back(comparator->reversed()[i] ? CASS_CLUSTERING_ORDER_DESC
                                                                   : CASS_CLUSTERING_ORDER_ASC);
       }
@@ -1467,20 +1421,20 @@ void TableMetadataBase::build_keys_and_sort(const VersionNumber& server_version,
 
 const TableMetadata::Ptr TableMetadata::NIL;
 
-TableMetadata::TableMetadata(const VersionNumber& server_version,
-                             const String& name, const RefBuffer::Ptr& buffer, const Row* row,
-                             bool is_virtual)
-  : TableMetadataBase(server_version, name, buffer, row, is_virtual) {
+TableMetadata::TableMetadata(const VersionNumber& server_version, const String& name,
+                             const RefBuffer::Ptr& buffer, const Row* row, bool is_virtual)
+    : TableMetadataBase(server_version, name, buffer, row, is_virtual) {
   add_field(buffer, row, table_column_name(server_version));
   if (server_version >= VersionNumber(3, 0, 0)) {
     add_field(buffer, row, "flags");
   }
 }
 
-void TableMetadata::add_column(const VersionNumber& server_version, const ColumnMetadata::Ptr& column) {
+void TableMetadata::add_column(const VersionNumber& server_version,
+                               const ColumnMetadata::Ptr& column) {
   if (server_version >= VersionNumber(3, 0, 0)) {
     if (column->type() == CASS_COLUMN_TYPE_REGULAR && column->data_type()->is_custom()) {
-      const CustomType *customType = static_cast<const CustomType *>(column->data_type().get());
+      const CustomType* customType = static_cast<const CustomType*>(column->data_type().get());
       if (customType->class_name() == EMPTY_TYPE) {
         // Don't add this column; it's a surrogate column in a dense table and
         // should not be exposed to the user.
@@ -1501,13 +1455,9 @@ const ViewMetadata* TableMetadata::get_view(const String& name) const {
   return i->get();
 }
 
-void TableMetadata::add_view(const ViewMetadata::Ptr& view) {
-  views_.push_back(view);
-}
+void TableMetadata::add_view(const ViewMetadata::Ptr& view) { views_.push_back(view); }
 
-void TableMetadata::sort_views() {
-  std::sort(views_.begin(), views_.end());
-}
+void TableMetadata::sort_views() { std::sort(views_.begin(), views_.end()); }
 
 void TableMetadata::key_aliases(SimpleDataTypeCache& cache, KeyAliases* output) const {
   const Value* aliases = get_field("key_aliases");
@@ -1518,14 +1468,15 @@ void TableMetadata::key_aliases(SimpleDataTypeCache& cache, KeyAliases* output)
       output->push_back(itr.value()->to_string());
     }
   }
-  if (output->empty()) {// C* 1.2 tables created via CQL2 or thrift don't have col meta or key aliases
-    ParseResult::Ptr key_validator_type
-        = DataTypeClassNameParser::parse_with_composite(get_string_field("key_validator"), cache);
+  if (output->empty()) { // C* 1.2 tables created via CQL2 or thrift don't have col meta or key
+                         // aliases
+    ParseResult::Ptr key_validator_type =
+        DataTypeClassNameParser::parse_with_composite(get_string_field("key_validator"), cache);
     const size_t count = key_validator_type->types().size();
     OStringStream ss("key");
     for (size_t i = 0; i < count; ++i) {
       if (i > 0) {
-        ss.seekp(3);// position after "key"
+        ss.seekp(3); // position after "key"
         ss << i + 1;
       }
       output->push_back(ss.str());
@@ -1535,13 +1486,11 @@ void TableMetadata::key_aliases(SimpleDataTypeCache& cache, KeyAliases* output)
 
 const ViewMetadata::Ptr ViewMetadata::NIL;
 
-ViewMetadata::ViewMetadata(const VersionNumber& server_version,
-                           const TableMetadata* table,
-                           const String& name, const RefBuffer::Ptr& buffer,
-                           const Row* row,
+ViewMetadata::ViewMetadata(const VersionNumber& server_version, const TableMetadata* table,
+                           const String& name, const RefBuffer::Ptr& buffer, const Row* row,
                            bool is_virtual)
-  : TableMetadataBase(server_version, name, buffer, row, is_virtual)
-  , base_table_(table) {
+    : TableMetadataBase(server_version, name, buffer, row, is_virtual)
+    , base_table_(table) {
   add_field(buffer, row, "keyspace_name");
   add_field(buffer, row, "view_name");
   add_field(buffer, row, "base_table_name");
@@ -1569,10 +1518,10 @@ void TableMetadata::clear_indexes() {
 
 FunctionMetadata::FunctionMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
                                    const String& name, const Value* signature,
-                                   KeyspaceMetadata* keyspace,
-                                   const RefBuffer::Ptr& buffer, const Row* row)
-  : MetadataBase(Metadata::full_function_name(name, signature->as_stringlist()))
-  , simple_name_(name) {
+                                   KeyspaceMetadata* keyspace, const RefBuffer::Ptr& buffer,
+                                   const Row* row)
+    : MetadataBase(Metadata::full_function_name(name, signature->as_stringlist()))
+    , simple_name_(name) {
   const Value* value1;
   const Value* value2;
 
@@ -1581,10 +1530,8 @@ FunctionMetadata::FunctionMetadata(const VersionNumber& server_version, SimpleDa
 
   value1 = add_field(buffer, row, "argument_names");
   value2 = add_field(buffer, row, "argument_types");
-  if (value1 != NULL &&
-      value1->value_type() == CASS_VALUE_TYPE_LIST &&
-      value1->primary_value_type() == CASS_VALUE_TYPE_VARCHAR &&
-      value2 != NULL &&
+  if (value1 != NULL && value1->value_type() == CASS_VALUE_TYPE_LIST &&
+      value1->primary_value_type() == CASS_VALUE_TYPE_VARCHAR && value2 != NULL &&
       value2->value_type() == CASS_VALUE_TYPE_LIST &&
       value2->primary_value_type() == CASS_VALUE_TYPE_VARCHAR) {
     CollectionIterator iterator1(value1);
@@ -1592,21 +1539,22 @@ FunctionMetadata::FunctionMetadata(const VersionNumber& server_version, SimpleDa
     if (server_version >= VersionNumber(3, 0, 0)) {
       while (iterator1.next() && iterator2.next()) {
         StringRef arg_name(iterator1.value()->to_string_ref());
-        DataType::ConstPtr arg_type(DataTypeCqlNameParser::parse(iterator2.value()->to_string(), cache, keyspace));
+        DataType::ConstPtr arg_type(
+            DataTypeCqlNameParser::parse(iterator2.value()->to_string(), cache, keyspace));
         args_.push_back(Argument(arg_name, arg_type));
       }
     } else {
       while (iterator1.next() && iterator2.next()) {
         StringRef arg_name(iterator1.value()->to_string_ref());
-        DataType::ConstPtr arg_type(DataTypeClassNameParser::parse_one(iterator2.value()->to_string(), cache));
+        DataType::ConstPtr arg_type(
+            DataTypeClassNameParser::parse_one(iterator2.value()->to_string(), cache));
         args_.push_back(Argument(arg_name, arg_type));
       }
     }
   }
 
   value1 = add_field(buffer, row, "return_type");
-  if (value1 != NULL &&
-      value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value1 != NULL && value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     if (server_version >= VersionNumber(3, 0, 0)) {
       return_type_ = DataTypeCqlNameParser::parse(value1->to_string(), cache, keyspace);
     } else {
@@ -1615,20 +1563,17 @@ FunctionMetadata::FunctionMetadata(const VersionNumber& server_version, SimpleDa
   }
 
   value1 = add_field(buffer, row, "body");
-  if (value1 != NULL &&
-      value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value1 != NULL && value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     body_ = value1->to_string_ref();
   }
 
   value1 = add_field(buffer, row, "language");
-  if (value1 != NULL &&
-      value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value1 != NULL && value1->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     language_ = value1->to_string_ref();
   }
 
   value1 = add_field(buffer, row, "called_on_null_input");
-  if (value1 != NULL &&
-      value1->value_type() == CASS_VALUE_TYPE_BOOLEAN) {
+  if (value1 != NULL && value1->value_type() == CASS_VALUE_TYPE_BOOLEAN) {
     called_on_null_input_ = value1->as_bool();
   }
 }
@@ -1639,12 +1584,12 @@ const DataType* FunctionMetadata::get_arg_type(StringRef name) const {
   return i->type.get();
 }
 
-AggregateMetadata::AggregateMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
-                                     const String& name, const Value* signature,
-                                     KeyspaceMetadata* keyspace,
+AggregateMetadata::AggregateMetadata(const VersionNumber& server_version,
+                                     SimpleDataTypeCache& cache, const String& name,
+                                     const Value* signature, KeyspaceMetadata* keyspace,
                                      const RefBuffer::Ptr& buffer, const Row* row)
-  : MetadataBase(Metadata::full_function_name(name, signature->as_stringlist()))
-  , simple_name_(name) {
+    : MetadataBase(Metadata::full_function_name(name, signature->as_stringlist()))
+    , simple_name_(name) {
   const Value* value;
   const FunctionMetadata::Map& functions = keyspace->functions();
 
@@ -1652,24 +1597,24 @@ AggregateMetadata::AggregateMetadata(const VersionNumber& server_version, Simple
   add_field(buffer, row, "aggregate_name");
 
   value = add_field(buffer, row, "argument_types");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_LIST &&
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_LIST &&
       value->primary_value_type() == CASS_VALUE_TYPE_VARCHAR) {
     CollectionIterator iterator(value);
     if (server_version >= VersionNumber(3, 0, 0)) {
       while (iterator.next()) {
-        arg_types_.push_back(DataTypeCqlNameParser::parse(iterator.value()->to_string(), cache, keyspace));
+        arg_types_.push_back(
+            DataTypeCqlNameParser::parse(iterator.value()->to_string(), cache, keyspace));
       }
     } else {
       while (iterator.next()) {
-        arg_types_.push_back(DataTypeClassNameParser::parse_one(iterator.value()->to_string(), cache));
+        arg_types_.push_back(
+            DataTypeClassNameParser::parse_one(iterator.value()->to_string(), cache));
       }
     }
   }
 
   value = add_field(buffer, row, "return_type");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     if (server_version >= VersionNumber(3, 0, 0)) {
       return_type_ = DataTypeCqlNameParser::parse(value->to_string(), cache, keyspace);
     } else {
@@ -1678,8 +1623,7 @@ AggregateMetadata::AggregateMetadata(const VersionNumber& server_version, Simple
   }
 
   value = add_field(buffer, row, "state_type");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     if (server_version >= VersionNumber(3, 0, 0)) {
       state_type_ = DataTypeCqlNameParser::parse(value->to_string(), cache, keyspace);
     } else {
@@ -1688,25 +1632,25 @@ AggregateMetadata::AggregateMetadata(const VersionNumber& server_version, Simple
   }
 
   value = add_field(buffer, row, "final_func");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     StringVec final_func_signature;
     final_func_signature.push_back(state_type_->to_string());
-    String full_final_func_name(Metadata::full_function_name(value->to_string(), final_func_signature));
+    String full_final_func_name(
+        Metadata::full_function_name(value->to_string(), final_func_signature));
     FunctionMetadata::Map::const_iterator i = functions.find(full_final_func_name);
     if (i != functions.end()) final_func_ = i->second;
   }
 
   value = add_field(buffer, row, "state_func");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     StringVec state_func_signature;
     state_func_signature.push_back(state_type_->to_string());
     CollectionIterator iterator(signature);
     while (iterator.next()) {
       state_func_signature.push_back(iterator.value()->to_string());
     }
-    String full_state_func_name(Metadata::full_function_name(value->to_string(), state_func_signature));
+    String full_state_func_name(
+        Metadata::full_function_name(value->to_string(), state_func_signature));
     FunctionMetadata::Map::const_iterator i = functions.find(full_state_func_name);
     if (i != functions.end()) state_func_ = i->second;
   }
@@ -1717,21 +1661,18 @@ AggregateMetadata::AggregateMetadata(const VersionNumber& server_version, Simple
       init_cond_ = Value(state_type_, value->decoder());
     } else if (server_version >= VersionNumber(3, 0, 0) &&
                value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
-      init_cond_ = Value(cache.by_value_type(CASS_VALUE_TYPE_VARCHAR),
-                         value->decoder());
+      init_cond_ = Value(cache.by_value_type(CASS_VALUE_TYPE_VARCHAR), value->decoder());
     }
-
   }
 }
 
-IndexMetadata::Ptr IndexMetadata::from_row(const String& index_name,
-                                           const RefBuffer::Ptr& buffer, const Row* row) {
+IndexMetadata::Ptr IndexMetadata::from_row(const String& index_name, const RefBuffer::Ptr& buffer,
+                                           const Row* row) {
   IndexMetadata::Ptr index(new IndexMetadata(index_name));
 
   StringRef kind;
   const Value* value = index->add_field(buffer, row, "kind");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     kind = value->to_string_ref();
   }
 
@@ -1744,10 +1685,9 @@ IndexMetadata::Ptr IndexMetadata::from_row(const String& index_name,
 void IndexMetadata::update(StringRef kind, const Value* options) {
   type_ = index_type_from_string(kind);
 
-  if (options != NULL &&
-      options->value_type() == CASS_VALUE_TYPE_MAP) {
+  if (options != NULL && options->value_type() == CASS_VALUE_TYPE_MAP) {
     MapIterator iterator(options);
-    while(iterator.next()) {
+    while (iterator.next()) {
       if (iterator.key()->to_string_ref() == "target") {
         target_ = iterator.value()->to_string();
       }
@@ -1757,7 +1697,8 @@ void IndexMetadata::update(StringRef kind, const Value* options) {
   options_ = *options;
 }
 
-IndexMetadata::Ptr IndexMetadata::from_legacy(const String& index_name, const ColumnMetadata* column,
+IndexMetadata::Ptr IndexMetadata::from_legacy(const String& index_name,
+                                              const ColumnMetadata* column,
                                               const RefBuffer::Ptr& buffer, const Row* row) {
   IndexMetadata::Ptr index(new IndexMetadata(index_name));
 
@@ -1765,8 +1706,7 @@ IndexMetadata::Ptr IndexMetadata::from_legacy(const String& index_name, const Co
 
   StringRef index_type;
   const Value* value = index->add_field(buffer, row, "index_type");
-  if (value != NULL &&
-      value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+  if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
     index_type = value->to_string_ref();
   }
 
@@ -1776,30 +1716,29 @@ IndexMetadata::Ptr IndexMetadata::from_legacy(const String& index_name, const Co
   return index;
 }
 
-void IndexMetadata::update_legacy(StringRef index_type, const ColumnMetadata* column, const Value* options) {
+void IndexMetadata::update_legacy(StringRef index_type, const ColumnMetadata* column,
+                                  const Value* options) {
   type_ = index_type_from_string(index_type);
   target_ = target_from_legacy(column, options);
   options_ = *options;
 }
 
-String IndexMetadata::target_from_legacy(const ColumnMetadata* column,
-                                         const Value* options) {
+String IndexMetadata::target_from_legacy(const ColumnMetadata* column, const Value* options) {
   String column_name(column->name());
 
   escape_id(column_name);
 
-  if (options != NULL &&
-      options->value_type() == CASS_VALUE_TYPE_MAP) {
+  if (options != NULL && options->value_type() == CASS_VALUE_TYPE_MAP) {
     MapIterator iterator(options);
 
     while (iterator.next()) {
       String key(iterator.key()->to_string());
       if (key.find("index_keys") != String::npos) {
-        return "keys("  + column_name + ")";
+        return "keys(" + column_name + ")";
       } else if (key.find("index_keys_and_values") != String::npos) {
-        return "entries("  + column_name + ")";
-      } else  if (column->data_type()->is_collection()) { // TODO(mpenick): && is_frozen()
-        return "full("  + column_name + ")";
+        return "entries(" + column_name + ")";
+      } else if (column->data_type()->is_collection()) { // TODO(mpenick): && is_frozen()
+        return "full(" + column_name + ")";
       }
     }
   }
@@ -1819,13 +1758,12 @@ CassIndexType IndexMetadata::index_type_from_string(StringRef index_type) {
 }
 
 ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
-                               const String& name,
-                               KeyspaceMetadata* keyspace,
+                               const String& name, KeyspaceMetadata* keyspace,
                                const RefBuffer::Ptr& buffer, const Row* row)
-  : MetadataBase(name)
-  , type_(CASS_COLUMN_TYPE_REGULAR)
-  , position_(0)
-  , is_reversed_(false) {
+    : MetadataBase(name)
+    , type_(CASS_COLUMN_TYPE_REGULAR)
+    , position_(0)
+    , is_reversed_(false) {
   const Value* value;
 
   add_field(buffer, row, "keyspace_name");
@@ -1834,8 +1772,7 @@ ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTy
 
   if (server_version >= VersionNumber(3, 0, 0)) {
     value = add_field(buffer, row, "clustering_order");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_VARCHAR &&
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR &&
         value->to_string_ref().iequals("desc")) {
       is_reversed_ = true;
     }
@@ -1843,14 +1780,13 @@ ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTy
     add_field(buffer, row, "column_name_bytes");
 
     value = add_field(buffer, row, "kind");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
       StringRef type = value->to_string_ref();
       if (type == "partition_key") {
         type_ = CASS_COLUMN_TYPE_PARTITION_KEY;
-      } else  if (type == "clustering") {
+      } else if (type == "clustering") {
         type_ = CASS_COLUMN_TYPE_CLUSTERING_KEY;
-      } else  if (type == "static") {
+      } else if (type == "static") {
         type_ = CASS_COLUMN_TYPE_STATIC;
       } else {
         type_ = CASS_COLUMN_TYPE_REGULAR;
@@ -1858,30 +1794,27 @@ ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTy
     }
 
     value = add_field(buffer, row, "position");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_INT) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_INT) {
       position_ = value->as_int32();
       if (position_ < 0) position_ = 0;
     }
 
     value = add_field(buffer, row, "type");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
       String type(value->to_string());
       data_type_ = DataTypeCqlNameParser::parse(type, cache, keyspace);
     }
   } else {
     value = add_field(buffer, row, "type");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
       StringRef type = value->to_string_ref();
       if (type == "partition_key") {
         type_ = CASS_COLUMN_TYPE_PARTITION_KEY;
-      } else  if (type == "clustering_key") {
+      } else if (type == "clustering_key") {
         type_ = CASS_COLUMN_TYPE_CLUSTERING_KEY;
-      } else  if (type == "static") {
+      } else if (type == "static") {
         type_ = CASS_COLUMN_TYPE_STATIC;
-      } else  if (type == "compact_value") {
+      } else if (type == "compact_value") {
         type_ = CASS_COLUMN_TYPE_COMPACT_VALUE;
       } else {
         type_ = CASS_COLUMN_TYPE_REGULAR;
@@ -1891,14 +1824,12 @@ ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTy
     value = add_field(buffer, row, "component_index");
     // For C* 2.0 to 2.2 this is "null" for single component partition keys
     // so the default position of 0 works. C* 1.2 and below don't use this.
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_INT) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_INT) {
       position_ = value->as_int32();
     }
 
     value = add_field(buffer, row, "validator");
-    if (value != NULL &&
-        value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+    if (value != NULL && value->value_type() == CASS_VALUE_TYPE_VARCHAR) {
       String validator(value->to_string());
       data_type_ = DataTypeClassNameParser::parse_one(validator, cache);
       is_reversed_ = DataTypeClassNameParser::is_reversed(validator);
@@ -1911,8 +1842,7 @@ ColumnMetadata::ColumnMetadata(const VersionNumber& server_version, SimpleDataTy
 }
 
 void Metadata::InternalData::update_keyspaces(const VersionNumber& server_version,
-                                              const ResultResponse* result,
-                                              bool is_virtual) {
+                                              const ResultResponse* result, bool is_virtual) {
   RefBuffer::Ptr buffer = result->buffer();
   ResultIterator rows(result);
 
@@ -1946,7 +1876,8 @@ void Metadata::InternalData::update_tables(const VersionNumber& server_version,
 
     if (!row->get_string_by_name("keyspace_name", &temp_keyspace_name) ||
         !row->get_string_by_name(table_column_name(server_version), &table_name)) {
-      LOG_ERROR("Unable to get column value for 'keyspace_name' or '%s'", table_column_name(server_version));
+      LOG_ERROR("Unable to get column value for 'keyspace_name' or '%s'",
+                table_column_name(server_version));
       continue;
     }
 
@@ -1955,10 +1886,8 @@ void Metadata::InternalData::update_tables(const VersionNumber& server_version,
       keyspace = get_or_create_keyspace(keyspace_name);
     }
 
-    keyspace->add_table(TableMetadata::Ptr(new TableMetadata(server_version,
-                                                             table_name,
-                                                             buffer, row,
-                                                             keyspace->is_virtual())));
+    keyspace->add_table(TableMetadata::Ptr(
+        new TableMetadata(server_version, table_name, buffer, row, keyspace->is_virtual())));
   }
 }
 
@@ -2006,24 +1935,22 @@ void Metadata::InternalData::update_views(const VersionNumber& server_version,
       continue;
     }
 
-    ViewMetadata::Ptr view(new ViewMetadata(server_version,
-                                            table.get(),
-                                            view_name,
-                                            buffer, row,
+    ViewMetadata::Ptr view(new ViewMetadata(server_version, table.get(), view_name, buffer, row,
                                             keyspace->is_virtual()));
     keyspace->add_view(view);
     table->add_view(view);
     updated_tables.push_back(table);
   }
 
-  for (TableMetadata::Vec::iterator i = updated_tables.begin(),
-       end = updated_tables.end(); i != end; ++i) {
+  for (TableMetadata::Vec::iterator i = updated_tables.begin(), end = updated_tables.end();
+       i != end; ++i) {
     (*i)->sort_views();
   }
 }
 
 void Metadata::InternalData::update_user_types(const VersionNumber& server_version,
-                                               SimpleDataTypeCache& cache, const ResultResponse* result) {
+                                               SimpleDataTypeCache& cache,
+                                               const ResultResponse* result) {
   ResultIterator rows(result);
 
   String keyspace_name;
@@ -2065,14 +1992,15 @@ void Metadata::InternalData::update_user_types(const VersionNumber& server_versi
     UserType::FieldVec fields;
 
     while (names.next()) {
-      if(!types.next()) {
-        LOG_ERROR("The number of 'field_type's doesn\"t match the number of field_names for keyspace \"%s\" and type \"%s\"",
+      if (!types.next()) {
+        LOG_ERROR("The number of 'field_type's doesn\"t match the number of field_names for "
+                  "keyspace \"%s\" and type \"%s\"",
                   keyspace_name.c_str(), type_name.c_str());
         break;
       }
 
-      const cass::Value* name = names.value();
-      const cass::Value* type = types.value();
+      const Value* name = names.value();
+      const Value* type = types.value();
 
       if (name->is_null() || type->is_null()) {
         LOG_ERROR("'field_name' or 'field_type' is null for keyspace \"%s\" and type \"%s\"",
@@ -2092,9 +2020,7 @@ void Metadata::InternalData::update_user_types(const VersionNumber& server_versi
 
       if (!data_type) {
         LOG_ERROR("Invalid 'field_type' for field \"%s\", keyspace \"%s\" and type \"%s\"",
-                  field_name.c_str(),
-                  keyspace_name.c_str(),
-                  type_name.c_str());
+                  field_name.c_str(), keyspace_name.c_str(), type_name.c_str());
         break;
       }
 
@@ -2106,7 +2032,8 @@ void Metadata::InternalData::update_user_types(const VersionNumber& server_versi
 }
 
 void Metadata::InternalData::update_functions(const VersionNumber& server_version,
-                                              SimpleDataTypeCache& cache, const ResultResponse *result) {
+                                              SimpleDataTypeCache& cache,
+                                              const ResultResponse* result) {
   RefBuffer::Ptr buffer = result->buffer();
 
   ResultIterator rows(result);
@@ -2121,8 +2048,7 @@ void Metadata::InternalData::update_functions(const VersionNumber& server_versio
 
     const Value* signature = row->get_by_name(signature_column_name(server_version));
     if (!row->get_string_by_name("keyspace_name", &temp_keyspace_name) ||
-        !row->get_string_by_name("function_name", &function_name) ||
-        signature == NULL) {
+        !row->get_string_by_name("function_name", &function_name) || signature == NULL) {
       LOG_ERROR("Unable to get column value for 'keyspace_name', 'function_name' or 'signature'");
       continue;
     }
@@ -2132,16 +2058,14 @@ void Metadata::InternalData::update_functions(const VersionNumber& server_versio
       keyspace = get_or_create_keyspace(keyspace_name);
     }
 
-    keyspace->add_function(FunctionMetadata::Ptr(new FunctionMetadata(server_version, cache,
-                                                                      function_name, signature,
-                                                                      keyspace,
-                                                                      buffer, row)));
-
+    keyspace->add_function(FunctionMetadata::Ptr(new FunctionMetadata(
+        server_version, cache, function_name, signature, keyspace, buffer, row)));
   }
 }
 
 void Metadata::InternalData::update_aggregates(const VersionNumber& server_version,
-                                               SimpleDataTypeCache& cache, const ResultResponse* result) {
+                                               SimpleDataTypeCache& cache,
+                                               const ResultResponse* result) {
   RefBuffer::Ptr buffer = result->buffer();
 
   ResultIterator rows(result);
@@ -2156,8 +2080,7 @@ void Metadata::InternalData::update_aggregates(const VersionNumber& server_versi
 
     const Value* signature = row->get_by_name(signature_column_name(server_version));
     if (!row->get_string_by_name("keyspace_name", &temp_keyspace_name) ||
-        !row->get_string_by_name("aggregate_name", &aggregate_name) ||
-        signature == NULL) {
+        !row->get_string_by_name("aggregate_name", &aggregate_name) || signature == NULL) {
       LOG_ERROR("Unable to get column value for 'keyspace_name', 'aggregate_name' or 'signature'");
       continue;
     }
@@ -2167,10 +2090,8 @@ void Metadata::InternalData::update_aggregates(const VersionNumber& server_versi
       keyspace = get_or_create_keyspace(keyspace_name);
     }
 
-    keyspace->add_aggregate(AggregateMetadata::Ptr(new AggregateMetadata(server_version, cache,
-                                                                         aggregate_name, signature,
-                                                                         keyspace,
-                                                                         buffer, row)));
+    keyspace->add_aggregate(AggregateMetadata::Ptr(new AggregateMetadata(
+        server_version, cache, aggregate_name, signature, keyspace, buffer, row)));
   }
 }
 
@@ -2191,20 +2112,23 @@ void Metadata::InternalData::drop_user_type(const String& keyspace_name, const S
   i->second.drop_user_type(type_name);
 }
 
-void Metadata::InternalData::drop_function(const String& keyspace_name, const String& full_function_name) {
+void Metadata::InternalData::drop_function(const String& keyspace_name,
+                                           const String& full_function_name) {
   KeyspaceMetadata::Map::iterator i = keyspaces_->find(keyspace_name);
   if (i == keyspaces_->end()) return;
   i->second.drop_function(full_function_name);
 }
 
-void Metadata::InternalData::drop_aggregate(const String& keyspace_name, const String& full_aggregate_name) {
+void Metadata::InternalData::drop_aggregate(const String& keyspace_name,
+                                            const String& full_aggregate_name) {
   KeyspaceMetadata::Map::iterator i = keyspaces_->find(keyspace_name);
   if (i == keyspaces_->end()) return;
   i->second.drop_aggregate(full_aggregate_name);
 }
 
 void Metadata::InternalData::update_columns(const VersionNumber& server_version,
-                                            SimpleDataTypeCache& cache, const ResultResponse* result) {
+                                            SimpleDataTypeCache& cache,
+                                            const ResultResponse* result) {
   RefBuffer::Ptr buffer = result->buffer();
 
   ResultIterator rows(result);
@@ -2242,7 +2166,7 @@ void Metadata::InternalData::update_columns(const VersionNumber& server_version,
       }
       table_or_view_name = temp_table_or_view_name;
       table_or_view = TableMetadataBase::Ptr(keyspace->get_table(table_or_view_name));
-      if (!table_or_view)  {
+      if (!table_or_view) {
         table_or_view = TableMetadataBase::Ptr(keyspace->get_view(table_or_view_name));
         if (!table_or_view) continue;
       }
@@ -2250,10 +2174,9 @@ void Metadata::InternalData::update_columns(const VersionNumber& server_version,
     }
 
     if (table_or_view) {
-      table_or_view->add_column(server_version,
-                                ColumnMetadata::Ptr(new ColumnMetadata(server_version,
-                                                                       cache, column_name,
-                                                                       keyspace, buffer, row)));
+      table_or_view->add_column(
+          server_version, ColumnMetadata::Ptr(new ColumnMetadata(server_version, cache, column_name,
+                                                                 keyspace, buffer, row)));
     }
   }
 
@@ -2306,8 +2229,7 @@ void Metadata::InternalData::update_legacy_indexes(const VersionNumber& server_v
       const ColumnMetadata* column = table->get_column(column_name);
       if (column != NULL) {
         const Value* index_type = column->get_field("index_type");
-        if (index_type != NULL &&
-            index_type->value_type() == CASS_VALUE_TYPE_VARCHAR) {
+        if (index_type != NULL && index_type->value_type() == CASS_VALUE_TYPE_VARCHAR) {
           String index_name = column->get_string_field("index_name");
           table->add_index(IndexMetadata::from_legacy(index_name, column, buffer, row));
         }
@@ -2358,13 +2280,11 @@ void Metadata::InternalData::update_indexes(const VersionNumber& server_version,
   }
 }
 
-KeyspaceMetadata* Metadata::InternalData::get_or_create_keyspace(const String& name, bool is_virtual) {
+KeyspaceMetadata* Metadata::InternalData::get_or_create_keyspace(const String& name,
+                                                                 bool is_virtual) {
   KeyspaceMetadata::Map::iterator i = keyspaces_->find(name);
   if (i == keyspaces_->end()) {
     i = keyspaces_->insert(std::make_pair(name, KeyspaceMetadata(name, is_virtual))).first;
   }
   return &i->second;
 }
-
-} // namespace cass
-
diff --git a/src/metadata.hpp b/src/metadata.hpp
index 518a24c7f..b500f8217 100644
--- a/src/metadata.hpp
+++ b/src/metadata.hpp
@@ -14,11 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SCHEMA_METADATA_HPP_INCLUDED__
-#define __CASS_SCHEMA_METADATA_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SCHEMA_METADATA_HPP
+#define DATASTAX_INTERNAL_SCHEMA_METADATA_HPP
 
 #include "allocated.hpp"
 #include "copy_on_write_ptr.hpp"
+#include "data_type.hpp"
 #include "external.hpp"
 #include "host.hpp"
 #include "iterator.hpp"
@@ -28,13 +29,12 @@
 #include "scoped_lock.hpp"
 #include "scoped_ptr.hpp"
 #include "string.hpp"
-#include "data_type.hpp"
 #include "value.hpp"
 #include "vector.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ColumnMetadata;
 class TableMetadata;
@@ -42,15 +42,15 @@ class KeyspaceMetadata;
 class Row;
 class ResultResponse;
 
-template<class T>
+template <class T>
 class MapIteratorImpl {
 public:
   typedef T ItemType;
-  typedef cass::Map<String, T> Collection;
+  typedef internal::Map<String, T> Collection;
 
   MapIteratorImpl(const Collection& map)
-    : next_(map.begin())
-    , end_(map.end()) { }
+      : next_(map.begin())
+      , end_(map.end()) {}
 
   bool next() {
     if (next_ == end_) {
@@ -60,9 +60,7 @@ class MapIteratorImpl {
     return true;
   }
 
-  const T& item() const {
-    return current_->second;
-  }
+  const T& item() const { return current_->second; }
 
 private:
   typename Collection::const_iterator next_;
@@ -70,15 +68,15 @@ class MapIteratorImpl {
   typename Collection::const_iterator end_;
 };
 
-template<class T>
+template <class T>
 class VecIteratorImpl {
 public:
   typedef T ItemType;
   typedef Vector<T> Collection;
 
   VecIteratorImpl(const Collection& vec)
-    : next_(vec.begin())
-    , end_(vec.end()) { }
+      : next_(vec.begin())
+      , end_(vec.end()) {}
 
   bool next() {
     if (next_ == end_) {
@@ -88,9 +86,7 @@ class VecIteratorImpl {
     return true;
   }
 
-  const T& item() const {
-    return (*current_);
-  }
+  const T& item() const { return (*current_); }
 
 private:
   typename Collection::const_iterator next_;
@@ -100,27 +96,21 @@ class VecIteratorImpl {
 
 class MetadataField {
 public:
-  typedef cass::Map<String, MetadataField> Map;
+  typedef internal::Map<String, MetadataField> Map;
 
-  MetadataField() { }
+  MetadataField() {}
 
   MetadataField(const String& name)
-    : name_(name) { }
+      : name_(name) {}
 
-  MetadataField(const String& name,
-                const Value& value,
-                const RefBuffer::Ptr& buffer)
-    : name_(name)
-    , value_(value)
-    , buffer_(buffer) { }
+  MetadataField(const String& name, const Value& value, const RefBuffer::Ptr& buffer)
+      : name_(name)
+      , value_(value)
+      , buffer_(buffer) {}
 
-  const String& name() const {
-    return name_;
-  }
+  const String& name() const { return name_; }
 
-  const Value* value() const {
-    return &value_;
-  }
+  const Value* value() const { return &value_; }
 
 private:
   String name_;
@@ -133,8 +123,8 @@ class MetadataFieldIterator : public Iterator {
   typedef MapIteratorImpl<MetadataField>::Collection Map;
 
   MetadataFieldIterator(const Map& map)
-    : Iterator(CASS_ITERATOR_TYPE_META_FIELD)
-    , impl_(map) { }
+      : Iterator(CASS_ITERATOR_TYPE_META_FIELD)
+      , impl_(map) {}
 
   virtual bool next() { return impl_.next(); }
   const MetadataField* field() const { return &impl_.item(); }
@@ -146,7 +136,7 @@ class MetadataFieldIterator : public Iterator {
 class MetadataBase {
 public:
   MetadataBase(const String& name)
-    : name_(name) { }
+      : name_(name) {}
 
   const String& name() const { return name_; }
 
@@ -154,9 +144,7 @@ class MetadataBase {
   String get_string_field(const String& name) const;
   Iterator* iterator_fields() const { return new MetadataFieldIterator(fields_); }
 
-  void swap_fields(MetadataBase& meta) {
-    fields_.swap(meta.fields_);
-  }
+  void swap_fields(MetadataBase& meta) { fields_.swap(meta.fields_); }
 
 protected:
   const Value* add_field(const RefBuffer::Ptr& buffer, const Row* row, const String& name);
@@ -170,14 +158,14 @@ class MetadataBase {
   const String name_;
 };
 
-template<class IteratorImpl>
+template <class IteratorImpl>
 class MetadataIteratorImpl : public Iterator {
 public:
   typedef typename IteratorImpl::Collection Collection;
 
   MetadataIteratorImpl(CassIteratorType type, const Collection& colleciton)
-    : Iterator(type)
-    , impl_(colleciton) { }
+      : Iterator(type)
+      , impl_(colleciton) {}
 
   virtual bool next() { return impl_.next(); }
 
@@ -185,25 +173,26 @@ class MetadataIteratorImpl : public Iterator {
   IteratorImpl impl_;
 };
 
-class FunctionMetadata : public MetadataBase, public RefCounted<FunctionMetadata> {
+class FunctionMetadata
+    : public MetadataBase
+    , public RefCounted<FunctionMetadata> {
 public:
   typedef SharedRefPtr<FunctionMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
 
   struct Argument {
     typedef Vector<Argument> Vec;
 
     Argument(const StringRef& name, const DataType::ConstPtr& type)
-      : name(name)
-      , type(type) { }
+        : name(name)
+        , type(type) {}
     StringRef name;
     DataType::ConstPtr type;
   };
 
   FunctionMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
-                   const String& name, const Value* signature,
-                   KeyspaceMetadata* keyspace,
+                   const String& name, const Value* signature, KeyspaceMetadata* keyspace,
                    const RefBuffer::Ptr& buffer, const Row* row);
 
   const String& simple_name() const { return simple_name_; }
@@ -224,19 +213,18 @@ class FunctionMetadata : public MetadataBase, public RefCounted<FunctionMetadata
   bool called_on_null_input_;
 };
 
-inline bool operator==(const FunctionMetadata::Argument& a, StringRef b) {
-  return a.name == b;
-}
+inline bool operator==(const FunctionMetadata::Argument& a, StringRef b) { return a.name == b; }
 
-class AggregateMetadata : public MetadataBase, public RefCounted<AggregateMetadata> {
+class AggregateMetadata
+    : public MetadataBase
+    , public RefCounted<AggregateMetadata> {
 public:
   typedef SharedRefPtr<AggregateMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
 
   AggregateMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
-                    const String& name, const Value* signature,
-                    KeyspaceMetadata* keyspace,
+                    const String& name, const Value* signature, KeyspaceMetadata* keyspace,
                     const RefBuffer::Ptr& buffer, const Row* row);
 
   const String& simple_name() const { return simple_name_; }
@@ -257,10 +245,12 @@ class AggregateMetadata : public MetadataBase, public RefCounted<AggregateMetada
   Value init_cond_;
 };
 
-class IndexMetadata : public MetadataBase, public RefCounted<IndexMetadata> {
+class IndexMetadata
+    : public MetadataBase
+    , public RefCounted<IndexMetadata> {
 public:
   typedef SharedRefPtr<IndexMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
 
   CassIndexType type() const { return type_; }
@@ -268,22 +258,20 @@ class IndexMetadata : public MetadataBase, public RefCounted<IndexMetadata> {
   const Value* options() const { return &options_; }
 
   IndexMetadata(const String& index_name)
-    : MetadataBase(index_name)
-    , type_(CASS_INDEX_TYPE_UNKNOWN) { }
+      : MetadataBase(index_name)
+      , type_(CASS_INDEX_TYPE_UNKNOWN) {}
 
-  static IndexMetadata::Ptr from_row(const String& index_name,
-                                     const RefBuffer::Ptr& buffer, const Row* row);
+  static IndexMetadata::Ptr from_row(const String& index_name, const RefBuffer::Ptr& buffer,
+                                     const Row* row);
   void update(StringRef index_type, const Value* options);
 
   static IndexMetadata::Ptr from_legacy(const String& index_name, const ColumnMetadata* column,
                                         const RefBuffer::Ptr& buffer, const Row* row);
   void update_legacy(StringRef index_type, const ColumnMetadata* column, const Value* options);
 
-
 private:
   static CassIndexType index_type_from_string(StringRef index_type);
-  static String target_from_legacy(const ColumnMetadata* column,
-                                        const Value* options);
+  static String target_from_legacy(const ColumnMetadata* column, const Value* options);
 
 private:
   CassIndexType type_;
@@ -294,32 +282,31 @@ class IndexMetadata : public MetadataBase, public RefCounted<IndexMetadata> {
   DISALLOW_COPY_AND_ASSIGN(IndexMetadata);
 };
 
-class ColumnMetadata : public MetadataBase, public RefCounted<ColumnMetadata> {
+class ColumnMetadata
+    : public MetadataBase
+    , public RefCounted<ColumnMetadata> {
 public:
   typedef SharedRefPtr<ColumnMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
 
   ColumnMetadata(const String& name)
-    : MetadataBase(name)
-    , type_(CASS_COLUMN_TYPE_REGULAR)
-    , position_(0)
-    , is_reversed_(false) { }
-
-  ColumnMetadata(const String& name,
-                 int32_t position,
-                 CassColumnType type,
+      : MetadataBase(name)
+      , type_(CASS_COLUMN_TYPE_REGULAR)
+      , position_(0)
+      , is_reversed_(false) {}
+
+  ColumnMetadata(const String& name, int32_t position, CassColumnType type,
                  const DataType::ConstPtr& data_type)
-    : MetadataBase(name)
-    , type_(type)
-    , position_(position)
-    , data_type_(data_type)
-    , is_reversed_(false) { }
+      : MetadataBase(name)
+      , type_(type)
+      , position_(position)
+      , data_type_(data_type)
+      , is_reversed_(false) {}
 
   ColumnMetadata(const VersionNumber& server_version, SimpleDataTypeCache& cache,
-                 const String& name,
-                 KeyspaceMetadata* keyspace,
-                 const RefBuffer::Ptr& buffer, const Row* row);
+                 const String& name, KeyspaceMetadata* keyspace, const RefBuffer::Ptr& buffer,
+                 const Row* row);
 
   CassColumnType type() const { return type_; }
   int32_t position() const { return position_; }
@@ -336,11 +323,11 @@ class ColumnMetadata : public MetadataBase, public RefCounted<ColumnMetadata> {
   DISALLOW_COPY_AND_ASSIGN(ColumnMetadata);
 };
 
-inline bool operator==(const ColumnMetadata::Ptr& a, const String& b) {
-  return a->name() == b;
-}
+inline bool operator==(const ColumnMetadata::Ptr& a, const String& b) { return a->name() == b; }
 
-class TableMetadataBase : public MetadataBase, public RefCounted<TableMetadataBase> {
+class TableMetadataBase
+    : public MetadataBase
+    , public RefCounted<TableMetadataBase> {
 public:
   typedef SharedRefPtr<TableMetadataBase> Ptr;
   typedef Vector<CassClusteringOrder> ClusteringOrderVec;
@@ -348,25 +335,25 @@ class TableMetadataBase : public MetadataBase, public RefCounted<TableMetadataBa
   class ColumnIterator : public MetadataIteratorImpl<VecIteratorImpl<ColumnMetadata::Ptr> > {
   public:
     ColumnIterator(const ColumnIterator::Collection& collection)
-      : MetadataIteratorImpl<VecIteratorImpl<ColumnMetadata::Ptr> >(CASS_ITERATOR_TYPE_COLUMN_META, collection) { }
+        : MetadataIteratorImpl<VecIteratorImpl<ColumnMetadata::Ptr> >(
+              CASS_ITERATOR_TYPE_COLUMN_META, collection) {}
     const ColumnMetadata* column() const { return impl_.item().get(); }
   };
 
-  TableMetadataBase(const VersionNumber& server_version,
-                    const String& name, const RefBuffer::Ptr& buffer, const Row* row,
-                    bool is_virtual);
+  TableMetadataBase(const VersionNumber& server_version, const String& name,
+                    const RefBuffer::Ptr& buffer, const Row* row, bool is_virtual);
 
   TableMetadataBase(const TableMetadataBase& other)
-    : MetadataBase(other)
-    , RefCounted<TableMetadataBase>()
-    , is_virtual_(other.is_virtual_)
-    , columns_(other.columns_)
-    , columns_by_name_(other.columns_by_name_)
-    , partition_key_(other.partition_key_)
-    , clustering_key_(other.clustering_key_)
-    , clustering_key_order_(other.clustering_key_order_) { }
+      : MetadataBase(other)
+      , RefCounted<TableMetadataBase>()
+      , is_virtual_(other.is_virtual_)
+      , columns_(other.columns_)
+      , columns_by_name_(other.columns_by_name_)
+      , partition_key_(other.partition_key_)
+      , clustering_key_(other.clustering_key_)
+      , clustering_key_order_(other.clustering_key_order_) {}
 
-  virtual ~TableMetadataBase() { }
+  virtual ~TableMetadataBase() {}
 
   bool is_virtual() const { return is_virtual_; }
 
@@ -394,21 +381,17 @@ class TableMetadataBase : public MetadataBase, public RefCounted<TableMetadataBa
 class ViewMetadata : public TableMetadataBase {
 public:
   typedef SharedRefPtr<ViewMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
 
   static const ViewMetadata::Ptr NIL;
 
-  ViewMetadata(const VersionNumber& server_version,
-               const TableMetadata* table,
-               const String& name,
-               const RefBuffer::Ptr& buffer, const Row* row,
-               bool is_virtual);
+  ViewMetadata(const VersionNumber& server_version, const TableMetadata* table, const String& name,
+               const RefBuffer::Ptr& buffer, const Row* row, bool is_virtual);
 
-  ViewMetadata(const ViewMetadata& other,
-               const TableMetadata* table)
-    : TableMetadataBase(other)
-    , base_table_(table) { }
+  ViewMetadata(const ViewMetadata& other, const TableMetadata* table)
+      : TableMetadataBase(other)
+      , base_table_(table) {}
 
   const TableMetadata* base_table() const { return base_table_; }
 
@@ -423,7 +406,7 @@ class ViewMetadata : public TableMetadataBase {
 class ViewIteratorBase : public Iterator {
 public:
   ViewIteratorBase(CassIteratorType type)
-    : Iterator(type) { }
+      : Iterator(type) {}
 
   virtual ViewMetadata* view() const = 0;
 };
@@ -431,8 +414,8 @@ class ViewIteratorBase : public Iterator {
 class ViewIteratorVec : public ViewIteratorBase {
 public:
   ViewIteratorVec(const ViewMetadata::Vec& views)
-    : ViewIteratorBase(CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META)
-    , impl_(views) { }
+      : ViewIteratorBase(CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META)
+      , impl_(views) {}
 
   virtual ViewMetadata* view() const { return impl_.item().get(); }
   virtual bool next() { return impl_.next(); }
@@ -444,8 +427,8 @@ class ViewIteratorVec : public ViewIteratorBase {
 class ViewIteratorMap : public ViewIteratorBase {
 public:
   ViewIteratorMap(const ViewMetadata::Map& views)
-    : ViewIteratorBase(CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META)
-    , impl_(views) { }
+      : ViewIteratorBase(CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META)
+      , impl_(views) {}
 
   virtual ViewMetadata* view() const { return impl_.item().get(); }
   virtual bool next() { return impl_.next(); }
@@ -458,9 +441,7 @@ inline bool operator<(const ViewMetadata::Ptr& a, const ViewMetadata::Ptr& b) {
   return a->name() < b->name();
 }
 
-inline  bool operator<(const ViewMetadata::Ptr& a, const String& b) {
-  return a->name() < b;
-}
+inline bool operator<(const ViewMetadata::Ptr& a, const String& b) { return a->name() < b; }
 
 inline bool operator==(const ViewMetadata::Ptr& a, const ViewMetadata::Ptr& b) {
   return a->name() == b->name();
@@ -469,7 +450,7 @@ inline bool operator==(const ViewMetadata::Ptr& a, const ViewMetadata::Ptr& b) {
 class TableMetadata : public TableMetadataBase {
 public:
   typedef SharedRefPtr<TableMetadata> Ptr;
-  typedef cass::Map<String, Ptr> Map;
+  typedef internal::Map<String, Ptr> Map;
   typedef Vector<Ptr> Vec;
   typedef Vector<String> KeyAliases;
 
@@ -477,19 +458,19 @@ class TableMetadata : public TableMetadataBase {
 
   class IndexIterator : public MetadataIteratorImpl<VecIteratorImpl<IndexMetadata::Ptr> > {
   public:
-  IndexIterator(const IndexIterator::Collection& collection)
-    : MetadataIteratorImpl<VecIteratorImpl<IndexMetadata::Ptr> >(CASS_ITERATOR_TYPE_INDEX_META, collection) { }
+    IndexIterator(const IndexIterator::Collection& collection)
+        : MetadataIteratorImpl<VecIteratorImpl<IndexMetadata::Ptr> >(CASS_ITERATOR_TYPE_INDEX_META,
+                                                                     collection) {}
     const IndexMetadata* index() const { return impl_.item().get(); }
   };
 
   TableMetadata(const VersionNumber& server_version, const String& name,
-                const RefBuffer::Ptr& buffer, const Row* row,
-                bool is_virtual);
+                const RefBuffer::Ptr& buffer, const Row* row, bool is_virtual);
 
   TableMetadata(const TableMetadata& other)
-    : TableMetadataBase(other)
-    , indexes_(other.indexes_)
-    , indexes_by_name_(other.indexes_by_name_) { }
+      : TableMetadataBase(other)
+      , indexes_(other.indexes_)
+      , indexes_by_name_(other.indexes_by_name_) {}
 
   const ViewMetadata::Vec& views() const { return views_; }
   const IndexMetadata::Vec& indexes() const { return indexes_; }
@@ -515,48 +496,51 @@ class TableMetadata : public TableMetadataBase {
 
 class KeyspaceMetadata : public MetadataBase {
 public:
-  typedef cass::Map<String, KeyspaceMetadata> Map;
+  typedef internal::Map<String, KeyspaceMetadata> Map;
   typedef CopyOnWritePtr<KeyspaceMetadata::Map> MapPtr;
 
   class TableIterator : public MetadataIteratorImpl<MapIteratorImpl<TableMetadata::Ptr> > {
   public:
-   TableIterator(const TableIterator::Collection& collection)
-     : MetadataIteratorImpl<MapIteratorImpl<TableMetadata::Ptr> >(CASS_ITERATOR_TYPE_TABLE_META, collection) { }
+    TableIterator(const TableIterator::Collection& collection)
+        : MetadataIteratorImpl<MapIteratorImpl<TableMetadata::Ptr> >(CASS_ITERATOR_TYPE_TABLE_META,
+                                                                     collection) {}
     const TableMetadata* table() const { return static_cast<TableMetadata*>(impl_.item().get()); }
   };
 
   class TypeIterator : public MetadataIteratorImpl<MapIteratorImpl<UserType::Ptr> > {
   public:
-   TypeIterator(const TypeIterator::Collection& collection)
-     : MetadataIteratorImpl<MapIteratorImpl<UserType::Ptr> >(CASS_ITERATOR_TYPE_TYPE_META, collection) { }
+    TypeIterator(const TypeIterator::Collection& collection)
+        : MetadataIteratorImpl<MapIteratorImpl<UserType::Ptr> >(CASS_ITERATOR_TYPE_TYPE_META,
+                                                                collection) {}
     const UserType* type() const { return impl_.item().get(); }
   };
 
   class FunctionIterator : public MetadataIteratorImpl<MapIteratorImpl<FunctionMetadata::Ptr> > {
   public:
-   FunctionIterator(const FunctionIterator::Collection& collection)
-     : MetadataIteratorImpl<MapIteratorImpl<FunctionMetadata::Ptr> >(CASS_ITERATOR_TYPE_FUNCTION_META, collection) { }
+    FunctionIterator(const FunctionIterator::Collection& collection)
+        : MetadataIteratorImpl<MapIteratorImpl<FunctionMetadata::Ptr> >(
+              CASS_ITERATOR_TYPE_FUNCTION_META, collection) {}
     const FunctionMetadata* function() const { return impl_.item().get(); }
   };
 
   class AggregateIterator : public MetadataIteratorImpl<MapIteratorImpl<AggregateMetadata::Ptr> > {
   public:
-   AggregateIterator(const AggregateIterator::Collection& collection)
-     : MetadataIteratorImpl<MapIteratorImpl<AggregateMetadata::Ptr> >(CASS_ITERATOR_TYPE_AGGREGATE_META, collection) { }
+    AggregateIterator(const AggregateIterator::Collection& collection)
+        : MetadataIteratorImpl<MapIteratorImpl<AggregateMetadata::Ptr> >(
+              CASS_ITERATOR_TYPE_AGGREGATE_META, collection) {}
     const AggregateMetadata* aggregate() const { return impl_.item().get(); }
   };
 
   KeyspaceMetadata(const String& name, bool is_virtual = false)
-    : MetadataBase(name)
-    , is_virtual_(is_virtual)
-    , tables_(new TableMetadata::Map())
-    , views_(new ViewMetadata::Map())
-    , user_types_(new UserType::Map())
-    , functions_(new FunctionMetadata::Map())
-    , aggregates_(new AggregateMetadata::Map()) { }
+      : MetadataBase(name)
+      , is_virtual_(is_virtual)
+      , tables_(new TableMetadata::Map())
+      , views_(new ViewMetadata::Map())
+      , user_types_(new UserType::Map())
+      , functions_(new FunctionMetadata::Map())
+      , aggregates_(new AggregateMetadata::Map()) {}
 
-  void update(const VersionNumber& server_version,
-              const RefBuffer::Ptr& buffer, const Row* row);
+  void update(const VersionNumber& server_version, const RefBuffer::Ptr& buffer, const Row* row);
 
   bool is_virtual() const { return is_virtual_; }
 
@@ -594,8 +578,7 @@ class KeyspaceMetadata : public MetadataBase {
   const Value* strategy_options() const { return &strategy_options_; }
 
 private:
-  void internal_add_table(const TableMetadata::Ptr& table,
-                          const ViewMetadata::Vec& views);
+  void internal_add_table(const TableMetadata::Ptr& table, const ViewMetadata::Vec& views);
 
 private:
   const bool is_virtual_;
@@ -613,19 +596,19 @@ class Metadata {
 public:
   class KeyspaceIterator : public MetadataIteratorImpl<MapIteratorImpl<KeyspaceMetadata> > {
   public:
-  KeyspaceIterator(const KeyspaceIterator::Collection& collection)
-    : MetadataIteratorImpl<MapIteratorImpl<KeyspaceMetadata> >(CASS_ITERATOR_TYPE_KEYSPACE_META, collection) { }
+    KeyspaceIterator(const KeyspaceIterator::Collection& collection)
+        : MetadataIteratorImpl<MapIteratorImpl<KeyspaceMetadata> >(CASS_ITERATOR_TYPE_KEYSPACE_META,
+                                                                   collection) {}
     const KeyspaceMetadata* keyspace() const { return &impl_.item(); }
   };
 
   class SchemaSnapshot : public Allocated {
   public:
-    SchemaSnapshot(uint32_t version,
-                   const VersionNumber& server_version,
+    SchemaSnapshot(uint32_t version, const VersionNumber& server_version,
                    const KeyspaceMetadata::MapPtr& keyspaces)
-      : version_(version)
-      , server_version_(server_version)
-      , keyspaces_(keyspaces) { }
+        : version_(version)
+        , server_version_(server_version)
+        , keyspaces_(keyspaces) {}
 
     uint32_t version() const { return version_; }
     VersionNumber server_version() const { return server_version_; }
@@ -633,8 +616,7 @@ class Metadata {
     const KeyspaceMetadata* get_keyspace(const String& name) const;
     Iterator* iterator_keyspaces() const { return new KeyspaceIterator(*keyspaces_); }
 
-    const UserType* get_user_type(const String& keyspace_name,
-                                  const String& type_name) const;
+    const UserType* get_user_type(const String& keyspace_name, const String& type_name) const;
 
   private:
     uint32_t version_;
@@ -646,14 +628,12 @@ class Metadata {
 
 public:
   Metadata()
-    : updating_(&front_)
-    , schema_snapshot_version_(0) {
+      : updating_(&front_)
+      , schema_snapshot_version_(0) {
     uv_mutex_init(&mutex_);
   }
 
-  ~Metadata() {
-    uv_mutex_destroy(&mutex_);
-  }
+  ~Metadata() { uv_mutex_destroy(&mutex_); }
 
   SchemaSnapshot schema_snapshot() const;
 
@@ -689,14 +669,16 @@ class Metadata {
   class InternalData {
   public:
     InternalData()
-      : keyspaces_(new KeyspaceMetadata::Map()) { }
+        : keyspaces_(new KeyspaceMetadata::Map()) {}
 
     const KeyspaceMetadata::MapPtr& keyspaces() const { return keyspaces_; }
 
-    void update_keyspaces(const VersionNumber& server_version, const ResultResponse* result, bool is_virtual);
+    void update_keyspaces(const VersionNumber& server_version, const ResultResponse* result,
+                          bool is_virtual);
     void update_tables(const VersionNumber& server_version, const ResultResponse* result);
     void update_views(const VersionNumber& server_version, const ResultResponse* result);
-    void update_columns(const VersionNumber& server_version, SimpleDataTypeCache& cache, const ResultResponse* result);
+    void update_columns(const VersionNumber& server_version, SimpleDataTypeCache& cache,
+                        const ResultResponse* result);
     void update_legacy_indexes(const VersionNumber& server_version, const ResultResponse* result);
     void update_indexes(const VersionNumber& server_version, const ResultResponse* result);
     void update_user_types(const VersionNumber& server_version, SimpleDataTypeCache& cache,
@@ -748,17 +730,15 @@ class Metadata {
   DISALLOW_COPY_AND_ASSIGN(Metadata);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Metadata::SchemaSnapshot, CassSchemaMeta)
-EXTERNAL_TYPE(cass::KeyspaceMetadata, CassKeyspaceMeta)
-EXTERNAL_TYPE(cass::TableMetadata, CassTableMeta)
-EXTERNAL_TYPE(cass::ViewMetadata, CassMaterializedViewMeta)
-EXTERNAL_TYPE(cass::ColumnMetadata, CassColumnMeta)
-EXTERNAL_TYPE(cass::IndexMetadata, CassIndexMeta)
-EXTERNAL_TYPE(cass::FunctionMetadata, CassFunctionMeta)
-EXTERNAL_TYPE(cass::AggregateMetadata, CassAggregateMeta)
+EXTERNAL_TYPE(datastax::internal::core::Metadata::SchemaSnapshot, CassSchemaMeta)
+EXTERNAL_TYPE(datastax::internal::core::KeyspaceMetadata, CassKeyspaceMeta)
+EXTERNAL_TYPE(datastax::internal::core::TableMetadata, CassTableMeta)
+EXTERNAL_TYPE(datastax::internal::core::ViewMetadata, CassMaterializedViewMeta)
+EXTERNAL_TYPE(datastax::internal::core::ColumnMetadata, CassColumnMeta)
+EXTERNAL_TYPE(datastax::internal::core::IndexMetadata, CassIndexMeta)
+EXTERNAL_TYPE(datastax::internal::core::FunctionMetadata, CassFunctionMeta)
+EXTERNAL_TYPE(datastax::internal::core::AggregateMetadata, CassAggregateMeta)
 
 #endif
-
-
diff --git a/src/metrics.hpp b/src/metrics.hpp
index 70c50ed6f..b5c909e79 100644
--- a/src/metrics.hpp
+++ b/src/metrics.hpp
@@ -17,42 +17,38 @@
 // Based on implemenations of metrics (especially Meter) from Java library
 // com.codehale.Metrics (https://github.com/dropwizard/metrics)
 
-#ifndef __CASS_METRICS_HPP_INCLUDED__
-#define __CASS_METRICS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_METRICS_HPP
+#define DATASTAX_INTERNAL_METRICS_HPP
 
 #include "allocated.hpp"
 #include "atomic.hpp"
 #include "constants.hpp"
-#include "scoped_ptr.hpp"
 #include "scoped_lock.hpp"
+#include "scoped_ptr.hpp"
 #include "utils.hpp"
 
 #include "third_party/hdr_histogram/hdr_histogram.hpp"
 
-#include <uv.h>
 #include <stdlib.h>
+#include <uv.h>
 
 #include <math.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Metrics : public Allocated {
 public:
   class ThreadState {
   public:
     ThreadState(size_t max_threads)
-      : max_threads_(max_threads)
-      , thread_count_(1) {
+        : max_threads_(max_threads)
+        , thread_count_(1) {
       uv_key_create(&thread_id_key_);
     }
 
-    ~ThreadState() {
-      uv_key_delete(&thread_id_key_);
-    }
+    ~ThreadState() { uv_key_delete(&thread_id_key_); }
 
-    size_t max_threads() const {
-      return max_threads_;
-    }
+    size_t max_threads() const { return max_threads_; }
 
     size_t current_thread_id() {
       void* id = uv_key_get(&thread_id_key_);
@@ -74,16 +70,12 @@ class Metrics : public Allocated {
   class Counter {
   public:
     Counter(ThreadState* thread_state)
-      : thread_state_(thread_state)
-      , counters_(new PerThreadCounter[thread_state->max_threads()]) {}
+        : thread_state_(thread_state)
+        , counters_(new PerThreadCounter[thread_state->max_threads()]) {}
 
-    void inc() {
-      counters_[thread_state_->current_thread_id()].add(1LL);
-    }
+    void inc() { counters_[thread_state_->current_thread_id()].add(1LL); }
 
-    void dec() {
-      counters_[thread_state_->current_thread_id()].sub(1LL);
-    }
+    void dec() { counters_[thread_state_->current_thread_id()].sub(1LL); }
 
     int64_t sum() const {
       int64_t sum = 0;
@@ -105,23 +97,15 @@ class Metrics : public Allocated {
     class PerThreadCounter : public Allocated {
     public:
       PerThreadCounter()
-        : value_(0) {}
+          : value_(0) {}
 
-      void add(int64_t n) {
-        value_.fetch_add(n, MEMORY_ORDER_RELEASE);
-      }
+      void add(int64_t n) { value_.fetch_add(n, MEMORY_ORDER_RELEASE); }
 
-      void sub(int64_t n) {
-        value_.fetch_sub(n, MEMORY_ORDER_RELEASE);
-      }
+      void sub(int64_t n) { value_.fetch_sub(n, MEMORY_ORDER_RELEASE); }
 
-      int64_t get() const {
-        return value_.load(MEMORY_ORDER_ACQUIRE);
-      }
+      int64_t get() const { return value_.load(MEMORY_ORDER_ACQUIRE); }
 
-      int64_t get_and_reset() {
-        return value_.exchange(0, MEMORY_ORDER_RELEASE);
-      }
+      int64_t get_and_reset() { return value_.exchange(0, MEMORY_ORDER_RELEASE); }
 
     private:
       Atomic<int64_t> value_;
@@ -140,132 +124,131 @@ class Metrics : public Allocated {
   };
 
   class ExponentiallyWeightedMovingAverage {
-    public:
-      static const uint64_t INTERVAL = 5;
+  public:
+    static const uint64_t INTERVAL = 5;
 
-      ExponentiallyWeightedMovingAverage(double alpha, ThreadState* thread_state)
+    ExponentiallyWeightedMovingAverage(double alpha, ThreadState* thread_state)
         : alpha_(alpha)
         , uncounted_(thread_state)
         , is_initialized_(false)
         , rate_(0.0) {}
 
-      double rate() const {
-        return rate_.load(MEMORY_ORDER_ACQUIRE);
-      }
+    double rate() const { return rate_.load(MEMORY_ORDER_ACQUIRE); }
 
-      void update() {
-        uncounted_.inc();
-      }
+    void update() { uncounted_.inc(); }
 
-      void tick() {
-        const int64_t count = uncounted_.sum_and_reset();
-        double instant_rate = static_cast<double>(count) / INTERVAL;
+    void tick() {
+      const int64_t count = uncounted_.sum_and_reset();
+      double instant_rate = static_cast<double>(count) / INTERVAL;
 
-        if (is_initialized_.load(MEMORY_ORDER_ACQUIRE)) {
-          double rate = rate_.load(MEMORY_ORDER_ACQUIRE);
-          rate_.store(rate + (alpha_ * (instant_rate - rate)), MEMORY_ORDER_RELEASE);
-        } else {
-          rate_.store(instant_rate, MEMORY_ORDER_RELEASE);
-          is_initialized_.store(true, MEMORY_ORDER_RELEASE);
-        }
+      if (is_initialized_.load(MEMORY_ORDER_ACQUIRE)) {
+        double rate = rate_.load(MEMORY_ORDER_ACQUIRE);
+        rate_.store(rate + (alpha_ * (instant_rate - rate)), MEMORY_ORDER_RELEASE);
+      } else {
+        rate_.store(instant_rate, MEMORY_ORDER_RELEASE);
+        is_initialized_.store(true, MEMORY_ORDER_RELEASE);
       }
+    }
 
-    private:
-      const double alpha_;
-      Counter uncounted_;
-      Atomic<bool> is_initialized_;
-      Atomic<double> rate_;
+  private:
+    const double alpha_;
+    Counter uncounted_;
+    Atomic<bool> is_initialized_;
+    Atomic<double> rate_;
   };
 
   class Meter {
-    public:
-      Meter(ThreadState* thread_state)
-        : one_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 1), thread_state)
-        , five_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 5), thread_state)
-        , fifteen_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 15), thread_state)
+  public:
+    Meter(ThreadState* thread_state)
+        : one_minute_rate_(
+              1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 /
+                        1),
+              thread_state)
+        , five_minute_rate_(
+              1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 /
+                        5),
+              thread_state)
+        , fifteen_minute_rate_(
+              1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 /
+                        15),
+              thread_state)
         , count_(thread_state)
         , speculative_request_count_(thread_state)
         , start_time_(uv_hrtime())
         , last_tick_(start_time_) {}
 
-      void mark() {
-        tick_if_necessary();
-        count_.inc();
-        one_minute_rate_.update();
-        five_minute_rate_.update();
-        fifteen_minute_rate_.update();
-      }
+    void mark() {
+      tick_if_necessary();
+      count_.inc();
+      one_minute_rate_.update();
+      five_minute_rate_.update();
+      fifteen_minute_rate_.update();
+    }
 
-      void mark_speculative() {
-        speculative_request_count_.inc();
-      }
+    void mark_speculative() { speculative_request_count_.inc(); }
 
-      double one_minute_rate() const { return one_minute_rate_.rate(); }
-      double five_minute_rate() const { return five_minute_rate_.rate(); }
-      double fifteen_minute_rate() const { return fifteen_minute_rate_.rate(); }
+    double one_minute_rate() const { return one_minute_rate_.rate(); }
+    double five_minute_rate() const { return five_minute_rate_.rate(); }
+    double fifteen_minute_rate() const { return fifteen_minute_rate_.rate(); }
 
-      double mean_rate() const {
-        if (count() == 0) {
-          return 0.0;
-        } else {
-          double elapsed = static_cast<double>(uv_hrtime() - start_time_) / 1e9;
-          return count() / elapsed;
-        }
+    double mean_rate() const {
+      if (count() == 0) {
+        return 0.0;
+      } else {
+        double elapsed = static_cast<double>(uv_hrtime() - start_time_) / 1e9;
+        return count() / elapsed;
       }
+    }
 
-      uint64_t count() const {
-        return count_.sum();
-      }
+    uint64_t count() const { return count_.sum(); }
 
-      uint64_t speculative_request_count() const {
-        return speculative_request_count_.sum();
-      }
+    uint64_t speculative_request_count() const { return speculative_request_count_.sum(); }
 
-      double speculative_request_percent() const {
-        // count() gives us the number of requests that we successfully handled.
-        //
-        // speculative_request_count() give us the number of requests sent on
-        // the wire but were aborted after we received a good response.
+    double speculative_request_percent() const {
+      // count() gives us the number of requests that we successfully handled.
+      //
+      // speculative_request_count() give us the number of requests sent on
+      // the wire but were aborted after we received a good response.
 
-        uint64_t spec_count = speculative_request_count();
-        uint64_t total_requests = spec_count + count();
+      uint64_t spec_count = speculative_request_count();
+      uint64_t total_requests = spec_count + count();
 
-        // Be wary of div by 0.
-        return total_requests ?
-               static_cast<double>(spec_count) / total_requests * 100 : 0;
-      }
+      // Be wary of div by 0.
+      return total_requests ? static_cast<double>(spec_count) / total_requests * 100 : 0;
+    }
 
-    private:
-      static const uint64_t TICK_INTERVAL = ExponentiallyWeightedMovingAverage::INTERVAL * 1000LL * 1000LL * 1000LL;
-
-      void tick_if_necessary() {
-        uint64_t old_tick = last_tick_.load();
-        uint64_t new_tick = uv_hrtime();
-        uint64_t elapsed = new_tick - old_tick;
-
-        if (elapsed > TICK_INTERVAL) {
-          uint64_t new_interval_start_tick = new_tick - elapsed % TICK_INTERVAL;
-          if (last_tick_.compare_exchange_strong(old_tick, new_interval_start_tick)) {
-            uint64_t required_ticks = elapsed / TICK_INTERVAL;
-            for (uint64_t i = 0; i < required_ticks; ++i) {
-              one_minute_rate_.tick();
-              five_minute_rate_.tick();
-              fifteen_minute_rate_.tick();
-            }
+  private:
+    static const uint64_t TICK_INTERVAL =
+        ExponentiallyWeightedMovingAverage::INTERVAL * 1000LL * 1000LL * 1000LL;
+
+    void tick_if_necessary() {
+      uint64_t old_tick = last_tick_.load();
+      uint64_t new_tick = uv_hrtime();
+      uint64_t elapsed = new_tick - old_tick;
+
+      if (elapsed > TICK_INTERVAL) {
+        uint64_t new_interval_start_tick = new_tick - elapsed % TICK_INTERVAL;
+        if (last_tick_.compare_exchange_strong(old_tick, new_interval_start_tick)) {
+          uint64_t required_ticks = elapsed / TICK_INTERVAL;
+          for (uint64_t i = 0; i < required_ticks; ++i) {
+            one_minute_rate_.tick();
+            five_minute_rate_.tick();
+            fifteen_minute_rate_.tick();
           }
         }
       }
+    }
 
-      ExponentiallyWeightedMovingAverage one_minute_rate_;
-      ExponentiallyWeightedMovingAverage five_minute_rate_;
-      ExponentiallyWeightedMovingAverage fifteen_minute_rate_;
-      Counter count_;
-      Counter speculative_request_count_;
-      const uint64_t start_time_;
-      Atomic<uint64_t> last_tick_;
+    ExponentiallyWeightedMovingAverage one_minute_rate_;
+    ExponentiallyWeightedMovingAverage five_minute_rate_;
+    ExponentiallyWeightedMovingAverage fifteen_minute_rate_;
+    Counter count_;
+    Counter speculative_request_count_;
+    const uint64_t start_time_;
+    Atomic<uint64_t> last_tick_;
 
   private:
-      DISALLOW_COPY_AND_ASSIGN(Meter);
+    DISALLOW_COPY_AND_ASSIGN(Meter);
   };
 
   class Histogram {
@@ -286,8 +269,8 @@ class Metrics : public Allocated {
     };
 
     Histogram(ThreadState* thread_state)
-      : thread_state_(thread_state)
-      , histograms_(new PerThreadHistogram[thread_state->max_threads()]) {
+        : thread_state_(thread_state)
+        , histograms_(new PerThreadHistogram[thread_state->max_threads()]) {
       hdr_init(1LL, HIGHEST_TRACKABLE_VALUE, 3, &histogram_);
       uv_mutex_init(&mutex_);
     }
@@ -338,13 +321,11 @@ class Metrics : public Allocated {
     class WriterReaderPhaser {
     public:
       WriterReaderPhaser()
-        : start_epoch_(0)
-        , even_end_epoch_(0)
-        , odd_end_epoch_(CASS_INT64_MIN) {}
+          : start_epoch_(0)
+          , even_end_epoch_(0)
+          , odd_end_epoch_(CASS_INT64_MIN) {}
 
-      int64_t writer_critical_section_enter() {
-        return start_epoch_.fetch_add(1);
-      }
+      int64_t writer_critical_section_enter() { return start_epoch_.fetch_add(1); }
 
       void writer_critical_section_end(int64_t critical_value_enter) {
         if (critical_value_enter < 0) {
@@ -380,7 +361,7 @@ class Metrics : public Allocated {
           if (!is_caught_up) {
             thread_yield();
           }
-        } while(!is_caught_up);
+        } while (!is_caught_up);
       }
 
     private:
@@ -392,7 +373,7 @@ class Metrics : public Allocated {
     class PerThreadHistogram : public Allocated {
     public:
       PerThreadHistogram()
-        : active_index_(0) {
+          : active_index_(0) {
         hdr_init(1LL, HIGHEST_TRACKABLE_VALUE, 3, &histograms_[0]);
         hdr_init(1LL, HIGHEST_TRACKABLE_VALUE, 3, &histograms_[1]);
       }
@@ -433,14 +414,14 @@ class Metrics : public Allocated {
   };
 
   Metrics(size_t max_threads)
-    : thread_state_(max_threads)
-    , request_latencies(&thread_state_)
-    , speculative_request_latencies(&thread_state_)
-    , request_rates(&thread_state_)
-    , total_connections(&thread_state_)
-    , connection_timeouts(&thread_state_)
-    , pending_request_timeouts(&thread_state_)
-    , request_timeouts(&thread_state_) {}
+      : thread_state_(max_threads)
+      , request_latencies(&thread_state_)
+      , speculative_request_latencies(&thread_state_)
+      , request_rates(&thread_state_)
+      , total_connections(&thread_state_)
+      , connection_timeouts(&thread_state_)
+      , pending_request_timeouts(&thread_state_)
+      , request_timeouts(&thread_state_) {}
 
   void record_request(uint64_t latency_ns) {
     // Final measurement is in microseconds
@@ -453,6 +434,7 @@ class Metrics : public Allocated {
     speculative_request_latencies.record_value(latency_ns / 1000);
     request_rates.mark_speculative();
   }
+
 private:
   ThreadState thread_state_;
 
@@ -471,6 +453,6 @@ class Metrics : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(Metrics);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/micro_timer.cpp b/src/micro_timer.cpp
index a372d7a6d..1a68da4c6 100644
--- a/src/micro_timer.cpp
+++ b/src/micro_timer.cpp
@@ -16,29 +16,26 @@
 
 #include "micro_timer.hpp"
 
-
 #ifdef HAVE_TIMERFD
 #include <string.h>
 #include <sys/timerfd.h>
 #include <unistd.h>
 #endif
 
-namespace cass {
+using namespace datastax::internal::core;
 
 #ifdef HAVE_TIMERFD
 
 MicroTimer::MicroTimer()
-  : handle_(NULL)
-  , fd_(-1)
-  , state_(CLOSED) { }
+    : handle_(NULL)
+    , fd_(-1)
+    , state_(CLOSED) {}
 
-int MicroTimer::start(uv_loop_t* loop,
-                      uint64_t timeout_us,
-                      const Callback& callback) {
+int MicroTimer::start(uv_loop_t* loop, uint64_t timeout_us, const Callback& callback) {
   int rc = 0;
   if (fd_ == -1) {
     fd_ = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
-    if (fd_ == -1)  return errno;
+    if (fd_ == -1) return errno;
   }
   if (handle_ == NULL) {
     handle_ = new AllocatedT<uv_poll_t>();
@@ -57,7 +54,7 @@ int MicroTimer::start(uv_loop_t* loop,
     memset(&ts.it_interval, 0, sizeof(struct timespec));
     if (timeout_us > 0) {
       ts.it_value.tv_sec = timeout_us / (1000 * 1000);
-      ts.it_value.tv_nsec = (timeout_us % (1000 * 1000))  * 1000;
+      ts.it_value.tv_nsec = (timeout_us % (1000 * 1000)) * 1000;
     } else {
       // If the timeout is 0 then set the smallest possible timeout (1 ns)
       // because all zeros disables the timer.
@@ -87,9 +84,7 @@ void MicroTimer::stop() {
   }
 }
 
-bool MicroTimer::is_running() const {
-  return state_ == STARTED;
-}
+bool MicroTimer::is_running() const { return state_ == STARTED; }
 
 void MicroTimer::on_timeout(uv_poll_t* poll, int status, int events) {
   MicroTimer* timer = static_cast<MicroTimer*>(poll->data);
@@ -111,17 +106,15 @@ void MicroTimer::on_close(uv_handle_t* handle) {
 #else
 
 MicroTimer::MicroTimer()
-  : timeout_ns_(0) { }
+    : timeout_ns_(0) {}
 
-int MicroTimer::start(uv_loop_t* loop,
-                      uint64_t timeout_us,
-                      const Callback& callback) {
+int MicroTimer::start(uv_loop_t* loop, uint64_t timeout_us, const Callback& callback) {
   if (is_running()) {
     return 0;
   }
 
   uint64_t ms = timeout_us / 1000;
-  uint64_t us =  timeout_us - (ms * 1000);
+  uint64_t us = timeout_us - (ms * 1000);
 
   timeout_ns_ = uv_hrtime() + timeout_us * 1000; // Convert to nanoseconds
   callback_ = callback;
@@ -130,24 +123,18 @@ int MicroTimer::start(uv_loop_t* loop,
     // If the requested sub-millisecond part of the timeout is within a certain
     // percentage of a millisecond then round up to the next millisecond and use
     // the timer.
-    return timer_.start(loop, ms + 1,
-                        bind_callback(&MicroTimer::on_timeout, this));
+    return timer_.start(loop, ms + 1, bind_callback(&MicroTimer::on_timeout, this));
   } else {
     // Note: This can potentially wait for 0 milliseconds and in that case the
     // loop will busy spin until the sub-millsecond part of the timeout is
     // reached.
-    return timer_.start(loop, ms,
-                        bind_callback(&MicroTimer::on_timeout, this));
+    return timer_.start(loop, ms, bind_callback(&MicroTimer::on_timeout, this));
   }
 }
 
-void MicroTimer::stop() {
-  timer_.stop();
-}
+void MicroTimer::stop() { timer_.stop(); }
 
-bool MicroTimer::is_running() const {
-  return timer_.is_running();
-}
+bool MicroTimer::is_running() const { return timer_.is_running(); }
 
 void MicroTimer::on_timeout(Timer* timer) {
   uint64_t now = uv_hrtime();
@@ -162,5 +149,3 @@ void MicroTimer::on_timeout(Timer* timer) {
 }
 
 #endif
-
-} // namespace cass
diff --git a/src/micro_timer.hpp b/src/micro_timer.hpp
index bf95f0498..5eb026c07 100644
--- a/src/micro_timer.hpp
+++ b/src/micro_timer.hpp
@@ -14,12 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_MICRO_TIMER_HPP_INCLUDED__
-#define __CASS_MICRO_TIMER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MICRO_TIMER_HPP
+#define DATASTAX_INTERNAL_MICRO_TIMER_HPP
 
 #include "allocated.hpp"
 #include "callback.hpp"
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 #include "macros.hpp"
 
 #ifndef HAVE_TIMERFD
@@ -32,7 +32,7 @@
 // Only affects busy wait timer version
 #define CASS_PERCENT_OF_MILLSECOND_THRESHOLD 95
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A timer that supports microsecond precision. It is not intended for general
@@ -48,7 +48,7 @@ namespace cass {
  */
 class MicroTimer {
 public:
-  typedef cass::Callback<void, MicroTimer*> Callback;
+  typedef internal::Callback<void, MicroTimer*> Callback;
 
   MicroTimer();
   ~MicroTimer() { stop(); }
@@ -64,9 +64,7 @@ class MicroTimer {
    * @param callback The callback that handles the timeout.
    * @return 0 for success (or no change), otherwise an error occurred.
    */
-  int start(uv_loop_t* loop,
-            uint64_t timeout_us,
-            const Callback& callback);
+  int start(uv_loop_t* loop, uint64_t timeout_us, const Callback& callback);
 
   /**
    * Stop the timer and cleanup its handles.
@@ -93,11 +91,7 @@ class MicroTimer {
 
 private:
 #ifdef HAVE_TIMERFD
-  enum State {
-    CLOSED,
-    STOPPED,
-    STARTED
-  };
+  enum State { CLOSED, STOPPED, STARTED };
 
   AllocatedT<uv_poll_t>* handle_;
   int fd_;
@@ -113,6 +107,6 @@ class MicroTimer {
   DISALLOW_COPY_AND_ASSIGN(MicroTimer);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/monitor_reporting.cpp b/src/monitor_reporting.cpp
index 588298f29..1bd5d7092 100644
--- a/src/monitor_reporting.cpp
+++ b/src/monitor_reporting.cpp
@@ -16,12 +16,14 @@
 
 #include "monitor_reporting.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
-MonitorReporting* create_monitor_reporting(const String& client_id,
-                                           const String& session_id,
+namespace datastax { namespace internal { namespace core {
+
+MonitorReporting* create_monitor_reporting(const String& client_id, const String& session_id,
                                            const Config& config) {
   return new NopMonitorReporting();
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
diff --git a/src/monitor_reporting.hpp b/src/monitor_reporting.hpp
index 6cfc1a3ba..218d627f4 100644
--- a/src/monitor_reporting.hpp
+++ b/src/monitor_reporting.hpp
@@ -14,45 +14,40 @@
   limitations under the License.
 */
 
-#ifndef __CASS_MONITOR_REPORTING_HPP_INCLUDED__
-#define __CASS_MONITOR_REPORTING_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MONITOR_REPORTING_HPP
+#define DATASTAX_INTERNAL_MONITOR_REPORTING_HPP
 
 #include "connection.hpp"
 #include "host.hpp"
 #include "load_balancing.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 
 class MonitorReporting {
 public:
-  virtual ~MonitorReporting() { }
+  virtual ~MonitorReporting() {}
   virtual uint64_t interval_ms(const VersionNumber& dse_server_version) const = 0;
-  virtual void send_startup_message(const Connection::Ptr& connection,
-                                    const Config& config,
+  virtual void send_startup_message(const Connection::Ptr& connection, const Config& config,
                                     const HostMap& hosts,
                                     const LoadBalancingPolicy::Vec& initialized_policies) = 0;
-  virtual void send_status_message(const Connection::Ptr& connection,
-                                   const HostMap& hosts) = 0;
+  virtual void send_status_message(const Connection::Ptr& connection, const HostMap& hosts) = 0;
 };
 
 class NopMonitorReporting : public MonitorReporting {
 public:
   uint64_t interval_ms(const VersionNumber& dse_server_version) const { return 0; }
-  void send_startup_message(const Connection::Ptr& connection,
-                            const Config& config,
+  void send_startup_message(const Connection::Ptr& connection, const Config& config,
                             const HostMap& hosts,
-                            const LoadBalancingPolicy::Vec& initialized_policies) { }
-  void send_status_message(const Connection::Ptr& connection,
-                           const HostMap& hosts) { }
+                            const LoadBalancingPolicy::Vec& initialized_policies) {}
+  void send_status_message(const Connection::Ptr& connection, const HostMap& hosts) {}
 };
 
-MonitorReporting* create_monitor_reporting(const String& client_id,
-                                           const String& session_id,
+MonitorReporting* create_monitor_reporting(const String& client_id, const String& session_id,
                                            const Config& config);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-#endif // __CASS_MONITOR_REPORTING_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_MONITOR_REPORTING_HPP
diff --git a/src/mpmc_queue.hpp b/src/mpmc_queue.hpp
index f1cfc875f..f6cd146ca 100644
--- a/src/mpmc_queue.hpp
+++ b/src/mpmc_queue.hpp
@@ -19,19 +19,19 @@
   http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
 */
 
-#ifndef __CASS_MPMC_QUEUE_INCLUDED__
-#define __CASS_MPMC_QUEUE_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MPMC_QUEUE
+#define DATASTAX_INTERNAL_MPMC_QUEUE
 
 #include "allocated.hpp"
 #include "atomic.hpp"
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 #include "macros.hpp"
 #include "scoped_ptr.hpp"
 #include "utils.hpp"
 
 #include <assert.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 template <typename T>
 class MPMCQueue : public Allocated {
@@ -160,6 +160,6 @@ class MPMCQueue : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(MPMCQueue);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/murmur3.cpp b/src/murmur3.cpp
index 72e6be578..20f81acba 100644
--- a/src/murmur3.cpp
+++ b/src/murmur3.cpp
@@ -27,58 +27,54 @@
 
 #if defined(_MSC_VER)
 
-#define FORCE_INLINE	__forceinline
+#define FORCE_INLINE __forceinline
 
-#define ROTL32(x,y)	_rotl(x,y)
-#define ROTL64(x,y)	_rotl64(x,y)
+#define ROTL32(x, y) _rotl(x, y)
+#define ROTL64(x, y) _rotl64(x, y)
 
 #define BIG_CONSTANT(x) (x)
 
 // Other compilers
 
-#else	// defined(_MSC_VER)
+#else // defined(_MSC_VER)
 
-#define	FORCE_INLINE inline __attribute__((always_inline))
+#define FORCE_INLINE inline __attribute__((always_inline))
 
-inline uint32_t rotl32 (int32_t x, int8_t r) {
+inline uint32_t rotl32(int32_t x, int8_t r) {
   // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
-  return (x << r) | ((int32_t) (((uint32_t) x) >> (32 - r)));
+  return (x << r) | ((int32_t)(((uint32_t)x) >> (32 - r)));
 }
 
-inline int64_t rotl64 (int64_t x, int8_t r) {
+inline int64_t rotl64(int64_t x, int8_t r) {
   // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
-  return (x << r) | ((int64_t) (((uint64_t) x) >> (64 - r)));
+  return (x << r) | ((int64_t)(((uint64_t)x) >> (64 - r)));
 }
 
-#define ROTL32(x,y)	rotl32(x,y)
-#define ROTL64(x,y)	rotl64(x,y)
+#define ROTL32(x, y) rotl32(x, y)
+#define ROTL64(x, y) rotl64(x, y)
 
 #define BIG_CONSTANT(x) (x##LL)
 
 #endif // !defined(_MSC_VER)
 
-namespace cass {
+namespace datastax { namespace internal {
 
-FORCE_INLINE int64_t getblock(const int64_t * p, int i) {
-  return p[i];
-}
+FORCE_INLINE int64_t getblock(const int64_t* p, int i) { return p[i]; }
 
 // Finalization mix - force all bits of a hash block to avalanche
 FORCE_INLINE int64_t fmix(int64_t k) {
   // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
-  k ^= ((uint64_t) k) >> 33;
+  k ^= ((uint64_t)k) >> 33;
   k *= BIG_CONSTANT(0xff51afd7ed558ccd);
-  k ^= ((uint64_t) k) >> 33;
+  k ^= ((uint64_t)k) >> 33;
   k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
-  k ^= ((uint64_t) k) >> 33;
+  k ^= ((uint64_t)k) >> 33;
 
   return k;
 }
 
-int64_t MurmurHash3_x64_128(const void * key, const int len,
-                            const uint32_t seed)
-{
-  const int8_t * data = (const int8_t*)key;
+int64_t MurmurHash3_x64_128(const void* key, const int len, const uint32_t seed) {
+  const int8_t* data = (const int8_t*)key;
   const int nblocks = len / 16;
 
   int64_t h1 = seed;
@@ -89,56 +85,85 @@ int64_t MurmurHash3_x64_128(const void * key, const int len,
   int64_t k1 = 0;
   int64_t k2 = 0;
 
-  const int64_t * blocks = (const int64_t *)(data);
-  const int8_t * tail = (const int8_t*)(data + nblocks*16);
+  const int64_t* blocks = (const int64_t*)(data);
+  const int8_t* tail = (const int8_t*)(data + nblocks * 16);
 
   //----------
   // body
 
   int i;
-  for (i = 0; i < nblocks; i++)
-  {
-    int64_t k1 = getblock(blocks,i*2+0);
-    int64_t k2 = getblock(blocks,i*2+1);
-
-    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
-
-    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
-
-    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
-
-    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
-
+  for (i = 0; i < nblocks; i++) {
+    int64_t k1 = getblock(blocks, i * 2 + 0);
+    int64_t k2 = getblock(blocks, i * 2 + 1);
+
+    k1 *= c1;
+    k1 = ROTL64(k1, 31);
+    k1 *= c2;
+    h1 ^= k1;
+
+    h1 = ROTL64(h1, 27);
+    h1 += h2;
+    h1 = h1 * 5 + 0x52dce729;
+
+    k2 *= c2;
+    k2 = ROTL64(k2, 33);
+    k2 *= c1;
+    h2 ^= k2;
+
+    h2 = ROTL64(h2, 31);
+    h2 += h1;
+    h2 = h2 * 5 + 0x38495ab5;
   }
 
   //----------
   // tail
-  switch (len & 15)
-  {
-    case 15: k2 ^= ((int64_t) (tail[14])) << 48; /* FALLTHRU */
-    case 14: k2 ^= ((int64_t) (tail[13])) << 40; /* FALLTHRU */
-    case 13: k2 ^= ((int64_t) (tail[12])) << 32; /* FALLTHRU */
-    case 12: k2 ^= ((int64_t) (tail[11])) << 24; /* FALLTHRU */
-    case 11: k2 ^= ((int64_t) (tail[10])) << 16; /* FALLTHRU */
-    case 10: k2 ^= ((int64_t) (tail[ 9])) << 8;  /* FALLTHRU */
-    case  9: k2 ^= ((int64_t) (tail[ 8])) << 0;
-             k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2; /* FALLTHRU */
-
-    case  8: k1 ^= ((int64_t) (tail[ 7])) << 56; /* FALLTHRU */
-    case  7: k1 ^= ((int64_t) (tail[ 6])) << 48; /* FALLTHRU */
-    case  6: k1 ^= ((int64_t) (tail[ 5])) << 40; /* FALLTHRU */
-    case  5: k1 ^= ((int64_t) (tail[ 4])) << 32; /* FALLTHRU */
-    case  4: k1 ^= ((int64_t) (tail[ 3])) << 24; /* FALLTHRU */
-    case  3: k1 ^= ((int64_t) (tail[ 2])) << 16; /* FALLTHRU */
-    case  2: k1 ^= ((int64_t) (tail[ 1])) << 8;  /* FALLTHRU */
-    case  1: k1 ^= ((int64_t) (tail[ 0])) << 0;
-             k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1; /* FALLTHRU */
+  switch (len & 15) {
+    case 15:
+      k2 ^= ((int64_t)(tail[14])) << 48; /* FALLTHRU */
+    case 14:
+      k2 ^= ((int64_t)(tail[13])) << 40; /* FALLTHRU */
+    case 13:
+      k2 ^= ((int64_t)(tail[12])) << 32; /* FALLTHRU */
+    case 12:
+      k2 ^= ((int64_t)(tail[11])) << 24; /* FALLTHRU */
+    case 11:
+      k2 ^= ((int64_t)(tail[10])) << 16; /* FALLTHRU */
+    case 10:
+      k2 ^= ((int64_t)(tail[9])) << 8; /* FALLTHRU */
+    case 9:
+      k2 ^= ((int64_t)(tail[8])) << 0;
+      k2 *= c2;
+      k2 = ROTL64(k2, 33);
+      k2 *= c1;
+      h2 ^= k2; /* FALLTHRU */
+
+    case 8:
+      k1 ^= ((int64_t)(tail[7])) << 56; /* FALLTHRU */
+    case 7:
+      k1 ^= ((int64_t)(tail[6])) << 48; /* FALLTHRU */
+    case 6:
+      k1 ^= ((int64_t)(tail[5])) << 40; /* FALLTHRU */
+    case 5:
+      k1 ^= ((int64_t)(tail[4])) << 32; /* FALLTHRU */
+    case 4:
+      k1 ^= ((int64_t)(tail[3])) << 24; /* FALLTHRU */
+    case 3:
+      k1 ^= ((int64_t)(tail[2])) << 16; /* FALLTHRU */
+    case 2:
+      k1 ^= ((int64_t)(tail[1])) << 8; /* FALLTHRU */
+    case 1:
+      k1 ^= ((int64_t)(tail[0])) << 0;
+      k1 *= c1;
+      k1 = ROTL64(k1, 31);
+      k1 *= c2;
+      h1 ^= k1; /* FALLTHRU */
   };
 
   //----------
   // finalization
 
-  h1 ^= len; h2 ^= len;
+  h1 ^= len;
+  h2 ^= len;
 
   h1 += h2;
   h2 += h1;
@@ -152,4 +177,4 @@ int64_t MurmurHash3_x64_128(const void * key, const int len,
   return h1;
 }
 
-}
+}} // namespace datastax::internal
diff --git a/src/murmur3.hpp b/src/murmur3.hpp
index 1e6ff9b54..edeefe267 100644
--- a/src/murmur3.hpp
+++ b/src/murmur3.hpp
@@ -19,18 +19,17 @@
  * domain. The author hereby disclaims copyright to this source code.
  */
 
-#ifndef __CASS_MURMUR3_HPP_INCLUDED__
-#define __CASS_MURMUR3_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_MURMUR3_HPP
+#define DATASTAX_INTERNAL_MURMUR3_HPP
 
 #include "macros.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
-int64_t MurmurHash3_x64_128(const void * key, const int len,
-                            const uint32_t seed);
+int64_t MurmurHash3_x64_128(const void* key, const int len, const uint32_t seed);
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/name_resolver.hpp b/src/name_resolver.hpp
index c7301db56..a234f924e 100644
--- a/src/name_resolver.hpp
+++ b/src/name_resolver.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_NAME_RESOLVER_HPP_INCLUDED__
-#define __CASS_NAME_RESOLVER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_NAME_RESOLVER_HPP
+#define DATASTAX_INTERNAL_NAME_RESOLVER_HPP
 
 #include "address.hpp"
 #include "callback.hpp"
@@ -25,13 +25,13 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class NameResolver : public RefCounted<NameResolver> {
 public:
   typedef SharedRefPtr<NameResolver> Ptr;
 
-  typedef cass::Callback<void, NameResolver*> Callback;
+  typedef internal::Callback<void, NameResolver*> Callback;
 
   enum Status {
     NEW,
@@ -51,7 +51,7 @@ class NameResolver : public RefCounted<NameResolver> {
     req_.data = this;
   }
 
-  uv_loop_t* loop() { return req_.loop;  }
+  uv_loop_t* loop() { return req_.loop; }
 
   bool is_success() { return status_ == SUCCESS; }
   bool is_canceled() { return status_ == CANCELED; }
@@ -69,11 +69,11 @@ class NameResolver : public RefCounted<NameResolver> {
     inc_ref(); // For the event loop
 
     if (timeout > 0) {
-      timer_.start(loop, timeout,
-                   bind_callback(&NameResolver::on_timeout, this));
+      timer_.start(loop, timeout, bind_callback(&NameResolver::on_timeout, this));
     }
 
-    int rc = uv_getnameinfo(loop, &req_, on_resolve, static_cast<const Address>(address_).addr(), flags);
+    int rc =
+        uv_getnameinfo(loop, &req_, on_resolve, static_cast<const Address>(address_).addr(), flags);
 
     if (rc != 0) {
       status_ = FAILED_BAD_PARAM;
@@ -93,8 +93,8 @@ class NameResolver : public RefCounted<NameResolver> {
   }
 
 private:
-  static void on_resolve(uv_getnameinfo_t* req, int status,
-                         const char* hostname, const char* service) {
+  static void on_resolve(uv_getnameinfo_t* req, int status, const char* hostname,
+                         const char* service) {
     NameResolver* resolver = static_cast<NameResolver*>(req->data);
 
     if (resolver->status_ == RESOLVING) { // A timeout may have happened
@@ -134,6 +134,6 @@ class NameResolver : public RefCounted<NameResolver> {
   Callback callback_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/options_request.hpp b/src/options_request.hpp
index c61f5787f..e6d5a4899 100644
--- a/src/options_request.hpp
+++ b/src/options_request.hpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#ifndef __CASS_OPTIONS_REQUEST_HPP_INCLUDED__
-#define __CASS_OPTIONS_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_OPTIONS_REQUEST_HPP
+#define DATASTAX_INTERNAL_OPTIONS_REQUEST_HPP
 
-#include "request.hpp"
 #include "constants.hpp"
+#include "request.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class OptionsRequest : public Request {
 public:
@@ -28,9 +28,11 @@ class OptionsRequest : public Request {
       : Request(CQL_OPCODE_OPTIONS) {}
 
 private:
-  int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const { return 0; }
+  int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+    return 0;
+  }
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/pooled_connection.cpp b/src/pooled_connection.cpp
index 4e17dcbe4..bc46e3c25 100644
--- a/src/pooled_connection.cpp
+++ b/src/pooled_connection.cpp
@@ -20,7 +20,8 @@
 #include "event_loop.hpp"
 #include "query_request.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 /**
  * A request callback that sets the keyspace then runs the original request
@@ -29,16 +30,14 @@ namespace cass {
  */
 class ChainedSetKeyspaceCallback : public SimpleRequestCallback {
 public:
-  ChainedSetKeyspaceCallback(Connection* connection,
-                             const String& keyspace,
+  ChainedSetKeyspaceCallback(Connection* connection, const String& keyspace,
                              const RequestCallback::Ptr& chained_callback);
 
 private:
   class SetKeyspaceRequest : public QueryRequest {
   public:
-    SetKeyspaceRequest(const String& keyspace,
-                       uint64_t request_timeout_ms)
-      : QueryRequest("USE \"" + keyspace + "\"") {
+    SetKeyspaceRequest(const String& keyspace, uint64_t request_timeout_ms)
+        : QueryRequest("USE \"" + keyspace + "\"") {
       set_request_timeout_ms(request_timeout_ms);
     }
   };
@@ -58,12 +57,10 @@ class ChainedSetKeyspaceCallback : public SimpleRequestCallback {
 ChainedSetKeyspaceCallback::ChainedSetKeyspaceCallback(Connection* connection,
                                                        const String& keyspace,
                                                        const RequestCallback::Ptr& chained_callback)
-  : SimpleRequestCallback(
-      Request::ConstPtr(
-        new SetKeyspaceRequest(keyspace,
-                               chained_callback->request_timeout_ms())))
-  , connection_(connection)
-  , chained_callback_(chained_callback) { }
+    : SimpleRequestCallback(Request::ConstPtr(
+          new SetKeyspaceRequest(keyspace, chained_callback->request_timeout_ms())))
+    , connection_(connection)
+    , chained_callback_(chained_callback) {}
 
 void ChainedSetKeyspaceCallback::on_internal_set(ResponseMessage* response) {
   switch (response->opcode()) {
@@ -72,30 +69,24 @@ void ChainedSetKeyspaceCallback::on_internal_set(ResponseMessage* response) {
       break;
     case CQL_OPCODE_ERROR:
       connection_->defunct();
-      chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE,
-                                  "Unable to set keyspace");
+      chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE, "Unable to set keyspace");
       break;
     default:
       connection_->defunct();
-      chained_callback_->on_error(CASS_ERROR_LIB_UNEXPECTED_RESPONSE,
-                                  "Unexpected response");
+      chained_callback_->on_error(CASS_ERROR_LIB_UNEXPECTED_RESPONSE, "Unexpected response");
       break;
   }
 }
 
 void ChainedSetKeyspaceCallback::on_internal_error(CassError code, const String& message) {
   connection_->defunct();
-  chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE,
-                              "Unable to set keyspace");
+  chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE, "Unable to set keyspace");
 }
 
-void ChainedSetKeyspaceCallback::on_internal_timeout() {
-  chained_callback_->on_retry_next_host();
-}
+void ChainedSetKeyspaceCallback::on_internal_timeout() { chained_callback_->on_retry_next_host(); }
 
 void ChainedSetKeyspaceCallback::on_result_response(ResponseMessage* response) {
-  ResultResponse* result =
-      static_cast<ResultResponse*>(response->response_body().get());
+  ResultResponse* result = static_cast<ResultResponse*>(response->response_body().get());
   if (result->kind() == CASS_RESULT_KIND_SET_KEYSPACE) {
     if (!connection_->write_and_flush(chained_callback_)) {
       // Try on the same host but a different connection
@@ -103,17 +94,15 @@ void ChainedSetKeyspaceCallback::on_result_response(ResponseMessage* response) {
     }
   } else {
     connection_->defunct();
-    chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE,
-                                "Unable to set keyspace");
+    chained_callback_->on_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE, "Unable to set keyspace");
   }
 }
 
-PooledConnection::PooledConnection(ConnectionPool* pool,
-                                   const Connection::Ptr& connection)
-  : connection_(connection)
-  , pool_(pool)
-  // If the user data is set then use it to start the I/O timer.
-  , event_loop_(static_cast<EventLoop*>(pool->loop()->data)) {
+PooledConnection::PooledConnection(ConnectionPool* pool, const Connection::Ptr& connection)
+    : connection_(connection)
+    , pool_(pool)
+    // If the user data is set then use it to start the I/O timer.
+    , event_loop_(static_cast<EventLoop*>(pool->loop()->data)) {
   inc_ref(); // Reference for the connection's lifetime
   connection_->set_listener(this);
 }
@@ -122,15 +111,10 @@ bool PooledConnection::write(RequestCallback* callback) {
   bool result = false;
   const String& keyspace(pool_->keyspace());
   if (keyspace != connection_->keyspace()) {
-    LOG_DEBUG("Setting keyspace %s on connection(%p) pool(%p)",
-              keyspace.c_str(),
-              static_cast<void*>(connection_.get()),
-              static_cast<void*>(pool_));
-    result = connection_->write(RequestCallback::Ptr(
-                                  new ChainedSetKeyspaceCallback(
-                                    connection_.get(),
-                                    keyspace,
-                                    RequestCallback::Ptr(callback))));
+    LOG_DEBUG("Setting keyspace %s on connection(%p) pool(%p)", keyspace.c_str(),
+              static_cast<void*>(connection_.get()), static_cast<void*>(pool_));
+    result = connection_->write(RequestCallback::Ptr(new ChainedSetKeyspaceCallback(
+        connection_.get(), keyspace, RequestCallback::Ptr(callback))));
   } else {
     result = connection_->write(RequestCallback::Ptr(callback));
   }
@@ -152,9 +136,7 @@ void PooledConnection::flush() {
 #endif
 }
 
-void PooledConnection::close() {
-  connection_->close();
-}
+void PooledConnection::close() { connection_->close(); }
 
 int PooledConnection::inflight_request_count() const {
   return connection_->inflight_request_count();
@@ -176,5 +158,3 @@ void PooledConnection::on_close(Connection* connection) {
   pool_->close_connection(this, ConnectionPool::Protected());
   dec_ref();
 }
-
-} // namespace cass
diff --git a/src/pooled_connection.hpp b/src/pooled_connection.hpp
index 483a32d52..272dac5e9 100644
--- a/src/pooled_connection.hpp
+++ b/src/pooled_connection.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_POOLED_CONNECTION_HPP_INCLUDED__
-#define __CASS_POOLED_CONNECTION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_POOLED_CONNECTION_HPP
+#define DATASTAX_INTERNAL_POOLED_CONNECTION_HPP
 
 #include "atomic.hpp"
 #include "connection.hpp"
 #include "ref_counted.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ConnectionPool;
 class EventLoop;
@@ -31,8 +31,9 @@ class RequestCallback;
 /**
  * A connection wrapper that handles connection pool functionality.
  */
-class PooledConnection : public RefCounted<PooledConnection>
-                       , public ConnectionListener {
+class PooledConnection
+    : public RefCounted<PooledConnection>
+    , public ConnectionListener {
 public:
   typedef SharedRefPtr<PooledConnection> Ptr;
   typedef Vector<Ptr> Vec;
@@ -43,8 +44,7 @@ class PooledConnection : public RefCounted<PooledConnection>
    * @param pool The connection pool of the connection.
    * @param connection The wrapped connection.
    */
-  PooledConnection(ConnectionPool* pool,
-                   const Connection::Ptr& connection);
+  PooledConnection(ConnectionPool* pool, const Connection::Ptr& connection);
 
   /**
    * Writes a request to a connection, but it's not written to the socket until
@@ -87,6 +87,6 @@ class PooledConnection : public RefCounted<PooledConnection>
   EventLoop* const event_loop_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/prepare_all_handler.cpp b/src/prepare_all_handler.cpp
index 519edaa67..7671b28b7 100644
--- a/src/prepare_all_handler.cpp
+++ b/src/prepare_all_handler.cpp
@@ -18,16 +18,15 @@
 
 #include "connection.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
-PrepareAllHandler::PrepareAllHandler(const Host::Ptr& current_host,
-                                     const Response::Ptr& response,
-                                     const RequestHandler::Ptr& request_handler,
-                                     int remaining)
-  : current_host_(current_host)
-  , response_(response)
-  , request_handler_(request_handler)
-  , remaining_(remaining) {
+PrepareAllHandler::PrepareAllHandler(const Host::Ptr& current_host, const Response::Ptr& response,
+                                     const RequestHandler::Ptr& request_handler, int remaining)
+    : current_host_(current_host)
+    , response_(response)
+    , request_handler_(request_handler)
+    , remaining_(remaining) {
   assert(remaining > 0);
 }
 
@@ -39,14 +38,12 @@ void PrepareAllHandler::finish() {
 
 PrepareAllCallback::PrepareAllCallback(const Address& address,
                                        const PrepareAllHandler::Ptr& handler)
-  : SimpleRequestCallback(handler->wrapper())
-  , address_(address)
-  , handler_(handler)
-  , is_finished_(false) { }
+    : SimpleRequestCallback(handler->wrapper())
+    , address_(address)
+    , handler_(handler)
+    , is_finished_(false) {}
 
-PrepareAllCallback::~PrepareAllCallback() {
-  finish();
-}
+PrepareAllCallback::~PrepareAllCallback() { finish(); }
 
 void PrepareAllCallback::finish() {
   // Only finish the callback one time. This can happen if the request times out.
@@ -58,15 +55,13 @@ void PrepareAllCallback::finish() {
 
 void PrepareAllCallback::on_internal_set(ResponseMessage* response) {
   if (!is_finished_) { // The request hasn't timed out
-    LOG_DEBUG("Successfully prepared all on host %s",
-              address_.to_string().c_str());
+    LOG_DEBUG("Successfully prepared all on host %s", address_.to_string().c_str());
   }
 }
 
 void PrepareAllCallback::on_internal_error(CassError code, const String& message) {
   if (!is_finished_) { // The request hasn't timed out
-    LOG_WARN("Failed to prepare all on host %s with error: '%s'",
-             address_.to_string().c_str(),
+    LOG_WARN("Failed to prepare all on host %s with error: '%s'", address_.to_string().c_str(),
              message.c_str());
   }
 }
@@ -75,5 +70,3 @@ void PrepareAllCallback::on_internal_timeout() {
   LOG_WARN("Prepare all timed out on host %s", address_.to_string().c_str());
   finish(); // Don't wait for the request to come back
 }
-
-} // namespace cass
diff --git a/src/prepare_all_handler.hpp b/src/prepare_all_handler.hpp
index 1cfbbf8b7..2bb1fa4d7 100644
--- a/src/prepare_all_handler.hpp
+++ b/src/prepare_all_handler.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_PREPARE_ALL_HANDLER_HPP_INCLUDED__
-#define __CASS_PREPARE_ALL_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_PREPARE_ALL_HANDLER_HPP
+#define DATASTAX_INTERNAL_PREPARE_ALL_HANDLER_HPP
 
 #include "address.hpp"
 #include "atomic.hpp"
@@ -25,7 +25,7 @@
 #include "request_handler.hpp"
 #include "response.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A handler that tracks the progress of prepares on all hosts and returns the
@@ -35,10 +35,8 @@ class PrepareAllHandler : public RefCounted<PrepareAllHandler> {
 public:
   typedef SharedRefPtr<PrepareAllHandler> Ptr;
 
-  PrepareAllHandler(const Host::Ptr& current_host,
-                    const Response::Ptr& response,
-                    const RequestHandler::Ptr& request_handler,
-                    int remaining);
+  PrepareAllHandler(const Host::Ptr& current_host, const Response::Ptr& response,
+                    const RequestHandler::Ptr& request_handler, int remaining);
 
 private:
   friend class PrepareAllCallback;
@@ -78,6 +76,6 @@ class PrepareAllCallback : public SimpleRequestCallback {
   bool is_finished_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/prepare_host_handler.cpp b/src/prepare_host_handler.cpp
index 9b5571bb0..0b0c4bd2a 100644
--- a/src/prepare_host_handler.cpp
+++ b/src/prepare_host_handler.cpp
@@ -23,7 +23,8 @@
 
 #include <algorithm>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 struct CompareEntryKeyspace {
   bool operator()(const PreparedMetadata::Entry::Ptr& lhs,
@@ -32,31 +33,26 @@ struct CompareEntryKeyspace {
   }
 };
 
-PrepareHostHandler::PrepareHostHandler(const Host::Ptr& host,
-                                       const PreparedMetadata::Entry::Vec& prepared_metadata_entries,
-                                       const Callback& callback,
-                                       ProtocolVersion protocol_version,
-                                       unsigned max_requests_per_flush)
-  : host_(host)
-  , protocol_version_(protocol_version)
-  , callback_(callback)
-  , connection_(NULL)
-  , prepares_outstanding_(0)
-  , max_prepares_outstanding_(CASS_MAX_STREAMS)
-  , prepared_metadata_entries_(prepared_metadata_entries) {
+PrepareHostHandler::PrepareHostHandler(
+    const Host::Ptr& host, const PreparedMetadata::Entry::Vec& prepared_metadata_entries,
+    const Callback& callback, ProtocolVersion protocol_version, unsigned max_requests_per_flush)
+    : host_(host)
+    , protocol_version_(protocol_version)
+    , callback_(callback)
+    , connection_(NULL)
+    , prepares_outstanding_(0)
+    , max_prepares_outstanding_(CASS_MAX_STREAMS)
+    , prepared_metadata_entries_(prepared_metadata_entries) {
 
   // Sort by keyspace to minimize the number of times the keyspace
   // needs to be changed.
-  std::sort(prepared_metadata_entries_.begin(),
-            prepared_metadata_entries_.end(),
+  std::sort(prepared_metadata_entries_.begin(), prepared_metadata_entries_.end(),
             CompareEntryKeyspace());
 
   current_entry_it_ = prepared_metadata_entries_.begin();
 }
 
-
-void PrepareHostHandler::prepare(uv_loop_t* loop,
-                                 const ConnectionSettings& settings) {
+void PrepareHostHandler::prepare(uv_loop_t* loop, const ConnectionSettings& settings) {
   if (prepared_metadata_entries_.empty()) {
     callback_(this);
     return;
@@ -64,13 +60,10 @@ void PrepareHostHandler::prepare(uv_loop_t* loop,
 
   inc_ref(); // Reference for the event loop
 
-  Connector::Ptr connector(new Connector(host_,
-                                         protocol_version_,
+  Connector::Ptr connector(new Connector(host_, protocol_version_,
                                          bind_callback(&PrepareHostHandler::on_connect, this)));
 
-  connector->with_settings(settings)
-      ->with_listener(this)
-      ->connect(loop);
+  connector->with_settings(settings)->with_listener(this)->connect(loop);
 }
 
 void PrepareHostHandler::on_close(Connection* connection) {
@@ -110,8 +103,7 @@ void PrepareHostHandler::prepare_next() {
 
   // Write prepare requests until there's no more left, the keyspace changes,
   // or the maximum number of outstanding prepares is reached.
-  while (!is_done() &&
-         check_and_set_keyspace() &&
+  while (!is_done() && check_and_set_keyspace() &&
          prepares_outstanding_ < max_prepares_outstanding_) {
     const String& query((*current_entry_it_)->query());
     PrepareRequest::Ptr prepare_request(new PrepareRequest(query));
@@ -119,8 +111,8 @@ void PrepareHostHandler::prepare_next() {
     // Set the keyspace in case per request keyspaces are supported
     prepare_request->set_keyspace(current_keyspace_);
 
-    if (!connection_->write(PrepareCallback::Ptr(
-                              new PrepareCallback(prepare_request, Ptr(this))))) {
+    if (!connection_->write(
+            PrepareCallback::Ptr(new PrepareCallback(prepare_request, Ptr(this))))) {
       LOG_WARN("Failed to write prepare request while preparing all queries on host %s",
                host_->address_string().c_str());
       close();
@@ -142,8 +134,8 @@ bool PrepareHostHandler::check_and_set_keyspace() {
   const String& keyspace((*current_entry_it_)->keyspace());
 
   if (keyspace != current_keyspace_) {
-    if (!connection_->write_and_flush(PrepareCallback::Ptr(
-                                        new SetKeyspaceCallback(keyspace, Ptr(this))))) {
+    if (!connection_->write_and_flush(
+            PrepareCallback::Ptr(new SetKeyspaceCallback(keyspace, Ptr(this))))) {
       LOG_WARN("Failed to write \"USE\" keyspace request while preparing all queries on host %s",
                host_->address_string().c_str());
       close();
@@ -160,14 +152,12 @@ bool PrepareHostHandler::is_done() const {
   return current_entry_it_ == prepared_metadata_entries_.end();
 }
 
-void PrepareHostHandler::close() {
-  connection_->close();
-}
+void PrepareHostHandler::close() { connection_->close(); }
 
-PrepareHostHandler::PrepareCallback::PrepareCallback(const PrepareRequest::ConstPtr& prepare_request,
-                                                     const PrepareHostHandler::Ptr& handler)
-  : SimpleRequestCallback(prepare_request)
-  , handler_(handler) { }
+PrepareHostHandler::PrepareCallback::PrepareCallback(
+    const PrepareRequest::ConstPtr& prepare_request, const PrepareHostHandler::Ptr& handler)
+    : SimpleRequestCallback(prepare_request)
+    , handler_(handler) {}
 
 void PrepareHostHandler::PrepareCallback::on_internal_set(ResponseMessage* response) {
   LOG_DEBUG("Successfully prepared query \"%s\" on host %s while preparing all queries",
@@ -178,9 +168,7 @@ void PrepareHostHandler::PrepareCallback::on_internal_set(ResponseMessage* respo
 
 void PrepareHostHandler::PrepareCallback::on_internal_error(CassError code, const String& message) {
   LOG_WARN("Prepare request failed on host %s while attempting to prepare all queries: %s (%s)",
-           handler_->host_->address_string().c_str(),
-           message.c_str(),
-           cass_error_desc(code));
+           handler_->host_->address_string().c_str(), message.c_str(), cass_error_desc(code));
   handler_->close();
 }
 
@@ -192,22 +180,20 @@ void PrepareHostHandler::PrepareCallback::on_internal_timeout() {
 
 PrepareHostHandler::SetKeyspaceCallback::SetKeyspaceCallback(const String& keyspace,
                                                              const PrepareHostHandler::Ptr& handler)
-  : SimpleRequestCallback(Request::ConstPtr(
-                            new QueryRequest("USE " + keyspace)))
-  , handler_(handler) { }
+    : SimpleRequestCallback(Request::ConstPtr(new QueryRequest("USE " + keyspace)))
+    , handler_(handler) {}
 
 void PrepareHostHandler::SetKeyspaceCallback::on_internal_set(ResponseMessage* response) {
   LOG_TRACE("Successfully set keyspace to \"%s\" on host %s while preparing all queries",
-            handler_->current_keyspace_.c_str(),
-            handler_->host()->address_string().c_str());
+            handler_->current_keyspace_.c_str(), handler_->host()->address_string().c_str());
   handler_->prepare_next();
 }
 
-void PrepareHostHandler::SetKeyspaceCallback::on_internal_error(CassError code, const String& message) {
-  LOG_WARN("\"USE\" keyspace request failed on host %s while attempting to prepare all queries: %s (%s)",
-           handler_->host_->address_string().c_str(),
-           message.c_str(),
-           cass_error_desc(code));
+void PrepareHostHandler::SetKeyspaceCallback::on_internal_error(CassError code,
+                                                                const String& message) {
+  LOG_WARN(
+      "\"USE\" keyspace request failed on host %s while attempting to prepare all queries: %s (%s)",
+      handler_->host_->address_string().c_str(), message.c_str(), cass_error_desc(code));
   handler_->close();
 }
 
@@ -216,5 +202,3 @@ void PrepareHostHandler::SetKeyspaceCallback::on_internal_timeout() {
            handler_->host_->address_string().c_str());
   handler_->close();
 }
-
-} // namespace cass
diff --git a/src/prepare_host_handler.hpp b/src/prepare_host_handler.hpp
index 0ceafa3d8..70f346cbc 100644
--- a/src/prepare_host_handler.hpp
+++ b/src/prepare_host_handler.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_PREPARE_HOST_HANDLER_HPP_INCLUDED__
-#define __CASS_PREPARE_HOST_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_PREPARE_HOST_HANDLER_HPP
+#define DATASTAX_INTERNAL_PREPARE_HOST_HANDLER_HPP
 
 #include "callback.hpp"
 #include "connector.hpp"
@@ -24,30 +24,29 @@
 #include "ref_counted.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Connector;
 
 /**
  * A handler for pre-preparing statements on a newly available host.
  */
-class PrepareHostHandler : public RefCounted<PrepareHostHandler>
-                         , public ConnectionListener {
+class PrepareHostHandler
+    : public RefCounted<PrepareHostHandler>
+    , public ConnectionListener {
 public:
-  typedef cass::Callback<void, const PrepareHostHandler*> Callback;
+  typedef internal::Callback<void, const PrepareHostHandler*> Callback;
 
   typedef SharedRefPtr<PrepareHostHandler> Ptr;
 
   PrepareHostHandler(const Host::Ptr& host,
                      const PreparedMetadata::Entry::Vec& prepared_metadata_entries,
-                     const Callback& callback,
-                     ProtocolVersion protocol_version,
+                     const Callback& callback, ProtocolVersion protocol_version,
                      unsigned max_requests_per_flush);
 
   const Host::Ptr host() const { return host_; }
 
-  void prepare(uv_loop_t* loop,
-               const ConnectionSettings& settings);
+  void prepare(uv_loop_t* loop, const ConnectionSettings& settings);
 
 private:
   virtual void on_close(Connection* connection);
@@ -83,8 +82,7 @@ class PrepareHostHandler : public RefCounted<PrepareHostHandler>
    */
   class SetKeyspaceCallback : public SimpleRequestCallback {
   public:
-    SetKeyspaceCallback(const String& keyspace,
-                        const PrepareHostHandler::Ptr& handler);
+    SetKeyspaceCallback(const String& keyspace, const PrepareHostHandler::Ptr& handler);
 
     virtual void on_internal_set(ResponseMessage* response);
 
@@ -119,6 +117,6 @@ class PrepareHostHandler : public RefCounted<PrepareHostHandler>
   PreparedMetadata::Entry::Vec::const_iterator current_entry_it_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/prepare_request.cpp b/src/prepare_request.cpp
index 7af0b9c45..d9a4eaf06 100644
--- a/src/prepare_request.cpp
+++ b/src/prepare_request.cpp
@@ -19,11 +19,12 @@
 #include "protocol.hpp"
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
-int PrepareRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int PrepareRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                           BufferVec* bufs) const {
   // <query> [long string]
-  size_t length = sizeof(int32_t) +  query_.size();
+  size_t length = sizeof(int32_t) + query_.size();
   bufs->push_back(Buffer(length));
   bufs->back().encode_long_string(0, query_.data(), query().size());
 
@@ -49,5 +50,3 @@ int PrepareRequest::encode(ProtocolVersion version, RequestCallback* callback, B
   }
   return length;
 }
-
-} // namespace cass
diff --git a/src/prepare_request.hpp b/src/prepare_request.hpp
index 515d3a66e..f50ab4b2c 100644
--- a/src/prepare_request.hpp
+++ b/src/prepare_request.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_PREPARE_REQUEST_HPP_INCLUDED__
-#define __CASS_PREPARE_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_PREPARE_REQUEST_HPP
+#define DATASTAX_INTERNAL_PREPARE_REQUEST_HPP
 
 #include "constants.hpp"
 #include "request.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class PrepareRequest : public Request {
 public:
@@ -30,15 +30,13 @@ class PrepareRequest : public Request {
 
   PrepareRequest(const String& query)
       : Request(CQL_OPCODE_PREPARE)
-      , query_(query) { }
+      , query_(query) {}
 
   const String& query() const { return query_; }
 
   void set_query(const String& query) { query_ = query; }
 
-  void set_query(const char* query, size_t query_length) {
-    query_.assign(query, query_length);
-  }
+  void set_query(const char* query, size_t query_length) { query_.assign(query, query_length); }
 
 private:
   int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
@@ -47,6 +45,6 @@ class PrepareRequest : public Request {
   String query_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/prepared.cpp b/src/prepared.cpp
index 4e1000e5d..7db059d3a 100644
--- a/src/prepared.cpp
+++ b/src/prepared.cpp
@@ -17,38 +17,37 @@
 #include "prepared.hpp"
 
 #include "execute_request.hpp"
-#include "logger.hpp"
 #include "external.hpp"
+#include "logger.hpp"
+
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 extern "C" {
 
-void cass_prepared_free(const CassPrepared* prepared) {
-  prepared->dec_ref();
-}
+void cass_prepared_free(const CassPrepared* prepared) { prepared->dec_ref(); }
 
 CassStatement* cass_prepared_bind(const CassPrepared* prepared) {
-  cass::ExecuteRequest* execute = new cass::ExecuteRequest(prepared);
+  ExecuteRequest* execute = new ExecuteRequest(prepared);
   execute->inc_ref();
   return CassStatement::to(execute);
 }
 
-CassError cass_prepared_parameter_name(const CassPrepared* prepared,
-                                       size_t index,
-                                       const char** name,
-                                       size_t* name_length) {
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(prepared->result()->metadata());
+CassError cass_prepared_parameter_name(const CassPrepared* prepared, size_t index,
+                                       const char** name, size_t* name_length) {
+  const SharedRefPtr<ResultMetadata>& metadata(prepared->result()->metadata());
   if (index >= metadata->column_count()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
-  const cass::ColumnDefinition def = metadata->get_column_definition(index);
+  const ColumnDefinition def = metadata->get_column_definition(index);
   *name = def.name.data();
   *name_length = def.name.size();
   return CASS_OK;
 }
 
-const CassDataType* cass_prepared_parameter_data_type(const CassPrepared* prepared,
-                                                      size_t index) {
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(prepared->result()->metadata());
+const CassDataType* cass_prepared_parameter_data_type(const CassPrepared* prepared, size_t index) {
+  const SharedRefPtr<ResultMetadata>& metadata(prepared->result()->metadata());
   if (index >= metadata->column_count()) {
     return NULL;
   }
@@ -57,18 +56,17 @@ const CassDataType* cass_prepared_parameter_data_type(const CassPrepared* prepar
 
 const CassDataType* cass_prepared_parameter_data_type_by_name(const CassPrepared* prepared,
                                                               const char* name) {
-  return cass_prepared_parameter_data_type_by_name_n(prepared,
-                                                     name, SAFE_STRLEN(name));
+  return cass_prepared_parameter_data_type_by_name_n(prepared, name, SAFE_STRLEN(name));
 }
 
 const CassDataType* cass_prepared_parameter_data_type_by_name_n(const CassPrepared* prepared,
                                                                 const char* name,
                                                                 size_t name_length) {
 
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(prepared->result()->metadata());
+  const SharedRefPtr<ResultMetadata>& metadata(prepared->result()->metadata());
 
-  cass::IndexVec indices;
-  if (metadata->get_indices(cass::StringRef(name, name_length), &indices) == 0) {
+  IndexVec indices;
+  if (metadata->get_indices(StringRef(name, name_length), &indices) == 0) {
     return NULL;
   }
   return CassDataType::to(metadata->get_column_definition(indices[0]).data_type.get());
@@ -76,16 +74,14 @@ const CassDataType* cass_prepared_parameter_data_type_by_name_n(const CassPrepar
 
 } // extern "C"
 
-namespace cass {
-
 Prepared::Prepared(const ResultResponse::Ptr& result,
                    const PrepareRequest::ConstPtr& prepare_request,
                    const Metadata::SchemaSnapshot& schema_metadata)
-  : result_(result)
-  , id_(result->prepared_id().to_string())
-  , query_(prepare_request->query())
-  , keyspace_(prepare_request->keyspace())
-  , request_settings_(prepare_request->settings()) {
+    : result_(result)
+    , id_(result->prepared_id().to_string())
+    , query_(prepare_request->query())
+    , keyspace_(prepare_request->keyspace())
+    , request_settings_(prepare_request->settings()) {
   assert(result->protocol_version() > 0 && "The protocol version should be set");
   if (result->protocol_version() >= CASS_PROTOCOL_VERSION_V4) {
     key_indices_ = result->pk_indices();
@@ -97,7 +93,8 @@ Prepared::Prepared(const ResultResponse::Ptr& result,
         const ColumnMetadata::Vec& partition_key = table->partition_key();
         IndexVec indices;
         for (ColumnMetadata::Vec::const_iterator i = partition_key.begin(),
-             end = partition_key.end(); i != end; ++i) {
+                                                 end = partition_key.end();
+             i != end; ++i) {
           const ColumnMetadata::Ptr& column(*i);
           if (column && result->metadata()->get_indices(column->name(), &indices) > 0) {
             key_indices_.push_back(indices[0]);
@@ -112,5 +109,3 @@ Prepared::Prepared(const ResultResponse::Ptr& result,
     }
   }
 }
-
-} // namespace cass
diff --git a/src/prepared.hpp b/src/prepared.hpp
index b536747ac..fdbcc00ed 100644
--- a/src/prepared.hpp
+++ b/src/prepared.hpp
@@ -14,31 +14,30 @@
   limitations under the License.
 */
 
-#ifndef __CASS_PREPARED_HPP_INCLUDED__
-#define __CASS_PREPARED_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_PREPARED_HPP
+#define DATASTAX_INTERNAL_PREPARED_HPP
 
 #include "buffer.hpp"
+#include "dense_hash_map.hpp"
 #include "external.hpp"
+#include "metadata.hpp"
 #include "prepare_request.hpp"
 #include "ref_counted.hpp"
 #include "request.hpp"
 #include "result_response.hpp"
-#include "metadata.hpp"
 #include "scoped_lock.hpp"
 #include "scoped_ptr.hpp"
 #include "string.hpp"
-#include "dense_hash_map.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Prepared : public RefCounted<Prepared> {
 public:
   typedef SharedRefPtr<const Prepared> ConstPtr;
 
-  Prepared(const ResultResponse::Ptr& result,
-           const PrepareRequest::ConstPtr& prepare_request,
+  Prepared(const ResultResponse::Ptr& result, const PrepareRequest::ConstPtr& prepare_request,
            const Metadata::SchemaSnapshot& schema_metadata);
 
   const ResultResponse::ConstPtr& result() const { return result_; }
@@ -64,17 +63,13 @@ class PreparedMetadata {
     typedef SharedRefPtr<const Entry> Ptr;
     typedef Vector<Ptr> Vec;
 
-    Entry(const String& query,
-          const String& keyspace,
-          const String& result_metadata_id,
+    Entry(const String& query, const String& keyspace, const String& result_metadata_id,
           const ResultResponse::ConstPtr& result)
-      : query_(query)
-      , keyspace_(keyspace)
-      , result_metadata_id_(sizeof(uint16_t) + result_metadata_id.size())
-      , result_(result) {
-      result_metadata_id_.encode_string(0,
-                                        result_metadata_id.data(),
-                                        result_metadata_id.size());
+        : query_(query)
+        , keyspace_(keyspace)
+        , result_metadata_id_(sizeof(uint16_t) + result_metadata_id.size())
+        , result_(result) {
+      result_metadata_id_.encode_string(0, result_metadata_id.data(), result_metadata_id.size());
     }
 
     const String& query() const { return query_; }
@@ -94,11 +89,9 @@ class PreparedMetadata {
     uv_rwlock_init(&rwlock_);
   }
 
-  ~PreparedMetadata() {
-    uv_rwlock_destroy(&rwlock_);
-  }
+  ~PreparedMetadata() { uv_rwlock_destroy(&rwlock_); }
 
-   Entry::Ptr get(const String& prepared_id) const {
+  Entry::Ptr get(const String& prepared_id) const {
     ScopedReadLock rl(&rwlock_);
     Map::const_iterator i = metadata_.find(prepared_id);
     if (i != metadata_.end()) {
@@ -116,8 +109,7 @@ class PreparedMetadata {
     ScopedReadLock rl(&rwlock_);
     Entry::Vec temp;
     temp.reserve(metadata_.size());
-    for (Map::const_iterator it = metadata_.begin(),
-         end = metadata_.end(); it != end; ++it) {
+    for (Map::const_iterator it = metadata_.begin(), end = metadata_.end(); it != end; ++it) {
       temp.push_back(it->second);
     }
     return temp;
@@ -130,8 +122,8 @@ class PreparedMetadata {
   Map metadata_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Prepared, CassPrepared)
+EXTERNAL_TYPE(datastax::internal::core::Prepared, CassPrepared)
 
 #endif
diff --git a/src/protocol.cpp b/src/protocol.cpp
index e417044a7..2fc149f4f 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -18,16 +18,17 @@
 
 #include "logger.hpp"
 
-#define DSE_PROTOCOL_VERSION_BIT  0x40
+#define DSE_PROTOCOL_VERSION_BIT 0x40
 #define DSE_PROTOCOL_VERSION_MASK 0x3F
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 ProtocolVersion::ProtocolVersion()
-  : value_(-1) { }
+    : value_(-1) {}
 
 ProtocolVersion::ProtocolVersion(int value)
-  : value_(value) { }
+    : value_(value) {}
 
 ProtocolVersion ProtocolVersion::lowest_supported() {
   return ProtocolVersion(CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION);
@@ -41,37 +42,31 @@ ProtocolVersion ProtocolVersion::newest_beta() {
   return ProtocolVersion(CASS_NEWEST_BETA_PROTOCOL_VERSION);
 }
 
-int ProtocolVersion::value() const {
-  return value_;
-}
+int ProtocolVersion::value() const { return value_; }
 
 bool ProtocolVersion::is_valid() const {
   if (value_ < CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION) {
     LOG_ERROR("Protocol version %s is lower than the lowest supported "
               " protocol version %s",
-              to_string().c_str(),
-              lowest_supported().to_string().c_str());
+              to_string().c_str(), lowest_supported().to_string().c_str());
     return false;
   } else if (value_ > CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION) {
     LOG_ERROR("Protocol version %s is higher than the highest supported "
               "protocol version %s (consider using the newest beta protocol version).",
-              to_string().c_str(),
-              highest_supported().to_string().c_str());
+              to_string().c_str(), highest_supported().to_string().c_str());
     return false;
   }
   return true;
 }
 
-bool ProtocolVersion::is_beta() const {
-  return value_ == CASS_NEWEST_BETA_PROTOCOL_VERSION;
-}
+bool ProtocolVersion::is_beta() const { return value_ == CASS_NEWEST_BETA_PROTOCOL_VERSION; }
 
 String ProtocolVersion::to_string() const {
   if (value_ > 0) {
     OStringStream ss;
     if (value_ & DSE_PROTOCOL_VERSION_BIT) {
       ss << "DSEv" << (value_ & DSE_PROTOCOL_VERSION_MASK);
-   } else {
+    } else {
       ss << "v" << value_;
     }
     return ss.str();
@@ -82,17 +77,16 @@ String ProtocolVersion::to_string() const {
 
 bool ProtocolVersion::attempt_lower_supported(const String& host) {
   if (value_ <= CASS_LOWEST_SUPPORTED_PROTOCOL_VERSION) {
-    LOG_ERROR("Host %s does not support any valid protocol version (lowest supported version is %s)",
-              host.c_str(),
-              lowest_supported().to_string().c_str());
+    LOG_ERROR(
+        "Host %s does not support any valid protocol version (lowest supported version is %s)",
+        host.c_str(), lowest_supported().to_string().c_str());
     return false;
   }
 
   int previous_version = value_--;
   LOG_WARN("Host %s does not support protocol version %s. "
            "Trying protocol version %s...",
-           host.c_str(),
-           ProtocolVersion(previous_version).to_string().c_str(),
+           host.c_str(), ProtocolVersion(previous_version).to_string().c_str(),
            to_string().c_str());
   return true;
 }
@@ -109,7 +103,5 @@ bool ProtocolVersion::supports_result_metadata_id() const {
   // Mailing List Discussion: https://www.mail-archive.com/dev@cassandra.apache.org/msg11731.html
   // TODO: Remove after Cassandra v4.0.0 is released
   return false;
-  //return version_ >= CASS_PROTOCOL_VERSION_V5;
+  // return version_ >= CASS_PROTOCOL_VERSION_V5;
 }
-
-} // namespace cass
diff --git a/src/protocol.hpp b/src/protocol.hpp
index 145b70223..58e747880 100644
--- a/src/protocol.hpp
+++ b/src/protocol.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_PROTOCOL_HPP_INCLUDED__
-#define __CASS_PROTOCOL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_PROTOCOL_HPP
+#define DATASTAX_INTERNAL_PROTOCOL_HPP
 
 #include "cassandra.h"
 #include "constants.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A type that represents the protocol version for Cassandra/DSE.
@@ -135,6 +135,6 @@ class ProtocolVersion {
   int value_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/query_request.cpp b/src/query_request.cpp
index 16dcdc041..c120b4a23 100644
--- a/src/query_request.cpp
+++ b/src/query_request.cpp
@@ -17,13 +17,15 @@
 #include "query_request.hpp"
 
 #include "constants.hpp"
-#include "request_callback.hpp"
 #include "logger.hpp"
+#include "request_callback.hpp"
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
-int QueryRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int QueryRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                         BufferVec* bufs) const {
   int32_t result;
   int32_t length = encode_query_or_id(bufs);
   if (has_names_for_values()) {
@@ -43,7 +45,8 @@ int QueryRequest::encode(ProtocolVersion version, RequestCallback* callback, Buf
 // where:
 // <name> is a [string]
 // <value> is a [bytes]
-int32_t QueryRequest::encode_values_with_names(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int32_t QueryRequest::encode_values_with_names(ProtocolVersion version, RequestCallback* callback,
+                                               BufferVec* bufs) const {
   int32_t size = 0;
   for (size_t i = 0; i < value_names_->size(); ++i) {
     const Buffer& name_buf = (*value_names_)[i].buf;
@@ -76,5 +79,3 @@ size_t QueryRequest::get_indices(StringRef name, IndexVec* indices) {
 
   return indices->size();
 }
-
-} // namespace cass
diff --git a/src/query_request.hpp b/src/query_request.hpp
index a61e216da..6cd662362 100644
--- a/src/query_request.hpp
+++ b/src/query_request.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_QUERY_REQUEST_HPP_INCLUDED__
-#define __CASS_QUERY_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_QUERY_REQUEST_HPP
+#define DATASTAX_INTERNAL_QUERY_REQUEST_HPP
 
 #include "constants.hpp"
 #include "hash_table.hpp"
@@ -23,36 +23,33 @@
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class QueryRequest : public Statement {
 public:
-  QueryRequest(const String& query,
-               size_t value_count = 0)
-    : Statement(query.data(), query.size(), value_count) { }
+  QueryRequest(const String& query, size_t value_count = 0)
+      : Statement(query.data(), query.size(), value_count) {}
 
-  QueryRequest(const char* query, size_t query_length,
-               size_t value_count)
-    : Statement(query, query_length, value_count) { }
+  QueryRequest(const char* query, size_t query_length, size_t value_count)
+      : Statement(query, query_length, value_count) {}
 
   virtual int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
 
 private:
-  int32_t encode_values_with_names(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
+  int32_t encode_values_with_names(ProtocolVersion version, RequestCallback* callback,
+                                   BufferVec* bufs) const;
 
   virtual size_t get_indices(StringRef name, IndexVec* indices);
 
-  virtual const DataType::ConstPtr& get_type(size_t index) const {
-    return DataType::NIL;
-  }
+  virtual const DataType::ConstPtr& get_type(size_t index) const { return DataType::NIL; }
 
 private:
   struct ValueName : HashTableEntry<ValueName> {
-    ValueName() { }
+    ValueName() {}
 
     ValueName(const String& name)
-      : name(name)
-      , buf(sizeof(uint16_t) + name.size()) {
+        : name(name)
+        , buf(sizeof(uint16_t) + name.size()) {
       buf.encode_string(0, name.data(), name.size());
     }
 
@@ -63,6 +60,6 @@ class QueryRequest : public Statement {
   ScopedPtr<ValueNameHashTable> value_names_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/random.cpp b/src/random.cpp
index e38b17f26..8ca8baf86 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -16,8 +16,8 @@
 
 #include "random.hpp"
 
-#include "cassconfig.hpp"
 #include "cassandra.h"
+#include "driver_config.hpp"
 #include "logger.hpp"
 #include "scoped_lock.hpp"
 
@@ -25,33 +25,31 @@
 #ifndef _WINSOCKAPI_
 #define _WINSOCKAPI_
 #endif
-#include <Windows.h>
 #include <WinCrypt.h>
+#include <Windows.h>
 #else
 #if defined(HAVE_GETRANDOM)
-#include <syscall.h>
 #include <linux/random.h>
+#include <syscall.h>
 #endif
 #include <errno.h>
 #include <fcntl.h>
-#include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/uio.h>
+#include <unistd.h>
 #endif
 
-namespace cass {
+namespace datastax { namespace internal {
 
 Random::Random()
- // Use high resolution time if we can't get a real random seed
-  : rng_(get_random_seed(uv_hrtime())) {
+    // Use high resolution time if we can't get a real random seed
+    : rng_(get_random_seed(uv_hrtime())) {
   uv_mutex_init(&mutex_);
 }
 
-Random::~Random() {
-  uv_mutex_destroy(&mutex_);
-}
+Random::~Random() { uv_mutex_destroy(&mutex_); }
 
 uint64_t Random::next(uint64_t max) {
   ScopedMutex l(&mutex_);
@@ -59,32 +57,31 @@ uint64_t Random::next(uint64_t max) {
   uint64_t r;
   do {
     r = rng_();
-  } while(r >= limit);
+  } while (r >= limit);
   return r % max;
 }
 
 #if defined(_WIN32)
 
-  uint64_t get_random_seed(uint64_t seed) {
-    HCRYPTPROV provider;
-
-    if (!CryptAcquireContext(&provider,
-                             NULL, NULL,
-                             PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
-      LOG_CRITICAL("Unable to aqcuire cryptographic provider: 0x%x", GetLastError());
-      return seed;
-    }
-
-    if (!CryptGenRandom(provider, sizeof(seed), (BYTE*)&seed)) {
-      LOG_CRITICAL("An error occurred attempting to generate random data: 0x%x", GetLastError());
-      return seed;
-    }
+uint64_t get_random_seed(uint64_t seed) {
+  HCRYPTPROV provider;
 
-    CryptReleaseContext(provider, 0);
+  if (!CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL,
+                           CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+    LOG_CRITICAL("Unable to aqcuire cryptographic provider: 0x%x", GetLastError());
+    return seed;
+  }
 
+  if (!CryptGenRandom(provider, sizeof(seed), (BYTE*)&seed)) {
+    LOG_CRITICAL("An error occurred attempting to generate random data: 0x%x", GetLastError());
     return seed;
   }
 
+  CryptReleaseContext(provider, 0);
+
+  return seed;
+}
+
 #else
 
 #define STRERROR_BUFSIZE_ 256
@@ -95,59 +92,55 @@ uint64_t Random::next(uint64_t max) {
 #define STRERROR_R_(errno, buf, bufsize) strerror_r(errno, buf, bufsize)
 #endif
 
-  uint64_t get_random_seed(uint64_t seed) {
+uint64_t get_random_seed(uint64_t seed) {
 #if defined(HAVE_ARC4RANDOM)
-    arc4random_buf(&seed, sizeof(seed));
+  arc4random_buf(&seed, sizeof(seed));
 #else
-    static const char* device = "/dev/urandom";
-    ssize_t num_bytes;
-    bool readurandom = true;
+  static const char* device = "/dev/urandom";
+  ssize_t num_bytes;
+  bool readurandom = true;
 #if defined(HAVE_GETRANDOM)
-    num_bytes = static_cast<ssize_t>(syscall(SYS_getrandom, &seed,
-            sizeof(seed), GRND_NONBLOCK));
-    if (num_bytes < static_cast<ssize_t>(sizeof(seed))) {
+  num_bytes = static_cast<ssize_t>(syscall(SYS_getrandom, &seed, sizeof(seed), GRND_NONBLOCK));
+  if (num_bytes < static_cast<ssize_t>(sizeof(seed))) {
+    char buf[STRERROR_BUFSIZE_];
+    char* err = STRERROR_R_(errno, buf, sizeof(buf));
+    LOG_WARN("Unable to read %u random bytes (%s): %u read",
+             static_cast<unsigned int>(sizeof(seed)), err, static_cast<unsigned int>(num_bytes));
+  } else {
+    readurandom = false;
+  }
+#endif // defined(HAVE_GETRANDOM)
+
+  if (readurandom) {
+    int fd = open(device, O_RDONLY);
+
+    if (fd < 0) {
       char buf[STRERROR_BUFSIZE_];
       char* err = STRERROR_R_(errno, buf, sizeof(buf));
-      LOG_WARN("Unable to read %u random bytes (%s): %u read",
-            static_cast<unsigned int>(sizeof(seed)), err, 
-            static_cast<unsigned int>(num_bytes));
-    } else {
-      readurandom = false;      
+      LOG_CRITICAL("Unable to open random device (%s): %s", device, err);
+      return seed;
     }
-#endif // defined(HAVE_GETRANDOM)
 
-    if (readurandom) {
-      int fd = open(device, O_RDONLY);
-
-      if (fd < 0) {
-        char buf[STRERROR_BUFSIZE_];
-        char* err = STRERROR_R_(errno, buf, sizeof(buf));
-        LOG_CRITICAL("Unable to open random device (%s): %s", device, err);
-        return seed;
-      }
-
-      num_bytes = read(fd, reinterpret_cast<char*>(&seed), sizeof(seed));
-      if (num_bytes < 0) {
-        char buf[STRERROR_BUFSIZE_];
-        char* err = STRERROR_R_(errno, buf, sizeof(buf));
-        LOG_CRITICAL("Unable to read from random device (%s): %s", device, err);
-      } else if (num_bytes != sizeof(seed)) {
-        char buf[STRERROR_BUFSIZE_];
-        char* err = STRERROR_R_(errno, buf, sizeof(buf));
-        LOG_CRITICAL("Unable to read full seed value (expected: %u read: %u) "
-            "from random device (%s): %s",
-            static_cast<unsigned int>(sizeof(seed)),
-            static_cast<unsigned int>(num_bytes),
-            device, err);
-      }
-
-      close(fd);
+    num_bytes = read(fd, reinterpret_cast<char*>(&seed), sizeof(seed));
+    if (num_bytes < 0) {
+      char buf[STRERROR_BUFSIZE_];
+      char* err = STRERROR_R_(errno, buf, sizeof(buf));
+      LOG_CRITICAL("Unable to read from random device (%s): %s", device, err);
+    } else if (num_bytes != sizeof(seed)) {
+      char buf[STRERROR_BUFSIZE_];
+      char* err = STRERROR_R_(errno, buf, sizeof(buf));
+      LOG_CRITICAL("Unable to read full seed value (expected: %u read: %u) "
+                   "from random device (%s): %s",
+                   static_cast<unsigned int>(sizeof(seed)), static_cast<unsigned int>(num_bytes),
+                   device, err);
     }
-#endif // defined(HAVE_ARC4RANDOM)
 
-    return seed;
+    close(fd);
   }
+#endif // defined(HAVE_ARC4RANDOM)
 
+  return seed;
+}
 #endif
 
-} // namespace cass
+}} // namespace datastax::internal
diff --git a/src/random.hpp b/src/random.hpp
index e6d2fe77b..a39fabd77 100644
--- a/src/random.hpp
+++ b/src/random.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RANDOM_HPP_INCLUDED__
-#define __CASS_RANDOM_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RANDOM_HPP
+#define DATASTAX_INTERNAL_RANDOM_HPP
 
 #include "allocated.hpp"
 #include "third_party/mt19937_64/mt19937_64.hpp"
@@ -23,7 +23,7 @@
 #include <algorithm>
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Random : public Allocated {
 public:
@@ -40,16 +40,13 @@ class Random : public Allocated {
 uint64_t get_random_seed(uint64_t seed);
 
 template <class RandomAccessIterator>
-void random_shuffle(RandomAccessIterator first,
-                    RandomAccessIterator last,
-                    Random* random) {
+void random_shuffle(RandomAccessIterator first, RandomAccessIterator last, Random* random) {
   size_t size = last - first;
   for (size_t i = size - 1; i > 0; --i) {
     std::swap(first[i], first[random->next(i + 1)]);
   }
 }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
-
diff --git a/src/ready_response.hpp b/src/ready_response.hpp
index 10fd4e52b..03b55233d 100644
--- a/src/ready_response.hpp
+++ b/src/ready_response.hpp
@@ -14,12 +14,12 @@
   limitations under the License.
 */
 
-#ifndef __CASS_READY_RESPONSE_HPP_INCLUDED__
-#define __CASS_READY_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_READY_RESPONSE_HPP
+#define DATASTAX_INTERNAL_READY_RESPONSE_HPP
 
 #include "response.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ReadyResponse : public Response {
 public:
@@ -29,6 +29,6 @@ class ReadyResponse : public Response {
   virtual bool decode(Decoder& decoder) { return true; }
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/reconnection_policy.cpp b/src/reconnection_policy.cpp
new file mode 100644
index 000000000..2e82bbfe7
--- /dev/null
+++ b/src/reconnection_policy.cpp
@@ -0,0 +1,101 @@
+/*
+  Copyright (c) DataStax, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include "reconnection_policy.hpp"
+#include "utils.hpp"
+
+#include <algorithm>
+#include <limits>
+
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
+
+unsigned calculate_max_attempts(uint64_t base_delay_ms) {
+  assert(base_delay_ms > 0 && "Base delay cannot be zero");
+  return 63u - num_leading_zeros(std::numeric_limits<uint64_t>::max() / base_delay_ms);
+}
+
+ReconnectionSchedule::~ReconnectionSchedule() {}
+
+ReconnectionPolicy::ReconnectionPolicy(Type type)
+    : type_(type) {}
+
+ReconnectionPolicy::~ReconnectionPolicy() {}
+
+ReconnectionPolicy::Type ReconnectionPolicy::type() const { return type_; }
+
+ConstantReconnectionPolicy::ConstantReconnectionPolicy(uint64_t delay_ms)
+    : ReconnectionPolicy(CONSTANT)
+    , delay_ms_(delay_ms) {}
+
+uint64_t ConstantReconnectionPolicy::delay_ms() const { return delay_ms_; }
+
+const char* ConstantReconnectionPolicy::name() const { return "constant"; }
+
+ReconnectionSchedule* ConstantReconnectionPolicy::new_reconnection_schedule() {
+  return new ConstantReconnectionSchedule(delay_ms_);
+}
+
+ConstantReconnectionSchedule::ConstantReconnectionSchedule(uint64_t delay_ms)
+    : delay_ms_(delay_ms) {}
+
+uint64_t ConstantReconnectionSchedule::next_delay_ms() { return delay_ms_; }
+
+ExponentialReconnectionPolicy::ExponentialReconnectionPolicy(uint64_t base_delay_ms,
+                                                             uint64_t max_delay_ms)
+    : ReconnectionPolicy(EXPONENTIAL)
+    , base_delay_ms_(base_delay_ms)
+    , max_delay_ms_(max_delay_ms)
+    , max_attempts_(calculate_max_attempts(base_delay_ms)) {}
+
+uint64_t ExponentialReconnectionPolicy::base_delay_ms() const { return base_delay_ms_; }
+
+uint64_t ExponentialReconnectionPolicy::max_delay_ms() const { return max_delay_ms_; }
+
+const char* ExponentialReconnectionPolicy::name() const { return "exponential"; }
+
+ReconnectionSchedule* ExponentialReconnectionPolicy::new_reconnection_schedule() {
+  return new ExponentialReconnectionSchedule(base_delay_ms_, max_delay_ms_, max_attempts_,
+                                             &random_);
+}
+
+ExponentialReconnectionSchedule::ExponentialReconnectionSchedule(uint64_t base_delay_ms,
+                                                                 uint64_t max_delay_ms,
+                                                                 unsigned max_attempts,
+                                                                 Random* random)
+    : base_delay_ms_(base_delay_ms)
+    , max_delay_ms_(max_delay_ms)
+    , max_attempts_(max_attempts)
+    , attempt_(0)
+    , random_(random) {}
+
+uint64_t ExponentialReconnectionSchedule::next_delay_ms() {
+  uint64_t delay_ms = max_delay_ms_;
+  if (attempt_ <= max_attempts_) {
+    // Calculate the delay and add +/- 15% jitter
+    delay_ms = std::min(base_delay_ms_ * (static_cast<uint64_t>(1) << attempt_++), max_delay_ms_);
+    uint64_t jitter = random_->next(30) + 85; // 85 - 115 range
+    delay_ms = (jitter * delay_ms) / 100;
+
+    // Ensure the delay is not less than the base and not greater than the max delay
+    delay_ms = std::min(std::max(base_delay_ms_, delay_ms), max_delay_ms_);
+    assert(delay_ms > 0);
+  }
+  return delay_ms;
+}
+
+}}} // namespace datastax::internal::core
diff --git a/src/reconnection_policy.hpp b/src/reconnection_policy.hpp
new file mode 100644
index 000000000..a6ecf0d93
--- /dev/null
+++ b/src/reconnection_policy.hpp
@@ -0,0 +1,113 @@
+/*
+  Copyright (c) DataStax, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#ifndef DATASTAX_INTERNAL_RECONNECTION_POLICY_HPP
+#define DATASTAX_INTERNAL_RECONNECTION_POLICY_HPP
+
+#include "constants.hpp"
+#include "random.hpp"
+#include "ref_counted.hpp"
+
+namespace datastax { namespace internal { namespace core {
+
+class ReconnectionSchedule : public RefCounted<ReconnectionSchedule> {
+public:
+  virtual ~ReconnectionSchedule();
+
+  virtual uint64_t next_delay_ms() = 0;
+};
+
+class ReconnectionPolicy : public RefCounted<ReconnectionPolicy> {
+public:
+  typedef SharedRefPtr<ReconnectionPolicy> Ptr;
+  enum Type { CONSTANT, EXPONENTIAL };
+
+  ReconnectionPolicy(Type type);
+  virtual ~ReconnectionPolicy();
+
+  Type type() const;
+
+  virtual const char* name() const = 0;
+  virtual ReconnectionSchedule* new_reconnection_schedule() = 0;
+
+private:
+  Type type_;
+};
+
+class ConstantReconnectionSchedule : public ReconnectionSchedule {
+public:
+  ConstantReconnectionSchedule(uint64_t delay_ms);
+
+  virtual uint64_t next_delay_ms();
+
+private:
+  uint64_t delay_ms_;
+};
+
+class ConstantReconnectionPolicy : public ReconnectionPolicy {
+public:
+  typedef SharedRefPtr<ConstantReconnectionPolicy> Ptr;
+
+  ConstantReconnectionPolicy(uint64_t delay_ms = CASS_DEFAULT_CONSTANT_RECONNECT_WAIT_TIME_MS);
+
+  uint64_t delay_ms() const;
+
+  virtual const char* name() const;
+  virtual ReconnectionSchedule* new_reconnection_schedule();
+
+private:
+  uint64_t delay_ms_;
+};
+
+class ExponentialReconnectionSchedule : public ReconnectionSchedule {
+public:
+  ExponentialReconnectionSchedule(uint64_t base_delay_ms, uint64_t max_delay_ms,
+                                  unsigned max_attempts, Random* random);
+
+  virtual uint64_t next_delay_ms();
+
+private:
+  uint64_t base_delay_ms_;
+  uint64_t max_delay_ms_;
+  unsigned max_attempts_;
+  unsigned attempt_;
+  Random* random_;
+};
+
+class ExponentialReconnectionPolicy : public ReconnectionPolicy {
+public:
+  typedef SharedRefPtr<ExponentialReconnectionPolicy> Ptr;
+
+  ExponentialReconnectionPolicy(
+      uint64_t base_delay_ms = CASS_DEFAULT_EXPONENTIAL_RECONNECT_BASE_DELAY_MS,
+      uint64_t max_delay_ms = CASS_DEFAULT_EXPONENTIAL_RECONNECT_MAX_DELAY_MS);
+
+  uint64_t base_delay_ms() const;
+  uint64_t max_delay_ms() const;
+
+  virtual const char* name() const;
+  virtual ReconnectionSchedule* new_reconnection_schedule();
+
+private:
+  uint64_t base_delay_ms_;
+  uint64_t max_delay_ms_;
+  unsigned max_attempts_;
+  Random random_;
+};
+
+}}} // namespace datastax::internal::core
+
+#endif
diff --git a/src/ref_counted.hpp b/src/ref_counted.hpp
index f56574f0b..03dcf6110 100644
--- a/src/ref_counted.hpp
+++ b/src/ref_counted.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REF_COUNTED_HPP_INCLUDED__
-#define __CASS_REF_COUNTED_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REF_COUNTED_HPP
+#define DATASTAX_INTERNAL_REF_COUNTED_HPP
 
 #include "allocated.hpp"
 #include "atomic.hpp"
@@ -26,21 +26,17 @@
 #include <new>
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 class RefCounted : public Allocated {
 public:
   RefCounted()
-      : ref_count_(0) { }
+      : ref_count_(0) {}
 
-  int ref_count() const {
-    return ref_count_.load(MEMORY_ORDER_ACQUIRE);
-  }
+  int ref_count() const { return ref_count_.load(MEMORY_ORDER_ACQUIRE); }
 
-  void inc_ref() const {
-    ref_count_.fetch_add(1, MEMORY_ORDER_RELAXED);
-  }
+  void inc_ref() const { ref_count_.fetch_add(1, MEMORY_ORDER_RELAXED); }
 
   void dec_ref() const {
     int new_ref_count = ref_count_.fetch_sub(1, MEMORY_ORDER_RELEASE);
@@ -56,24 +52,24 @@ class RefCounted : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(RefCounted);
 };
 
-template<class T>
+template <class T>
 class SharedRefPtr {
 public:
   explicit SharedRefPtr(T* ptr = NULL)
-       : ptr_(ptr) {
+      : ptr_(ptr) {
     if (ptr_ != NULL) {
       ptr_->inc_ref();
     }
   }
 
   SharedRefPtr(const SharedRefPtr<T>& ref)
-    : ptr_(NULL) {
+      : ptr_(NULL) {
     copy<T>(ref.ptr_);
   }
 
-  template<class S>
+  template <class S>
   SharedRefPtr(const SharedRefPtr<S>& ref)
-    : ptr_(NULL) {
+      : ptr_(NULL) {
     copy<S>(ref.ptr_);
   }
 
@@ -82,7 +78,7 @@ class SharedRefPtr {
     return *this;
   }
 
-  template<class S>
+  template <class S>
   SharedRefPtr<S>& operator=(const SharedRefPtr<S>& ref) {
     copy<S>(ref.ptr_);
     return *this;
@@ -94,17 +90,11 @@ class SharedRefPtr {
     }
   }
 
-  bool operator==(const T* ptr) const {
-    return ptr_ == ptr;
-  }
+  bool operator==(const T* ptr) const { return ptr_ == ptr; }
 
-  bool operator==(const SharedRefPtr<T>& ref) const {
-    return ptr_ == ref.ptr_;
-  }
+  bool operator==(const SharedRefPtr<T>& ref) const { return ptr_ == ref.ptr_; }
 
-  void reset(T* ptr = NULL) {
-    copy<T>(ptr);
-  }
+  void reset(T* ptr = NULL) { copy<T>(ptr); }
 
   T* get() const { return ptr_; }
   T& operator*() const { return *ptr_; }
@@ -112,9 +102,10 @@ class SharedRefPtr {
   operator bool() const { return ptr_ != NULL; }
 
 private:
-  template<class S> friend class SharedRefPtr;
+  template <class S>
+  friend class SharedRefPtr;
 
-  template<class S>
+  template <class S>
   void copy(S* ptr) {
     if (ptr == ptr_) return;
     if (ptr != NULL) {
@@ -137,7 +128,7 @@ class RefBuffer : public RefCounted<RefBuffer> {
   static RefBuffer* create(size_t size) {
 #if defined(_WIN32)
 #pragma warning(push)
-#pragma warning(disable: 4291) //Invalid warning thrown RefBuffer has a delete function
+#pragma warning(disable : 4291) // Invalid warning thrown RefBuffer has a delete function
 #endif
     return new (size) RefBuffer();
 #if defined(_WIN32)
@@ -145,24 +136,18 @@ class RefBuffer : public RefCounted<RefBuffer> {
 #endif
   }
 
-  char* data() {
-    return reinterpret_cast<char*>(this) + sizeof(RefBuffer);
-  }
+  char* data() { return reinterpret_cast<char*>(this) + sizeof(RefBuffer); }
 
-  void operator delete(void* ptr) {
-    Memory::free(ptr);
-  }
+  void operator delete(void* ptr) { Memory::free(ptr); }
 
 private:
-  RefBuffer() { }
+  RefBuffer() {}
 
-  void* operator new(size_t size, size_t extra) {
-    return Memory::malloc(size + extra);
-  }
+  void* operator new(size_t size, size_t extra) { return Memory::malloc(size + extra); }
 
   DISALLOW_COPY_AND_ASSIGN(RefBuffer);
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/register_request.cpp b/src/register_request.cpp
index 33aeebcd7..a957a7f01 100644
--- a/src/register_request.cpp
+++ b/src/register_request.cpp
@@ -18,9 +18,10 @@
 
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
-int RegisterRequest::encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int RegisterRequest::encode(ProtocolVersion version, RequestCallback* callback,
+                            BufferVec* bufs) const {
   // <events> [string list]
   size_t length = sizeof(uint16_t);
   Vector<String> events;
@@ -48,6 +49,3 @@ int RegisterRequest::encode(ProtocolVersion version, RequestCallback* callback,
 
   return length;
 }
-
-} // namespace cas
-
diff --git a/src/register_request.hpp b/src/register_request.hpp
index f6f9ee1d1..f95a9daa8 100644
--- a/src/register_request.hpp
+++ b/src/register_request.hpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REGISTER_REQUEST_HPP_INCLUDED__
-#define __CASS_REGISTER_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REGISTER_REQUEST_HPP
+#define DATASTAX_INTERNAL_REGISTER_REQUEST_HPP
 
-#include "request.hpp"
 #include "constants.hpp"
+#include "request.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RegisterRequest : public Request {
 public:
@@ -34,5 +34,5 @@ class RegisterRequest : public Request {
   int event_types_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 #endif
diff --git a/src/request.cpp b/src/request.cpp
index c40a2bd41..0b9d23c82 100644
--- a/src/request.cpp
+++ b/src/request.cpp
@@ -18,49 +18,41 @@
 
 #include "external.hpp"
 
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassCustomPayload* cass_custom_payload_new() {
-  cass::CustomPayload* payload = new cass::CustomPayload();
+  CustomPayload* payload = new CustomPayload();
   payload->inc_ref();
   return CassCustomPayload::to(payload);
 }
 
-void cass_custom_payload_set(CassCustomPayload* payload,
-                                const char* name,
-                                const cass_byte_t* value,
-                                size_t value_size) {
+void cass_custom_payload_set(CassCustomPayload* payload, const char* name, const cass_byte_t* value,
+                             size_t value_size) {
   payload->set(name, SAFE_STRLEN(name), value, value_size);
 }
 
-void cass_custom_payload_set_n(CassCustomPayload* payload,
-                                  const char* name,
-                                  size_t name_length,
-                                  const cass_byte_t* value,
-                                  size_t value_size) {
+void cass_custom_payload_set_n(CassCustomPayload* payload, const char* name, size_t name_length,
+                               const cass_byte_t* value, size_t value_size) {
   payload->set(name, name_length, value, value_size);
 }
 
-void cass_custom_payload_remove(CassCustomPayload* payload,
-                                const char* name) {
+void cass_custom_payload_remove(CassCustomPayload* payload, const char* name) {
   payload->remove(name, SAFE_STRLEN(name));
 }
 
-void cass_custom_payload_remove_n(CassCustomPayload* payload,
-                                  const char* name,
+void cass_custom_payload_remove_n(CassCustomPayload* payload, const char* name,
                                   size_t name_length) {
   payload->remove(name, name_length);
 }
 
-void cass_custom_payload_free(CassCustomPayload* payload) {
-  payload->dec_ref();
-}
+void cass_custom_payload_free(CassCustomPayload* payload) { payload->dec_ref(); }
 
 } // extern "C"
 
-namespace cass {
-
-void CustomPayload::set(const char* name, size_t name_length, const uint8_t* value, size_t value_size) {
+void CustomPayload::set(const char* name, size_t name_length, const uint8_t* value,
+                        size_t value_size) {
   Buffer buf(sizeof(uint16_t) + name_length + sizeof(int32_t) + value_size);
   size_t pos = buf.encode_string(0, name, name_length);
   buf.encode_bytes(pos, reinterpret_cast<const char*>(value), value_size);
@@ -69,14 +61,10 @@ void CustomPayload::set(const char* name, size_t name_length, const uint8_t* val
 
 int32_t CustomPayload::encode(BufferVec* bufs) const {
   int32_t length = 0;
-  for (ItemMap::const_iterator i = items_.begin(), end = items_.end();
-       i != end;
-       ++i) {
+  for (ItemMap::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) {
     const Buffer& buf = i->second;
     length += buf.size();
     bufs->push_back(buf);
   }
   return length;
 }
-
-} // namespace cass
diff --git a/src/request.hpp b/src/request.hpp
index a3b75997c..9ec31b7a3 100644
--- a/src/request.hpp
+++ b/src/request.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REQUEST_HPP_INCLUDED__
-#define __CASS_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REQUEST_HPP
+#define DATASTAX_INTERNAL_REQUEST_HPP
 
 #include "buffer.hpp"
 #include "cassandra.h"
@@ -31,7 +31,7 @@
 #include <stdint.h>
 #include <utility>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RequestCallback;
 
@@ -39,24 +39,18 @@ class CustomPayload : public RefCounted<CustomPayload> {
 public:
   typedef SharedRefPtr<const CustomPayload> ConstPtr;
 
-  virtual ~CustomPayload() { }
+  virtual ~CustomPayload() {}
 
-  void set(const char* name, size_t name_length,
-           const uint8_t* value, size_t value_size);
+  void set(const char* name, size_t name_length, const uint8_t* value, size_t value_size);
 
-  void remove(const char* name, size_t name_length) {
-    items_.erase(String(name, name_length));
-  }
+  void remove(const char* name, size_t name_length) { items_.erase(String(name, name_length)); }
 
   int32_t encode(BufferVec* bufs) const;
 
-  inline bool empty() const {
-    return items_.empty();
-  }
+  inline bool empty() const { return items_.empty(); }
+
+  inline size_t size() const { return items_.size(); }
 
-  inline size_t size() const {
-    return items_.size();
-  }
 private:
   typedef Map<String, Buffer> ItemMap;
   ItemMap items_;
@@ -67,10 +61,10 @@ class CustomPayload : public RefCounted<CustomPayload> {
 // be updated to reflect the new inherited setting(s).
 struct RequestSettings {
   RequestSettings()
-    : consistency(CASS_CONSISTENCY_UNKNOWN)
-    , serial_consistency(CASS_CONSISTENCY_UNKNOWN)
-    , request_timeout_ms(CASS_UINT64_MAX)
-    , is_idempotent(false) { }
+      : consistency(CASS_CONSISTENCY_UNKNOWN)
+      , serial_consistency(CASS_CONSISTENCY_UNKNOWN)
+      , request_timeout_ms(CASS_UINT64_MAX)
+      , is_idempotent(false) {}
   CassConsistency consistency;
   CassConsistency serial_consistency;
   uint64_t request_timeout_ms;
@@ -94,9 +88,9 @@ class Request : public RefCounted<Request> {
       : opcode_(opcode)
       , flags_(0)
       , timestamp_(CASS_INT64_MIN)
-      , record_attempted_addresses_(false) { }
+      , record_attempted_addresses_(false) {}
 
-  virtual ~Request() { }
+  virtual ~Request() {}
 
   uint8_t opcode() const { return opcode_; }
 
@@ -130,13 +124,9 @@ class Request : public RefCounted<Request> {
     settings_.request_timeout_ms = request_timeout_ms;
   }
 
-  const RetryPolicy::Ptr& retry_policy() const {
-    return settings_.retry_policy;
-  }
+  const RetryPolicy::Ptr& retry_policy() const { return settings_.retry_policy; }
 
-  void set_retry_policy(RetryPolicy* retry_policy) {
-    settings_.retry_policy.reset(retry_policy);
-  }
+  void set_retry_policy(RetryPolicy* retry_policy) { settings_.retry_policy.reset(retry_policy); }
 
   bool is_idempotent() const {
     // Prepare requests are idempotent and should be retried regardless of the
@@ -160,31 +150,21 @@ class Request : public RefCounted<Request> {
     record_attempted_addresses_ = record_attempted_addresses;
   }
 
-  const CustomPayload::ConstPtr& custom_payload() const {
-    return custom_payload_;
-  }
+  const CustomPayload::ConstPtr& custom_payload() const { return custom_payload_; }
 
-  bool has_custom_payload() const {
-    return custom_payload_ || !custom_payload_extra_.empty();
-  }
+  bool has_custom_payload() const { return custom_payload_ || !custom_payload_extra_.empty(); }
 
-  void set_custom_payload(const CustomPayload* payload) {
-    custom_payload_.reset(payload);
-  }
+  void set_custom_payload(const CustomPayload* payload) { custom_payload_.reset(payload); }
 
   void set_custom_payload(const char* key, const uint8_t* value, size_t value_len) {
     custom_payload_extra_.set(key, strlen(key), value, value_len);
   }
 
-  bool has_execution_profile() const {
-    return !profile_name_.empty();
-  }
+  bool has_execution_profile() const { return !profile_name_.empty(); }
 
   const String& execution_profile_name() const { return profile_name_; }
 
-  void set_execution_profile_name(const String& name) {
-    profile_name_ = name;
-  }
+  void set_execution_profile_name(const String& name) { profile_name_ = name; }
 
   int32_t encode_custom_payload(BufferVec* bufs) const {
     int32_t length = sizeof(uint16_t);
@@ -203,9 +183,7 @@ class Request : public RefCounted<Request> {
     return length;
   }
 
-  void set_host(const Address& host) {
-    host_.reset(new Address(host));
-  }
+  void set_host(const Address& host) { host_.reset(new Address(host)); }
   const Address* host() const { return host_.get(); }
 
   virtual int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const = 0;
@@ -228,14 +206,13 @@ class Request : public RefCounted<Request> {
 class RoutableRequest : public Request {
 public:
   RoutableRequest(uint8_t opcode)
-    : Request(opcode) { }
+      : Request(opcode) {}
 
   virtual bool get_routing_key(String* routing_key) const = 0;
 };
 
-} // namespace cass
-
-EXTERNAL_TYPE(cass::CustomPayload, CassCustomPayload)
+}}} // namespace datastax::internal::core
 
+EXTERNAL_TYPE(datastax::internal::core::CustomPayload, CassCustomPayload)
 
 #endif
diff --git a/src/request_callback.cpp b/src/request_callback.cpp
index f4c35d363..7a1c38959 100644
--- a/src/request_callback.cpp
+++ b/src/request_callback.cpp
@@ -27,7 +27,8 @@
 #include "result_response.hpp"
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 void RequestWrapper::set_prepared_metadata(const PreparedMetadata::Entry::Ptr& entry) {
   prepared_metadata_entry_ = entry;
@@ -50,9 +51,8 @@ void RequestCallback::notify_write(Connection* connection, int stream) {
 
 bool RequestCallback::skip_metadata() const {
   // Skip the metadata if this an execute request and we have an entry cached
-  return request()->opcode() == CQL_OPCODE_EXECUTE &&
-      prepared_metadata_entry() &&
-      prepared_metadata_entry()->result()->result_metadata();
+  return request()->opcode() == CQL_OPCODE_EXECUTE && prepared_metadata_entry() &&
+         prepared_metadata_entry()->result()->result_metadata();
 }
 
 int32_t RequestCallback::encode(BufferVec* bufs) {
@@ -125,8 +125,7 @@ void RequestCallback::on_close() {
 void RequestCallback::set_state(RequestCallback::State next_state) {
   switch (state_) {
     case REQUEST_STATE_NEW:
-      if (next_state == REQUEST_STATE_NEW ||
-          next_state == REQUEST_STATE_WRITING) {
+      if (next_state == REQUEST_STATE_NEW || next_state == REQUEST_STATE_WRITING) {
         state_ = next_state;
       } else {
         assert(false && "Invalid request state after new");
@@ -134,8 +133,7 @@ void RequestCallback::set_state(RequestCallback::State next_state) {
       break;
 
     case REQUEST_STATE_WRITING:
-      if (next_state == REQUEST_STATE_READING ||
-          next_state == REQUEST_STATE_READ_BEFORE_WRITE ||
+      if (next_state == REQUEST_STATE_READING || next_state == REQUEST_STATE_READ_BEFORE_WRITE ||
           next_state == REQUEST_STATE_FINISHED) {
         state_ = next_state;
       } else {
@@ -174,15 +172,13 @@ void RequestCallback::set_state(RequestCallback::State next_state) {
 }
 
 SimpleRequestCallback::SimpleRequestCallback(const String& query, uint64_t request_timeout_ms)
-  : RequestCallback(
-      RequestWrapper(Request::ConstPtr(new QueryRequest(query)),
-                     request_timeout_ms)) { }
+    : RequestCallback(
+          RequestWrapper(Request::ConstPtr(new QueryRequest(query)), request_timeout_ms)) {}
 
 void SimpleRequestCallback::on_write(Connection* connection) {
   uint64_t request_timeout_ms = this->request_timeout_ms();
   if (request_timeout_ms > 0) { // 0 means no timeout
-    timer_.start(connection->loop(),
-                 request_timeout_ms,
+    timer_.start(connection->loop(), request_timeout_ms,
                  bind_callback(&SimpleRequestCallback::on_timeout, this));
   }
   on_internal_write(connection);
@@ -212,30 +208,31 @@ void SimpleRequestCallback::on_timeout(Timer* timer) {
   LOG_DEBUG("Request timed out (internal)");
 }
 
-ChainedRequestCallback::ChainedRequestCallback(const String& key, const String& query, const Ptr& chain)
-  : SimpleRequestCallback(query)
-  , chain_(chain)
-  , has_pending_(false)
-  , has_error_or_timeout_(false)
-  , key_(key) { }
-
-ChainedRequestCallback::ChainedRequestCallback(const String& key, const Request::ConstPtr& request, const Ptr& chain)
-  : SimpleRequestCallback(request)
-  , chain_(chain)
-  , has_pending_(false)
-  , has_error_or_timeout_(false)
-  , key_(key) { }
+ChainedRequestCallback::ChainedRequestCallback(const String& key, const String& query,
+                                               const Ptr& chain)
+    : SimpleRequestCallback(query)
+    , chain_(chain)
+    , has_pending_(false)
+    , has_error_or_timeout_(false)
+    , key_(key) {}
+
+ChainedRequestCallback::ChainedRequestCallback(const String& key, const Request::ConstPtr& request,
+                                               const Ptr& chain)
+    : SimpleRequestCallback(request)
+    , chain_(chain)
+    , has_pending_(false)
+    , has_error_or_timeout_(false)
+    , key_(key) {}
 
 ChainedRequestCallback::Ptr ChainedRequestCallback::chain(const String& key, const String& query) {
   has_pending_ = true;
-  return ChainedRequestCallback::Ptr(
-        new ChainedRequestCallback(key, query, Ptr(this)));
+  return ChainedRequestCallback::Ptr(new ChainedRequestCallback(key, query, Ptr(this)));
 }
 
-ChainedRequestCallback::Ptr ChainedRequestCallback::chain(const String& key, const Request::ConstPtr& request) {
+ChainedRequestCallback::Ptr ChainedRequestCallback::chain(const String& key,
+                                                          const Request::ConstPtr& request) {
   has_pending_ = true;
-  return ChainedRequestCallback::Ptr(
-        new ChainedRequestCallback(key, request, Ptr(this)));
+  return ChainedRequestCallback::Ptr(new ChainedRequestCallback(key, request, Ptr(this)));
 }
 
 ResultResponse::Ptr ChainedRequestCallback::result(const String& key) const {
@@ -290,9 +287,8 @@ void ChainedRequestCallback::set_chain_responses(Map& responses) {
 }
 
 bool ChainedRequestCallback::is_finished() const {
-  return response_ &&
-      !has_error_or_timeout_ &&
-      ((has_pending_ && !responses_.empty()) || !has_pending_);
+  return response_ && !has_error_or_timeout_ &&
+         ((has_pending_ && !responses_.empty()) || !has_pending_);
 }
 
 void ChainedRequestCallback::maybe_finish() {
@@ -315,5 +311,3 @@ void ChainedRequestCallback::maybe_finish() {
     }
   }
 }
-
-} // namespace cass
diff --git a/src/request_callback.hpp b/src/request_callback.hpp
index 200f1b946..9d5325f0d 100644
--- a/src/request_callback.hpp
+++ b/src/request_callback.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REQUEST_CALLBACK_HPP_INCLUDED__
-#define __CASS_REQUEST_CALLBACK_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REQUEST_CALLBACK_HPP
+#define DATASTAX_INTERNAL_REQUEST_CALLBACK_HPP
 
 #include "buffer.hpp"
 #include "cassandra.h"
@@ -34,7 +34,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 class Connection;
@@ -55,22 +55,19 @@ typedef Vector<uv_buf_t> UvBufVec;
  */
 class RequestWrapper {
 public:
-  RequestWrapper(const Request::ConstPtr &request,
+  RequestWrapper(const Request::ConstPtr& request,
                  uint64_t request_timeout_ms = CASS_DEFAULT_REQUEST_TIMEOUT_MS)
-    : request_(request)
-    , consistency_(CASS_DEFAULT_CONSISTENCY)
-    , serial_consistency_(CASS_DEFAULT_SERIAL_CONSISTENCY)
-    , request_timeout_ms_(request_timeout_ms)
-    , timestamp_(CASS_INT64_MIN) { }
+      : request_(request)
+      , consistency_(CASS_DEFAULT_CONSISTENCY)
+      , serial_consistency_(CASS_DEFAULT_SERIAL_CONSISTENCY)
+      , request_timeout_ms_(request_timeout_ms)
+      , timestamp_(CASS_INT64_MIN) {}
 
   void set_prepared_metadata(const PreparedMetadata::Entry::Ptr& entry);
 
-  void init(const ExecutionProfile& profile,
-            TimestampGenerator* timestamp_generator);
+  void init(const ExecutionProfile& profile, TimestampGenerator* timestamp_generator);
 
-  const Request::ConstPtr& request() const {
-    return request_;
-  }
+  const Request::ConstPtr& request() const { return request_; }
 
   CassConsistency consistency() const {
     if (request()->consistency() != CASS_CONSISTENCY_UNKNOWN) {
@@ -121,7 +118,9 @@ class RequestWrapper {
   PreparedMetadata::Entry::Ptr prepared_metadata_entry_;
 };
 
-class RequestCallback : public RefCounted<RequestCallback>, public SocketRequest {
+class RequestCallback
+    : public RefCounted<RequestCallback>
+    , public SocketRequest {
 public:
   typedef SharedRefPtr<RequestCallback> Ptr;
   typedef Vector<Ptr> Vec;
@@ -135,15 +134,14 @@ class RequestCallback : public RefCounted<RequestCallback>, public SocketRequest
   };
 
   RequestCallback(const RequestWrapper& wrapper)
-    : wrapper_(wrapper)
-    , stream_(-1)
-    , state_(REQUEST_STATE_NEW)
-    , retry_consistency_(CASS_CONSISTENCY_UNKNOWN) { }
+      : wrapper_(wrapper)
+      , stream_(-1)
+      , state_(REQUEST_STATE_NEW)
+      , retry_consistency_(CASS_CONSISTENCY_UNKNOWN) {}
 
-  virtual ~RequestCallback() { }
+  virtual ~RequestCallback() {}
 
-  void notify_write(Connection* connection,
-                    int stream);
+  void notify_write(Connection* connection, int stream);
 
 public:
   // Called to retry a request on a different connection
@@ -172,21 +170,13 @@ class RequestCallback : public RefCounted<RequestCallback>, public SocketRequest
     return wrapper_.consistency();
   }
 
-  CassConsistency serial_consistency() {
-    return wrapper_.serial_consistency();
-  }
+  CassConsistency serial_consistency() { return wrapper_.serial_consistency(); }
 
-  uint64_t request_timeout_ms() {
-    return wrapper_.request_timeout_ms();
-  }
+  uint64_t request_timeout_ms() { return wrapper_.request_timeout_ms(); }
 
-  int64_t timestamp() {
-    return wrapper_.timestamp();
-  }
+  int64_t timestamp() { return wrapper_.timestamp(); }
 
-  const RetryPolicy::Ptr& retry_policy() {
-    return wrapper_.retry_policy();
-  }
+  const RetryPolicy::Ptr& retry_policy() { return wrapper_.retry_policy(); }
 
   const PreparedMetadata::Entry::Ptr& prepared_metadata_entry() const {
     return wrapper_.prepared_metadata_entry();
@@ -199,9 +189,7 @@ class RequestCallback : public RefCounted<RequestCallback>, public SocketRequest
   State state() const { return state_; }
   void set_state(State next_state);
 
-  ResponseMessage* read_before_write_response() const {
-    return read_before_write_response_.get();
-  }
+  ResponseMessage* read_before_write_response() const { return read_before_write_response_.get(); }
 
   void set_read_before_write_response(ResponseMessage* response) {
     read_before_write_response_.reset(response);
@@ -230,13 +218,13 @@ class SimpleRequestCallback : public RequestCallback {
 
   SimpleRequestCallback(const Request::ConstPtr& request,
                         uint64_t request_timeout_ms = CASS_DEFAULT_REQUEST_TIMEOUT_MS)
-    : RequestCallback(RequestWrapper(request, request_timeout_ms)) { }
+      : RequestCallback(RequestWrapper(request, request_timeout_ms)) {}
 
   SimpleRequestCallback(const RequestWrapper& wrapper)
-    : RequestCallback(wrapper) { }
+      : RequestCallback(wrapper) {}
 
 protected:
-  virtual void on_internal_write(Connection* connection) { }
+  virtual void on_internal_write(Connection* connection) {}
   virtual void on_internal_set(ResponseMessage* response) = 0;
   virtual void on_internal_error(CassError code, const String& message) = 0;
   virtual void on_internal_timeout() = 0;
@@ -268,9 +256,7 @@ class ChainedRequestCallback : public SimpleRequestCallback {
 
   class Map : public DenseHashMap<String, Response::Ptr> {
   public:
-    Map() {
-      set_empty_key(String());
-    }
+    Map() { set_empty_key(String()); }
   };
 
   /**
@@ -291,7 +277,8 @@ class ChainedRequestCallback : public SimpleRequestCallback {
    * @param chain A request that's chained to this request. Don't use directly
    * instead use the chain() method.
    */
-  ChainedRequestCallback(const String& key, const Request::ConstPtr& request, const Ptr& chain = Ptr());
+  ChainedRequestCallback(const String& key, const Request::ConstPtr& request,
+                         const Ptr& chain = Ptr());
 
   /**
    * Add a chained query to this request callback.
@@ -341,12 +328,12 @@ class ChainedRequestCallback : public SimpleRequestCallback {
    *
    * @param connection The connection the callback was written to.
    */
-  virtual void on_chain_write(Connection* connection) { }
+  virtual void on_chain_write(Connection* connection) {}
 
   /**
    * A callback for when all responses have been received.
    */
-  virtual void on_chain_set() { }
+  virtual void on_chain_set() {}
 
   /**
    * A callback for when an error occurs. A single error causes the whole
@@ -355,13 +342,13 @@ class ChainedRequestCallback : public SimpleRequestCallback {
    * @param code The error code.
    * @param message The error message.
    */
-  virtual void on_chain_error(CassError code, const String& message) { }
+  virtual void on_chain_error(CassError code, const String& message) {}
 
   /**
    * A callback for a request timeout. A single timeout causes the whole
    * chain to fail.
    */
-  virtual void on_chain_timeout() { }
+  virtual void on_chain_timeout() {}
 
 private:
   virtual void on_internal_write(Connection* connection);
@@ -384,6 +371,6 @@ class ChainedRequestCallback : public SimpleRequestCallback {
   Map responses_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/request_handler.cpp b/src/request_handler.cpp
index c671f0db9..281c59ea9 100644
--- a/src/request_handler.cpp
+++ b/src/request_handler.cpp
@@ -32,12 +32,14 @@
 
 #include <uv.h>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class SingleHostQueryPlan : public QueryPlan {
 public:
   SingleHostQueryPlan(const Address& address)
-    : host_(new Host(address)) { }
+      : host_(new Host(address)) {}
 
   virtual Host::Ptr compute_next() {
     Host::Ptr temp = host_;
@@ -54,12 +56,10 @@ class PrepareCallback : public SimpleRequestCallback {
   PrepareCallback(const String& query, RequestExecution* request_execution);
 
 private:
-  class PrepareRequest : public cass::PrepareRequest {
+  class PrepareRequest : public core::PrepareRequest {
   public:
-    PrepareRequest(const String& query,
-                   const String& keyspace,
-                   uint64_t request_timeout_ms)
-      : cass::PrepareRequest(query) {
+    PrepareRequest(const String& query, const String& keyspace, uint64_t request_timeout_ms)
+        : core::PrepareRequest(query) {
       set_keyspace(keyspace);
       set_request_timeout_ms(request_timeout_ms);
     }
@@ -75,18 +75,15 @@ class PrepareCallback : public SimpleRequestCallback {
 };
 
 PrepareCallback::PrepareCallback(const String& query, RequestExecution* request_execution)
-  : SimpleRequestCallback(
-      Request::ConstPtr(
-        new PrepareRequest(query,
-                                         request_execution->request()->keyspace(),
-                                         request_execution->request_timeout_ms())))
-  , request_execution_(request_execution) { }
+    : SimpleRequestCallback(
+          Request::ConstPtr(new PrepareRequest(query, request_execution->request()->keyspace(),
+                                               request_execution->request_timeout_ms())))
+    , request_execution_(request_execution) {}
 
 void PrepareCallback::on_internal_set(ResponseMessage* response) {
   switch (response->opcode()) {
     case CQL_OPCODE_RESULT: {
-      ResultResponse* result =
-          static_cast<ResultResponse*>(response->response_body().get());
+      ResultResponse* result = static_cast<ResultResponse*>(response->response_body().get());
       if (result->kind() == CASS_RESULT_KIND_PREPARED) {
         request_execution_->notify_result_metadata_changed(request(), result);
         request_execution_->on_retry_current_host();
@@ -106,17 +103,14 @@ void PrepareCallback::on_internal_error(CassError code, const String& message) {
   request_execution_->on_retry_next_host();
 }
 
-void PrepareCallback::on_internal_timeout() {
-  request_execution_->on_retry_next_host();
-}
+void PrepareCallback::on_internal_timeout() { request_execution_->on_retry_next_host(); }
 
 class NopRequestListener : public RequestListener {
 public:
   virtual void on_prepared_metadata_changed(const String& id,
-                                            const PreparedMetadata::Entry::Ptr& entry) { }
+                                            const PreparedMetadata::Entry::Ptr& entry) {}
 
-  virtual void on_keyspace_changed(const String& keyspace,
-                                   KeyspaceChangedResponse response) { }
+  virtual void on_keyspace_changed(const String& keyspace, KeyspaceChangedResponse response) {}
 
   virtual bool on_wait_for_tracing_data(const RequestHandler::Ptr& request_handler,
                                         const Host::Ptr& current_host,
@@ -131,45 +125,41 @@ class NopRequestListener : public RequestListener {
   }
 
   virtual bool on_prepare_all(const RequestHandler::Ptr& request_handler,
-                              const Host::Ptr& current_host,
-                              const Response::Ptr& response) {
+                              const Host::Ptr& current_host, const Response::Ptr& response) {
     return false;
   }
 
-  virtual void on_done() { }
+  virtual void on_done() {}
 };
 
 static NopRequestListener nop_request_listener__;
 
-RequestHandler::RequestHandler(const Request::ConstPtr& request,
-                               const ResponseFuture::Ptr& future,
-                               Metrics* metrics,
-                               const Address* preferred_address)
-  : wrapper_(request)
-  , future_(future)
-  , is_done_(false)
-  , running_executions_(0)
-  , start_time_ns_(uv_hrtime())
-  , listener_(&nop_request_listener__)
-  , manager_(NULL)
-  , metrics_(metrics)
-  , preferred_address_(preferred_address != NULL ? *preferred_address : Address()) { }
+RequestHandler::RequestHandler(const Request::ConstPtr& request, const ResponseFuture::Ptr& future,
+                               Metrics* metrics, const Address* preferred_address)
+    : wrapper_(request)
+    , future_(future)
+    , is_done_(false)
+    , running_executions_(0)
+    , start_time_ns_(uv_hrtime())
+    , listener_(&nop_request_listener__)
+    , manager_(NULL)
+    , metrics_(metrics)
+    , preferred_address_(preferred_address != NULL ? *preferred_address : Address()) {}
 
 void RequestHandler::set_prepared_metadata(const PreparedMetadata::Entry::Ptr& entry) {
   wrapper_.set_prepared_metadata(entry);
 }
 
-void RequestHandler::init(const ExecutionProfile& profile,
-                          ConnectionPoolManager* manager,
-                          const TokenMap* token_map,
-                          TimestampGenerator* timestamp_generator,
+void RequestHandler::init(const ExecutionProfile& profile, ConnectionPoolManager* manager,
+                          const TokenMap* token_map, TimestampGenerator* timestamp_generator,
                           RequestListener* listener) {
   manager_ = manager;
   listener_ = listener ? listener : &nop_request_listener__;
   wrapper_.init(profile, timestamp_generator);
 
   // Attempt to use the statement's keyspace first then if not set then use the session's keyspace
-  const String& keyspace(!request()->keyspace().empty() ? request()->keyspace() : manager_->keyspace());
+  const String& keyspace(!request()->keyspace().empty() ? request()->keyspace()
+                                                        : manager_->keyspace());
 
   // If a specific host is set then bypass the load balancing policy and use a
   // specialized single host query plan.
@@ -179,7 +169,8 @@ void RequestHandler::init(const ExecutionProfile& profile,
     query_plan_.reset(profile.load_balancing_policy()->new_query_plan(keyspace, this, token_map));
   }
 
-  execution_plan_.reset(profile.speculative_execution_policy()->new_plan(keyspace, wrapper_.request().get()));
+  execution_plan_.reset(
+      profile.speculative_execution_policy()->new_plan(keyspace, wrapper_.request().get()));
 }
 
 void RequestHandler::execute() {
@@ -196,15 +187,12 @@ void RequestHandler::start_request(uv_loop_t* loop, Protected) {
   if (!timer_.is_running()) {
     uint64_t request_timeout_ms = wrapper_.request_timeout_ms();
     if (request_timeout_ms > 0) { // 0 means no timeout
-      timer_.start(loop, request_timeout_ms,
-                   bind_callback(&RequestHandler::on_timeout, this));
+      timer_.start(loop, request_timeout_ms, bind_callback(&RequestHandler::on_timeout, this));
     }
   }
 }
 
-Host::Ptr RequestHandler::next_host(Protected) {
-  return query_plan_->compute_next();
-}
+Host::Ptr RequestHandler::next_host(Protected) { return query_plan_->compute_next(); }
 
 int64_t RequestHandler::next_execution(const Host::Ptr& current_host, Protected) {
   return execution_plan_->next_execution(current_host);
@@ -214,24 +202,20 @@ void RequestHandler::add_attempted_address(const Address& address, Protected) {
   future_->add_attempted_address(address);
 }
 
-void RequestHandler::notify_result_metadata_changed(const String& prepared_id,
-                                                    const String& query,
+void RequestHandler::notify_result_metadata_changed(const String& prepared_id, const String& query,
                                                     const String& keyspace,
                                                     const String& result_metadata_id,
-                                                    const ResultResponse::ConstPtr& result_response, Protected) {
+                                                    const ResultResponse::ConstPtr& result_response,
+                                                    Protected) {
   PreparedMetadata::Entry::Ptr entry(
-        new PreparedMetadata::Entry(query,
-                                    keyspace,
-                                    result_metadata_id,
-                                    result_response));
+      new PreparedMetadata::Entry(query, keyspace, result_metadata_id, result_response));
   listener_->on_prepared_metadata_changed(prepared_id, entry);
 }
 
-void RequestHandler::notify_keyspace_changed(const String& keyspace,
-                                             const Host::Ptr& current_host,
+void RequestHandler::notify_keyspace_changed(const String& keyspace, const Host::Ptr& current_host,
                                              const Response::Ptr& response) {
-  listener_->on_keyspace_changed(keyspace,
-                                 KeyspaceChangedResponse(RequestHandler::Ptr(this), current_host, response));
+  listener_->on_keyspace_changed(
+      keyspace, KeyspaceChangedResponse(RequestHandler::Ptr(this), current_host, response));
 }
 
 bool RequestHandler::wait_for_tracing_data(const Host::Ptr& current_host,
@@ -244,13 +228,11 @@ bool RequestHandler::wait_for_schema_agreement(const Host::Ptr& current_host,
   return listener_->on_wait_for_schema_agreement(Ptr(this), current_host, response);
 }
 
-bool RequestHandler::prepare_all(const Host::Ptr& current_host,
-                                 const Response::Ptr& response) {
+bool RequestHandler::prepare_all(const Host::Ptr& current_host, const Response::Ptr& response) {
   return listener_->on_prepare_all(Ptr(this), current_host, response);
 }
 
-void RequestHandler::set_response(const Host::Ptr& host,
-                                  const Response::Ptr& response) {
+void RequestHandler::set_response(const Host::Ptr& host, const Response::Ptr& response) {
   stop_request();
   running_executions_--;
 
@@ -268,8 +250,7 @@ void RequestHandler::set_response(const Host::Ptr& host,
   }
 }
 
-void RequestHandler::set_error(CassError code,
-                               const String& message) {
+void RequestHandler::set_error(CassError code, const String& message) {
   stop_request();
   bool skip = (code == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE && --running_executions_ > 0);
   if (!skip) {
@@ -277,8 +258,7 @@ void RequestHandler::set_error(CassError code,
   }
 }
 
-void RequestHandler::set_error(const Host::Ptr& host,
-                               CassError code, const String& message) {
+void RequestHandler::set_error(const Host::Ptr& host, CassError code, const String& message) {
   stop_request();
   bool skip = (code == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE && --running_executions_ > 0);
   if (!skip) {
@@ -291,16 +271,14 @@ void RequestHandler::set_error(const Host::Ptr& host,
 }
 
 void RequestHandler::set_error_with_error_response(const Host::Ptr& host,
-                                                   const Response::Ptr& error,
-                                                   CassError code, const String& message) {
+                                                   const Response::Ptr& error, CassError code,
+                                                   const String& message) {
   stop_request();
   running_executions_--;
   future_->set_error_with_response(host->address(), error, code, message);
 }
 
-void RequestHandler::stop_timer() {
-  timer_.stop();
-}
+void RequestHandler::stop_timer() { timer_.stop(); }
 
 void RequestHandler::on_timeout(Timer* timer) {
   if (metrics_) {
@@ -321,16 +299,17 @@ void RequestHandler::stop_request() {
 void RequestHandler::internal_retry(RequestExecution* request_execution) {
   if (is_done_) {
     LOG_DEBUG("Canceling speculative execution (%p) for request (%p) on host %s",
-              static_cast<void*>(request_execution),
-              static_cast<void*>(this),
-              request_execution->current_host() ? request_execution->current_host()->address_string().c_str()
-                                                : "<no current host>");
+              static_cast<void*>(request_execution), static_cast<void*>(this),
+              request_execution->current_host()
+                  ? request_execution->current_host()->address_string().c_str()
+                  : "<no current host>");
     return;
   }
 
   bool is_successful = false;
   while (request_execution->current_host()) {
-    PooledConnection::Ptr connection = manager_->find_least_busy(request_execution->current_host()->address());
+    PooledConnection::Ptr connection =
+        manager_->find_least_busy(request_execution->current_host()->address());
     if (connection && connection->write(request_execution)) {
       is_successful = true;
       break;
@@ -339,26 +318,21 @@ void RequestHandler::internal_retry(RequestExecution* request_execution) {
   }
 
   if (!is_successful) {
-    set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
-              "All hosts in current policy attempted "
-              "and were either unavailable or failed");
+    set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, "All hosts in current policy attempted "
+                                                 "and were either unavailable or failed");
   }
 }
 
 RequestExecution::RequestExecution(RequestHandler* request_handler)
-  : RequestCallback(request_handler->wrapper())
-  , request_handler_(request_handler)
-  , current_host_(request_handler->next_host(RequestHandler::Protected()))
-  , num_retries_(0)
-  , start_time_ns_(uv_hrtime()) { }
+    : RequestCallback(request_handler->wrapper())
+    , request_handler_(request_handler)
+    , current_host_(request_handler->next_host(RequestHandler::Protected()))
+    , num_retries_(0)
+    , start_time_ns_(uv_hrtime()) {}
 
-void RequestExecution::on_execute_next(Timer* timer) {
-  request_handler_->execute();
-}
+void RequestExecution::on_execute_next(Timer* timer) { request_handler_->execute(); }
 
-void RequestExecution::on_retry_current_host() {
-  retry_current_host();
-}
+void RequestExecution::on_retry_current_host() { retry_current_host(); }
 
 void RequestExecution::on_retry_next_host() {
   current_host_->decrement_inflight_requests();
@@ -421,8 +395,7 @@ void RequestExecution::on_error(CassError code, const String& message) {
   current_host_->decrement_inflight_requests();
 
   // Handle recoverable errors by retrying with the next host
-  if (code == CASS_ERROR_LIB_WRITE_ERROR ||
-      code == CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE) {
+  if (code == CASS_ERROR_LIB_WRITE_ERROR || code == CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE) {
     retry_next_host();
   } else {
     set_error(code, message);
@@ -434,37 +407,32 @@ void RequestExecution::notify_result_metadata_changed(const Request* request,
   // Attempt to use the per-query keyspace first (v5+/DSEv2+ only) then
   // the keyspace in the result metadata.
   String keyspace;
-  if (result_response->protocol_version().supports_set_keyspace() &&
-      !request->keyspace().empty()) {
+  if (result_response->protocol_version().supports_set_keyspace() && !request->keyspace().empty()) {
     keyspace = request->keyspace();
   } else {
     keyspace = result_response->keyspace().to_string();
   }
 
-  if (request->opcode() == CQL_OPCODE_EXECUTE &&
-      result_response->kind() == CASS_RESULT_KIND_ROWS) {
+  if (request->opcode() == CQL_OPCODE_EXECUTE && result_response->kind() == CASS_RESULT_KIND_ROWS) {
     const ExecuteRequest* execute = static_cast<const ExecuteRequest*>(request);
-    request_handler_->notify_result_metadata_changed(execute->prepared()->id(),
-                                                     execute->prepared()->query(),
-                                                     keyspace,
-                                                     result_response->new_metadata_id().to_string(),
-                                                     ResultResponse::ConstPtr(result_response), RequestHandler::Protected());
-  } else if (request->opcode()  == CQL_OPCODE_PREPARE &&
+    request_handler_->notify_result_metadata_changed(
+        execute->prepared()->id(), execute->prepared()->query(), keyspace,
+        result_response->new_metadata_id().to_string(), ResultResponse::ConstPtr(result_response),
+        RequestHandler::Protected());
+  } else if (request->opcode() == CQL_OPCODE_PREPARE &&
              result_response->kind() == CASS_RESULT_KIND_PREPARED) {
     const PrepareRequest* prepare = static_cast<const PrepareRequest*>(request);
-    request_handler_->notify_result_metadata_changed(result_response->prepared_id().to_string(),
-                                                     prepare->query(),
-                                                     keyspace,
-                                                     result_response->result_metadata_id().to_string(),
-                                                     ResultResponse::ConstPtr(result_response), RequestHandler::Protected());
+    request_handler_->notify_result_metadata_changed(
+        result_response->prepared_id().to_string(), prepare->query(), keyspace,
+        result_response->result_metadata_id().to_string(),
+        ResultResponse::ConstPtr(result_response), RequestHandler::Protected());
   } else {
-    assert (false && "Invalid response type for a result metadata change");
+    assert(false && "Invalid response type for a result metadata change");
   }
 }
 
 void RequestExecution::on_result_response(Connection* connection, ResponseMessage* response) {
-  ResultResponse* result =
-      static_cast<ResultResponse*>(response->response_body().get());
+  ResultResponse* result = static_cast<ResultResponse*>(response->response_body().get());
 
   switch (result->kind()) {
     case CASS_RESULT_KIND_ROWS:
@@ -487,15 +455,13 @@ void RequestExecution::on_result_response(Connection* connection, ResponseMessag
       }
 
       if (!response->response_body()->has_tracing_id() ||
-          !request_handler_->wait_for_tracing_data(current_host(),
-                                                   response->response_body())) {
+          !request_handler_->wait_for_tracing_data(current_host(), response->response_body())) {
         set_response(response->response_body());
       }
       break;
 
     case CASS_RESULT_KIND_SCHEMA_CHANGE: {
-      if (!request_handler_->wait_for_schema_agreement(current_host(),
-                                                       response->response_body())) {
+      if (!request_handler_->wait_for_schema_agreement(current_host(), response->response_body())) {
         set_response(response->response_body());
       }
       break;
@@ -503,15 +469,13 @@ void RequestExecution::on_result_response(Connection* connection, ResponseMessag
 
     case CASS_RESULT_KIND_SET_KEYSPACE:
       // The response is set after the keyspace is propagated to all threads.
-      request_handler_->notify_keyspace_changed(result->keyspace().to_string(),
-                                                current_host_,
+      request_handler_->notify_keyspace_changed(result->keyspace().to_string(), current_host_,
                                                 response->response_body());
       break;
 
     case CASS_RESULT_KIND_PREPARED:
       notify_result_metadata_changed(request(), result);
-      if (!request_handler_->prepare_all(current_host(),
-                                         response->response_body())) {
+      if (!request_handler_->prepare_all(current_host(), response->response_body())) {
         set_response(response->response_body());
       }
       break;
@@ -523,65 +487,47 @@ void RequestExecution::on_result_response(Connection* connection, ResponseMessag
 }
 
 void RequestExecution::on_error_response(Connection* connection, ResponseMessage* response) {
-  ErrorResponse* error =
-      static_cast<ErrorResponse*>(response->response_body().get());
+  ErrorResponse* error = static_cast<ErrorResponse*>(response->response_body().get());
 
   RetryPolicy::RetryDecision decision = RetryPolicy::RetryDecision::return_error();
 
-  switch(error->code()) {
+  switch (error->code()) {
     case CQL_ERROR_READ_TIMEOUT:
       if (retry_policy()) {
-        decision =  retry_policy()->on_read_timeout(request(),
-                                                    error->consistency(),
-                                                    error->received(),
-                                                    error->required(),
-                                                    error->data_present() > 0,
-                                                    num_retries_);
+        decision = retry_policy()->on_read_timeout(request(), error->consistency(),
+                                                   error->received(), error->required(),
+                                                   error->data_present() > 0, num_retries_);
       }
       break;
 
     case CQL_ERROR_WRITE_TIMEOUT:
       if (retry_policy() && request()->is_idempotent()) {
-        decision = retry_policy()->on_write_timeout(request(),
-                                                    error->consistency(),
-                                                    error->received(),
-                                                    error->required(),
-                                                    error->write_type(),
-                                                    num_retries_);
+        decision =
+            retry_policy()->on_write_timeout(request(), error->consistency(), error->received(),
+                                             error->required(), error->write_type(), num_retries_);
       }
       break;
 
     case CQL_ERROR_UNAVAILABLE:
       if (retry_policy()) {
-        decision =  retry_policy()->on_unavailable(request(),
-                                                   error->consistency(),
-                                                   error->required(),
-                                                   error->received(),
-                                                   num_retries_);
+        decision = retry_policy()->on_unavailable(
+            request(), error->consistency(), error->required(), error->received(), num_retries_);
       }
       break;
 
     case CQL_ERROR_OVERLOADED:
-      LOG_WARN("Host %s is overloaded.",
-               connection->address_string().c_str());
+      LOG_WARN("Host %s is overloaded.", connection->address_string().c_str());
       if (retry_policy() && request()->is_idempotent()) {
-        decision = retry_policy()->on_request_error(request(),
-                                                    consistency(),
-                                                    error,
-                                                    num_retries_);
+        decision = retry_policy()->on_request_error(request(), consistency(), error, num_retries_);
       }
       break;
 
     case CQL_ERROR_SERVER_ERROR:
       LOG_WARN("Received server error '%s' from host %s. Defuncting the connection...",
-               error->message().to_string().c_str(),
-               connection->address_string().c_str());
+               error->message().to_string().c_str(), connection->address_string().c_str());
       connection->defunct();
       if (retry_policy() && request()->is_idempotent()) {
-        decision = retry_policy()->on_request_error(request(),
-                                                    consistency(),
-                                                    error,
-                                                    num_retries_);
+        decision = retry_policy()->on_request_error(request(), consistency(), error, num_retries_);
       }
       break;
 
@@ -601,12 +547,12 @@ void RequestExecution::on_error_response(Connection* connection, ResponseMessage
   }
 
   // Process retry decision
-  switch(decision.type()) {
+  switch (decision.type()) {
     case RetryPolicy::RetryDecision::RETURN_ERROR:
-      set_error_with_error_response(response->response_body(),
-                                    static_cast<CassError>(CASS_ERROR(
-                                                             CASS_ERROR_SOURCE_SERVER, error->code())),
-                                    error->message().to_string());
+      set_error_with_error_response(
+          response->response_body(),
+          static_cast<CassError>(CASS_ERROR(CASS_ERROR_SOURCE_SERVER, error->code())),
+          error->message().to_string());
       break;
 
     case RetryPolicy::RetryDecision::RETRY:
@@ -640,14 +586,12 @@ void RequestExecution::on_error_unprepared(Connection* connection, ErrorResponse
     }
   } else {
     connection->defunct();
-    set_error(CASS_ERROR_LIB_UNEXPECTED_RESPONSE,
-              "Received unprepared error for invalid "
-              "request type or invalid prepared id");
+    set_error(CASS_ERROR_LIB_UNEXPECTED_RESPONSE, "Received unprepared error for invalid "
+                                                  "request type or invalid prepared id");
     return;
   }
 
-  if (!connection->write_and_flush(RequestCallback::Ptr(
-                                     new PrepareCallback(query, this)))) {
+  if (!connection->write_and_flush(RequestCallback::Ptr(new PrepareCallback(query, this)))) {
     // Try to prepare on the same host but on a different connection
     retry_current_host();
   }
@@ -661,9 +605,7 @@ void RequestExecution::set_error(CassError code, const String& message) {
   request_handler_->set_error(current_host_, code, message);
 }
 
-void RequestExecution::set_error_with_error_response(const Response::Ptr& error,
-                                                     CassError code, const String& message) {
+void RequestExecution::set_error_with_error_response(const Response::Ptr& error, CassError code,
+                                                     const String& message) {
   request_handler_->set_error_with_error_response(current_host_, error, code, message);
 }
-
-} // namespace cass
diff --git a/src/request_handler.hpp b/src/request_handler.hpp
index 4130c1b2c..9f6f0e3ae 100644
--- a/src/request_handler.hpp
+++ b/src/request_handler.hpp
@@ -14,18 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REQUEST_HANDLER_HPP_INCLUDED__
-#define __CASS_REQUEST_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REQUEST_HANDLER_HPP
+#define DATASTAX_INTERNAL_REQUEST_HANDLER_HPP
 
 #include "constants.hpp"
 #include "error_response.hpp"
 #include "future.hpp"
-#include "request_callback.hpp"
 #include "host.hpp"
 #include "load_balancing.hpp"
 #include "metadata.hpp"
 #include "prepare_request.hpp"
 #include "request.hpp"
+#include "request_callback.hpp"
 #include "response.hpp"
 #include "result_response.hpp"
 #include "retry_policy.hpp"
@@ -37,7 +37,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 class Connection;
@@ -52,11 +52,11 @@ class ResponseFuture : public Future {
   typedef SharedRefPtr<ResponseFuture> Ptr;
 
   ResponseFuture()
-    : Future(FUTURE_TYPE_RESPONSE) { }
+      : Future(FUTURE_TYPE_RESPONSE) {}
 
   ResponseFuture(const Metadata::SchemaSnapshot& schema_metadata)
-    : Future(FUTURE_TYPE_RESPONSE)
-    , schema_metadata(new Metadata::SchemaSnapshot(schema_metadata)) { }
+      : Future(FUTURE_TYPE_RESPONSE)
+      , schema_metadata(new Metadata::SchemaSnapshot(schema_metadata)) {}
 
   bool set_response(Address address, const Response::Ptr& response) {
     ScopedMutex lock(&mutex_);
@@ -85,8 +85,8 @@ class ResponseFuture : public Future {
     return false;
   }
 
-  bool set_error_with_response(Address address, const Response::Ptr& response,
-                               CassError code, const String& message) {
+  bool set_error_with_response(Address address, const Response::Ptr& response, CassError code,
+                               const String& message) {
     ScopedMutex lock(&mutex_);
     if (!is_set()) {
       address_ = address;
@@ -136,17 +136,13 @@ class RequestHandler : public RefCounted<RequestHandler> {
 public:
   typedef SharedRefPtr<RequestHandler> Ptr;
 
-  RequestHandler(const Request::ConstPtr& request,
-                 const ResponseFuture::Ptr& future,
-                 Metrics* metrics = NULL,
-                 const Address* preferred_address = NULL);
+  RequestHandler(const Request::ConstPtr& request, const ResponseFuture::Ptr& future,
+                 Metrics* metrics = NULL, const Address* preferred_address = NULL);
 
   void set_prepared_metadata(const PreparedMetadata::Entry::Ptr& entry);
 
-  void init(const ExecutionProfile& profile,
-            ConnectionPoolManager* manager,
-            const TokenMap* token_map,
-            TimestampGenerator* timestamp_generator,
+  void init(const ExecutionProfile& profile, ConnectionPoolManager* manager,
+            const TokenMap* token_map, TimestampGenerator* timestamp_generator,
             RequestListener* listener);
 
   void execute();
@@ -159,8 +155,8 @@ class RequestHandler : public RefCounted<RequestHandler> {
 public:
   class Protected {
     friend class RequestExecution;
-    Protected() { }
-    Protected(Protected const&) { }
+    Protected() {}
+    Protected(Protected const&) {}
   };
 
   void retry(RequestExecution* request_execution, Protected);
@@ -172,31 +168,22 @@ class RequestHandler : public RefCounted<RequestHandler> {
 
   void add_attempted_address(const Address& address, Protected);
 
-  void notify_result_metadata_changed(const String& prepared_id,
-                                      const String& query,
-                                      const String& keyspace,
-                                      const String& result_metadata_id,
+  void notify_result_metadata_changed(const String& prepared_id, const String& query,
+                                      const String& keyspace, const String& result_metadata_id,
                                       const ResultResponse::ConstPtr& result_response, Protected);
 
-  void notify_keyspace_changed(const String& keyspace,
-                               const Host::Ptr& current_host,
+  void notify_keyspace_changed(const String& keyspace, const Host::Ptr& current_host,
                                const Response::Ptr& response);
 
-  bool wait_for_tracing_data(const Host::Ptr& current_host,
-                             const Response::Ptr& response);
-  bool wait_for_schema_agreement(const Host::Ptr& current_host,
-                                 const Response::Ptr& response);
+  bool wait_for_tracing_data(const Host::Ptr& current_host, const Response::Ptr& response);
+  bool wait_for_schema_agreement(const Host::Ptr& current_host, const Response::Ptr& response);
 
-  bool prepare_all(const Host::Ptr& current_host,
-                   const Response::Ptr& response);
+  bool prepare_all(const Host::Ptr& current_host, const Response::Ptr& response);
 
-  void set_response(const Host::Ptr& host,
-                    const Response::Ptr& response);
+  void set_response(const Host::Ptr& host, const Response::Ptr& response);
   void set_error(CassError code, const String& message);
-  void set_error(const Host::Ptr& host,
-                 CassError code, const String& message);
-  void set_error_with_error_response(const Host::Ptr& host,
-                                     const Response::Ptr& error,
+  void set_error(const Host::Ptr& host, CassError code, const String& message);
+  void set_error_with_error_response(const Host::Ptr& host, const Response::Ptr& error,
                                      CassError code, const String& message);
 
   void stop_timer();
@@ -229,16 +216,13 @@ class RequestHandler : public RefCounted<RequestHandler> {
 
 class KeyspaceChangedResponse {
 public:
-  KeyspaceChangedResponse(const RequestHandler::Ptr& request_handler,
-                          const Host::Ptr& current_host,
+  KeyspaceChangedResponse(const RequestHandler::Ptr& request_handler, const Host::Ptr& current_host,
                           const Response::Ptr& response)
-    : request_handler_(request_handler)
-    , current_host_(current_host)
-    , response_(response) { }
+      : request_handler_(request_handler)
+      , current_host_(current_host)
+      , response_(response) {}
 
-  void set_response() {
-    request_handler_->set_response(current_host_, response_);
-  }
+  void set_response() { request_handler_->set_response(current_host_, response_); }
 
 private:
   RequestHandler::Ptr request_handler_;
@@ -248,7 +232,7 @@ class KeyspaceChangedResponse {
 
 class PreparedMetadataListener {
 public:
-  virtual ~PreparedMetadataListener() { }
+  virtual ~PreparedMetadataListener() {}
 
   virtual void on_prepared_metadata_changed(const String& id,
                                             const PreparedMetadata::Entry::Ptr& entry) = 0;
@@ -256,7 +240,7 @@ class PreparedMetadataListener {
 
 class RequestListener : public PreparedMetadataListener {
 public:
-  virtual ~RequestListener() { }
+  virtual ~RequestListener() {}
 
   /**
    * A callback called when the keyspace has changed.
@@ -265,8 +249,7 @@ class RequestListener : public PreparedMetadataListener {
    * @param response The response for the keyspace change. `set_response()`
    * must be called when the callback is done processing the keyspace change.
    */
-  virtual void on_keyspace_changed(const String& keyspace,
-                                   KeyspaceChangedResponse response) = 0;
+  virtual void on_keyspace_changed(const String& keyspace, KeyspaceChangedResponse response) = 0;
 
   virtual bool on_wait_for_tracing_data(const RequestHandler::Ptr& request_handler,
                                         const Host::Ptr& current_host,
@@ -277,8 +260,7 @@ class RequestListener : public PreparedMetadataListener {
                                             const Response::Ptr& response) = 0;
 
   virtual bool on_prepare_all(const RequestHandler::Ptr& request_handler,
-                              const Host::Ptr& current_host,
-                              const Response::Ptr& response) = 0;
+                              const Host::Ptr& current_host, const Response::Ptr& response) = 0;
 
   virtual void on_done() = 0;
 };
@@ -290,12 +272,9 @@ class RequestExecution : public RequestCallback {
   RequestExecution(RequestHandler* request_handler);
 
   const Host::Ptr& current_host() const { return current_host_; }
-  void next_host() {
-    current_host_ = request_handler_->next_host(RequestHandler::Protected());
-  }
+  void next_host() { current_host_ = request_handler_->next_host(RequestHandler::Protected()); }
 
-  void notify_result_metadata_changed(const Request *request,
-                                      ResultResponse* result_response);
+  void notify_result_metadata_changed(const Request* request, ResultResponse* result_response);
 
   virtual void on_retry_current_host();
   virtual void on_retry_next_host();
@@ -318,8 +297,8 @@ class RequestExecution : public RequestCallback {
 private:
   void set_response(const Response::Ptr& response);
   void set_error(CassError code, const String& message);
-  void set_error_with_error_response(const Response::Ptr& error,
-                                     CassError code, const String& message);
+  void set_error_with_error_response(const Response::Ptr& error, CassError code,
+                                     const String& message);
 
 private:
   RequestHandler::Ptr request_handler_;
@@ -330,6 +309,6 @@ class RequestExecution : public RequestCallback {
   const uint64_t start_time_ns_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/request_processor.cpp b/src/request_processor.cpp
index b293feaa8..709b0d624 100644
--- a/src/request_processor.cpp
+++ b/src/request_processor.cpp
@@ -23,16 +23,18 @@
 #include "tracing_data_handler.hpp"
 #include "utils.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 class ProcessorRunClose : public Task {
 public:
   ProcessorRunClose(const RequestProcessor::Ptr& processor)
-    : processor_(processor) { }
+      : processor_(processor) {}
 
-  virtual void run(EventLoop* event_loop) {
-    processor_->internal_close();
-  }
+  virtual void run(EventLoop* event_loop) { processor_->internal_close(); }
 
 private:
   const RequestProcessor::Ptr processor_;
@@ -40,13 +42,11 @@ class ProcessorRunClose : public Task {
 
 class ProcessorNotifyHostAdd : public Task {
 public:
-  ProcessorNotifyHostAdd(const Host::Ptr host,
-                         const RequestProcessor::Ptr& request_processor)
-    : request_processor_(request_processor)
-    , host_(host) { }
-  virtual void run(EventLoop* event_loop) {
-    request_processor_->internal_host_add(host_);
-  }
+  ProcessorNotifyHostAdd(const Host::Ptr host, const RequestProcessor::Ptr& request_processor)
+      : request_processor_(request_processor)
+      , host_(host) {}
+  virtual void run(EventLoop* event_loop) { request_processor_->internal_host_add(host_); }
+
 private:
   const RequestProcessor::Ptr request_processor_;
   const Host::Ptr host_;
@@ -54,13 +54,11 @@ class ProcessorNotifyHostAdd : public Task {
 
 class ProcessorNotifyHostRemove : public Task {
 public:
-  ProcessorNotifyHostRemove(const Host::Ptr host,
-                            const RequestProcessor::Ptr& request_processor)
-    : request_processor_(request_processor)
-    , host_(host) { }
-  virtual void run(EventLoop* event_loop) {
-    request_processor_->internal_host_remove(host_);
-  }
+  ProcessorNotifyHostRemove(const Host::Ptr host, const RequestProcessor::Ptr& request_processor)
+      : request_processor_(request_processor)
+      , host_(host) {}
+  virtual void run(EventLoop* event_loop) { request_processor_->internal_host_remove(host_); }
+
 private:
   RequestProcessor::Ptr request_processor_;
   const Host::Ptr host_;
@@ -68,13 +66,11 @@ class ProcessorNotifyHostRemove : public Task {
 
 class ProcessorNotifyHostReady : public Task {
 public:
-  ProcessorNotifyHostReady(const Host::Ptr& host,
-                           const RequestProcessor::Ptr& request_processor)
-    : request_processor_(request_processor)
-    , host_(host) { }
-  virtual void run(EventLoop* event_loop) {
-    request_processor_->internal_host_ready(host_);
-  }
+  ProcessorNotifyHostReady(const Host::Ptr& host, const RequestProcessor::Ptr& request_processor)
+      : request_processor_(request_processor)
+      , host_(host) {}
+  virtual void run(EventLoop* event_loop) { request_processor_->internal_host_ready(host_); }
+
 private:
   const RequestProcessor::Ptr request_processor_;
   const Host::Ptr host_;
@@ -82,13 +78,11 @@ class ProcessorNotifyHostReady : public Task {
 
 class ProcessorNotifyMaybeHostUp : public Task {
 public:
-  ProcessorNotifyMaybeHostUp(const Address& address,
-                             const RequestProcessor::Ptr& request_processor)
-    : request_processor_(request_processor)
-    , address_(address) { }
-  virtual void run(EventLoop* event_loop) {
-    request_processor_->internal_host_maybe_up(address_);
-  }
+  ProcessorNotifyMaybeHostUp(const Address& address, const RequestProcessor::Ptr& request_processor)
+      : request_processor_(request_processor)
+      , address_(address) {}
+  virtual void run(EventLoop* event_loop) { request_processor_->internal_host_maybe_up(address_); }
+
 private:
   const RequestProcessor::Ptr request_processor_;
   const Address address_;
@@ -98,12 +92,11 @@ class ProcessorNotifyTokenMapUpdate : public Task {
 public:
   ProcessorNotifyTokenMapUpdate(const TokenMap::Ptr& token_map,
                                 const RequestProcessor::Ptr& request_processor)
-    : request_processor_(request_processor)
-    , token_map_(token_map) { }
+      : request_processor_(request_processor)
+      , token_map_(token_map) {}
+
+  virtual void run(EventLoop* event_loop) { request_processor_->token_map_ = token_map_; }
 
-  virtual void run(EventLoop* event_loop) {
-    request_processor_->token_map_ = token_map_;
-  }
 private:
   const RequestProcessor::Ptr request_processor_;
   const TokenMap::Ptr token_map_;
@@ -111,16 +104,14 @@ class ProcessorNotifyTokenMapUpdate : public Task {
 
 class SetKeyspaceProcessor : public Task {
 public:
-  SetKeyspaceProcessor(const ConnectionPoolManager::Ptr& manager,
-                       const String& keyspace,
+  SetKeyspaceProcessor(const ConnectionPoolManager::Ptr& manager, const String& keyspace,
                        const KeyspaceChangedHandler::Ptr& handler)
-    : manager_(manager)
-    , keyspace_(keyspace)
-    , handler_(handler) { }
+      : manager_(manager)
+      , keyspace_(keyspace)
+      , handler_(handler) {}
+
+  virtual void run(EventLoop* event_loop) { manager_->set_keyspace(keyspace_); }
 
-  virtual void run(EventLoop* event_loop) {
-    manager_->set_keyspace(keyspace_);
-  }
 private:
   ConnectionPoolManager::Ptr manager_;
   const String keyspace_;
@@ -129,73 +120,71 @@ class SetKeyspaceProcessor : public Task {
 
 class NopRequestProcessorListener : public RequestProcessorListener {
 public:
-  virtual void on_pool_up(const Address& address)  { }
-  virtual void on_pool_down(const Address& address) { }
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
-                                      const String& message) { }
+  virtual void on_pool_up(const Address& address) {}
+  virtual void on_pool_down(const Address& address) {}
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message) {}
   virtual void on_keyspace_changed(const String& keyspace,
-                                   const KeyspaceChangedHandler::Ptr& handler) { }
+                                   const KeyspaceChangedHandler::Ptr& handler) {}
   virtual void on_prepared_metadata_changed(const String& id,
-                                            const PreparedMetadata::Entry::Ptr& entry) { }
-  virtual void on_close(RequestProcessor* processor) { }
+                                            const PreparedMetadata::Entry::Ptr& entry) {}
+  virtual void on_close(RequestProcessor* processor) {}
 };
 
+}}} // namespace datastax::internal::core
+
 static NopRequestProcessorListener nop_request_processor_listener__;
 
 RequestProcessorSettings::RequestProcessorSettings()
-  : max_schema_wait_time_ms(10000)
-  , prepare_on_all_hosts(true)
-  , timestamp_generator(new ServerSideTimestampGenerator())
-  , default_profile(Config().default_profile())
-  , request_queue_size(8192)
-  , coalesce_delay_us(CASS_DEFAULT_COALESCE_DELAY)
-  , new_request_ratio(CASS_DEFAULT_NEW_REQUEST_RATIO)
-  , max_tracing_wait_time_ms(CASS_DEFAULT_MAX_TRACING_DATA_WAIT_TIME_MS)
-  , retry_tracing_wait_time_ms(CASS_DEFAULT_RETRY_TRACING_DATA_WAIT_TIME_MS)
-  , tracing_consistency(CASS_DEFAULT_TRACING_CONSISTENCY) {
-    profiles.set_empty_key("");
-  }
+    : max_schema_wait_time_ms(10000)
+    , prepare_on_all_hosts(true)
+    , timestamp_generator(new ServerSideTimestampGenerator())
+    , default_profile(Config().default_profile())
+    , request_queue_size(8192)
+    , coalesce_delay_us(CASS_DEFAULT_COALESCE_DELAY)
+    , new_request_ratio(CASS_DEFAULT_NEW_REQUEST_RATIO)
+    , max_tracing_wait_time_ms(CASS_DEFAULT_MAX_TRACING_DATA_WAIT_TIME_MS)
+    , retry_tracing_wait_time_ms(CASS_DEFAULT_RETRY_TRACING_DATA_WAIT_TIME_MS)
+    , tracing_consistency(CASS_DEFAULT_TRACING_CONSISTENCY) {
+  profiles.set_empty_key("");
+}
 
 RequestProcessorSettings::RequestProcessorSettings(const Config& config)
-  : connection_pool_settings(config)
-  , max_schema_wait_time_ms(config.max_schema_wait_time_ms())
-  , prepare_on_all_hosts(config.prepare_on_all_hosts())
-  , timestamp_generator(config.timestamp_gen())
-  , default_profile(config.default_profile())
-  , profiles(config.profiles())
-  , request_queue_size(config.queue_size_io())
-  , coalesce_delay_us(config.coalesce_delay_us())
-  , new_request_ratio(config.new_request_ratio())
-  , max_tracing_wait_time_ms(config.max_tracing_wait_time_ms())
-  , retry_tracing_wait_time_ms(config.retry_tracing_wait_time_ms())
-  , tracing_consistency(config.tracing_consistency()) { }
-
-RequestProcessor::RequestProcessor(RequestProcessorListener* listener,
-                                   EventLoop* event_loop,
+    : connection_pool_settings(config)
+    , max_schema_wait_time_ms(config.max_schema_wait_time_ms())
+    , prepare_on_all_hosts(config.prepare_on_all_hosts())
+    , timestamp_generator(config.timestamp_gen())
+    , default_profile(config.default_profile())
+    , profiles(config.profiles())
+    , request_queue_size(config.queue_size_io())
+    , coalesce_delay_us(config.coalesce_delay_us())
+    , new_request_ratio(config.new_request_ratio())
+    , max_tracing_wait_time_ms(config.max_tracing_wait_time_ms())
+    , retry_tracing_wait_time_ms(config.retry_tracing_wait_time_ms())
+    , tracing_consistency(config.tracing_consistency()) {}
+
+RequestProcessor::RequestProcessor(RequestProcessorListener* listener, EventLoop* event_loop,
                                    const ConnectionPoolManager::Ptr& connection_pool_manager,
-                                   const Host::Ptr& connected_host,
-                                   const HostMap& hosts,
+                                   const Host::Ptr& connected_host, const HostMap& hosts,
                                    const TokenMap::Ptr& token_map,
-                                   const RequestProcessorSettings& settings,
-                                   Random* random)
-  : connection_pool_manager_(connection_pool_manager)
-  , listener_(listener ? listener : &nop_request_processor_listener__)
-  , event_loop_(event_loop)
-  , settings_(settings)
-  , default_profile_(settings.default_profile)
-  , profiles_(settings.profiles)
-  , request_count_(0)
-  , request_queue_(new MPMCQueue<RequestHandler*>(settings.request_queue_size))
-  , is_closing_(false)
-  , is_processing_(false)
-  , attempts_without_requests_(0)
-  , io_time_during_coalesce_(0)
+                                   const RequestProcessorSettings& settings, Random* random)
+    : connection_pool_manager_(connection_pool_manager)
+    , listener_(listener ? listener : &nop_request_processor_listener__)
+    , event_loop_(event_loop)
+    , settings_(settings)
+    , default_profile_(settings.default_profile)
+    , profiles_(settings.profiles)
+    , request_count_(0)
+    , request_queue_(new MPMCQueue<RequestHandler*>(settings.request_queue_size))
+    , is_closing_(false)
+    , is_processing_(false)
+    , attempts_without_requests_(0)
+    , io_time_during_coalesce_(0)
 #ifdef CASS_INTERNAL_DIAGNOSTICS
-  , reads_during_coalesce_(0)
-  , writes_during_coalesce_(0)
-  , writes_per_("writes")
-  , reads_per_("reads")
+    , reads_during_coalesce_(0)
+    , writes_during_coalesce_(0)
+    , writes_per_("writes")
+    , reads_per_("reads")
 #endif
 {
   inc_ref(); // For the connection pool manager
@@ -204,13 +193,12 @@ RequestProcessor::RequestProcessor(RequestProcessorListener* listener,
   // Build/Assign the load balancing policies from the execution profiles
   default_profile_.build_load_balancing_policy();
   load_balancing_policies_.push_back(default_profile_.load_balancing_policy());
-  for (ExecutionProfile::Map::iterator it = profiles_.begin(),
-       end = profiles_.end();  it != end; ++it) {
+  for (ExecutionProfile::Map::iterator it = profiles_.begin(), end = profiles_.end(); it != end;
+       ++it) {
     it->second.build_load_balancing_policy();
     const LoadBalancingPolicy::Ptr& load_balancing_policy = it->second.load_balancing_policy();
     if (load_balancing_policy) {
-      LOG_TRACE("Built load balancing policy for '%s' execution profile",
-                it->first.c_str());
+      LOG_TRACE("Built load balancing policy for '%s' execution profile", it->first.c_str());
       load_balancing_policies_.push_back(load_balancing_policy);
     } else {
       it->second.set_load_balancing_policy(default_profile_.load_balancing_policy().get());
@@ -220,8 +208,7 @@ RequestProcessor::RequestProcessor(RequestProcessorListener* listener,
   token_map_ = token_map;
 
   LoadBalancingPolicy::Vec policies = load_balancing_policies();
-  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin();
-       it != policies.end(); ++it) {
+  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(); it != policies.end(); ++it) {
     // Initialize the load balancing policies
     (*it)->init(connected_host, hosts, random);
   }
@@ -229,9 +216,7 @@ RequestProcessor::RequestProcessor(RequestProcessorListener* listener,
   listener_->on_connect(this);
 }
 
-void RequestProcessor::close() {
-  event_loop_->add(new ProcessorRunClose(Ptr(this)));
-}
+void RequestProcessor::close() { event_loop_->add(new ProcessorRunClose(Ptr(this))); }
 
 void RequestProcessor::set_listener(RequestProcessorListener* listener) {
   listener_ = listener ? listener : &nop_request_processor_listener__;
@@ -288,11 +273,9 @@ void RequestProcessor::process_request(const RequestHandler::Ptr& request_handle
 }
 
 int RequestProcessor::init(Protected) {
-  int rc = async_.start(event_loop_->loop(),
-                        bind_callback(&RequestProcessor::on_async, this));
+  int rc = async_.start(event_loop_->loop(), bind_callback(&RequestProcessor::on_async, this));
   if (rc != 0) return rc;
-  return prepare_.start(event_loop_->loop(),
-                        bind_callback(&RequestProcessor::on_prepare, this));
+  return prepare_.start(event_loop_->loop(), bind_callback(&RequestProcessor::on_prepare, this));
 }
 
 void RequestProcessor::on_pool_up(const Address& address) {
@@ -337,20 +320,16 @@ void RequestProcessor::on_prepared_metadata_changed(const String& id,
 
 void RequestProcessor::on_keyspace_changed(const String& keyspace,
                                            KeyspaceChangedResponse response) {
-  listener_->on_keyspace_changed(keyspace,
-                                 KeyspaceChangedHandler::Ptr(
-                                   new KeyspaceChangedHandler(event_loop_, response)));
+  listener_->on_keyspace_changed(
+      keyspace, KeyspaceChangedHandler::Ptr(new KeyspaceChangedHandler(event_loop_, response)));
 }
 
 bool RequestProcessor::on_wait_for_tracing_data(const RequestHandler::Ptr& request_handler,
                                                 const Host::Ptr& current_host,
                                                 const Response::Ptr& response) {
-  TracingDataHandler::Ptr handler(new TracingDataHandler(request_handler,
-                                                         current_host,
-                                                         response,
-                                                         settings_.tracing_consistency,
-                                                         settings_.max_tracing_wait_time_ms,
-                                                         settings_.retry_tracing_wait_time_ms));
+  TracingDataHandler::Ptr handler(new TracingDataHandler(
+      request_handler, current_host, response, settings_.tracing_consistency,
+      settings_.max_tracing_wait_time_ms, settings_.retry_tracing_wait_time_ms));
 
   return write_wait_callback(request_handler, current_host, handler->callback());
 }
@@ -358,11 +337,8 @@ bool RequestProcessor::on_wait_for_tracing_data(const RequestHandler::Ptr& reque
 bool RequestProcessor::on_wait_for_schema_agreement(const RequestHandler::Ptr& request_handler,
                                                     const Host::Ptr& current_host,
                                                     const Response::Ptr& response) {
-  SchemaAgreementHandler::Ptr handler(new SchemaAgreementHandler(request_handler,
-                                                                 current_host,
-                                                                 response,
-                                                                 this,
-                                                                 settings_.max_schema_wait_time_ms));
+  SchemaAgreementHandler::Ptr handler(new SchemaAgreementHandler(
+      request_handler, current_host, response, this, settings_.max_schema_wait_time_ms));
 
   return write_wait_callback(request_handler, current_host, handler->callback());
 }
@@ -375,19 +351,16 @@ bool RequestProcessor::on_prepare_all(const RequestHandler::Ptr& request_handler
   }
 
   AddressVec addresses = connection_pool_manager_->available();
-  if (addresses.empty() ||
-      (addresses.size() == 1 && addresses[0] == current_host->address())) {
+  if (addresses.empty() || (addresses.size() == 1 && addresses[0] == current_host->address())) {
     return false;
   }
 
-  PrepareAllHandler::Ptr prepare_all_handler(new PrepareAllHandler(current_host,
-                                                                   response,
-                                                                   request_handler,
-                                                                   // Subtract the node that's already been prepared
-                                                                   addresses.size() - 1));
+  PrepareAllHandler::Ptr prepare_all_handler(
+      new PrepareAllHandler(current_host, response, request_handler,
+                            // Subtract the node that's already been prepared
+                            addresses.size() - 1));
 
-  for (AddressVec::const_iterator it = addresses.begin(),
-       end = addresses.end(); it != end; ++it) {
+  for (AddressVec::const_iterator it = addresses.begin(), end = addresses.end(); it != end; ++it) {
     const Address& address(*it);
 
     // Skip over the node we've already prepared
@@ -398,8 +371,8 @@ bool RequestProcessor::on_prepare_all(const RequestHandler::Ptr& request_handler
     // The destructor of `PrepareAllCallback` will decrement the remaining
     // count in `PrepareAllHandler` even if this is unable to write to a
     // connection successfully.
-    PrepareAllCallback::Ptr prepare_all_callback(new PrepareAllCallback(address,
-                                                                        prepare_all_handler));
+    PrepareAllCallback::Ptr prepare_all_callback(
+        new PrepareAllCallback(address, prepare_all_handler));
 
     PooledConnection::Ptr connection(connection_pool_manager_->find_least_busy(address));
     if (connection) {
@@ -428,8 +401,7 @@ void RequestProcessor::internal_close() {
 
 void RequestProcessor::internal_pool_down(const Address& address) {
   LoadBalancingPolicy::Vec policies = load_balancing_policies();
-  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin();
-       it != policies.end(); ++it) {
+  for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(); it != policies.end(); ++it) {
     (*it)->on_host_down(address);
   }
 }
@@ -457,15 +429,14 @@ void RequestProcessor::internal_host_add(const Host::Ptr& host) {
     LoadBalancingPolicy::Vec policies = load_balancing_policies();
     if (!is_host_ignored(policies, host)) {
       connection_pool_manager_->add(host);
-      for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin();
-           it != policies.end(); ++it) {
+      for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(); it != policies.end();
+           ++it) {
         if ((*it)->distance(host) != CASS_HOST_DISTANCE_IGNORE) {
           (*it)->on_host_added(host);
         }
       }
     } else {
-      LOG_DEBUG("Host %s will be ignored by all query plans",
-                host->address_string().c_str());
+      LOG_DEBUG("Host %s will be ignored by all query plans", host->address_string().c_str());
     }
   }
 }
@@ -474,8 +445,8 @@ void RequestProcessor::internal_host_remove(const Host::Ptr& host) {
   if (connection_pool_manager_) {
     connection_pool_manager_->remove(host->address());
     LoadBalancingPolicy::Vec policies = load_balancing_policies();
-    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin();
-         it != policies.end(); ++it) {
+    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(); it != policies.end();
+         ++it) {
       (*it)->on_host_removed(host);
     }
   }
@@ -483,11 +454,10 @@ void RequestProcessor::internal_host_remove(const Host::Ptr& host) {
 
 void RequestProcessor::internal_host_ready(const Host::Ptr& host) {
   // Only mark the host as up if it has connections.
-  if (connection_pool_manager_ &&
-      connection_pool_manager_->has_connections(host->address())) {
+  if (connection_pool_manager_ && connection_pool_manager_->has_connections(host->address())) {
     LoadBalancingPolicy::Vec policies = load_balancing_policies();
-    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin();
-         it != policies.end(); ++it) {
+    for (LoadBalancingPolicy::Vec::const_iterator it = policies.begin(); it != policies.end();
+         ++it) {
       if ((*it)->distance(host) != CASS_HOST_DISTANCE_IGNORE) {
         (*it)->on_host_up(host);
       }
@@ -509,8 +479,9 @@ void RequestProcessor::start_coalescing() {
 
 void RequestProcessor::on_timeout(MicroTimer* timer) {
   // Don't process for more time than the coalesce delay.
-  uint64_t processing_time = std::min((io_time_during_coalesce_ * settings_.new_request_ratio) / 100,
-                                      settings_.coalesce_delay_us * 1000);
+  uint64_t processing_time =
+      std::min((io_time_during_coalesce_ * settings_.new_request_ratio) / 100,
+               settings_.coalesce_delay_us * 1000);
   int processed = process_requests(processing_time);
 
   connection_pool_manager_->flush();
@@ -532,8 +503,7 @@ void RequestProcessor::on_timeout(MicroTimer* timer) {
       attempts_without_requests_ = 0;
       is_processing_.store(false);
       bool expected = false;
-      if (request_queue_->is_empty() ||
-          !is_processing_.compare_exchange_strong(expected, true)) {
+      if (request_queue_->is_empty() || !is_processing_.compare_exchange_strong(expected, true)) {
         return;
       }
     }
@@ -561,9 +531,7 @@ void RequestProcessor::on_prepare(Prepare* prepare) {
 }
 
 void RequestProcessor::maybe_close(int request_count) {
-  if (is_closing_ &&
-      request_count <= 0 &&
-      request_queue_->is_empty()) {
+  if (is_closing_ && request_count <= 0 && request_queue_->is_empty()) {
     if (connection_pool_manager_) connection_pool_manager_->close();
   }
 }
@@ -581,11 +549,8 @@ int RequestProcessor::process_requests(uint64_t processing_time) {
         if (!profile_name.empty()) {
           LOG_TRACE("Using execution profile '%s'", profile_name.c_str());
         }
-        request_handler->init(*profile,
-                              connection_pool_manager_.get(),
-                              token_map_.get(),
-                              settings_.timestamp_generator.get(),
-                              this);
+        request_handler->init(*profile, connection_pool_manager_.get(), token_map_.get(),
+                              settings_.timestamp_generator.get(), this);
         request_handler->execute();
         processed++;
       } else {
@@ -612,7 +577,8 @@ int RequestProcessor::process_requests(uint64_t processing_time) {
 bool RequestProcessor::write_wait_callback(const RequestHandler::Ptr& request_handler,
                                            const Host::Ptr& current_host,
                                            const RequestCallback::Ptr& callback) {
-  PooledConnection::Ptr connection(connection_pool_manager_->find_least_busy(current_host->address()));
+  PooledConnection::Ptr connection(
+      connection_pool_manager_->find_least_busy(current_host->address()));
   if (connection && connection->write(callback.get())) {
     // Stop the original request timer now that we have a response and
     // are waiting for the maximum wait time of the handler.
@@ -621,5 +587,3 @@ bool RequestProcessor::write_wait_callback(const RequestHandler::Ptr& request_ha
   }
   return false;
 }
-
-} // namespace cass
diff --git a/src/request_processor.hpp b/src/request_processor.hpp
index 0567428cf..56bb45673 100644
--- a/src/request_processor.hpp
+++ b/src/request_processor.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REQUEST_PROCESSOR_HPP_INCLUDED__
-#define __CASS_REQUEST_PROCESSOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REQUEST_PROCESSOR_HPP
+#define DATASTAX_INTERNAL_REQUEST_PROCESSOR_HPP
 
 #include "atomic.hpp"
 #include "config.hpp"
@@ -23,9 +23,9 @@
 #include "event_loop.hpp"
 #include "histogram_wrapper.hpp"
 #include "host.hpp"
+#include "loop_watcher.hpp"
 #include "micro_timer.hpp"
 #include "mpmc_queue.hpp"
-#include "loop_watcher.hpp"
 #include "prepare_host_handler.hpp"
 #include "random.hpp"
 #include "schema_agreement_handler.hpp"
@@ -33,7 +33,7 @@
 #include "timer.hpp"
 #include "token_map.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ConnectionPoolManagerInitializer;
 class RequestProcessor;
@@ -50,27 +50,23 @@ class KeyspaceChangedHandler : public RefCounted<KeyspaceChangedHandler> {
 public:
   typedef SharedRefPtr<KeyspaceChangedHandler> Ptr;
 
-  KeyspaceChangedHandler(EventLoop* event_loop,
-                         const KeyspaceChangedResponse& response)
-    : event_loop_(event_loop)
-    , response_(response) { }
+  KeyspaceChangedHandler(EventLoop* event_loop, const KeyspaceChangedResponse& response)
+      : event_loop_(event_loop)
+      , response_(response) {}
 
-  ~KeyspaceChangedHandler() {
-    event_loop_->add(new Task(response_));
-  }
+  ~KeyspaceChangedHandler() { event_loop_->add(new Task(response_)); }
 
 private:
   /**
    * An internal task that keeps the original keyspace change handler
    * alive so that processing happens on the original event loop.
    */
-  class Task : public cass::Task {
+  class Task : public core::Task {
   public:
     Task(const KeyspaceChangedResponse& response)
-      : response_(response) { }
-    virtual void run(EventLoop* event_loop) {
-      response_.set_response();
-    }
+        : response_(response) {}
+    virtual void run(EventLoop* event_loop) { response_.set_response(); }
+
   private:
     KeyspaceChangedResponse response_;
   };
@@ -82,7 +78,7 @@ class KeyspaceChangedHandler : public RefCounted<KeyspaceChangedHandler> {
 
 class KeyspaceChangedListener {
 public:
-  virtual ~KeyspaceChangedListener() { }
+  virtual ~KeyspaceChangedListener() {}
 
   virtual void on_keyspace_changed(const String& keyspace,
                                    const KeyspaceChangedHandler::Ptr& handler) = 0;
@@ -100,7 +96,7 @@ class RequestProcessorListener
    *
    * @param processor The processor object.
    */
-  virtual void on_connect(RequestProcessor* processor) { }
+  virtual void on_connect(RequestProcessor* processor) {}
 
   /**
    * A callback that's called when the processor has closed.
@@ -146,10 +142,11 @@ struct RequestProcessorSettings {
  * the load balancing policy, executing and routing the request to the
  * appropriate node and perform the callback to the client.
  */
-class RequestProcessor : public RefCounted<RequestProcessor>
-                       , public ConnectionPoolManagerListener
-                       , public RequestListener
-                       , public SchemaAgreementListener {
+class RequestProcessor
+    : public RefCounted<RequestProcessor>
+    , public ConnectionPoolManagerListener
+    , public RequestListener
+    , public SchemaAgreementListener {
 public:
   typedef SharedRefPtr<RequestProcessor> Ptr;
   typedef Vector<Ptr> Vec;
@@ -167,13 +164,10 @@ class RequestProcessor : public RefCounted<RequestProcessor>
    * @param settings The current settings for the request processor.
    * @param random A RNG for randomizing hosts in the load balancing policies.
    */
-  RequestProcessor(RequestProcessorListener* listener,
-                   EventLoop* event_loop,
+  RequestProcessor(RequestProcessorListener* listener, EventLoop* event_loop,
                    const ConnectionPoolManager::Ptr& connection_pool_manager,
-                   const Host::Ptr& connected_host,
-                   const HostMap& hosts,
-                   const TokenMap::Ptr& token_map,
-                   const RequestProcessorSettings& settings,
+                   const Host::Ptr& connected_host, const HostMap& hosts,
+                   const TokenMap::Ptr& token_map, const RequestProcessorSettings& settings,
                    Random* random);
 
   /**
@@ -196,8 +190,7 @@ class RequestProcessor : public RefCounted<RequestProcessor>
    * @param keyspace New current keyspace to utilize
    * @param handler A keyspace handler to trigger a response to a "USE" query.
    */
-  void set_keyspace(const String& keyspace,
-                    const KeyspaceChangedHandler::Ptr& handler);
+  void set_keyspace(const String& keyspace, const KeyspaceChangedHandler::Ptr& handler);
 
   /**
    * Notify that a host has been added to the cluster
@@ -256,15 +249,13 @@ class RequestProcessor : public RefCounted<RequestProcessor>
    *
    * @return Request count
    */
-  int request_count() const {
-    return request_count_.load(MEMORY_ORDER_RELAXED);
-  }
+  int request_count() const { return request_count_.load(MEMORY_ORDER_RELAXED); }
 
 public:
   class Protected {
     friend class RequestProcessorInitializer;
-    Protected() { }
-    Protected(Protected const&) { }
+    Protected() {}
+    Protected(Protected const&) {}
   };
 
   /**
@@ -279,9 +270,8 @@ class RequestProcessor : public RefCounted<RequestProcessor>
 
   virtual void on_pool_up(const Address& address);
   virtual void on_pool_down(const Address& address);
-  virtual void on_pool_critical_error(const Address& address,
-                                 Connector::ConnectionError code,
-                                 const String& message);
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
+                                      const String& message);
   virtual void on_requires_flush();
   virtual void on_close(ConnectionPoolManager* manager);
 
@@ -290,8 +280,7 @@ class RequestProcessor : public RefCounted<RequestProcessor>
 
   virtual void on_prepared_metadata_changed(const String& id,
                                             const PreparedMetadata::Entry::Ptr& entry);
-  virtual void on_keyspace_changed(const String& keyspace,
-                                   KeyspaceChangedResponse handler);
+  virtual void on_keyspace_changed(const String& keyspace, KeyspaceChangedResponse handler);
   virtual bool on_wait_for_tracing_data(const RequestHandler::Ptr& request_handler,
                                         const Host::Ptr& current_host,
                                         const Response::Ptr& response);
@@ -299,8 +288,7 @@ class RequestProcessor : public RefCounted<RequestProcessor>
                                             const Host::Ptr& current_host,
                                             const Response::Ptr& response);
   virtual bool on_prepare_all(const RequestHandler::Ptr& request_handler,
-                              const Host::Ptr& current_host,
-                              const Response::Ptr& response);
+                              const Host::Ptr& current_host, const Response::Ptr& response);
   virtual void on_done();
 
 private:
@@ -340,8 +328,7 @@ class RequestProcessor : public RefCounted<RequestProcessor>
   int process_requests(uint64_t processing_time);
 
   bool write_wait_callback(const RequestHandler::Ptr& request_handler,
-                           const Host::Ptr& current_host,
-                           const RequestCallback::Ptr& callback);
+                           const Host::Ptr& current_host, const RequestCallback::Ptr& callback);
 
 private:
   ConnectionPoolManager::Ptr connection_pool_manager_;
@@ -373,6 +360,6 @@ class RequestProcessor : public RefCounted<RequestProcessor>
 #endif
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-#endif // __CASS_REQUEST_PROCESSOR_HPP_INCLUDED__
+#endif // DATASTAX_INTERNAL_REQUEST_PROCESSOR_HPP
diff --git a/src/request_processor_initializer.cpp b/src/request_processor_initializer.cpp
index 8ba01642e..fb3b2d693 100644
--- a/src/request_processor_initializer.cpp
+++ b/src/request_processor_initializer.cpp
@@ -14,47 +14,49 @@
   limitations under the License.
 */
 
+#include "request_processor_initializer.hpp"
 #include "config.hpp"
 #include "event_loop.hpp"
-#include "request_processor_initializer.hpp"
 #include "scoped_lock.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 class RunInitializeProcessor : public Task {
 public:
   RunInitializeProcessor(const RequestProcessorInitializer::Ptr& initializer)
-    : initializer_(initializer) { }
+      : initializer_(initializer) {}
 
-  virtual void run(EventLoop* event_loop) {
-    initializer_->internal_intialize();
-  }
+  virtual void run(EventLoop* event_loop) { initializer_->internal_intialize(); }
 
 private:
   RequestProcessorInitializer::Ptr initializer_;
 };
 
+}}} // namespace datastax::internal::core
+
 RequestProcessorInitializer::RequestProcessorInitializer(const Host::Ptr& connected_host,
                                                          ProtocolVersion protocol_version,
                                                          const HostMap& hosts,
                                                          const TokenMap::Ptr& token_map,
                                                          const Callback& callback)
-  : event_loop_(NULL)
-  , listener_(NULL)
-  , metrics_(NULL)
-  , random_(NULL)
-  , connected_host_(connected_host)
-  , protocol_version_(protocol_version)
-  , hosts_(hosts)
-  , token_map_(token_map)
-  , error_code_(REQUEST_PROCESSOR_OK)
-  , callback_(callback) {
+    : event_loop_(NULL)
+    , listener_(NULL)
+    , metrics_(NULL)
+    , random_(NULL)
+    , connected_host_(connected_host)
+    , protocol_version_(protocol_version)
+    , hosts_(hosts)
+    , token_map_(token_map)
+    , error_code_(REQUEST_PROCESSOR_OK)
+    , callback_(callback) {
   uv_mutex_init(&mutex_);
 }
 
-RequestProcessorInitializer::~RequestProcessorInitializer() {
-  uv_mutex_destroy(&mutex_);
-}
+RequestProcessorInitializer::~RequestProcessorInitializer() { uv_mutex_destroy(&mutex_); }
 
 void RequestProcessorInitializer::initialize(EventLoop* event_loop) {
   ScopedMutex l(&mutex_);
@@ -62,12 +64,14 @@ void RequestProcessorInitializer::initialize(EventLoop* event_loop) {
   event_loop_->add(new RunInitializeProcessor(Ptr(this)));
 }
 
-RequestProcessorInitializer* RequestProcessorInitializer::with_settings(const RequestProcessorSettings& settings) {
+RequestProcessorInitializer*
+RequestProcessorInitializer::with_settings(const RequestProcessorSettings& settings) {
   settings_ = settings;
   return this;
 }
 
-RequestProcessorInitializer* RequestProcessorInitializer::with_listener(RequestProcessorListener* listener) {
+RequestProcessorInitializer*
+RequestProcessorInitializer::with_listener(RequestProcessorListener* listener) {
   listener_ = listener;
   return this;
 }
@@ -119,12 +123,10 @@ void RequestProcessorInitializer::on_close(ConnectionPoolManager* manager) {
 
 void RequestProcessorInitializer::internal_intialize() {
   inc_ref();
-  connection_pool_manager_initializer_.reset(
-        new ConnectionPoolManagerInitializer(protocol_version_,
-                                             bind_callback(&RequestProcessorInitializer::on_initialize, this)));
+  connection_pool_manager_initializer_.reset(new ConnectionPoolManagerInitializer(
+      protocol_version_, bind_callback(&RequestProcessorInitializer::on_initialize, this)));
 
-  connection_pool_manager_initializer_
-      ->with_settings(settings_.connection_pool_settings)
+  connection_pool_manager_initializer_->with_settings(settings_.connection_pool_settings)
       ->with_listener(this)
       ->with_keyspace(keyspace_)
       ->with_metrics(metrics_)
@@ -136,8 +138,8 @@ void RequestProcessorInitializer::on_initialize(ConnectionPoolManagerInitializer
 
   // Prune hosts
   const ConnectionPoolConnector::Vec& failures = initializer->failures();
-  for (ConnectionPoolConnector::Vec::const_iterator it = failures.begin(),
-       end = failures.end(); it != end; ++it) {
+  for (ConnectionPoolConnector::Vec::const_iterator it = failures.begin(), end = failures.end();
+       it != end; ++it) {
     ConnectionPoolConnector::Ptr connector(*it);
     if (connector->is_keyspace_error()) {
       is_keyspace_error = true;
@@ -155,14 +157,8 @@ void RequestProcessorInitializer::on_initialize(ConnectionPoolManagerInitializer
     error_code_ = REQUEST_PROCESSOR_ERROR_NO_HOSTS_AVAILABLE;
     error_message_ = "Unable to connect to any hosts";
   } else {
-    processor_.reset(new RequestProcessor(listener_,
-                                          event_loop_,
-                                          initializer->release_manager(),
-                                          connected_host_,
-                                          hosts_,
-                                          token_map_,
-                                          settings_,
-                                          random_));
+    processor_.reset(new RequestProcessor(listener_, event_loop_, initializer->release_manager(),
+                                          connected_host_, hosts_, token_map_, settings_, random_));
 
     int rc = processor_->init(RequestProcessor::Protected());
     if (rc != 0) {
@@ -183,5 +179,3 @@ void RequestProcessorInitializer::on_initialize(ConnectionPoolManagerInitializer
   connection_pool_manager_initializer_.reset();
   dec_ref();
 }
-
-} // namespace cass
diff --git a/src/request_processor_initializer.hpp b/src/request_processor_initializer.hpp
index a45aba63a..1efea75de 100644
--- a/src/request_processor_initializer.hpp
+++ b/src/request_processor_initializer.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_REQUEST_PROCESSOR_INITIALIZER_HPP_INCLUDED__
-#define __CASS_REQUEST_PROCESSOR_INITIALIZER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_REQUEST_PROCESSOR_INITIALIZER_HPP
+#define DATASTAX_INTERNAL_REQUEST_PROCESSOR_INITIALIZER_HPP
 
 #include "atomic.hpp"
 #include "callback.hpp"
@@ -27,7 +27,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 class EventLoop;
@@ -43,7 +43,7 @@ class RequestProcessorInitializer
 public:
   typedef SharedRefPtr<RequestProcessorInitializer> Ptr;
   typedef Vector<Ptr> Vec;
-  typedef cass::Callback<void, RequestProcessorInitializer*> Callback;
+  typedef internal::Callback<void, RequestProcessorInitializer*> Callback;
 
   enum RequestProcessorError {
     REQUEST_PROCESSOR_OK,
@@ -62,10 +62,8 @@ class RequestProcessorInitializer
    * @param callback A callback that is called when the processor is initialized
    * or if an error occurred.
    */
-  RequestProcessorInitializer(const Host::Ptr& connected_host,
-                              ProtocolVersion protocol_version,
-                              const HostMap& hosts,
-                              const TokenMap::Ptr& token_map,
+  RequestProcessorInitializer(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                              const HostMap& hosts, const TokenMap::Ptr& token_map,
                               const Callback& callback);
   ~RequestProcessorInitializer();
 
@@ -140,8 +138,7 @@ class RequestProcessorInitializer
 
   virtual void on_pool_up(const Address& address);
   virtual void on_pool_down(const Address& address);
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
                                       const String& message);
   virtual void on_close(ConnectionPoolManager* manager);
 
@@ -177,6 +174,6 @@ class RequestProcessorInitializer
   Atomic<size_t> remaining_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/resolver.hpp b/src/resolver.hpp
index 13e076c64..a284b9ce4 100644
--- a/src/resolver.hpp
+++ b/src/resolver.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RESOLVER_HPP_INCLUDED__
-#define __CASS_RESOLVER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RESOLVER_HPP
+#define DATASTAX_INTERNAL_RESOLVER_HPP
 
 #include "address.hpp"
 #include "callback.hpp"
@@ -28,13 +28,13 @@
 
 #include <functional>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Resolver : public RefCounted<Resolver> {
 public:
   typedef SharedRefPtr<Resolver> Ptr;
   typedef Vector<Ptr> Vec;
-  typedef cass::Callback<void, Resolver*> Callback;
+  typedef internal::Callback<void, Resolver*> Callback;
 
   enum Status {
     NEW,
@@ -48,14 +48,14 @@ class Resolver : public RefCounted<Resolver> {
   };
 
   Resolver(const String& hostname, int port, const Callback& callback)
-    : hostname_(hostname)
-    , port_(port)
-    , status_(NEW)
-    , callback_(callback) {
+      : hostname_(hostname)
+      , port_(port)
+      , status_(NEW)
+      , callback_(callback) {
     req_.data = this;
   }
 
-  ~Resolver() { }
+  ~Resolver() {}
 
   const String& hostname() { return hostname_; }
   int port() { return port_; }
@@ -74,14 +74,12 @@ class Resolver : public RefCounted<Resolver> {
     inc_ref(); // For the event loop
 
     if (timeout > 0) {
-      timer_.start(loop, timeout,
-                   bind_callback(&Resolver::on_timeout, this));
+      timer_.start(loop, timeout, bind_callback(&Resolver::on_timeout, this));
     }
 
     OStringStream ss;
     ss << port_;
-    int rc = uv_getaddrinfo(loop, &req_, on_resolve, hostname_.c_str(),
-                            ss.str().c_str(), hints);
+    int rc = uv_getaddrinfo(loop, &req_, on_resolve, hostname_.c_str(), ss.str().c_str(), hints);
 
     if (rc != 0) {
       status_ = FAILED_BAD_PARAM;
@@ -101,8 +99,7 @@ class Resolver : public RefCounted<Resolver> {
   }
 
 private:
-  static void on_resolve(uv_getaddrinfo_t* req, int status,
-                         struct addrinfo* res) {
+  static void on_resolve(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
     Resolver* resolver = static_cast<Resolver*>(req->data);
 
     if (resolver->status_ == RESOLVING) { // A timeout may have happened
@@ -139,7 +136,7 @@ class Resolver : public RefCounted<Resolver> {
         status = true;
       }
       res = res->ai_next;
-    } while(res);
+    } while (res);
     return status;
   }
 
@@ -160,29 +157,26 @@ class Resolver : public RefCounted<Resolver> {
 class MultiResolver : public RefCounted<MultiResolver> {
 public:
   typedef SharedRefPtr<MultiResolver> Ptr;
-  typedef cass::Callback<void, MultiResolver*> Callback;
+  typedef internal::Callback<void, MultiResolver*> Callback;
 
   MultiResolver(const Callback& callback)
-    : remaining_(0)
-    , callback_(callback) { }
+      : remaining_(0)
+      , callback_(callback) {}
 
   const Resolver::Vec& resolvers() { return resolvers_; }
 
-  void resolve(uv_loop_t* loop,
-               const String& host, int port,
-               uint64_t timeout, struct addrinfo* hints = NULL) {
+  void resolve(uv_loop_t* loop, const String& host, int port, uint64_t timeout,
+               struct addrinfo* hints = NULL) {
     inc_ref();
     Resolver::Ptr resolver(
-          new Resolver(host, port,
-                       bind_callback(&MultiResolver::on_resolve, this)));
+        new Resolver(host, port, bind_callback(&MultiResolver::on_resolve, this)));
     resolver->resolve(loop, timeout, hints);
     resolvers_.push_back(resolver);
     remaining_++;
   }
 
   void cancel() {
-    for (Resolver::Vec::iterator it = resolvers_.begin(),
-         end = resolvers_.end(); it != end; ++it) {
+    for (Resolver::Vec::iterator it = resolvers_.begin(), end = resolvers_.end(); it != end; ++it) {
       (*it)->cancel();
     }
   }
@@ -205,6 +199,6 @@ class MultiResolver : public RefCounted<MultiResolver> {
   DISALLOW_COPY_AND_ASSIGN(MultiResolver);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/response.cpp b/src/response.cpp
index eb54cb9a0..f93931bb6 100644
--- a/src/response.cpp
+++ b/src/response.cpp
@@ -26,7 +26,7 @@
 
 #include <cstring>
 
-namespace cass {
+using namespace datastax::internal::core;
 
 /**
  * A dummy invalid protocol error response that's used to handle responses
@@ -35,8 +35,7 @@ namespace cass {
 class InvalidProtocolErrorResponse : public ErrorResponse {
 public:
   InvalidProtocolErrorResponse()
-    : ErrorResponse(CQL_ERROR_PROTOCOL_ERROR,
-                    "Invalid or unsupported protocol version") { }
+      : ErrorResponse(CQL_ERROR_PROTOCOL_ERROR, "Invalid or unsupported protocol version") {}
 
   virtual bool decode(Decoder& decoder) {
     return true; //  Ignore decoding the body
@@ -44,25 +43,19 @@ class InvalidProtocolErrorResponse : public ErrorResponse {
 };
 
 Response::Response(uint8_t opcode)
-  : opcode_(opcode) {
+    : opcode_(opcode) {
   memset(&tracing_id_, 0, sizeof(CassUuid));
 }
 
-bool Response::has_tracing_id() const {
-  return tracing_id_.time_and_version != 0;
-}
+bool Response::has_tracing_id() const { return tracing_id_.time_and_version != 0; }
 
-bool Response::decode_trace_id(Decoder& decoder) {
-  return decoder.decode_uuid(&tracing_id_);
-}
+bool Response::decode_trace_id(Decoder& decoder) { return decoder.decode_uuid(&tracing_id_); }
 
 bool Response::decode_custom_payload(Decoder& decoder) {
   return decoder.decode_custom_payload(custom_payload_);
 }
 
-bool Response::decode_warnings(Decoder& decoder) {
-  return decoder.decode_warnings(warnings_);
-}
+bool Response::decode_warnings(Decoder& decoder) { return decoder.decode_warnings(warnings_); }
 
 bool ResponseMessage::allocate_body(int8_t opcode) {
   response_body_.reset();
@@ -118,7 +111,7 @@ ssize_t ResponseMessage::decode(const char* input, size_t size) {
       }
       version_ = input[0] & 0x7F; // "input" will always have at least 1 bytes
       if (version_ >= CASS_PROTOCOL_VERSION_V3) {
-        header_size_  = CASS_HEADER_SIZE_V3;
+        header_size_ = CASS_HEADER_SIZE_V3;
       } else {
         header_size_ = CASS_HEADER_SIZE_V1_AND_V2;
       }
@@ -209,6 +202,3 @@ ssize_t ResponseMessage::decode(const char* input, size_t size) {
 
   return input_pos - input;
 }
-
-} // namespace cass
-
diff --git a/src/response.hpp b/src/response.hpp
index eb89f6222..d86c0b3ff 100644
--- a/src/response.hpp
+++ b/src/response.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RESPONSE_HPP_INCLUDED__
-#define __CASS_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RESPONSE_HPP
+#define DATASTAX_INTERNAL_RESPONSE_HPP
 
 #include "allocated.hpp"
 #include "constants.hpp"
@@ -27,9 +27,10 @@
 
 #include <uv.h>
 
-#define CHECK_RESULT(result) if(!(result)) return false;
+#define CHECK_RESULT(result) \
+  if (!(result)) return false;
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Response : public RefCounted<Response> {
 public:
@@ -37,7 +38,7 @@ class Response : public RefCounted<Response> {
 
   Response(uint8_t opcode);
 
-  virtual ~Response() { }
+  virtual ~Response() {}
 
   uint8_t opcode() const { return opcode_; }
 
@@ -45,9 +46,7 @@ class Response : public RefCounted<Response> {
 
   const RefBuffer::Ptr& buffer() const { return buffer_; }
 
-  void set_buffer(size_t size) {
-    buffer_ = RefBuffer::Ptr(RefBuffer::create(size));
-  }
+  void set_buffer(size_t size) { buffer_ = RefBuffer::Ptr(RefBuffer::create(size)); }
 
   bool has_tracing_id() const;
 
@@ -129,6 +128,6 @@ class ResponseMessage : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(ResponseMessage);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/result_iterator.hpp b/src/result_iterator.hpp
index c53a341f3..435b6279a 100644
--- a/src/result_iterator.hpp
+++ b/src/result_iterator.hpp
@@ -14,14 +14,14 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RESULT_ITERATOR_HPP_INCLUDED__
-#define __CASS_RESULT_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RESULT_ITERATOR_HPP
+#define DATASTAX_INTERNAL_RESULT_ITERATOR_HPP
 
 #include "iterator.hpp"
 #include "result_response.hpp"
 #include "row.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ResultIterator : public Iterator {
 public:
@@ -64,6 +64,6 @@ class ResultIterator : public Iterator {
   Row row_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/result_metadata.cpp b/src/result_metadata.cpp
index 29674ef49..3d615c81c 100644
--- a/src/result_metadata.cpp
+++ b/src/result_metadata.cpp
@@ -24,19 +24,16 @@
 
 #include <iterator>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-ResultMetadata::ResultMetadata(size_t column_count,
-                               const RefBuffer::Ptr& buffer)
-  : defs_(column_count)
-  , buffer_(buffer) { }
+ResultMetadata::ResultMetadata(size_t column_count, const RefBuffer::Ptr& buffer)
+    : defs_(column_count)
+    , buffer_(buffer) {}
 
-size_t ResultMetadata::get_indices(StringRef name, IndexVec* result) const{
+size_t ResultMetadata::get_indices(StringRef name, IndexVec* result) const {
   return defs_.get_indices(name, result);
 }
 
-void ResultMetadata::add(const ColumnDefinition& def) {
-  defs_.add(def);
-}
-
-} // namespace cass
+void ResultMetadata::add(const ColumnDefinition& def) { defs_.add(def); }
diff --git a/src/result_metadata.hpp b/src/result_metadata.hpp
index 7d4fbd613..90570c245 100644
--- a/src/result_metadata.hpp
+++ b/src/result_metadata.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RESULT_METADATA_HPP_INCLUDED__
-#define __CASS_RESULT_METADATA_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RESULT_METADATA_HPP
+#define DATASTAX_INTERNAL_RESULT_METADATA_HPP
 
 #include "cassandra.h"
 #include "data_type.hpp"
@@ -27,7 +27,7 @@
 
 #include <algorithm>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 struct ColumnDefinition : public HashTableEntry<ColumnDefinition> {
   StringRef name;
@@ -40,8 +40,7 @@ class ResultMetadata : public RefCounted<ResultMetadata> {
 public:
   typedef SharedRefPtr<ResultMetadata> Ptr;
 
-  ResultMetadata(size_t column_count,
-                 const RefBuffer::Ptr& buffer);
+  ResultMetadata(size_t column_count, const RefBuffer::Ptr& buffer);
 
   const ColumnDefinition& get_column_definition(size_t index) const { return defs_[index]; }
 
@@ -59,6 +58,6 @@ class ResultMetadata : public RefCounted<ResultMetadata> {
   DISALLOW_COPY_AND_ASSIGN(ResultMetadata);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/result_response.cpp b/src/result_response.cpp
index a4b4532b7..6a2978600 100644
--- a/src/result_response.cpp
+++ b/src/result_response.cpp
@@ -23,11 +23,13 @@
 #include "result_response.hpp"
 #include "serialization.hpp"
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-void cass_result_free(const CassResult* result) {
-  result->dec_ref();
-}
+void cass_result_free(const CassResult* result) { result->dec_ref(); }
 
 size_t cass_result_row_count(const CassResult* result) {
   if (result->kind() == CASS_RESULT_KIND_ROWS) {
@@ -43,36 +45,32 @@ size_t cass_result_column_count(const CassResult* result) {
   return 0;
 }
 
-CassError cass_result_column_name(const CassResult* result,
-                                  size_t index,
-                                  const char** name,
+CassError cass_result_column_name(const CassResult* result, size_t index, const char** name,
                                   size_t* name_length) {
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(result->metadata());
+  const SharedRefPtr<ResultMetadata>& metadata(result->metadata());
   if (index >= metadata->column_count()) {
     return CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS;
   }
   if (result->kind() != CASS_RESULT_KIND_ROWS) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  const cass::ColumnDefinition def = metadata->get_column_definition(index);
+  const ColumnDefinition def = metadata->get_column_definition(index);
   *name = def.name.data();
   *name_length = def.name.size();
   return CASS_OK;
 }
 
 CassValueType cass_result_column_type(const CassResult* result, size_t index) {
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(result->metadata());
-  if (result->kind() == CASS_RESULT_KIND_ROWS &&
-      index < metadata->column_count()) {
+  const SharedRefPtr<ResultMetadata>& metadata(result->metadata());
+  if (result->kind() == CASS_RESULT_KIND_ROWS && index < metadata->column_count()) {
     return metadata->get_column_definition(index).data_type->value_type();
   }
   return CASS_VALUE_TYPE_UNKNOWN;
 }
 
 const CassDataType* cass_result_column_data_type(const CassResult* result, size_t index) {
-  const cass::SharedRefPtr<cass::ResultMetadata>& metadata(result->metadata());
-  if (result->kind() == CASS_RESULT_KIND_ROWS &&
-      index < metadata->column_count()) {
+  const SharedRefPtr<ResultMetadata>& metadata(result->metadata());
+  if (result->kind() == CASS_RESULT_KIND_ROWS && index < metadata->column_count()) {
     return CassDataType::to(metadata->get_column_definition(index).data_type.get());
   }
   return NULL;
@@ -89,8 +87,7 @@ cass_bool_t cass_result_has_more_pages(const CassResult* result) {
   return static_cast<cass_bool_t>(result->has_more_pages());
 }
 
-CassError cass_result_paging_state_token(const CassResult* result,
-                                         const char** paging_state,
+CassError cass_result_paging_state_token(const CassResult* result, const char** paging_state,
                                          size_t* paging_state_size) {
   if (!result->has_more_pages()) {
     return CASS_ERROR_LIB_NO_PAGING_STATE;
@@ -102,13 +99,11 @@ CassError cass_result_paging_state_token(const CassResult* result,
 
 } // extern "C"
 
-namespace cass {
-
 class DataTypeDecoder {
 public:
   DataTypeDecoder(Decoder& decoder, SimpleDataTypeCache& cache)
-    : decoder_(decoder)
-    , cache_(cache) { }
+      : decoder_(decoder)
+      , cache_(cache) {}
 
   DataType::ConstPtr decode() {
     decoder_.set_type("data type");
@@ -172,10 +167,8 @@ class DataTypeDecoder {
       if (!decoder_.decode_string(&field_name)) return DataType::NIL;
       fields.push_back(UserType::Field(field_name.to_string(), decode()));
     }
-    return DataType::ConstPtr(new UserType(keyspace.to_string(),
-                                           type_name.to_string(),
-                                           fields,
-                                           false));
+    return DataType::ConstPtr(
+        new UserType(keyspace.to_string(), type_name.to_string(), fields, false));
   }
 
   DataType::ConstPtr decode_tuple() {
@@ -216,7 +209,7 @@ bool ResultResponse::decode(Decoder& decoder) {
       break;
 
     case CASS_RESULT_KIND_SET_KEYSPACE:
-      is_valid =  decode_set_keyspace(decoder);
+      is_valid = decode_set_keyspace(decoder);
       break;
 
     case CASS_RESULT_KIND_PREPARED:
@@ -236,8 +229,7 @@ bool ResultResponse::decode(Decoder& decoder) {
   return is_valid;
 }
 
-bool ResultResponse::decode_metadata(Decoder& decoder,
-                                     ResultMetadata::Ptr* metadata,
+bool ResultResponse::decode_metadata(Decoder& decoder, ResultMetadata::Ptr* metadata,
                                      bool has_pk_indices) {
   int32_t flags = 0;
   CHECK_RESULT(decoder.decode_int32(flags));
@@ -292,7 +284,6 @@ bool ResultResponse::decode_metadata(Decoder& decoder,
       if (!global_table_spec) {
         CHECK_RESULT(decoder.decode_string(&def.keyspace));
         CHECK_RESULT(decoder.decode_string(&def.table));
-
       }
 
       CHECK_RESULT(decoder.decode_string(&def.name));
@@ -308,9 +299,8 @@ bool ResultResponse::decode_metadata(Decoder& decoder,
 }
 
 bool ResultResponse::decode_first_row() {
-  if (row_count_ > 0 &&
-      metadata_ && // Valid metadata required for column count
-      first_row_.values.empty()) { // Only decode the first row once
+  if (row_count_ > 0 && metadata_ && // Valid metadata required for column count
+      first_row_.values.empty()) {   // Only decode the first row once
     first_row_.values.reserve(column_count());
     return decode_row(row_decoder_, this, first_row_.values);
   }
@@ -335,8 +325,8 @@ bool ResultResponse::decode_prepared(Decoder& decoder) {
   if (decoder.protocol_version().supports_result_metadata_id()) {
     CHECK_RESULT(decoder.decode_string(&result_metadata_id_));
   }
-  CHECK_RESULT(decode_metadata(decoder, &metadata_,
-                               decoder.protocol_version() >= CASS_PROTOCOL_VERSION_V4));
+  CHECK_RESULT(
+      decode_metadata(decoder, &metadata_, decoder.protocol_version() >= CASS_PROTOCOL_VERSION_V4));
   CHECK_RESULT(decode_metadata(decoder, &result_metadata_));
   return true;
 }
@@ -347,5 +337,3 @@ bool ResultResponse::decode_schema_change(Decoder& decoder) {
   CHECK_RESULT(decoder.decode_string(&table_));
   return true;
 }
-
-} // namespace cass
diff --git a/src/result_response.hpp b/src/result_response.hpp
index bf2ae1e50..48e7cf7c5 100644
--- a/src/result_response.hpp
+++ b/src/result_response.hpp
@@ -14,19 +14,19 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RESULT_RESPONSE_HPP_INCLUDED__
-#define __CASS_RESULT_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RESULT_RESPONSE_HPP
+#define DATASTAX_INTERNAL_RESULT_RESPONSE_HPP
 
 #include "constants.hpp"
 #include "data_type.hpp"
 #include "macros.hpp"
-#include "result_metadata.hpp"
 #include "response.hpp"
+#include "result_metadata.hpp"
 #include "row.hpp"
 #include "string_ref.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ResultIterator;
 
@@ -99,13 +99,13 @@ class ResultResponse : public Response {
   bool has_more_pages_; // row data
   ResultMetadata::Ptr metadata_;
   ResultMetadata::Ptr result_metadata_;
-  StringRef paging_state_; // row paging
-  StringRef prepared_id_; // prepared result
+  StringRef paging_state_;       // row paging
+  StringRef prepared_id_;        // prepared result
   StringRef result_metadata_id_; // prepared result, protocol v5/DSEv2
-  StringRef change_; // schema change
-  StringRef keyspace_; // rows, set keyspace, and schema change
-  StringRef table_; // rows, and schema change
-  StringRef new_metadata_id_; // rows result, protocol v5/DSEv2
+  StringRef change_;             // schema change
+  StringRef keyspace_;           // rows, set keyspace, and schema change
+  StringRef table_;              // rows, and schema change
+  StringRef new_metadata_id_;    // rows result, protocol v5/DSEv2
   int32_t row_count_;
   Decoder row_decoder_;
   Row first_row_;
@@ -115,8 +115,8 @@ class ResultResponse : public Response {
   DISALLOW_COPY_AND_ASSIGN(ResultResponse);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::ResultResponse, CassResult)
+EXTERNAL_TYPE(datastax::internal::core::ResultResponse, CassResult)
 
 #endif
diff --git a/src/retry_policy.cpp b/src/retry_policy.cpp
index 629aa463a..577843c85 100644
--- a/src/retry_policy.cpp
+++ b/src/retry_policy.cpp
@@ -20,45 +20,42 @@
 #include "logger.hpp"
 #include "request.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassRetryPolicy* cass_retry_policy_default_new() {
-  cass::RetryPolicy* policy = new cass::DefaultRetryPolicy();
+  RetryPolicy* policy = new DefaultRetryPolicy();
   policy->inc_ref();
   return CassRetryPolicy::to(policy);
 }
 
 CassRetryPolicy* cass_retry_policy_downgrading_consistency_new() {
-  cass::RetryPolicy* policy = new cass::DowngradingConsistencyRetryPolicy();
+  RetryPolicy* policy = new DowngradingConsistencyRetryPolicy();
   policy->inc_ref();
   return CassRetryPolicy::to(policy);
 }
 
 CassRetryPolicy* cass_retry_policy_fallthrough_new() {
-  cass::RetryPolicy* policy = new cass::FallthroughRetryPolicy();
+  RetryPolicy* policy = new FallthroughRetryPolicy();
   policy->inc_ref();
   return CassRetryPolicy::to(policy);
 }
 
 CassRetryPolicy* cass_retry_policy_logging_new(CassRetryPolicy* child_retry_policy) {
-  if (child_retry_policy->type() == cass::RetryPolicy::LOGGING) {
+  if (child_retry_policy->type() == RetryPolicy::LOGGING) {
     return NULL;
   }
-  cass::RetryPolicy* policy
-      = new cass::LoggingRetryPolicy(
-          cass::SharedRefPtr<cass::RetryPolicy>(child_retry_policy));
+  RetryPolicy* policy = new LoggingRetryPolicy(SharedRefPtr<RetryPolicy>(child_retry_policy));
   policy->inc_ref();
   return CassRetryPolicy::to(policy);
 }
 
-void cass_retry_policy_free(CassRetryPolicy* policy) {
-  policy->dec_ref();
-}
+void cass_retry_policy_free(CassRetryPolicy* policy) { policy->dec_ref(); }
 
 } // extern "C"
 
-namespace cass {
-
 inline RetryPolicy::RetryDecision max_likely_to_work(int received) {
   if (received >= 3) {
     return RetryPolicy::RetryDecision::retry(CASS_CONSISTENCY_THREE);
@@ -73,9 +70,10 @@ inline RetryPolicy::RetryDecision max_likely_to_work(int received) {
 
 // Default retry policy
 
-RetryPolicy::RetryDecision DefaultRetryPolicy::on_read_timeout(const Request* request, CassConsistency cl,
-                                                               int received, int required,
-                                                               bool data_recevied, int num_retries) const {
+RetryPolicy::RetryDecision DefaultRetryPolicy::on_read_timeout(const Request* request,
+                                                               CassConsistency cl, int received,
+                                                               int required, bool data_recevied,
+                                                               int num_retries) const {
   if (num_retries != 0) {
     return RetryDecision::return_error();
   }
@@ -87,9 +85,11 @@ RetryPolicy::RetryDecision DefaultRetryPolicy::on_read_timeout(const Request* re
   }
 }
 
-RetryPolicy::RetryDecision DefaultRetryPolicy::on_write_timeout(const Request* request, CassConsistency cl,
-                                                                int received, int required,
-                                                                CassWriteType write_type, int num_retries) const {
+RetryPolicy::RetryDecision DefaultRetryPolicy::on_write_timeout(const Request* request,
+                                                                CassConsistency cl, int received,
+                                                                int required,
+                                                                CassWriteType write_type,
+                                                                int num_retries) const {
   if (num_retries != 0) {
     return RetryDecision::return_error();
   }
@@ -101,9 +101,9 @@ RetryPolicy::RetryDecision DefaultRetryPolicy::on_write_timeout(const Request* r
   }
 }
 
-RetryPolicy::RetryDecision DefaultRetryPolicy::on_unavailable(const Request* request, CassConsistency cl,
-                                                              int required, int alive,
-                                                              int num_retries) const {
+RetryPolicy::RetryDecision DefaultRetryPolicy::on_unavailable(const Request* request,
+                                                              CassConsistency cl, int required,
+                                                              int alive, int num_retries) const {
   if (num_retries == 0) {
     return RetryDecision::retry_next_host(cl);
   } else {
@@ -111,22 +111,24 @@ RetryPolicy::RetryDecision DefaultRetryPolicy::on_unavailable(const Request* req
   }
 }
 
-RetryPolicy::RetryDecision DefaultRetryPolicy::on_request_error(const Request* request, CassConsistency cl,
-                                                                const ErrorResponse* error, int num_retries) const {
+RetryPolicy::RetryDecision DefaultRetryPolicy::on_request_error(const Request* request,
+                                                                CassConsistency cl,
+                                                                const ErrorResponse* error,
+                                                                int num_retries) const {
   return RetryDecision::retry_next_host(cl);
 }
 
 // Downgrading retry policy
 
-RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_read_timeout(const Request* request, CassConsistency cl,
-                                                                              int received, int required,
-                                                                              bool data_recevied, int num_retries) const {
+RetryPolicy::RetryDecision
+DowngradingConsistencyRetryPolicy::on_read_timeout(const Request* request, CassConsistency cl,
+                                                   int received, int required, bool data_recevied,
+                                                   int num_retries) const {
   if (num_retries != 0) {
     return RetryDecision::return_error();
   }
 
-  if (cl == CASS_CONSISTENCY_SERIAL ||
-      cl == CASS_CONSISTENCY_LOCAL_SERIAL) {
+  if (cl == CASS_CONSISTENCY_SERIAL || cl == CASS_CONSISTENCY_LOCAL_SERIAL) {
     return RetryDecision::return_error();
   }
 
@@ -141,9 +143,9 @@ RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_read_timeout(co
   }
 }
 
-RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_write_timeout(const Request* request, CassConsistency cl,
-                                                                               int received, int required,
-                                                                               CassWriteType write_type, int num_retries) const {
+RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_write_timeout(
+    const Request* request, CassConsistency cl, int received, int required,
+    CassWriteType write_type, int num_retries) const {
   if (num_retries != 0) {
     return RetryDecision::return_error();
   }
@@ -168,66 +170,73 @@ RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_write_timeout(c
   }
 }
 
-RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_unavailable(const Request* request, CassConsistency cl,
-                                                                             int required, int alive,
-                                                                             int num_retries) const {
+RetryPolicy::RetryDecision
+DowngradingConsistencyRetryPolicy::on_unavailable(const Request* request, CassConsistency cl,
+                                                  int required, int alive, int num_retries) const {
   if (num_retries != 0) {
     return RetryDecision::return_error();
   }
   return max_likely_to_work(alive);
 }
 
-RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_request_error(const Request* request, CassConsistency cl,
-                                                                               const ErrorResponse* error, int num_retries) const {
+RetryPolicy::RetryDecision DowngradingConsistencyRetryPolicy::on_request_error(
+    const Request* request, CassConsistency cl, const ErrorResponse* error, int num_retries) const {
   return RetryDecision::retry_next_host(cl);
 }
 
 // Fallthrough retry policy
 
-RetryPolicy::RetryDecision FallthroughRetryPolicy::on_read_timeout(const Request* request, CassConsistency cl,
-                                                                   int received, int required,
-                                                                   bool data_recevied, int num_retries) const {
+RetryPolicy::RetryDecision FallthroughRetryPolicy::on_read_timeout(const Request* request,
+                                                                   CassConsistency cl, int received,
+                                                                   int required, bool data_recevied,
+                                                                   int num_retries) const {
   return RetryDecision::return_error();
 }
 
-RetryPolicy::RetryDecision FallthroughRetryPolicy::on_write_timeout(const Request* request, CassConsistency cl,
+RetryPolicy::RetryDecision FallthroughRetryPolicy::on_write_timeout(const Request* request,
+                                                                    CassConsistency cl,
                                                                     int received, int required,
-                                                                    CassWriteType write_type, int num_retries) const {
+                                                                    CassWriteType write_type,
+                                                                    int num_retries) const {
   return RetryDecision::return_error();
 }
 
-RetryPolicy::RetryDecision FallthroughRetryPolicy::on_unavailable(const Request* request, CassConsistency cl,
-                                                                  int required, int alive,
+RetryPolicy::RetryDecision FallthroughRetryPolicy::on_unavailable(const Request* request,
+                                                                  CassConsistency cl, int required,
+                                                                  int alive,
                                                                   int num_retries) const {
   return RetryDecision::return_error();
 }
 
-RetryPolicy::RetryDecision FallthroughRetryPolicy::on_request_error(const Request* request, CassConsistency cl,
-                                                                    const ErrorResponse* error, int num_retries) const {
+RetryPolicy::RetryDecision FallthroughRetryPolicy::on_request_error(const Request* request,
+                                                                    CassConsistency cl,
+                                                                    const ErrorResponse* error,
+                                                                    int num_retries) const {
   return RetryDecision::return_error();
 }
 
 // Logging retry policy
 
-RetryPolicy::RetryDecision LoggingRetryPolicy::on_read_timeout(const Request* request, CassConsistency cl,
-                                                               int received, int required,
-                                                               bool data_recevied, int num_retries) const {
-  RetryDecision decision = retry_policy_->on_read_timeout(request, cl, received, required, data_recevied, num_retries);
+RetryPolicy::RetryDecision LoggingRetryPolicy::on_read_timeout(const Request* request,
+                                                               CassConsistency cl, int received,
+                                                               int required, bool data_recevied,
+                                                               int num_retries) const {
+  RetryDecision decision =
+      retry_policy_->on_read_timeout(request, cl, received, required, data_recevied, num_retries);
 
   switch (decision.type()) {
     case RetryDecision::IGNORE:
-      LOG_INFO("Ignoring read timeout (initial consistency: %s, required responses: %d, received responses: %d, data retrieved: %s, retries: %d)",
-               cass_consistency_string(cl),
-               required, received,
-               data_recevied ? "true" : "false", num_retries);
+      LOG_INFO("Ignoring read timeout (initial consistency: %s, required responses: %d, received "
+               "responses: %d, data retrieved: %s, retries: %d)",
+               cass_consistency_string(cl), required, received, data_recevied ? "true" : "false",
+               num_retries);
       break;
 
     case RetryDecision::RETRY:
-      LOG_INFO("Retrying on read timeout at consistency %s (initial consistency: %s, required responses: %d, received responses: %d, data retrieved: %s, retries: %d)",
-               cass_consistency_string(decision.retry_consistency()),
-               cass_consistency_string(cl),
-               required, received,
-               data_recevied ? "true" : "false", num_retries);
+      LOG_INFO("Retrying on read timeout at consistency %s (initial consistency: %s, required "
+               "responses: %d, received responses: %d, data retrieved: %s, retries: %d)",
+               cass_consistency_string(decision.retry_consistency()), cass_consistency_string(cl),
+               required, received, data_recevied ? "true" : "false", num_retries);
       break;
 
     default:
@@ -237,25 +246,27 @@ RetryPolicy::RetryDecision LoggingRetryPolicy::on_read_timeout(const Request* re
   return decision;
 }
 
-RetryPolicy::RetryDecision LoggingRetryPolicy::on_write_timeout(const Request* request, CassConsistency cl,
-                                                                int received, int required,
-                                                                CassWriteType write_type, int num_retries) const {
-  RetryDecision decision = retry_policy_->on_write_timeout(request, cl, received, required, write_type, num_retries);
+RetryPolicy::RetryDecision LoggingRetryPolicy::on_write_timeout(const Request* request,
+                                                                CassConsistency cl, int received,
+                                                                int required,
+                                                                CassWriteType write_type,
+                                                                int num_retries) const {
+  RetryDecision decision =
+      retry_policy_->on_write_timeout(request, cl, received, required, write_type, num_retries);
 
   switch (decision.type()) {
     case RetryDecision::IGNORE:
-      LOG_INFO("Ignoring write timeout (initial consistency: %s, required acknowledgments: %d, received acknowledgments: %d, write type: %s, retries: %d)",
-               cass_consistency_string(cl),
-               required, received,
-               cass_write_type_string(write_type), num_retries);
+      LOG_INFO("Ignoring write timeout (initial consistency: %s, required acknowledgments: %d, "
+               "received acknowledgments: %d, write type: %s, retries: %d)",
+               cass_consistency_string(cl), required, received, cass_write_type_string(write_type),
+               num_retries);
       break;
 
     case RetryDecision::RETRY:
-      LOG_INFO("Retrying on write timeout at consistency %s (initial consistency: %s, required acknowledgments: %d, received acknowledgments: %d, write type: %s, retries: %d)",
-               cass_consistency_string(decision.retry_consistency()),
-               cass_consistency_string(cl),
-               required, received,
-               cass_write_type_string(write_type), num_retries);
+      LOG_INFO("Retrying on write timeout at consistency %s (initial consistency: %s, required "
+               "acknowledgments: %d, received acknowledgments: %d, write type: %s, retries: %d)",
+               cass_consistency_string(decision.retry_consistency()), cass_consistency_string(cl),
+               required, received, cass_write_type_string(write_type), num_retries);
       break;
 
     default:
@@ -265,23 +276,22 @@ RetryPolicy::RetryDecision LoggingRetryPolicy::on_write_timeout(const Request* r
   return decision;
 }
 
-RetryPolicy::RetryDecision LoggingRetryPolicy::on_unavailable(const Request* request, CassConsistency cl,
-                                                              int required, int alive,
-                                                              int num_retries) const {
+RetryPolicy::RetryDecision LoggingRetryPolicy::on_unavailable(const Request* request,
+                                                              CassConsistency cl, int required,
+                                                              int alive, int num_retries) const {
   RetryDecision decision = retry_policy_->on_unavailable(request, cl, required, alive, num_retries);
 
   switch (decision.type()) {
     case RetryDecision::IGNORE:
-      LOG_INFO("Ignoring unavailable error (initial consistency: %s, required replica: %d, alive replica: %d, retries: %d)",
-               cass_consistency_string(cl),
-               required, alive,
-               num_retries);
+      LOG_INFO("Ignoring unavailable error (initial consistency: %s, required replica: %d, alive "
+               "replica: %d, retries: %d)",
+               cass_consistency_string(cl), required, alive, num_retries);
       break;
 
     case RetryDecision::RETRY:
-      LOG_INFO("Retrying on unavailable error at consistency %s (initial consistency: %s, required replica: %d, alive replica: %d, retries: %d)",
-               cass_consistency_string(decision.retry_consistency()),
-               cass_consistency_string(cl),
+      LOG_INFO("Retrying on unavailable error at consistency %s (initial consistency: %s, required "
+               "replica: %d, alive replica: %d, retries: %d)",
+               cass_consistency_string(decision.retry_consistency()), cass_consistency_string(cl),
                required, alive, num_retries);
       break;
 
@@ -292,24 +302,23 @@ RetryPolicy::RetryDecision LoggingRetryPolicy::on_unavailable(const Request* req
   return decision;
 }
 
-RetryPolicy::RetryDecision LoggingRetryPolicy::on_request_error(const Request* request, CassConsistency cl,
-                                                                const ErrorResponse* error, int num_retries) const {
+RetryPolicy::RetryDecision LoggingRetryPolicy::on_request_error(const Request* request,
+                                                                CassConsistency cl,
+                                                                const ErrorResponse* error,
+                                                                int num_retries) const {
   RetryDecision decision = retry_policy_->on_request_error(request, cl, error, num_retries);
 
   switch (decision.type()) {
     case RetryDecision::IGNORE:
       LOG_INFO("Ignoring request error (initial consistency: %s, error: %s, retries: %d)",
-               cass_consistency_string(cl),
-               error->message().to_string().c_str(),
-               num_retries);
+               cass_consistency_string(cl), error->message().to_string().c_str(), num_retries);
       break;
 
     case RetryDecision::RETRY:
-      LOG_INFO("Retrying on request error at consistency %s (initial consistency: %s, error: %s, retries: %d)",
-               cass_consistency_string(decision.retry_consistency()),
-               cass_consistency_string(cl),
-               error->message().to_string().c_str(),
-               num_retries);
+      LOG_INFO("Retrying on request error at consistency %s (initial consistency: %s, error: %s, "
+               "retries: %d)",
+               cass_consistency_string(decision.retry_consistency()), cass_consistency_string(cl),
+               error->message().to_string().c_str(), num_retries);
       break;
 
     default:
@@ -318,5 +327,3 @@ RetryPolicy::RetryDecision LoggingRetryPolicy::on_request_error(const Request* r
 
   return decision;
 }
-
-} // namespace cass
diff --git a/src/retry_policy.hpp b/src/retry_policy.hpp
index c0f73dd31..460fc06e9 100644
--- a/src/retry_policy.hpp
+++ b/src/retry_policy.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_RETRY_POLICY_HPP_INCLUDED__
-#define __CASS_RETRY_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RETRY_POLICY_HPP
+#define DATASTAX_INTERNAL_RETRY_POLICY_HPP
 
 #include "cassandra.h"
 #include "error_response.hpp"
@@ -23,12 +23,12 @@
 #include "ref_counted.hpp"
 
 #ifdef _WIN32
-# ifdef IGNORE
-#   undef IGNORE
-# endif
+#ifdef IGNORE
+#undef IGNORE
+#endif
 #endif
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ErrorResponse;
 class Request;
@@ -37,25 +37,16 @@ class RetryPolicy : public RefCounted<RetryPolicy> {
 public:
   typedef SharedRefPtr<RetryPolicy> Ptr;
 
-  enum Type {
-    DEFAULT,
-    DOWNGRADING,
-    FALLTHROUGH,
-    LOGGING
-  };
+  enum Type { DEFAULT, DOWNGRADING, FALLTHROUGH, LOGGING };
 
   class RetryDecision {
   public:
-    enum Type {
-      RETURN_ERROR,
-      RETRY,
-      IGNORE
-    };
+    enum Type { RETURN_ERROR, RETRY, IGNORE };
 
     RetryDecision(Type type, CassConsistency retry_cl, bool retry_current_host)
-      : type_(type)
-      , retry_cl_(retry_cl)
-      , retry_current_host_(retry_current_host) { }
+        : type_(type)
+        , retry_cl_(retry_cl)
+        , retry_current_host_(retry_current_host) {}
 
     Type type() const { return type_; }
     CassConsistency retry_consistency() const { return retry_cl_; }
@@ -65,17 +56,13 @@ class RetryPolicy : public RefCounted<RetryPolicy> {
       return RetryDecision(RETURN_ERROR, CASS_CONSISTENCY_UNKNOWN, false);
     }
 
-    static RetryDecision retry(CassConsistency cl) {
-      return RetryDecision(RETRY, cl, true);
-    }
+    static RetryDecision retry(CassConsistency cl) { return RetryDecision(RETRY, cl, true); }
 
     static RetryDecision retry_next_host(CassConsistency cl) {
       return RetryDecision(RETRY, cl, false);
     }
 
-    static RetryDecision ignore() {
-      return RetryDecision(IGNORE, CASS_CONSISTENCY_UNKNOWN, false);
-    }
+    static RetryDecision ignore() { return RetryDecision(IGNORE, CASS_CONSISTENCY_UNKNOWN, false); }
 
   private:
     Type type_;
@@ -84,21 +71,20 @@ class RetryPolicy : public RefCounted<RetryPolicy> {
   };
 
   RetryPolicy(Type type)
-    : type_(type) { }
+      : type_(type) {}
 
-  virtual ~RetryPolicy() { }
+  virtual ~RetryPolicy() {}
 
   Type type() const { return type_; }
 
-  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl,
-                                        int received, int required,
-                                        bool data_recevied, int num_retries) const = 0;
-  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl,
-                                         int received, int required,
-                                         CassWriteType write_type, int num_retries) const = 0;
-  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl,
-                                       int required, int alive,
-                                       int num_retries) const = 0;
+  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl, int received,
+                                        int required, bool data_recevied,
+                                        int num_retries) const = 0;
+  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl, int received,
+                                         int required, CassWriteType write_type,
+                                         int num_retries) const = 0;
+  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl, int required,
+                                       int alive, int num_retries) const = 0;
   virtual RetryDecision on_request_error(const Request* request, CassConsistency cl,
                                          const ErrorResponse* error, int num_retries) const = 0;
 
@@ -109,17 +95,15 @@ class RetryPolicy : public RefCounted<RetryPolicy> {
 class DefaultRetryPolicy : public RetryPolicy {
 public:
   DefaultRetryPolicy()
-    : RetryPolicy(DEFAULT) { }
-
-  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl,
-                                        int received, int required,
-                                        bool data_recevied, int num_retries) const;
-  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl,
-                                         int received, int required,
-                                         CassWriteType write_type, int num_retries) const;
-  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl,
-                                       int required, int alive,
-                                       int num_retries) const;
+      : RetryPolicy(DEFAULT) {}
+
+  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl, int received,
+                                        int required, bool data_recevied, int num_retries) const;
+  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl, int received,
+                                         int required, CassWriteType write_type,
+                                         int num_retries) const;
+  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl, int required,
+                                       int alive, int num_retries) const;
   virtual RetryDecision on_request_error(const Request* request, CassConsistency cl,
                                          const ErrorResponse* error, int num_retries) const;
 };
@@ -127,17 +111,15 @@ class DefaultRetryPolicy : public RetryPolicy {
 class DowngradingConsistencyRetryPolicy : public RetryPolicy {
 public:
   DowngradingConsistencyRetryPolicy()
-    : RetryPolicy(DOWNGRADING) { }
-
-  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl,
-                                        int received, int required,
-                                        bool data_recevied, int num_retries) const;
-  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl,
-                                         int received, int required,
-                                         CassWriteType write_type, int num_retries) const;
-  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl,
-                                       int required, int alive,
-                                       int num_retries) const;
+      : RetryPolicy(DOWNGRADING) {}
+
+  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl, int received,
+                                        int required, bool data_recevied, int num_retries) const;
+  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl, int received,
+                                         int required, CassWriteType write_type,
+                                         int num_retries) const;
+  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl, int required,
+                                       int alive, int num_retries) const;
   virtual RetryDecision on_request_error(const Request* request, CassConsistency cl,
                                          const ErrorResponse* error, int num_retries) const;
 };
@@ -145,17 +127,15 @@ class DowngradingConsistencyRetryPolicy : public RetryPolicy {
 class FallthroughRetryPolicy : public RetryPolicy {
 public:
   FallthroughRetryPolicy()
-    : RetryPolicy(FALLTHROUGH) { }
-
-  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl,
-                                        int received, int required,
-                                        bool data_recevied, int num_retries) const;
-  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl,
-                                         int received, int required,
-                                         CassWriteType write_type, int num_retries) const;
-  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl,
-                                       int required, int alive,
-                                       int num_retries) const;
+      : RetryPolicy(FALLTHROUGH) {}
+
+  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl, int received,
+                                        int required, bool data_recevied, int num_retries) const;
+  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl, int received,
+                                         int required, CassWriteType write_type,
+                                         int num_retries) const;
+  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl, int required,
+                                       int alive, int num_retries) const;
   virtual RetryDecision on_request_error(const Request* request, CassConsistency cl,
                                          const ErrorResponse* error, int num_retries) const;
 };
@@ -163,18 +143,16 @@ class FallthroughRetryPolicy : public RetryPolicy {
 class LoggingRetryPolicy : public RetryPolicy {
 public:
   LoggingRetryPolicy(const RetryPolicy::Ptr& retry_policy)
-    : RetryPolicy(LOGGING)
-    , retry_policy_(retry_policy) { }
-
-  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl,
-                                        int received, int required,
-                                        bool data_recevied, int num_retries) const;
-  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl,
-                                         int received, int required,
-                                         CassWriteType write_type, int num_retries) const;
-  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl,
-                                       int required, int alive,
-                                       int num_retries) const;
+      : RetryPolicy(LOGGING)
+      , retry_policy_(retry_policy) {}
+
+  virtual RetryDecision on_read_timeout(const Request* request, CassConsistency cl, int received,
+                                        int required, bool data_recevied, int num_retries) const;
+  virtual RetryDecision on_write_timeout(const Request* request, CassConsistency cl, int received,
+                                         int required, CassWriteType write_type,
+                                         int num_retries) const;
+  virtual RetryDecision on_unavailable(const Request* request, CassConsistency cl, int required,
+                                       int alive, int num_retries) const;
   virtual RetryDecision on_request_error(const Request* request, CassConsistency cl,
                                          const ErrorResponse* response, int num_retries) const;
 
@@ -182,9 +160,8 @@ class LoggingRetryPolicy : public RetryPolicy {
   RetryPolicy::Ptr retry_policy_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::RetryPolicy, CassRetryPolicy)
+EXTERNAL_TYPE(datastax::internal::core::RetryPolicy, CassRetryPolicy)
 
 #endif
-
diff --git a/src/ring_buffer.cpp b/src/ring_buffer.cpp
index 824072f44..5a14384a6 100644
--- a/src/ring_buffer.cpp
+++ b/src/ring_buffer.cpp
@@ -44,8 +44,7 @@
 #include <assert.h>
 #include <string.h>
 
-namespace cass {
-namespace rb {
+using namespace datastax::internal::rb;
 
 RingBuffer::~RingBuffer() {
   Buffer* current = head_.next_;
@@ -64,16 +63,14 @@ void RingBuffer::try_move_read_head() {
   // inside the buffer, respectively. When they're equal - its safe to reset
   // them, because both reader and writer will continue doing their stuff
   // from new (zero) positions.
-  while (read_head_->read_pos_ != 0 &&
-         read_head_->read_pos_ == read_head_->write_pos_) {
+  while (read_head_->read_pos_ != 0 && read_head_->read_pos_ == read_head_->write_pos_) {
     // Reset positions
     read_head_->read_pos_ = 0;
     read_head_->write_pos_ = 0;
 
     // Move read_head_ forward, just in case if there're still some data to
     // read in the next buffer.
-    if (read_head_ != write_head_)
-      read_head_ = read_head_->next_;
+    if (read_head_ != write_head_) read_head_ = read_head_->next_;
   }
 }
 
@@ -86,12 +83,10 @@ size_t RingBuffer::read(char* out, size_t size) {
   while (bytes_read < expected) {
     assert(read_head_->read_pos_ <= read_head_->write_pos_);
     size_t avail = read_head_->write_pos_ - read_head_->read_pos_;
-    if (avail > left)
-      avail = left;
+    if (avail > left) avail = left;
 
     // Copy data
-    if (out != NULL)
-      memcpy(out + offset, read_head_->data_ + read_head_->read_pos_, avail);
+    if (out != NULL) memcpy(out + offset, read_head_->data_ + read_head_->read_pos_, avail);
     read_head_->read_pos_ += avail;
 
     // Move pointers
@@ -110,14 +105,11 @@ size_t RingBuffer::read(char* out, size_t size) {
   return bytes_read;
 }
 
-
 void RingBuffer::free_empty() {
   Buffer* child = write_head_->next_;
-  if (child == write_head_ || child == read_head_)
-    return;
+  if (child == write_head_ || child == read_head_) return;
   Buffer* cur = child->next_;
-  if (cur == write_head_ || cur == read_head_)
-    return;
+  if (cur == write_head_ || cur == read_head_) return;
 
   Buffer* prev = child;
   while (cur != read_head_) {
@@ -139,7 +131,6 @@ void RingBuffer::free_empty() {
   prev->next_ = cur;
 }
 
-
 size_t RingBuffer::index_of(char delim, size_t limit) {
   size_t bytes_read = 0;
   size_t max = length_ > limit ? limit : length_;
@@ -149,8 +140,7 @@ size_t RingBuffer::index_of(char delim, size_t limit) {
   while (bytes_read < max) {
     assert(current->read_pos_ <= current->write_pos_);
     size_t avail = current->write_pos_ - current->read_pos_;
-    if (avail > left)
-      avail = left;
+    if (avail > left) avail = left;
 
     // Walk through data
     char* tmp = current->data_ + current->read_pos_;
@@ -187,13 +177,10 @@ void RingBuffer::write(const char* data, size_t size) {
     assert(write_head_->write_pos_ <= BUFFER_LENGTH);
     size_t avail = BUFFER_LENGTH - write_head_->write_pos_;
 
-    if (to_write > avail)
-      to_write = avail;
+    if (to_write > avail) to_write = avail;
 
     // Copy data
-    memcpy(write_head_->data_ + write_head_->write_pos_,
-           data + offset,
-           to_write);
+    memcpy(write_head_->data_ + write_head_->write_pos_, data + offset, to_write);
 
     // Move pointers
     left -= to_write;
@@ -246,8 +233,7 @@ void RingBuffer::commit(size_t size) {
 void RingBuffer::try_allocate_for_write() {
   // If write head is full, next buffer is either read head or not empty.
   if (write_head_->write_pos_ == BUFFER_LENGTH &&
-      (write_head_->next_ == read_head_ ||
-       write_head_->next_->write_pos_ != 0)) {
+      (write_head_->next_ == read_head_ || write_head_->next_->write_pos_ != 0)) {
     Buffer* next = new Buffer();
     next->next_ = write_head_->next_;
     write_head_->next_ = next;
@@ -267,6 +253,3 @@ void RingBuffer::reset() {
   write_head_ = read_head_;
   assert(length_ == 0);
 }
-
-} // namespace rb
-} // namespace cass
diff --git a/src/ring_buffer.hpp b/src/ring_buffer.hpp
index 4ee363eea..5e9a8f3ac 100644
--- a/src/ring_buffer.hpp
+++ b/src/ring_buffer.hpp
@@ -39,27 +39,28 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#ifndef __CASS_RING_BUFFER_HPP_INCLUDED__
-#define __CASS_RING_BUFFER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RING_BUFFER_HPP
+#define DATASTAX_INTERNAL_RING_BUFFER_HPP
 
 #include "allocated.hpp"
 #include "small_vector.hpp"
 
 #include <uv.h>
 
-namespace cass {
-namespace rb {
+namespace datastax { namespace internal { namespace rb {
 
 class RingBuffer {
- private:
+private:
   // NOTE: Size is maximum TLS frame length, this is required if we want
   // to fit whole ClientHello into one Buffer of RingBuffer.
   static const size_t BUFFER_LENGTH = 16 * 1024 + 5;
 
   class Buffer : public Allocated {
-   public:
-    Buffer() : read_pos_(0), write_pos_(0), next_(NULL) {
-    }
+  public:
+    Buffer()
+        : read_pos_(0)
+        , write_pos_(0)
+        , next_(NULL) {}
 
     size_t read_pos_;
     size_t write_pos_;
@@ -67,27 +68,26 @@ class RingBuffer {
     char data_[BUFFER_LENGTH];
   };
 
- public:
+public:
   struct Position {
     Position(Buffer* buf, size_t pos)
-      : buf(buf) , pos(pos) {}
+        : buf(buf)
+        , pos(pos) {}
     Buffer* buf;
     size_t pos;
   };
 
   RingBuffer()
-    : length_(0)
-    , read_head_(&head_)
-    , write_head_(&head_) {
+      : length_(0)
+      , read_head_(&head_)
+      , write_head_(&head_) {
     // Loop head
     head_.next_ = &head_;
   }
 
   ~RingBuffer();
 
-  Position write_position() {
-    return Position(write_head_, write_head_->write_pos_);
-  }
+  Position write_position() { return Position(write_head_, write_head_->write_pos_); }
 
   // Move read head to next buffer if needed
   void try_move_read_head();
@@ -125,11 +125,9 @@ class RingBuffer {
   void commit(size_t size);
 
   // Return size of buffer in bytes
-  size_t inline length() {
-    return length_;
-  }
+  size_t inline length() { return length_; }
 
- private:
+private:
   size_t length_;
   Buffer head_;
   Buffer* read_head_;
@@ -160,7 +158,6 @@ size_t RingBuffer::peek_multiple(Position pos, SmallVector<uv_buf_t, N>* bufs) {
   return total;
 }
 
-} // namespace rb
-} // namespace cass
+}}} // namespace datastax::internal::rb
 
 #endif
diff --git a/src/round_robin_policy.cpp b/src/round_robin_policy.cpp
index 06e95f014..53c102efc 100644
--- a/src/round_robin_policy.cpp
+++ b/src/round_robin_policy.cpp
@@ -20,24 +20,22 @@
 #include <algorithm>
 #include <iterator>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 RoundRobinPolicy::RoundRobinPolicy()
-  : hosts_(new HostVec())
-  , index_(0) {
+    : hosts_(new HostVec())
+    , index_(0) {
   uv_rwlock_init(&available_rwlock_);
 }
 
-RoundRobinPolicy::~RoundRobinPolicy() {
-  uv_rwlock_destroy(&available_rwlock_);
-}
+RoundRobinPolicy::~RoundRobinPolicy() { uv_rwlock_destroy(&available_rwlock_); }
 
-void RoundRobinPolicy::init(const Host::Ptr& connected_host,
-                            const HostMap& hosts,
-                            Random* random) {
+void RoundRobinPolicy::init(const Host::Ptr& connected_host, const HostMap& hosts, Random* random) {
   available_.resize(hosts.size());
-  std::transform(hosts.begin(), hosts.end(),
-                 std::inserter(available_, available_.begin()), GetAddress());
+  std::transform(hosts.begin(), hosts.end(), std::inserter(available_, available_.begin()),
+                 GetAddress());
   hosts_->reserve(hosts.size());
   std::transform(hosts.begin(), hosts.end(), std::back_inserter(*hosts_), GetHost());
 
@@ -50,8 +48,7 @@ CassHostDistance RoundRobinPolicy::distance(const Host::Ptr& host) const {
   return CASS_HOST_DISTANCE_LOCAL;
 }
 
-QueryPlan* RoundRobinPolicy::new_query_plan(const String& keyspace,
-                                            RequestHandler* request_handler,
+QueryPlan* RoundRobinPolicy::new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                             const TokenMap* token_map) {
   return new RoundRobinQueryPlan(this, hosts_, index_++);
 }
@@ -61,13 +58,9 @@ bool RoundRobinPolicy::is_host_up(const Address& address) const {
   return available_.count(address) > 0;
 }
 
-void RoundRobinPolicy::on_host_added(const Host::Ptr& host) {
-  add_host(hosts_, host);
-}
+void RoundRobinPolicy::on_host_added(const Host::Ptr& host) { add_host(hosts_, host); }
 
-void RoundRobinPolicy::on_host_removed(const Host::Ptr& host) {
-  on_host_down(host->address());
-}
+void RoundRobinPolicy::on_host_removed(const Host::Ptr& host) { on_host_down(host->address()); }
 
 void RoundRobinPolicy::on_host_up(const Host::Ptr& host) {
   add_host(hosts_, host);
@@ -96,5 +89,3 @@ Host::Ptr RoundRobinPolicy::RoundRobinQueryPlan::compute_next() {
   }
   return Host::Ptr();
 }
-
-} // namespace cass
diff --git a/src/round_robin_policy.hpp b/src/round_robin_policy.hpp
index 9ea1ea7d3..e09316813 100644
--- a/src/round_robin_policy.hpp
+++ b/src/round_robin_policy.hpp
@@ -14,16 +14,16 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ROUND_ROBIN_POLICY_HPP_INCLUDED__
-#define __CASS_ROUND_ROBIN_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ROUND_ROBIN_POLICY_HPP
+#define DATASTAX_INTERNAL_ROUND_ROBIN_POLICY_HPP
 
 #include "cassandra.h"
 #include "copy_on_write_ptr.hpp"
-#include "load_balancing.hpp"
 #include "host.hpp"
+#include "load_balancing.hpp"
 #include "random.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RoundRobinPolicy : public LoadBalancingPolicy {
 public:
@@ -34,8 +34,7 @@ class RoundRobinPolicy : public LoadBalancingPolicy {
 
   virtual CassHostDistance distance(const Host::Ptr& host) const;
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   virtual bool is_host_up(const Address& address) const;
@@ -50,13 +49,12 @@ class RoundRobinPolicy : public LoadBalancingPolicy {
 private:
   class RoundRobinQueryPlan : public QueryPlan {
   public:
-    RoundRobinQueryPlan(const RoundRobinPolicy* policy,
-                        const CopyOnWriteHostVec& hosts,
+    RoundRobinQueryPlan(const RoundRobinPolicy* policy, const CopyOnWriteHostVec& hosts,
                         size_t start_index)
-      : policy_(policy)
-      , hosts_(hosts)
-      , index_(start_index)
-      , remaining_(hosts->size()) { }
+        : policy_(policy)
+        , hosts_(hosts)
+        , index_(start_index)
+        , remaining_(hosts->size()) {}
 
     virtual Host::Ptr compute_next();
 
@@ -77,6 +75,6 @@ class RoundRobinPolicy : public LoadBalancingPolicy {
   DISALLOW_COPY_AND_ASSIGN(RoundRobinPolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/row.cpp b/src/row.cpp
index 6cd0ea301..b58f823a0 100644
--- a/src/row.cpp
+++ b/src/row.cpp
@@ -22,6 +22,9 @@
 #include "serialization.hpp"
 #include "string_ref.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 const CassValue* cass_row_get_column(const CassRow* row, size_t index) {
@@ -31,25 +34,22 @@ const CassValue* cass_row_get_column(const CassRow* row, size_t index) {
   return CassValue::to(&row->values[index]);
 }
 
-const CassValue* cass_row_get_column_by_name(const CassRow* row,
-                                             const char* name) {
+const CassValue* cass_row_get_column_by_name(const CassRow* row, const char* name) {
 
   return cass_row_get_column_by_name_n(row, name, SAFE_STRLEN(name));
 }
 
-const CassValue* cass_row_get_column_by_name_n(const CassRow* row,
-                                               const char* name,
+const CassValue* cass_row_get_column_by_name_n(const CassRow* row, const char* name,
                                                size_t name_length) {
 
-  return CassValue::to(row->get_by_name(cass::StringRef(name, name_length)));
+  return CassValue::to(row->get_by_name(StringRef(name, name_length)));
 }
 
 } // extern "C"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
-bool decode_row(Decoder& decoder, const ResultResponse* result,
-                OutputValueVec& output) {
+bool decode_row(Decoder& decoder, const ResultResponse* result, OutputValueVec& output) {
   output.clear();
   output.reserve(result->column_count());
   for (int i = 0; i < result->column_count(); ++i) {
@@ -62,6 +62,8 @@ bool decode_row(Decoder& decoder, const ResultResponse* result,
   return true;
 }
 
+}}} // namespace datastax::internal::core
+
 const Value* Row::get_by_name(const StringRef& name) const {
   IndexVec indices;
   if (result_->metadata()->get_indices(name, &indices) == 0) {
@@ -78,5 +80,3 @@ bool Row::get_string_by_name(const StringRef& name, String* out) const {
   *out = value->decoder().as_string();
   return true;
 }
-
-}
diff --git a/src/row.hpp b/src/row.hpp
index 20d777f18..0d3072e6b 100644
--- a/src/row.hpp
+++ b/src/row.hpp
@@ -14,25 +14,25 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ROW_HPP_INCLUDED__
-#define __CASS_ROW_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ROW_HPP
+#define DATASTAX_INTERNAL_ROW_HPP
 
 #include "decoder.hpp"
 #include "external.hpp"
 #include "string_ref.hpp"
 #include "value.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class ResultResponse;
 
 class Row {
 public:
   Row()
-    : result_(NULL) {}
+      : result_(NULL) {}
 
   Row(const ResultResponse* result)
-    : result_(result) {}
+      : result_(result) {}
 
   OutputValueVec values;
 
@@ -48,11 +48,10 @@ class Row {
   const ResultResponse* result_;
 };
 
-bool decode_row(Decoder& decoder, const ResultResponse* result,
-                OutputValueVec& output);
+bool decode_row(Decoder& decoder, const ResultResponse* result, OutputValueVec& output);
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Row, CassRow)
+EXTERNAL_TYPE(datastax::internal::core::Row, CassRow)
 
 #endif
diff --git a/src/row_iterator.hpp b/src/row_iterator.hpp
index 7fcd6c0f9..a30990a57 100644
--- a/src/row_iterator.hpp
+++ b/src/row_iterator.hpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#ifndef __CASS_ROW_ITERATOR_HPP_INCLUDED__
-#define __CASS_ROW_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_ROW_ITERATOR_HPP
+#define DATASTAX_INTERNAL_ROW_ITERATOR_HPP
 
 #include "iterator.hpp"
 #include "row.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RowIterator : public Iterator {
 public:
@@ -47,6 +47,6 @@ class RowIterator : public Iterator {
   int32_t index_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/schema_agreement_handler.cpp b/src/schema_agreement_handler.cpp
index 8179505f8..2a22dd219 100644
--- a/src/schema_agreement_handler.cpp
+++ b/src/schema_agreement_handler.cpp
@@ -19,21 +19,20 @@
 #include "result_iterator.hpp"
 
 #define RETRY_SCHEMA_AGREEMENT_WAIT_MS 200
-#define SELECT_LOCAL_SCHEMA \
-  "SELECT schema_version FROM system.local WHERE key='local'"
-#define SELECT_PEERS_SCHEMA \
-  "SELECT peer, rpc_address, schema_version FROM system.peers"
+#define SELECT_LOCAL_SCHEMA "SELECT schema_version FROM system.local WHERE key='local'"
+#define SELECT_PEERS_SCHEMA "SELECT peer, rpc_address, schema_version FROM system.peers"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 SchemaAgreementHandler::SchemaAgreementHandler(const RequestHandler::Ptr& request_handler,
                                                const Host::Ptr& current_host,
                                                const Response::Ptr& response,
                                                SchemaAgreementListener* listener,
                                                uint64_t max_wait_time_ms)
-  : WaitForHandler (request_handler, current_host, response,
-                    max_wait_time_ms, RETRY_SCHEMA_AGREEMENT_WAIT_MS)
-  , listener_(listener) { }
+    : WaitForHandler(request_handler, current_host, response, max_wait_time_ms,
+                     RETRY_SCHEMA_AGREEMENT_WAIT_MS)
+    , listener_(listener) {}
 
 ChainedRequestCallback::Ptr SchemaAgreementHandler::callback() {
   WaitforRequestVec requests;
@@ -54,8 +53,7 @@ bool SchemaAgreementHandler::on_set(const ChainedRequestCallback::Ptr& callback)
       current_version = v->to_string_ref();
     }
   } else {
-    LOG_DEBUG("No row found in %s's local system table",
-              address_string().c_str());
+    LOG_DEBUG("No row found in %s's local system table", address_string().c_str());
   }
 
   ResultResponse::Ptr peers_result(callback->result("peers"));
@@ -65,11 +63,8 @@ bool SchemaAgreementHandler::on_set(const ChainedRequestCallback::Ptr& callback)
       const Row* row = rows.row();
 
       Address address;
-      bool is_valid_address
-          = determine_address_for_peer_host(this->address(),
-                                            row->get_by_name("peer"),
-                                            row->get_by_name("rpc_address"),
-                                            &address);
+      bool is_valid_address = determine_address_for_peer_host(
+          this->address(), row->get_by_name("peer"), row->get_by_name("rpc_address"), &address);
 
       if (is_valid_address && listener_->on_is_host_up(address)) {
         const Value* v = row->get_by_name("schema_version");
@@ -95,8 +90,7 @@ bool SchemaAgreementHandler::on_set(const ChainedRequestCallback::Ptr& callback)
 void SchemaAgreementHandler::on_error(WaitForHandler::WaitForError code, const String& message) {
   switch (code) {
     case WAIT_FOR_ERROR_REQUEST_ERROR:
-      LOG_ERROR("An error occurred waiting for schema agreement: %s",
-                message.c_str());
+      LOG_ERROR("An error occurred waiting for schema agreement: %s", message.c_str());
       break;
     case WAIT_FOR_ERROR_REQUEST_TIMEOUT:
       LOG_WARN("A query timeout occurred waiting for schema agreement");
@@ -114,5 +108,3 @@ void SchemaAgreementHandler::on_error(WaitForHandler::WaitForError code, const S
       break;
   }
 }
-
-} // namespace cass
diff --git a/src/schema_agreement_handler.hpp b/src/schema_agreement_handler.hpp
index fdeb81be5..de59a18f3 100644
--- a/src/schema_agreement_handler.hpp
+++ b/src/schema_agreement_handler.hpp
@@ -14,21 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SCHEMA_CHANGE_HANDLER_HPP_INCLUDED__
-#define __CASS_SCHEMA_CHANGE_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SCHEMA_CHANGE_HANDLER_HPP
+#define DATASTAX_INTERNAL_SCHEMA_CHANGE_HANDLER_HPP
 
 #include "wait_for_handler.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A listener that used for determining if a host is up.
  */
 class SchemaAgreementListener {
 public:
-  virtual ~SchemaAgreementListener() { }
+  virtual ~SchemaAgreementListener() {}
 
   /**
    * A callback for determining if a host is up.
@@ -58,10 +58,8 @@ class SchemaAgreementHandler : public WaitForHandler {
    * @param max_wait_time_ms The maximum amount of time to wait for the data to
    * become available.
    */
-  SchemaAgreementHandler(const RequestHandler::Ptr& request_handler,
-                         const Host::Ptr& current_host,
-                         const Response::Ptr& response,
-                         SchemaAgreementListener* listener,
+  SchemaAgreementHandler(const RequestHandler::Ptr& request_handler, const Host::Ptr& current_host,
+                         const Response::Ptr& response, SchemaAgreementListener* listener,
                          uint64_t max_wait_time_ms);
 
   /**
@@ -79,6 +77,6 @@ class SchemaAgreementHandler : public WaitForHandler {
   SchemaAgreementListener* const listener_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/scoped_lock.hpp b/src/scoped_lock.hpp
index 0f68ac852..db759080c 100644
--- a/src/scoped_lock.hpp
+++ b/src/scoped_lock.hpp
@@ -14,23 +14,25 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SCOPED_LOCK_HPP_INCLUDED__
-#define __CASS_SCOPED_LOCK_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SCOPED_LOCK_HPP
+#define DATASTAX_INTERNAL_SCOPED_LOCK_HPP
 
 #include "macros.hpp"
 
-#include <uv.h>
 #include <assert.h>
+#include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 class Mutex {
 public:
   typedef uv_mutex_t Type;
-  Mutex(uv_mutex_t* m) : mutex_(m) {}
+  Mutex(uv_mutex_t* m)
+      : mutex_(m) {}
   void lock() { uv_mutex_lock(mutex_); }
   void unlock() { uv_mutex_unlock(mutex_); }
   uv_mutex_t* get() const { return mutex_; }
+
 private:
   uv_mutex_t* mutex_;
 };
@@ -38,10 +40,12 @@ class Mutex {
 class ReadLock {
 public:
   typedef uv_rwlock_t Type;
-  ReadLock(uv_rwlock_t* l) : rwlock_(l) {}
+  ReadLock(uv_rwlock_t* l)
+      : rwlock_(l) {}
   void lock() { uv_rwlock_rdlock(rwlock_); }
   void unlock() { uv_rwlock_rdunlock(rwlock_); }
   uv_rwlock_t* get() const { return rwlock_; }
+
 private:
   uv_rwlock_t* rwlock_;
 };
@@ -49,10 +53,12 @@ class ReadLock {
 class WriteLock {
 public:
   typedef uv_rwlock_t Type;
-  WriteLock(uv_rwlock_t* l) : rwlock_(l) {}
+  WriteLock(uv_rwlock_t* l)
+      : rwlock_(l) {}
   void lock() { uv_rwlock_wrlock(rwlock_); }
   void unlock() { uv_rwlock_wrunlock(rwlock_); }
   uv_rwlock_t* get() const { return rwlock_; }
+
 private:
   uv_rwlock_t* rwlock_;
 };
@@ -100,6 +106,6 @@ typedef ScopedLock<Mutex> ScopedMutex;
 typedef ScopedLock<ReadLock> ScopedReadLock;
 typedef ScopedLock<WriteLock> ScopedWriteLock;
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/scoped_ptr.hpp b/src/scoped_ptr.hpp
index cbac8d432..fc80d02ce 100644
--- a/src/scoped_ptr.hpp
+++ b/src/scoped_ptr.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SCOPED_PTR_HPP_INCLUDED__
-#define __CASS_SCOPED_PTR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SCOPED_PTR_HPP
+#define DATASTAX_INTERNAL_SCOPED_PTR_HPP
 
 #include "macros.hpp"
 #include "utils.hpp"
 
 #include <stddef.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 struct DefaultDeleter {
@@ -55,7 +55,7 @@ class ScopedPtr {
 
   type* get() const { return ptr_; }
   type& operator*() const { return *ptr_; }
-  type * operator->() const { return ptr_; }
+  type* operator->() const { return ptr_; }
   operator bool() const { return ptr_ != NULL; }
 
 private:
@@ -105,6 +105,6 @@ class ScopedArray {
   DISALLOW_COPY_AND_ASSIGN(ScopedArray);
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/serialization.hpp b/src/serialization.hpp
index e0bbcd4ec..3633bbb02 100644
--- a/src/serialization.hpp
+++ b/src/serialization.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SERIALIZATION_HPP_INCLUDED__
-#define __CASS_SERIALIZATION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SERIALIZATION_HPP
+#define DATASTAX_INTERNAL_SERIALIZATION_HPP
 
 #include "address.hpp"
 #include "cassandra.h"
@@ -30,7 +30,7 @@
 #include <limits>
 #include <string.h>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // http://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
 // This frees us from having to deal with endian stuff on every platform.
@@ -197,7 +197,7 @@ inline char* encode_uuid(char* output, CassUuid uuid) {
 }
 
 inline const char* decode_uuid(const char* input, CassUuid* output) {
-  output->time_and_version  = static_cast<uint64_t>(static_cast<uint8_t>(input[3]));
+  output->time_and_version = static_cast<uint64_t>(static_cast<uint8_t>(input[3]));
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[2])) << 8;
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[1])) << 16;
   output->time_and_version |= static_cast<uint64_t>(static_cast<uint8_t>(input[0])) << 24;
@@ -210,7 +210,8 @@ inline const char* decode_uuid(const char* input, CassUuid* output) {
 
   output->clock_seq_and_node = 0;
   for (size_t i = 0; i < 8; ++i) {
-    output->clock_seq_and_node |= static_cast<uint64_t>(static_cast<uint8_t>(input[15 - i])) << (8 * i);
+    output->clock_seq_and_node |= static_cast<uint64_t>(static_cast<uint8_t>(input[15 - i]))
+                                  << (8 * i);
   }
   return input + 16;
 }
@@ -221,10 +222,8 @@ inline int64_t decode_zig_zag(uint64_t n) {
   return (n >> 1) ^ -static_cast<int64_t>(n & 1);
 }
 
-inline uint64_t encode_zig_zag(int64_t n) {
-  return (n << 1) ^ (n >> 63);
-}
+inline uint64_t encode_zig_zag(int64_t n) { return (n << 1) ^ (n >> 63); }
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/session.cpp b/src/session.cpp
index 69d43e4bc..754752bdf 100644
--- a/src/session.cpp
+++ b/src/session.cpp
@@ -30,10 +30,13 @@
 #include "scoped_lock.hpp"
 #include "statement.hpp"
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassSession* cass_session_new() {
-  cass::Session* session = new cass::Session();
+  Session* session = new Session();
   return CassSession::to(session);
 }
 
@@ -50,27 +53,20 @@ CassFuture* cass_session_connect(CassSession* session, const CassCluster* cluste
   return cass_session_connect_keyspace(session, cluster, "");
 }
 
-CassFuture* cass_session_connect_keyspace(CassSession* session,
-                                          const CassCluster* cluster,
+CassFuture* cass_session_connect_keyspace(CassSession* session, const CassCluster* cluster,
                                           const char* keyspace) {
-  return cass_session_connect_keyspace_n(session,
-                                         cluster,
-                                         keyspace,
-                                         SAFE_STRLEN(keyspace));
-}
-
-CassFuture* cass_session_connect_keyspace_n(CassSession* session,
-                                            const CassCluster* cluster,
-                                            const char* keyspace,
-                                            size_t keyspace_length) {
-  cass::Future::Ptr future(
-        session->connect(cluster->config(), cass::String(keyspace, keyspace_length)));
+  return cass_session_connect_keyspace_n(session, cluster, keyspace, SAFE_STRLEN(keyspace));
+}
+
+CassFuture* cass_session_connect_keyspace_n(CassSession* session, const CassCluster* cluster,
+                                            const char* keyspace, size_t keyspace_length) {
+  Future::Ptr future(session->connect(cluster->config(), String(keyspace, keyspace_length)));
   future->inc_ref();
   return CassFuture::to(future.get());
 }
 
 CassFuture* cass_session_close(CassSession* session) {
-  cass::Future::Ptr future(session->close());
+  Future::Ptr future(session->close());
   future->inc_ref();
   return CassFuture::to(future.get());
 }
@@ -79,51 +75,44 @@ CassFuture* cass_session_prepare(CassSession* session, const char* query) {
   return cass_session_prepare_n(session, query, SAFE_STRLEN(query));
 }
 
-CassFuture* cass_session_prepare_n(CassSession* session,
-                                   const char* query,
-                                   size_t query_length) {
-  cass::Future::Ptr future(session->prepare(query, query_length));
+CassFuture* cass_session_prepare_n(CassSession* session, const char* query, size_t query_length) {
+  Future::Ptr future(session->prepare(query, query_length));
   future->inc_ref();
   return CassFuture::to(future.get());
 }
 
-CassFuture* cass_session_prepare_from_existing(CassSession* session,
-                                               CassStatement* statement) {
-  cass::Future::Ptr future(session->prepare(statement));
+CassFuture* cass_session_prepare_from_existing(CassSession* session, CassStatement* statement) {
+  Future::Ptr future(session->prepare(statement));
   future->inc_ref();
   return CassFuture::to(future.get());
 }
 
-CassFuture* cass_session_execute(CassSession* session,
-                                 const CassStatement* statement) {
-  cass::Future::Ptr future(session->execute(cass::Request::ConstPtr(statement->from())));
+CassFuture* cass_session_execute(CassSession* session, const CassStatement* statement) {
+  Future::Ptr future(session->execute(Request::ConstPtr(statement->from())));
   future->inc_ref();
   return CassFuture::to(future.get());
 }
 
 CassFuture* cass_session_execute_batch(CassSession* session, const CassBatch* batch) {
-  cass::Future::Ptr future(session->execute(cass::Request::ConstPtr(batch->from())));
+  Future::Ptr future(session->execute(Request::ConstPtr(batch->from())));
   future->inc_ref();
   return CassFuture::to(future.get());
 }
 
 const CassSchemaMeta* cass_session_get_schema_meta(const CassSession* session) {
-  return CassSchemaMeta::to(
-        new cass::Metadata::SchemaSnapshot(
-          session->cluster()->schema_snapshot()));
+  return CassSchemaMeta::to(new Metadata::SchemaSnapshot(session->cluster()->schema_snapshot()));
 }
 
-void cass_session_get_metrics(const CassSession* session,
-                               CassMetrics* metrics) {
-  const cass::Metrics* internal_metrics = session->metrics();
+void cass_session_get_metrics(const CassSession* session, CassMetrics* metrics) {
+  const Metrics* internal_metrics = session->metrics();
 
-  if (internal_metrics == NULL)  {
+  if (internal_metrics == NULL) {
     LOG_WARN("Attempted to get metrics before connecting session object");
     memset(metrics, 0, sizeof(CassMetrics));
     return;
   }
 
-  cass::Metrics::Histogram::Snapshot requests_snapshot;
+  Metrics::Histogram::Snapshot requests_snapshot;
   internal_metrics->request_latencies.get_snapshot(&requests_snapshot);
 
   metrics->requests.min = requests_snapshot.min;
@@ -143,25 +132,25 @@ void cass_session_get_metrics(const CassSession* session,
 
   metrics->stats.total_connections = internal_metrics->total_connections.sum();
   metrics->stats.available_connections = metrics->stats.total_connections; // Deprecated
-  metrics->stats.exceeded_write_bytes_water_mark = 0; // Deprecated
-  metrics->stats.exceeded_pending_requests_water_mark = 0; // Deprecated
+  metrics->stats.exceeded_write_bytes_water_mark = 0;                      // Deprecated
+  metrics->stats.exceeded_pending_requests_water_mark = 0;                 // Deprecated
 
   metrics->errors.connection_timeouts = internal_metrics->connection_timeouts.sum();
   metrics->errors.pending_request_timeouts = internal_metrics->pending_request_timeouts.sum();
   metrics->errors.request_timeouts = internal_metrics->request_timeouts.sum();
 }
 
-void  cass_session_get_speculative_execution_metrics(const CassSession* session,
-                                                     CassSpeculativeExecutionMetrics* metrics) {
-  const cass::Metrics* internal_metrics = session->metrics();
+void cass_session_get_speculative_execution_metrics(const CassSession* session,
+                                                    CassSpeculativeExecutionMetrics* metrics) {
+  const Metrics* internal_metrics = session->metrics();
 
-  if (internal_metrics == NULL)  {
+  if (internal_metrics == NULL) {
     LOG_WARN("Attempted to get speculative execution metrics before connecting session object");
     memset(metrics, 0, sizeof(CassSpeculativeExecutionMetrics));
     return;
   }
 
-  cass::Metrics::Histogram::Snapshot speculative_snapshot;
+  Metrics::Histogram::Snapshot speculative_snapshot;
   internal_metrics->speculative_request_latencies.get_snapshot(&speculative_snapshot);
 
   metrics->min = speculative_snapshot.min;
@@ -174,21 +163,18 @@ void  cass_session_get_speculative_execution_metrics(const CassSession* session,
   metrics->percentile_98th = speculative_snapshot.percentile_98th;
   metrics->percentile_99th = speculative_snapshot.percentile_99th;
   metrics->percentile_999th = speculative_snapshot.percentile_999th;
-  metrics->count =
-      internal_metrics->request_rates.speculative_request_count();
-  metrics->percentage =
-      internal_metrics->request_rates.speculative_request_percent();
+  metrics->count = internal_metrics->request_rates.speculative_request_count();
+  metrics->percentage = internal_metrics->request_rates.speculative_request_percent();
 }
 
 } // extern "C"
 
-namespace cass {
-
-static inline bool least_busy_comp(const RequestProcessor::Ptr& a,
-                                   const RequestProcessor::Ptr& b) {
+static inline bool least_busy_comp(const RequestProcessor::Ptr& a, const RequestProcessor::Ptr& b) {
   return a->request_count() < b->request_count();
 }
 
+namespace datastax { namespace internal { namespace core {
+
 /**
  * An initialize helper class for `Session`. This keeps the initialization
  * logic and data out of the core class itself.
@@ -198,36 +184,29 @@ class SessionInitializer : public RefCounted<SessionInitializer> {
   typedef SharedRefPtr<SessionInitializer> Ptr;
 
   SessionInitializer(Session* session)
-    : session_(session)
-    , remaining_(0)
-    , error_code_(CASS_OK) {
+      : session_(session)
+      , remaining_(0)
+      , error_code_(CASS_OK) {
     uv_mutex_init(&mutex_);
   }
 
-  SessionInitializer() {
-    uv_mutex_destroy(&mutex_);
-  }
+  SessionInitializer() { uv_mutex_destroy(&mutex_); }
 
-  void initialize(const Host::Ptr& connected_host,
-                  ProtocolVersion protocol_version,
-                  const HostMap& hosts,
-                  const TokenMap::Ptr& token_map) {
+  void initialize(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                  const HostMap& hosts, const TokenMap::Ptr& token_map) {
     inc_ref();
 
     const size_t thread_count_io = remaining_ = session_->config().thread_count_io();
     for (size_t i = 0; i < thread_count_io; ++i) {
       RequestProcessorInitializer::Ptr initializer(
-            new RequestProcessorInitializer(connected_host,
-                                            protocol_version,
-                                            hosts,
-                                            token_map,
-                                            bind_callback(&SessionInitializer::on_initialize, this)));
+          new RequestProcessorInitializer(connected_host, protocol_version, hosts, token_map,
+                                          bind_callback(&SessionInitializer::on_initialize, this)));
 
       RequestProcessorSettings settings(session_->config());
-      settings.connection_pool_settings.connection_settings.client_id = to_string(session_->client_id());
+      settings.connection_pool_settings.connection_settings.client_id =
+          to_string(session_->client_id());
 
-      initializer
-          ->with_settings(RequestProcessorSettings(settings))
+      initializer->with_settings(RequestProcessorSettings(settings))
           ->with_listener(session_)
           ->with_keyspace(session_->connect_keyspace())
           ->with_metrics(session_->metrics())
@@ -291,9 +270,11 @@ class SessionInitializer : public RefCounted<SessionInitializer> {
   RequestProcessor::Vec request_processors_;
 };
 
+}}} // namespace datastax::internal::core
+
 Session::Session()
-  : request_processor_count_(0)
-  , is_closing_(false) {
+    : request_processor_count_(0)
+    , is_closing_(false) {
   uv_mutex_init(&mutex_);
 }
 
@@ -308,8 +289,7 @@ Future::Ptr Session::prepare(const char* statement, size_t length) {
   ResponseFuture::Ptr future(new ResponseFuture(cluster()->schema_snapshot()));
   future->prepare_request = PrepareRequest::ConstPtr(prepare);
 
-  execute(RequestHandler::Ptr(
-            new RequestHandler(prepare, future, metrics())));
+  execute(RequestHandler::Ptr(new RequestHandler(prepare, future, metrics())));
 
   return future;
 }
@@ -332,8 +312,7 @@ Future::Ptr Session::prepare(const Statement* statement) {
   ResponseFuture::Ptr future(new ResponseFuture(cluster()->schema_snapshot()));
   future->prepare_request = PrepareRequest::ConstPtr(prepare);
 
-  execute(RequestHandler::Ptr(
-            new RequestHandler(prepare, future, metrics())));
+  execute(RequestHandler::Ptr(new RequestHandler(prepare, future, metrics())));
 
   return future;
 }
@@ -342,9 +321,7 @@ Future::Ptr Session::execute(const Request::ConstPtr& request, const Address* pr
   ResponseFuture::Ptr future(new ResponseFuture());
 
   RequestHandler::Ptr request_handler(
-            new RequestHandler(request, future,
-                                             metrics(), preferred_address));
-
+      new RequestHandler(request, future, metrics(), preferred_address));
 
   if (request_handler->request()->opcode() == CQL_OPCODE_EXECUTE) {
     const ExecuteRequest* execute = static_cast<const ExecuteRequest*>(request_handler->request());
@@ -358,19 +335,16 @@ Future::Ptr Session::execute(const Request::ConstPtr& request, const Address* pr
 
 void Session::execute(const RequestHandler::Ptr& request_handler) {
   if (state() != SESSION_STATE_CONNECTED) {
-    request_handler->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
-                               "Session is not connected");
+    request_handler->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, "Session is not connected");
     return;
   }
 
-
   // This intentionally doesn't lock the request processors. The processors will
   // be populated before the connect future returns and calling execute during
   // the connection process is undefined behavior. Locking would cause unnecessary
   // overhead for something that's constant once the session is connected.
-  const RequestProcessor::Ptr& request_processor
-      =  *std::min_element(request_processors_.begin(), request_processors_.end(),
-                           least_busy_comp);
+  const RequestProcessor::Ptr& request_processor =
+      *std::min_element(request_processors_.begin(), request_processors_.end(), least_busy_comp);
   request_processor->process_request(request_handler);
 }
 
@@ -382,10 +356,8 @@ void Session::join() {
   }
 }
 
-void Session::on_connect(const Host::Ptr& connected_host,
-                         ProtocolVersion protocol_version,
-                         const HostMap& hosts,
-                         const TokenMap::Ptr& token_map) {
+void Session::on_connect(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                         const HostMap& hosts, const TokenMap::Ptr& token_map) {
   int rc = 0;
 
   if (hosts.empty()) {
@@ -398,33 +370,28 @@ void Session::on_connect(const Host::Ptr& connected_host,
   event_loop_group_.reset(new RoundRobinEventLoopGroup(config().thread_count_io()));
   rc = event_loop_group_->init("Request Processor");
   if (rc != 0) {
-    notify_connect_failed(CASS_ERROR_LIB_UNABLE_TO_INIT,
-                          "Unable to initialize event loop group");
+    notify_connect_failed(CASS_ERROR_LIB_UNABLE_TO_INIT, "Unable to initialize event loop group");
     return;
   }
 
   rc = event_loop_group_->run();
   if (rc != 0) {
-    notify_connect_failed(CASS_ERROR_LIB_UNABLE_TO_INIT,
-                          "Unable to run event loop group");
+    notify_connect_failed(CASS_ERROR_LIB_UNABLE_TO_INIT, "Unable to run event loop group");
     return;
   }
 
-  for (HostMap::const_iterator it = hosts.begin(),
-       end = hosts.end(); it != end; ++it) {
+  for (HostMap::const_iterator it = hosts.begin(), end = hosts.end(); it != end; ++it) {
     const Host::Ptr& host = it->second;
     config().host_listener()->on_host_added(host);
-    config().host_listener()->on_host_up(host); // If host is down it will be marked down later in the connection process
+    config().host_listener()->on_host_up(
+        host); // If host is down it will be marked down later in the connection process
   }
 
   request_processors_.clear();
   request_processor_count_ = 0;
   is_closing_ = false;
   SessionInitializer::Ptr initializer(new SessionInitializer(this));
-  initializer->initialize(connected_host,
-                          protocol_version,
-                          hosts,
-                          token_map);
+  initializer->initialize(connected_host, protocol_version, hosts, token_map);
 }
 
 void Session::on_close() {
@@ -434,7 +401,8 @@ void Session::on_close() {
   is_closing_ = true;
   if (request_processor_count_ > 0) {
     for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-         end = request_processors_.end(); it != end; ++it) {
+                                               end = request_processors_.end();
+         it != end; ++it) {
       (*it)->close();
     }
   } else {
@@ -466,18 +434,20 @@ void Session::on_host_added(const Host::Ptr& host) {
   { // Lock for request processor
     ScopedMutex l(&mutex_);
     for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-         end = request_processors_.end(); it != end; ++it) {
+                                               end = request_processors_.end();
+         it != end; ++it) {
       (*it)->notify_host_added(host);
     }
   }
   config().host_listener()->on_host_added(host);
 }
 
-void Session::on_host_removed(const Host::Ptr& host)  {
+void Session::on_host_removed(const Host::Ptr& host) {
   { // Lock for request processor
     ScopedMutex l(&mutex_);
     for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-         end = request_processors_.end(); it != end; ++it) {
+                                               end = request_processors_.end();
+         it != end; ++it) {
       (*it)->notify_host_removed(host);
     }
   }
@@ -487,7 +457,8 @@ void Session::on_host_removed(const Host::Ptr& host)  {
 void Session::on_token_map_updated(const TokenMap::Ptr& token_map) {
   ScopedMutex l(&mutex_);
   for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-       end = request_processors_.end(); it != end; ++it) {
+                                             end = request_processors_.end();
+       it != end; ++it) {
     (*it)->notify_token_map_updated(token_map);
   }
 }
@@ -495,7 +466,8 @@ void Session::on_token_map_updated(const TokenMap::Ptr& token_map) {
 void Session::on_host_maybe_up(const Host::Ptr& host) {
   ScopedMutex l(&mutex_);
   for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-       end = request_processors_.end(); it != end; ++it) {
+                                             end = request_processors_.end();
+       it != end; ++it) {
     (*it)->notify_host_maybe_up(host->address());
   }
 }
@@ -503,21 +475,17 @@ void Session::on_host_maybe_up(const Host::Ptr& host) {
 void Session::on_host_ready(const Host::Ptr& host) {
   ScopedMutex l(&mutex_);
   for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-       end = request_processors_.end(); it != end; ++it) {
+                                             end = request_processors_.end();
+       it != end; ++it) {
     (*it)->notify_host_ready(host);
   }
 }
 
-void Session::on_pool_up(const Address& address) {
-  cluster()->notify_host_up(address);
-}
+void Session::on_pool_up(const Address& address) { cluster()->notify_host_up(address); }
 
-void Session::on_pool_down(const Address& address) {
-  cluster()->notify_host_down(address);
-}
+void Session::on_pool_down(const Address& address) { cluster()->notify_host_down(address); }
 
-void Session::on_pool_critical_error(const Address& address,
-                                     Connector::ConnectionError code,
+void Session::on_pool_critical_error(const Address& address, Connector::ConnectionError code,
                                      const String& message) {
   cluster()->notify_host_down(address);
 }
@@ -526,7 +494,8 @@ void Session::on_keyspace_changed(const String& keyspace,
                                   const KeyspaceChangedHandler::Ptr& handler) {
   ScopedMutex l(&mutex_);
   for (RequestProcessor::Vec::const_iterator it = request_processors_.begin(),
-       end = request_processors_.end(); it != end; ++it) {
+                                             end = request_processors_.end();
+       it != end; ++it) {
     (*it)->set_keyspace(keyspace, handler);
   }
 }
@@ -544,5 +513,3 @@ void Session::on_close(RequestProcessor* processor) {
     notify_closed();
   }
 }
-
-} // namespace cass
diff --git a/src/session.hpp b/src/session.hpp
index 504785715..0d8b0f0ff 100644
--- a/src/session.hpp
+++ b/src/session.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SESSION_HPP_INCLUDED__
-#define __CASS_SESSION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SESSION_HPP
+#define DATASTAX_INTERNAL_SESSION_HPP
 
 #include "allocated.hpp"
 #include "metrics.hpp"
@@ -25,7 +25,7 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RequestProcessorInitializer;
 class Statement;
@@ -42,8 +42,7 @@ class Session
 
   Future::Ptr prepare(const Statement* statement);
 
-  Future::Ptr execute(const Request::ConstPtr& request,
-                      const Address* preferred_address = NULL);
+  Future::Ptr execute(const Request::ConstPtr& request, const Address* preferred_address = NULL);
 
 private:
   void execute(const RequestHandler::Ptr& request_handler);
@@ -53,10 +52,8 @@ class Session
 private:
   // Session base methods
 
-  virtual void on_connect(const Host::Ptr& connected_host,
-                          ProtocolVersion protocol_version,
-                          const HostMap& hosts,
-                          const TokenMap::Ptr& token_map);
+  virtual void on_connect(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                          const HostMap& hosts, const TokenMap::Ptr& token_map);
 
   virtual void on_close();
 
@@ -86,15 +83,14 @@ class Session
 
   virtual void on_pool_down(const Address& address);
 
-  virtual void on_pool_critical_error(const Address& address,
-                                      Connector::ConnectionError code,
+  virtual void on_pool_critical_error(const Address& address, Connector::ConnectionError code,
                                       const String& message);
 
   virtual void on_keyspace_changed(const String& keyspace,
                                    const KeyspaceChangedHandler::Ptr& handler);
 
   virtual void on_prepared_metadata_changed(const String& id,
-                                           const PreparedMetadata::Entry::Ptr& entry);
+                                            const PreparedMetadata::Entry::Ptr& entry);
 
   virtual void on_close(RequestProcessor* processor);
 
@@ -111,8 +107,8 @@ class Session
   bool is_closing_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Session, CassSession)
+EXTERNAL_TYPE(datastax::internal::core::Session, CassSession)
 
 #endif
diff --git a/src/session_base.cpp b/src/session_base.cpp
index 2a0ecefde..e37140eb5 100644
--- a/src/session_base.cpp
+++ b/src/session_base.cpp
@@ -24,18 +24,20 @@
 #include "utils.hpp"
 #include "uuids.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 class SessionFuture : public Future {
 public:
   typedef SharedRefPtr<SessionFuture> Ptr;
 
   SessionFuture()
-    : Future(FUTURE_TYPE_SESSION) { }
+      : Future(FUTURE_TYPE_SESSION) {}
 };
 
 SessionBase::SessionBase()
-  : state_(SESSION_STATE_CLOSED) {
+    : state_(SESSION_STATE_CLOSED) {
   uv_mutex_init(&mutex_);
 
   UuidGen generator;
@@ -51,9 +53,8 @@ SessionBase::~SessionBase() {
   uv_mutex_destroy(&mutex_);
 }
 
-Future::Ptr SessionBase::connect(const Config& config,
-                                 const String& keyspace) {
-  cass::Future::Ptr future(new SessionFuture());
+Future::Ptr SessionBase::connect(const Config& config, const String& keyspace) {
+  Future::Ptr future(new SessionFuture());
 
   ScopedMutex l(&mutex_);
   if (state_ != SESSION_STATE_CLOSED) {
@@ -68,15 +69,13 @@ Future::Ptr SessionBase::connect(const Config& config,
 
     rc = event_loop_->init("Session/Control Connection");
     if (rc != 0) {
-      future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT,
-                        "Unable to initialize cluster event loop");
+      future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT, "Unable to initialize cluster event loop");
       return future;
     }
 
     rc = event_loop_->run();
     if (rc != 0) {
-      future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT,
-                        "Unable to run cluster event loop");
+      future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT, "Unable to run cluster event loop");
       return future;
     }
   }
@@ -102,16 +101,14 @@ Future::Ptr SessionBase::connect(const Config& config,
 
   cluster_.reset();
   ClusterConnector::Ptr connector(
-        new ClusterConnector(config_.contact_points(),
-                             config_.protocol_version(),
-                             bind_callback(&SessionBase::on_initialize, this)));
+      new ClusterConnector(config_.contact_points(), config_.protocol_version(),
+                           bind_callback(&SessionBase::on_initialize, this)));
 
   ClusterSettings settings(config_);
   settings.control_connection_settings.connection_settings.client_id = to_string(client_id_);
   settings.disable_events_on_startup = true;
 
-  connector
-      ->with_listener(this)
+  connector->with_listener(this)
       ->with_settings(settings)
       ->with_random(random_.get())
       ->with_metrics(metrics_.get())
@@ -121,13 +118,11 @@ Future::Ptr SessionBase::connect(const Config& config,
 }
 
 Future::Ptr SessionBase::close() {
-  cass::Future::Ptr future(new SessionFuture());
+  Future::Ptr future(new SessionFuture());
 
   ScopedMutex l(&mutex_);
-  if (state_ == SESSION_STATE_CLOSED ||
-      state_ == SESSION_STATE_CLOSING) {
-    future->set_error(CASS_ERROR_LIB_UNABLE_TO_CLOSE,
-                      "Already closing or closed");
+  if (state_ == SESSION_STATE_CLOSED || state_ == SESSION_STATE_CLOSING) {
+    future->set_error(CASS_ERROR_LIB_UNABLE_TO_CLOSE, "Already closing or closed");
     return future;
   }
   state_ = SESSION_STATE_CLOSING;
@@ -163,10 +158,8 @@ void SessionBase::notify_closed() {
   if (cluster_) cluster_->close();
 }
 
-void SessionBase::on_connect(const Host::Ptr& connected_host,
-                             ProtocolVersion protocol_version,
-                             const HostMap& hosts,
-                             const TokenMap::Ptr& token_map) {
+void SessionBase::on_connect(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                             const HostMap& hosts, const TokenMap::Ptr& token_map) {
   notify_connected();
 }
 
@@ -174,9 +167,7 @@ void SessionBase::on_connect_failed(CassError code, const String& message) {
   notify_connect_failed(code, message);
 }
 
-void SessionBase::on_close() {
-  notify_closed();
-}
+void SessionBase::on_close() { notify_closed(); }
 
 void SessionBase::on_close(Cluster* cluster) {
   ScopedMutex l(&mutex_);
@@ -194,36 +185,27 @@ void SessionBase::on_close(Cluster* cluster) {
 void SessionBase::on_initialize(ClusterConnector* connector) {
   if (connector->is_ok()) {
     cluster_ = connector->release_cluster();
-    on_connect(cluster_->connected_host(),
-               cluster_->protocol_version(),
-               cluster_->available_hosts(),
-               cluster_->token_map());
+    on_connect(cluster_->connected_host(), cluster_->protocol_version(),
+               cluster_->available_hosts(), cluster_->token_map());
   } else {
     assert(!connector->is_canceled() && "Cluster connection process canceled");
     switch (connector->error_code()) {
       case ClusterConnector::CLUSTER_ERROR_INVALID_PROTOCOL:
-        on_connect_failed(CASS_ERROR_LIB_UNABLE_TO_DETERMINE_PROTOCOL,
-                          connector->error_message());
+        on_connect_failed(CASS_ERROR_LIB_UNABLE_TO_DETERMINE_PROTOCOL, connector->error_message());
         break;
       case ClusterConnector::CLUSTER_ERROR_SSL_ERROR:
-        on_connect_failed(connector->ssl_error_code(),
-                          connector->error_message());
+        on_connect_failed(connector->ssl_error_code(), connector->error_message());
         break;
       case ClusterConnector::CLUSTER_ERROR_AUTH_ERROR:
-        on_connect_failed(CASS_ERROR_SERVER_BAD_CREDENTIALS,
-                          connector->error_message());
+        on_connect_failed(CASS_ERROR_SERVER_BAD_CREDENTIALS, connector->error_message());
         break;
       case ClusterConnector::CLUSTER_ERROR_NO_HOSTS_AVAILABLE:
-        on_connect_failed(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
-                          connector->error_message());
+        on_connect_failed(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE, connector->error_message());
         break;
       default:
         // This shouldn't happen, but let's handle it
-        on_connect_failed(CASS_ERROR_LIB_UNABLE_TO_CONNECT,
-                          connector->error_message());
+        on_connect_failed(CASS_ERROR_LIB_UNABLE_TO_CONNECT, connector->error_message());
         break;
     }
   }
 }
-
-} // namespace cass
diff --git a/src/session_base.hpp b/src/session_base.hpp
index ffbe6384f..ec3805c24 100644
--- a/src/session_base.hpp
+++ b/src/session_base.hpp
@@ -14,19 +14,22 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SESSION_BASE_HPP_INCLUDED__
-#define __CASS_SESSION_BASE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SESSION_BASE_HPP
+#define DATASTAX_INTERNAL_SESSION_BASE_HPP
 
 #include "cluster_connector.hpp"
 #include "prepared.hpp"
 #include "schema_agreement_handler.hpp"
 #include "token_map.hpp"
 
-namespace cass {
+namespace datastax { namespace internal {
 
-class ClusterConfig;
 class Random;
 
+namespace core {
+
+class ClusterConfig;
+
 /**
  * A base class for implementing a session. It manages the state machine for
  * connecting and closing a session.
@@ -57,8 +60,7 @@ class SessionBase : public ClusterListener {
    * keyspace should be used.
    * @return A future object for monitoring the connection progress.
    */
-  Future::Ptr connect(const Config& config,
-                      const String& keyspace = "");
+  Future::Ptr connect(const Config& config, const String& keyspace = "");
 
   /**
    * Close the session. There are not any failure conditions for closing a
@@ -111,10 +113,8 @@ class SessionBase : public ClusterListener {
    * @param hosts The current hosts in the cluster.
    * @param token_map The token map for the cluster.
    */
-  virtual void on_connect(const Host::Ptr& connected_host,
-                          ProtocolVersion protocol_version,
-                          const HostMap& hosts,
-                          const TokenMap::Ptr& token_map);
+  virtual void on_connect(const Host::Ptr& connected_host, ProtocolVersion protocol_version,
+                          const HostMap& hosts, const TokenMap::Ptr& token_map);
 
   /**
    * A callback called after the control connection fails to connect. By default
@@ -125,8 +125,7 @@ class SessionBase : public ClusterListener {
    * @param code The error code for the connection failure.
    * @param message The error message for the connection failure.
    */
-  virtual void on_connect_failed(CassError code,
-                                 const String& message);
+  virtual void on_connect_failed(CassError code, const String& message);
 
   /**
    * A callback called at the start of the close process. By default this closes
@@ -162,6 +161,7 @@ class SessionBase : public ClusterListener {
   CassUuid session_id_;
 };
 
-} // namespace cass
+} // namespace core
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/set.hpp b/src/set.hpp
index fb2876497..baad44f88 100644
--- a/src/set.hpp
+++ b/src/set.hpp
@@ -5,37 +5,35 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_SET_HPP_INCLUDED__
-#define __DSE_SET_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SET_HPP
+#define DATASTAX_INTERNAL_SET_HPP
 
 #include "allocated.hpp"
 #include "allocator.hpp"
 
 #include <set>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T, class Compare = std::less<T> >
 class Set
     : public Allocated
-    , public std::set<T, Compare, cass::Allocator<T> > {
+    , public std::set<T, Compare, internal::Allocator<T> > {
 public:
-  typedef cass::Allocator<T> Allocator;
+  typedef internal::Allocator<T> Allocator;
 
-  explicit Set(const Compare& compare = Compare(),
-               const Allocator& alloc = Allocator())
-    : std::set<T, Compare, Allocator>(compare, alloc) { }
+  explicit Set(const Compare& compare = Compare(), const Allocator& alloc = Allocator())
+      : std::set<T, Compare, Allocator>(compare, alloc) {}
 
   Set(const Set& other)
-    : std::set<T, Compare, Allocator>(other) { }
+      : std::set<T, Compare, Allocator>(other) {}
 
-  template<class InputIt>
-  Set(InputIt first, InputIt last,
-      const Compare& compare = Compare(),
+  template <class InputIt>
+  Set(InputIt first, InputIt last, const Compare& compare = Compare(),
       const Allocator& alloc = Allocator())
-    : std::set<T, Compare, Allocator>(first, last, compare, alloc) { }
+      : std::set<T, Compare, Allocator>(first, last, compare, alloc) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/small_dense_hash_map.hpp b/src/small_dense_hash_map.hpp
index d7263ca73..7834f1508 100644
--- a/src/small_dense_hash_map.hpp
+++ b/src/small_dense_hash_map.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SMALL_DENSE_HASH_MAP_HPP_INCLUDED__
-#define __CASS_SMALL_DENSE_HASH_MAP_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SMALL_DENSE_HASH_MAP_HPP
+#define DATASTAX_INTERNAL_SMALL_DENSE_HASH_MAP_HPP
 
 #include "fixed_allocator.hpp"
 #include "macros.hpp"
@@ -29,32 +29,30 @@
 
 #define MIN_BUCKETS(N) STATIC_NEXT_POW_2((((N * 100) / OCCUPANCY_PCT) + 1))
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 // This hash map uses a fixed buffer as long as it doesn't exceed N items.
 // This can help to avoid heap allocation in cases where the hash map remains
 // small and doesn't excceed the fixed buffer.
 
-template <class K, class V,
-          size_t N,
-          class HashFcn = SPARSEHASH_HASH<K>,
+template <class K, class V, size_t N, class HashFcn = SPARSEHASH_HASH<K>,
           class EqualKey = std::equal_to<K> >
 class SmallDenseHashMap
-    : public sparsehash::dense_hash_map<
-      K, V,  HashFcn, EqualKey,
-      FixedAllocator<std::pair<const K, V>, MIN_BUCKETS(N)> > {
+    : public sparsehash::dense_hash_map<K, V, HashFcn, EqualKey,
+                                        FixedAllocator<std::pair<const K, V>, MIN_BUCKETS(N)> > {
 public:
   typedef std::pair<const K, V> Pair;
   typedef FixedAllocator<std::pair<const K, V>, MIN_BUCKETS(N)> Allocator;
   typedef sparsehash::dense_hash_map<K, V, HashFcn, EqualKey, Allocator> HashMap;
 
   SmallDenseHashMap()
-    : HashMap(N, typename HashMap::hasher(), typename HashMap::key_equal(), Allocator(&fixed_)) {
+      : HashMap(N, typename HashMap::hasher(), typename HashMap::key_equal(), Allocator(&fixed_)) {
     assert(MIN_BUCKETS(N) >= this->bucket_count());
   }
 
   SmallDenseHashMap(size_t expected_max_items_in_table)
-    : HashMap(expected_max_items_in_table, HashMap::hasher(), HashMap::key_equal(), Allocator(&fixed_)) {
+      : HashMap(expected_max_items_in_table, HashMap::hasher(), HashMap::key_equal(),
+                Allocator(&fixed_)) {
     assert(MIN_BUCKETS(N) >= this->bucket_count());
   }
 
@@ -67,6 +65,6 @@ class SmallDenseHashMap
   DISALLOW_COPY_AND_ASSIGN(SmallDenseHashMap);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/small_vector.hpp b/src/small_vector.hpp
index a39b564b5..4fb6f36a8 100644
--- a/src/small_vector.hpp
+++ b/src/small_vector.hpp
@@ -14,29 +14,29 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SMALL_VECTOR_HPP_INCLUDED__
-#define __CASS_SMALL_VECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SMALL_VECTOR_HPP
+#define DATASTAX_INTERNAL_SMALL_VECTOR_HPP
 
 #include "fixed_allocator.hpp"
 
 #include <vector>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 // This vector uses a fixed buffer as long as it doesn't exceed N items.
 // This can help to avoid heap allocation in cases where the vector remains
 // small and doesn't excceed the fixed buffer.
 
-template<class T, size_t N>
+template <class T, size_t N>
 class SmallVector : public std::vector<T, FixedAllocator<T, N> > {
 public:
   SmallVector()
-    : std::vector<T, FixedAllocator<T, N> >(FixedAllocator<T, N>(&fixed_)) {
+      : std::vector<T, FixedAllocator<T, N> >(FixedAllocator<T, N>(&fixed_)) {
     this->reserve(N);
   }
 
   SmallVector(size_t inital_size)
-    : std::vector<T, FixedAllocator<T, N> >(FixedAllocator<T, N>(&fixed_)) {
+      : std::vector<T, FixedAllocator<T, N> >(FixedAllocator<T, N>(&fixed_)) {
     this->resize(inital_size);
   }
 
@@ -49,6 +49,6 @@ class SmallVector : public std::vector<T, FixedAllocator<T, N> > {
   DISALLOW_COPY_AND_ASSIGN(SmallVector);
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/socket.cpp b/src/socket.cpp
index 230da4ec0..fe4f54eaa 100644
--- a/src/socket.cpp
+++ b/src/socket.cpp
@@ -25,7 +25,8 @@
 #define MAX_BUFFER_REUSE_NO 8
 #define BUFFER_REUSE_SIZE 64 * 1024
 
-namespace cass {
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 typedef Vector<uv_buf_t> UvBufVec;
 
@@ -35,7 +36,7 @@ typedef Vector<uv_buf_t> UvBufVec;
 class SocketWrite : public SocketWriteBase {
 public:
   SocketWrite(Socket* socket)
-    : SocketWriteBase(socket) { }
+      : SocketWriteBase(socket) {}
 
   size_t flush();
 };
@@ -47,8 +48,7 @@ size_t SocketWrite::flush() {
 
     bufs.reserve(buffers_.size());
 
-    for (BufferVec::const_iterator it = buffers_.begin(),
-         end = buffers_.end(); it != end; ++it) {
+    for (BufferVec::const_iterator it = buffers_.begin(), end = buffers_.end(); it != end; ++it) {
       total += it->size();
       bufs.push_back(uv_buf_init(const_cast<char*>(it->data()), it->size()));
     }
@@ -78,7 +78,8 @@ void SocketHandler::alloc_buffer(size_t suggested_size, uv_buf_t* buf) {
       *buf = buffer_reuse_list_.top();
       buffer_reuse_list_.pop();
     } else {
-      *buf = uv_buf_init(reinterpret_cast<char*>(Memory::malloc(BUFFER_REUSE_SIZE)), BUFFER_REUSE_SIZE);
+      *buf = uv_buf_init(reinterpret_cast<char*>(Memory::malloc(BUFFER_REUSE_SIZE)),
+                         BUFFER_REUSE_SIZE);
     }
   } else {
     *buf = uv_buf_init(reinterpret_cast<char*>(Memory::malloc(suggested_size)), suggested_size);
@@ -99,9 +100,9 @@ void SocketHandler::free_buffer(const uv_buf_t* buf) {
 class SslSocketWrite : public SocketWriteBase {
 public:
   SslSocketWrite(Socket* socket, SslSession* ssl_session)
-    : SocketWriteBase(socket)
-    , ssl_session_(ssl_session)
-    , encrypted_size_(0) {}
+      : SocketWriteBase(socket)
+      , ssl_session_(ssl_session)
+      , encrypted_size_(0) {}
 
   virtual size_t flush();
 
@@ -142,8 +143,7 @@ void SslSocketWrite::encrypt() {
   size_t offset = 0;
   size_t total = 0;
 
-  BufferVec::const_iterator it = buffers_.begin(),
-      end = buffers_.end();
+  BufferVec::const_iterator it = buffers_.begin(), end = buffers_.end();
 
   LOG_TRACE("Copying %u bufs", static_cast<unsigned int>(buffers_.size()));
 
@@ -208,24 +208,20 @@ void SslSocketHandler::on_read(Socket* socket, ssize_t nread, const uv_buf_t* bu
 
   ssl_session_->incoming().commit(nread);
   char decrypted[SSL_READ_SIZE];
-  int rc =  0;
+  int rc = 0;
   while ((rc = ssl_session_->decrypt(decrypted, sizeof(decrypted))) > 0) {
     on_ssl_read(socket, decrypted, rc);
   }
   if (rc <= 0 && ssl_session_->has_error()) {
-    LOG_ERROR("Unable to decrypt data: %s",
-              ssl_session_->error_message().c_str());
+    LOG_ERROR("Unable to decrypt data: %s", ssl_session_->error_message().c_str());
     socket->defunct();
   }
 }
 
-uv_tcp_t* SocketWriteBase::tcp() {
-  return &socket_->tcp_;
-}
+uv_tcp_t* SocketWriteBase::tcp() { return &socket_->tcp_; }
 
 void SocketWriteBase::on_close() {
-  for (RequestVec::iterator i = requests_.begin(), end = requests_.end();
-       i != end; ++i) {
+  for (RequestVec::iterator i = requests_.begin(), end = requests_.end(); i != end; ++i) {
     (*i)->on_close();
   }
 }
@@ -259,8 +255,7 @@ void SocketWriteBase::handle_write(uv_write_t* req, int status) {
   }
 
   if (socket->handler_) {
-    for (RequestVec::iterator i = requests_.begin(),
-         end = requests_.end(); i != end; ++i) {
+    for (RequestVec::iterator i = requests_.begin(), end = requests_.end(); i != end; ++i) {
       socket->handler_->on_write(socket, status, *i);
     }
   }
@@ -278,31 +273,28 @@ void SocketWriteBase::handle_write(uv_write_t* req, int status) {
 }
 
 Socket::Socket(const Address& address, size_t max_reusable_write_objects)
-  : is_defunct_(false)
-  , max_reusable_write_objects_(max_reusable_write_objects)
-  , address_(address)
-  , address_string_(address.to_string()) {
+    : is_defunct_(false)
+    , max_reusable_write_objects_(max_reusable_write_objects)
+    , address_(address)
+    , address_string_(address.to_string()) {
   tcp_.data = this;
 }
 
-Socket::~Socket() {
-  cleanup_free_writes();
-}
+Socket::~Socket() { cleanup_free_writes(); }
 
 void Socket::set_handler(SocketHandlerBase* handler) {
   handler_.reset(handler);
   cleanup_free_writes();
   free_writes_.clear();
   if (handler_) {
-    uv_read_start(reinterpret_cast<uv_stream_t*>(&tcp_),
-                  Socket::alloc_buffer, Socket::on_read);
+    uv_read_start(reinterpret_cast<uv_stream_t*>(&tcp_), Socket::alloc_buffer, Socket::on_read);
   } else {
     uv_read_stop(reinterpret_cast<uv_stream_t*>(&tcp_));
   }
 }
 
 int32_t Socket::write(SocketRequest* request) {
-  if (!handler_)  {
+  if (!handler_) {
     return SocketRequest::SOCKET_REQUEST_ERROR_NO_HANDLER;
   }
 
@@ -322,7 +314,7 @@ int32_t Socket::write(SocketRequest* request) {
   return pending_writes_.back()->write(request);
 }
 
-int32_t Socket::write_and_flush(SocketRequest *request) {
+int32_t Socket::write_and_flush(SocketRequest* request) {
   int32_t result = write(request);
   if (result > 0) {
     flush();
@@ -378,9 +370,7 @@ void Socket::on_close(uv_handle_t* handle) {
 }
 
 void Socket::handle_close() {
-  LOG_DEBUG("Socket(%p) to host %s closed",
-            static_cast<void*>(this),
-            address_string().c_str());
+  LOG_DEBUG("Socket(%p) to host %s closed", static_cast<void*>(this), address_string().c_str());
 
   while (!pending_writes_.is_empty()) {
     SocketWriteBase* pending_write = pending_writes_.pop_front();
@@ -395,10 +385,7 @@ void Socket::handle_close() {
 }
 
 void Socket::cleanup_free_writes() {
-  for (SocketWriteVec::iterator i = free_writes_.begin(),
-       end = free_writes_.end(); i != end; ++i) {
+  for (SocketWriteVec::iterator i = free_writes_.begin(), end = free_writes_.end(); i != end; ++i) {
     delete *i;
   }
 }
-
-} // namespace cass
diff --git a/src/socket.hpp b/src/socket.hpp
index c53ebc448..3b845a4c3 100644
--- a/src/socket.hpp
+++ b/src/socket.hpp
@@ -14,24 +14,24 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SOCKET_HPP_INCLUDED__
-#define __CASS_SOCKET_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SOCKET_HPP
+#define DATASTAX_INTERNAL_SOCKET_HPP
 
 #include "allocated.hpp"
 #include "buffer.hpp"
 #include "constants.hpp"
-#include "tcp_connector.hpp"
 #include "list.hpp"
-#include "stack.hpp"
 #include "scoped_ptr.hpp"
 #include "ssl.hpp"
+#include "stack.hpp"
+#include "tcp_connector.hpp"
 #include "timer.hpp"
 
 #include <uv.h>
 
 #define MIN_BUFFERS_SIZE 128
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Socket;
 class SocketWriteBase;
@@ -44,7 +44,7 @@ class SocketRequest
     : public Allocated
     , public List<SocketRequest>::Node {
 public:
-  virtual ~SocketRequest() { }
+  virtual ~SocketRequest() {}
 
   enum {
     SOCKET_REQUEST_ERROR_CLOSED = CASS_INT32_MIN,
@@ -77,14 +77,14 @@ class BufferSocketRequest : public SocketRequest {
    * @param buf A buffer to append to buffers
    */
   BufferSocketRequest(const Buffer& buf)
-    : buf_(buf) { }
+      : buf_(buf) {}
 
   virtual int32_t encode(BufferVec* bufs) {
     bufs->push_back(buf_);
     return buf_.size();
   }
 
-  virtual void on_close() { }
+  virtual void on_close() {}
 
 private:
   Buffer buf_;
@@ -98,7 +98,7 @@ class BufferSocketRequest : public SocketRequest {
  */
 class SocketHandlerBase : public Allocated {
 public:
-  virtual ~SocketHandlerBase() { }
+  virtual ~SocketHandlerBase() {}
 
   /**
    * Allocate a write request.
@@ -171,7 +171,7 @@ class SslSocketHandler : public SocketHandlerBase {
    * @param ssl_session A SSL session used to encrypt/decrypt data.
    */
   SslSocketHandler(SslSession* ssl_session)
-    : ssl_session_(ssl_session) { }
+      : ssl_session_(ssl_session) {}
 
   virtual SocketWriteBase* new_pending_write(Socket* socket);
   virtual void alloc_buffer(size_t suggested_size, uv_buf_t* buf);
@@ -199,7 +199,7 @@ class SocketWriteBase
     : public Allocated
     , public List<SocketWriteBase>::Node {
 public:
-  typedef cass::List<SocketWriteBase> List;
+  typedef internal::List<SocketWriteBase> List;
 
   /**
    * Constructor
@@ -207,13 +207,13 @@ class SocketWriteBase
    * @param The socket handling the write.
    */
   SocketWriteBase(Socket* socket)
-    : socket_(socket)
-    , is_flushed_(false) {
+      : socket_(socket)
+      , is_flushed_(false) {
     req_.data = this;
     buffers_.reserve(MIN_BUFFERS_SIZE);
   }
 
-  virtual ~SocketWriteBase() { }
+  virtual ~SocketWriteBase() {}
 
   uv_tcp_t* tcp();
 
@@ -313,7 +313,7 @@ class Socket : public RefCounted<Socket> {
    * @param request The request to write to the socket.
    * @return The number of bytes written by the request to the socket.
    */
-  int32_t write_and_flush(SocketRequest *request);
+  int32_t write_and_flush(SocketRequest* request);
 
   /**
    * Flush all outstanding requests.
@@ -379,6 +379,6 @@ class Socket : public RefCounted<Socket> {
   String address_string_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/socket_connector.cpp b/src/socket_connector.cpp
index edb696d8d..9e44f6ad4 100644
--- a/src/socket_connector.cpp
+++ b/src/socket_connector.cpp
@@ -21,7 +21,10 @@
 
 #define SSL_HANDSHAKE_MAX_BUFFER_SIZE (16 * 1024 + 5)
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A socket handler that handles the SSL handshake process.
@@ -29,7 +32,7 @@ namespace cass {
 class SslHandshakeHandler : public SocketHandler {
 public:
   SslHandshakeHandler(SocketConnector* connector)
-    : connector_(connector) { }
+      : connector_(connector) {}
 
   virtual void alloc_buffer(size_t suggested_size, uv_buf_t* buf) {
     buf->base = connector_->ssl_session_->incoming().peek_writable(&suggested_size);
@@ -62,29 +65,31 @@ class SslHandshakeHandler : public SocketHandler {
   SocketConnector* connector_;
 };
 
+}}} // namespace datastax::internal::core
+
 SocketSettings::SocketSettings()
-  : hostname_resolution_enabled(CASS_DEFAULT_HOSTNAME_RESOLUTION_ENABLED)
-  , resolve_timeout_ms(CASS_DEFAULT_RESOLVE_TIMEOUT_MS)
-  , tcp_nodelay_enabled(CASS_DEFAULT_TCP_NO_DELAY_ENABLED)
-  , tcp_keepalive_enabled(CASS_DEFAULT_TCP_KEEPALIVE_ENABLED)
-  , tcp_keepalive_delay_secs(CASS_DEFAULT_TCP_KEEPALIVE_DELAY_SECS)
-  , max_reusable_write_objects(CASS_DEFAULT_MAX_REUSABLE_WRITE_OBJECTS) { }
+    : hostname_resolution_enabled(CASS_DEFAULT_HOSTNAME_RESOLUTION_ENABLED)
+    , resolve_timeout_ms(CASS_DEFAULT_RESOLVE_TIMEOUT_MS)
+    , tcp_nodelay_enabled(CASS_DEFAULT_TCP_NO_DELAY_ENABLED)
+    , tcp_keepalive_enabled(CASS_DEFAULT_TCP_KEEPALIVE_ENABLED)
+    , tcp_keepalive_delay_secs(CASS_DEFAULT_TCP_KEEPALIVE_DELAY_SECS)
+    , max_reusable_write_objects(CASS_DEFAULT_MAX_REUSABLE_WRITE_OBJECTS) {}
 
 SocketSettings::SocketSettings(const Config& config)
-  : hostname_resolution_enabled(config.use_hostname_resolution())
-  , resolve_timeout_ms(config.resolve_timeout_ms())
-  , ssl_context(config.ssl_context())
-  , tcp_nodelay_enabled(config.tcp_nodelay_enable())
-  , tcp_keepalive_enabled(config.tcp_keepalive_enable())
-  , tcp_keepalive_delay_secs(config.tcp_keepalive_delay_secs())
-  , max_reusable_write_objects(config.max_reusable_write_objects())
-  , local_address(config.local_address()) { }
+    : hostname_resolution_enabled(config.use_hostname_resolution())
+    , resolve_timeout_ms(config.resolve_timeout_ms())
+    , ssl_context(config.ssl_context())
+    , tcp_nodelay_enabled(config.tcp_nodelay_enable())
+    , tcp_keepalive_enabled(config.tcp_keepalive_enable())
+    , tcp_keepalive_delay_secs(config.tcp_keepalive_delay_secs())
+    , max_reusable_write_objects(config.max_reusable_write_objects())
+    , local_address(config.local_address()) {}
 
 SocketConnector::SocketConnector(const Address& address, const Callback& callback)
-  : address_(address)
-  , callback_(callback)
-  , error_code_(SOCKET_OK)
-  , ssl_error_code_(CASS_OK) { }
+    : address_(address)
+    , callback_(callback)
+    , error_code_(SOCKET_OK)
+    , ssl_error_code_(CASS_OK) {}
 
 SocketConnector* SocketConnector::with_settings(const SocketSettings& settings) {
   settings_ = settings;
@@ -96,9 +101,7 @@ void SocketConnector::connect(uv_loop_t* loop) {
 
   if (settings_.hostname_resolution_enabled) {
     // Run hostname resolution then connect.
-    resolver_.reset(
-          new NameResolver(address_,
-                           bind_callback(&SocketConnector::on_resolve, this)));
+    resolver_.reset(new NameResolver(address_, bind_callback(&SocketConnector::on_resolve, this)));
     resolver_->resolve(loop, settings_.resolve_timeout_ms);
   } else {
     // Postpone the connection process until after this method ends because it
@@ -124,9 +127,7 @@ Socket::Ptr SocketConnector::release_socket() {
 }
 
 void SocketConnector::internal_connect(uv_loop_t* loop) {
-  Socket::Ptr socket(
-        new Socket(address_,
-                   settings_.max_reusable_write_objects));
+  Socket::Ptr socket(new Socket(address_, settings_.max_reusable_write_objects));
 
   if (uv_tcp_init(loop, socket->handle()) != 0) {
     on_error(SOCKET_ERROR_INIT, "Unable to initialize TCP object");
@@ -141,20 +142,17 @@ void SocketConnector::internal_connect(uv_loop_t* loop) {
   if (local_address.is_valid()) {
     int rc = uv_tcp_bind(socket->handle(), local_address.addr(), 0);
     if (rc != 0) {
-      on_error(SOCKET_ERROR_BIND,
-               "Unable to bind local address: " + String(uv_strerror(rc)));
+      on_error(SOCKET_ERROR_BIND, "Unable to bind local address: " + String(uv_strerror(rc)));
 
       return;
     }
   }
 
-  if (uv_tcp_nodelay(socket_->handle(),
-                     settings_.tcp_nodelay_enabled ? 1 : 0) != 0) {
+  if (uv_tcp_nodelay(socket_->handle(), settings_.tcp_nodelay_enabled ? 1 : 0) != 0) {
     LOG_WARN("Unable to set tcp nodelay");
   }
 
-  if (uv_tcp_keepalive(socket_->handle(),
-                       settings_.tcp_keepalive_enabled ? 1 : 0,
+  if (uv_tcp_keepalive(socket_->handle(), settings_.tcp_keepalive_enabled ? 1 : 0,
                        settings_.tcp_keepalive_delay_secs) != 0) {
     LOG_WARN("Unable to set tcp keepalive");
   }
@@ -164,8 +162,7 @@ void SocketConnector::internal_connect(uv_loop_t* loop) {
   }
 
   connector_.reset(new TcpConnector(address_));
-  connector_->connect(socket_->handle(),
-                      bind_callback(&SocketConnector::on_connect, this));
+  connector_->connect(socket_->handle(), bind_callback(&SocketConnector::on_connect, this));
 }
 
 void SocketConnector::ssl_handshake() {
@@ -212,8 +209,7 @@ void SocketConnector::on_error(SocketError code, const String& message) {
   assert(code != SOCKET_OK && "Notified error without an error");
   if (error_code_ == SOCKET_OK) { // Only call this once
     LOG_DEBUG("Lost connection to host %s with the following error: %s",
-              address_.to_string().c_str(),
-              message.c_str());
+              address_.to_string().c_str(), message.c_str());
     error_message_ = message;
     error_code_ = code;
     if (is_ssl_error()) {
@@ -226,8 +222,7 @@ void SocketConnector::on_error(SocketError code, const String& message) {
 
 void SocketConnector::on_connect(TcpConnector* tcp_connector) {
   if (tcp_connector->is_success()) {
-    LOG_DEBUG("Connected to host %s on socket(%p)",
-              address_.to_string().c_str(),
+    LOG_DEBUG("Connected to host %s on socket(%p)", address_.to_string().c_str(),
               static_cast<void*>(this));
 
 #ifdef HAVE_NOSIGPIPE
@@ -238,7 +233,7 @@ void SocketConnector::on_connect(TcpConnector* tcp_connector) {
     uv_os_fd_t fd = 0;
     int enabled = 1;
     if (uv_fileno(reinterpret_cast<uv_handle_t*>(tcp), &fd) != 0 ||
-        setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&enabled, sizeof(int)) != 0) {
+        setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&enabled, sizeof(int)) != 0) {
       LOG_WARN("Unable to set socket option SO_NOSIGPIPE for host %s",
                address_.to_string().c_str());
     }
@@ -254,16 +249,13 @@ void SocketConnector::on_connect(TcpConnector* tcp_connector) {
     finish();
   } else {
     on_error(SOCKET_ERROR_CONNECT,
-             "Connect error '" +
-             String(uv_strerror(tcp_connector->uv_status())) +
-             "'");
+             "Connect error '" + String(uv_strerror(tcp_connector->uv_status())) + "'");
   }
 }
 
 void SocketConnector::on_resolve(NameResolver* resolver) {
   if (resolver->is_success()) {
-    LOG_DEBUG("Resolved the hostname %s for address %s",
-              resolver->hostname().c_str(),
+    LOG_DEBUG("Resolved the hostname %s for address %s", resolver->hostname().c_str(),
               resolver->address().to_string().c_str());
     const String& hostname = resolver->hostname();
     if (!hostname.empty() && hostname[hostname.size() - 1] == '.') {
@@ -276,13 +268,10 @@ void SocketConnector::on_resolve(NameResolver* resolver) {
   } else if (is_canceled() || resolver->is_canceled()) {
     finish();
   } else if (resolver->is_timed_out()) {
-    on_error(SOCKET_ERROR_RESOLVE_TIMEOUT,
-             "Timed out attempting to resolve hostname");
+    on_error(SOCKET_ERROR_RESOLVE_TIMEOUT, "Timed out attempting to resolve hostname");
   } else {
     on_error(SOCKET_ERROR_RESOLVE,
-             "Unable to resolve hostname '" +
-             String(uv_strerror(resolver->uv_status())) +
-             "'");
+             "Unable to resolve hostname '" + String(uv_strerror(resolver->uv_status())) + "'");
   }
 }
 
@@ -293,5 +282,3 @@ void SocketConnector::on_no_resolve(Timer* timer) {
     internal_connect(timer->loop());
   }
 }
-
-} // namespace cass
diff --git a/src/socket_connector.hpp b/src/socket_connector.hpp
index b99976f26..9349ddf04 100644
--- a/src/socket_connector.hpp
+++ b/src/socket_connector.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SOCKET_CONNECTOR_HPP_INCLUDED__
-#define __CASS_SOCKET_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SOCKET_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_SOCKET_CONNECTOR_HPP
 
 #include "callback.hpp"
 #include "name_resolver.hpp"
 #include "socket.hpp"
 #include "tcp_connector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Config;
 
@@ -62,7 +62,7 @@ class SocketConnector : public RefCounted<SocketConnector> {
 public:
   typedef SharedRefPtr<SocketConnector> Ptr;
 
-  typedef cass::Callback<void, SocketConnector*> Callback;
+  typedef internal::Callback<void, SocketConnector*> Callback;
 
   enum SocketError {
     SOCKET_OK,
@@ -126,17 +126,12 @@ class SocketConnector : public RefCounted<SocketConnector> {
   const String& error_message() { return error_message_; }
   CassError ssl_error_code() { return ssl_error_code_; }
 
-  bool is_ok() const {
-    return error_code_ == SOCKET_OK;
-  }
+  bool is_ok() const { return error_code_ == SOCKET_OK; }
 
-  bool is_canceled() const {
-    return error_code_ == SOCKET_CANCELED;
-  }
+  bool is_canceled() const { return error_code_ == SOCKET_CANCELED; }
 
   bool is_ssl_error() const {
-    return error_code_ == SOCKET_ERROR_SSL_HANDSHAKE ||
-        error_code_ == SOCKET_ERROR_SSL_VERIFY;
+    return error_code_ == SOCKET_ERROR_SSL_HANDSHAKE || error_code_ == SOCKET_ERROR_SSL_VERIFY;
   }
 
 private:
@@ -168,6 +163,6 @@ class SocketConnector : public RefCounted<SocketConnector> {
   SocketSettings settings_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/speculative_execution.hpp b/src/speculative_execution.hpp
index 6f7238f6e..1faf758a5 100644
--- a/src/speculative_execution.hpp
+++ b/src/speculative_execution.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SPECULATIVE_EXECUTION_HPP_INCLUDED__
-#define __CASS_SPECULATIVE_EXECUTION_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SPECULATIVE_EXECUTION_HPP
+#define DATASTAX_INTERNAL_SPECULATIVE_EXECUTION_HPP
 
 #include "allocated.hpp"
 #include "host.hpp"
@@ -24,13 +24,13 @@
 
 #include <stdint.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Request;
 
 class SpeculativeExecutionPlan : public Allocated {
 public:
-  virtual ~SpeculativeExecutionPlan() { }
+  virtual ~SpeculativeExecutionPlan() {}
 
   virtual int64_t next_execution(const Host::Ptr& current_host) = 0;
 };
@@ -39,10 +39,9 @@ class SpeculativeExecutionPolicy : public RefCounted<SpeculativeExecutionPolicy>
 public:
   typedef SharedRefPtr<SpeculativeExecutionPolicy> Ptr;
 
-  virtual ~SpeculativeExecutionPolicy() { }
+  virtual ~SpeculativeExecutionPolicy() {}
 
-  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace,
-                                             const Request* request) = 0;
+  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace, const Request* request) = 0;
 
   virtual SpeculativeExecutionPolicy* new_instance() = 0;
 };
@@ -54,21 +53,18 @@ class NoSpeculativeExecutionPlan : public SpeculativeExecutionPlan {
 
 class NoSpeculativeExecutionPolicy : public SpeculativeExecutionPolicy {
 public:
-  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace,
-                                             const Request* request) {
+  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace, const Request* request) {
     return new NoSpeculativeExecutionPlan();
   }
 
-  virtual SpeculativeExecutionPolicy* new_instance()  {
-    return  new NoSpeculativeExecutionPolicy();
-  }
+  virtual SpeculativeExecutionPolicy* new_instance() { return new NoSpeculativeExecutionPolicy(); }
 };
 
 class ConstantSpeculativeExecutionPlan : public SpeculativeExecutionPlan {
 public:
   ConstantSpeculativeExecutionPlan(int64_t constant_delay_ms, int count)
-    : constant_delay_ms_(constant_delay_ms)
-    , count_(count) { }
+      : constant_delay_ms_(constant_delay_ms)
+      , count_(count) {}
 
   virtual int64_t next_execution(const Host::Ptr& current_host) {
     return --count_ >= 0 ? constant_delay_ms_ : -1;
@@ -82,24 +78,21 @@ class ConstantSpeculativeExecutionPlan : public SpeculativeExecutionPlan {
 class ConstantSpeculativeExecutionPolicy : public SpeculativeExecutionPolicy {
 public:
   ConstantSpeculativeExecutionPolicy(int64_t constant_delay_ms, int max_speculative_executions)
-    : constant_delay_ms_(constant_delay_ms)
-    , max_speculative_executions_(max_speculative_executions) { }
+      : constant_delay_ms_(constant_delay_ms)
+      , max_speculative_executions_(max_speculative_executions) {}
 
-  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace,
-                                             const Request* request) {
-    return new ConstantSpeculativeExecutionPlan(constant_delay_ms_,
-                                                max_speculative_executions_);
+  virtual SpeculativeExecutionPlan* new_plan(const String& keyspace, const Request* request) {
+    return new ConstantSpeculativeExecutionPlan(constant_delay_ms_, max_speculative_executions_);
   }
 
-  virtual SpeculativeExecutionPolicy* new_instance()  {
-    return new ConstantSpeculativeExecutionPolicy(constant_delay_ms_,
-                                                  max_speculative_executions_);
+  virtual SpeculativeExecutionPolicy* new_instance() {
+    return new ConstantSpeculativeExecutionPolicy(constant_delay_ms_, max_speculative_executions_);
   }
 
   const int64_t constant_delay_ms_;
   const int max_speculative_executions_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/spin_lock.hpp b/src/spin_lock.hpp
index d42b9fb86..ecbea3439 100644
--- a/src/spin_lock.hpp
+++ b/src/spin_lock.hpp
@@ -17,17 +17,17 @@
 #include "atomic.hpp"
 #include "macros.hpp"
 
-#ifndef __CASS_SPINLOCK_HPP_INCLUDED__
-#define __CASS_SPINLOCK_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SPINLOCK_HPP
+#define DATASTAX_INTERNAL_SPINLOCK_HPP
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Spinlock {
 public:
   typedef enum { LOCKED, UNLOCKED } LockState;
 
   Spinlock()
-    : state_(UNLOCKED) {}
+      : state_(UNLOCKED) {}
 
   void lock() {
     while (state_.exchange(LOCKED, MEMORY_ORDER_ACQUIRE) == LOCKED) {
@@ -35,9 +35,7 @@ class Spinlock {
     }
   }
 
-  void unlock() {
-    state_.store(UNLOCKED, MEMORY_ORDER_RELEASE);
-  }
+  void unlock() { state_.store(UNLOCKED, MEMORY_ORDER_RELEASE); }
 
 private:
   Atomic<LockState> state_;
@@ -96,6 +94,6 @@ struct SpinlockPool {
 template <class N>
 Spinlock SpinlockPool<N>::spinlocks_[41];
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/spsc_queue.hpp b/src/spsc_queue.hpp
index 506175845..38e9fb3bc 100644
--- a/src/spsc_queue.hpp
+++ b/src/spsc_queue.hpp
@@ -23,18 +23,18 @@
   http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
 */
 
-#ifndef __CASS_SPSC_QUEUE_HPP_INCLUDED__
-#define __CASS_SPSC_QUEUE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SPSC_QUEUE_HPP
+#define DATASTAX_INTERNAL_SPSC_QUEUE_HPP
 
 #include <assert.h>
 
 #include "atomic.hpp"
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 #include "macros.hpp"
 #include "scoped_ptr.hpp"
 #include "utils.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 template <typename T>
 class SPSCQueue {
@@ -69,16 +69,13 @@ class SPSCQueue {
     return true;
   }
 
-  bool is_empty() {
-    return head_.load(MEMORY_ORDER_ACQUIRE) ==
-        tail_.load(MEMORY_ORDER_ACQUIRE);
-  }
+  bool is_empty() { return head_.load(MEMORY_ORDER_ACQUIRE) == tail_.load(MEMORY_ORDER_ACQUIRE); }
 
   static void memory_fence() {
-   // Internally, libuv has a "pending" flag check whose load can be reordered
-   // before storing the data into the queue causing the data in the queue
-   // not to be consumed. This fence ensures that the load happens after the
-   // data has been store in the queue.
+    // Internally, libuv has a "pending" flag check whose load can be reordered
+    // before storing the data into the queue causing the data in the queue
+    // not to be consumed. This fence ensures that the load happens after the
+    // data has been store in the queue.
 #if defined(HAVE_BOOST_ATOMIC) || defined(HAVE_STD_ATOMIC)
     atomic_thread_fence(MEMORY_ORDER_SEQ_CST);
 #endif
@@ -101,6 +98,6 @@ class SPSCQueue {
   DISALLOW_COPY_AND_ASSIGN(SPSCQueue);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/ssl.cpp b/src/ssl.cpp
index 0f0769227..679a73429 100644
--- a/src/ssl.cpp
+++ b/src/ssl.cpp
@@ -21,22 +21,22 @@
 
 #include <uv.h>
 
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassSsl* cass_ssl_new() {
-  cass::SslContextFactory::init_once();
+  SslContextFactory::init_once();
   return cass_ssl_new_no_lib_init();
 }
 
 CassSsl* cass_ssl_new_no_lib_init() {
-  cass::SslContext::Ptr ssl_context(cass::SslContextFactory::create());
+  SslContext::Ptr ssl_context(SslContextFactory::create());
   ssl_context->inc_ref();
   return CassSsl::to(ssl_context.get());
 }
 
-void cass_ssl_free(CassSsl* ssl) {
-  ssl->dec_ref();
-}
+void cass_ssl_free(CassSsl* ssl) { ssl->dec_ref(); }
 
 CassError cass_ssl_add_trusted_cert(CassSsl* ssl, const char* cert) {
   return cass_ssl_add_trusted_cert_n(ssl, cert, SAFE_STRLEN(cert));
@@ -46,44 +46,26 @@ CassError cass_ssl_add_trusted_cert_n(CassSsl* ssl, const char* cert, size_t cer
   return ssl->add_trusted_cert(cert, cert_length);
 }
 
-void cass_ssl_set_verify_flags(CassSsl* ssl, int flags) {
-  ssl->set_verify_flags(flags);
-}
+void cass_ssl_set_verify_flags(CassSsl* ssl, int flags) { ssl->set_verify_flags(flags); }
 
 CassError cass_ssl_set_cert(CassSsl* ssl, const char* cert) {
   return cass_ssl_set_cert_n(ssl, cert, SAFE_STRLEN(cert));
 }
 
-CassError cass_ssl_set_cert_n(CassSsl* ssl,
-                              const char* cert,
-                              size_t cert_length) {
+CassError cass_ssl_set_cert_n(CassSsl* ssl, const char* cert, size_t cert_length) {
   return ssl->set_cert(cert, cert_length);
 }
 
-CassError cass_ssl_set_private_key(CassSsl* ssl,
-                                   const char* key,
-                                   const char* password) {
-  return cass_ssl_set_private_key_n(ssl,
-                                    key, SAFE_STRLEN(key),
-                                    password, SAFE_STRLEN(password));
+CassError cass_ssl_set_private_key(CassSsl* ssl, const char* key, const char* password) {
+  return cass_ssl_set_private_key_n(ssl, key, SAFE_STRLEN(key), password, SAFE_STRLEN(password));
 }
 
-CassError cass_ssl_set_private_key_n(CassSsl* ssl,
-                                     const char* key,
-                                     size_t key_length,
-                                     const char* password,
-                                     size_t password_length) {
-  return ssl->set_private_key(key,
-                              key_length,
-                              password,
-                              password_length);
+CassError cass_ssl_set_private_key_n(CassSsl* ssl, const char* key, size_t key_length,
+                                     const char* password, size_t password_length) {
+  return ssl->set_private_key(key, key_length, password, password_length);
 }
 
 } // extern "C"
 
-namespace cass {
-
-template<class T>
+template <class T>
 uv_once_t SslContextFactoryBase<T>::ssl_init_guard = UV_ONCE_INIT;
-
-} // namespace cass
diff --git a/src/ssl.hpp b/src/ssl.hpp
index 50d29415d..2b6753c47 100644
--- a/src/ssl.hpp
+++ b/src/ssl.hpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SSL_HPP_INCLUDED__
-#define __CASS_SSL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SSL_HPP
+#define DATASTAX_INTERNAL_SSL_HPP
 
-#include "allocated.hpp"
 #include "address.hpp"
+#include "allocated.hpp"
 #include "cassandra.h"
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 #include "external.hpp"
 #include "ref_counted.hpp"
 #include "ring_buffer.hpp"
@@ -28,31 +28,23 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class SslSession : public Allocated {
 public:
-  SslSession(const Address& address,
-             const String& hostname,
-             int flags)
-    : address_(address)
-    , hostname_(hostname)
-    , verify_flags_(flags)
-    , error_code_(CASS_OK) {}
+  SslSession(const Address& address, const String& hostname, int flags)
+      : address_(address)
+      , hostname_(hostname)
+      , verify_flags_(flags)
+      , error_code_(CASS_OK) {}
 
   virtual ~SslSession() {}
 
-  bool has_error() const {
-    return error_code() != CASS_OK;
-  }
+  bool has_error() const { return error_code() != CASS_OK; }
 
-  CassError error_code() const {
-    return error_code_;
-  }
+  CassError error_code() const { return error_code_; }
 
-  String error_message() const {
-    return error_message_;
-  }
+  String error_message() const { return error_message_; }
 
   virtual bool is_handshake_done() const = 0;
   virtual void do_handshake() = 0;
@@ -79,23 +71,17 @@ class SslContext : public RefCounted<SslContext> {
   typedef SharedRefPtr<SslContext> Ptr;
 
   SslContext()
-    : verify_flags_(CASS_SSL_VERIFY_PEER_CERT) {}
+      : verify_flags_(CASS_SSL_VERIFY_PEER_CERT) {}
 
   virtual ~SslContext() {}
 
-  void set_verify_flags(int flags) {
-    verify_flags_ = flags;
-  }
-  bool is_cert_validation_enabled() {
-    return verify_flags_ != CASS_SSL_VERIFY_NONE;
-  }
+  void set_verify_flags(int flags) { verify_flags_ = flags; }
+  bool is_cert_validation_enabled() { return verify_flags_ != CASS_SSL_VERIFY_NONE; }
 
   virtual SslSession* create_session(const Address& address, const String& hostname) = 0;
   virtual CassError add_trusted_cert(const char* cert, size_t cert_length) = 0;
   virtual CassError set_cert(const char* cert, size_t cert_length) = 0;
-  virtual CassError set_private_key(const char* key,
-                                    size_t key_length,
-                                    const char* password,
+  virtual CassError set_private_key(const char* key, size_t key_length, const char* password,
                                     size_t password_length) = 0;
 
 protected:
@@ -109,39 +95,39 @@ class SslContextFactoryBase {
   static void init_once();
   static void thread_cleanup();
 
-  static void init(); // Tests only
+  static void init();    // Tests only
   static void cleanup(); // Tests only
 
 private:
   static uv_once_t ssl_init_guard;
 };
 
-template<class T>
+template <class T>
 SslContext::Ptr SslContextFactoryBase<T>::create() {
   return T::create();
 }
 
-template<class T>
+template <class T>
 void SslContextFactoryBase<T>::init_once() {
   uv_once(&ssl_init_guard, T::init);
 }
 
-template<class T>
+template <class T>
 void SslContextFactoryBase<T>::thread_cleanup() {
   T::internal_thread_cleanup();
 }
 
-template<class T>
+template <class T>
 void SslContextFactoryBase<T>::init() {
   T::internal_init();
 }
 
-template<class T>
+template <class T>
 void SslContextFactoryBase<T>::cleanup() {
   T::internal_cleanup();
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #ifdef HAVE_OPENSSL
 #include "ssl/ssl_openssl_impl.hpp"
@@ -149,6 +135,6 @@ void SslContextFactoryBase<T>::cleanup() {
 #include "ssl/ssl_no_impl.hpp"
 #endif
 
-EXTERNAL_TYPE(cass::SslContext, CassSsl)
+EXTERNAL_TYPE(datastax::internal::core::SslContext, CassSsl)
 
 #endif
diff --git a/src/ssl/ring_buffer_bio.cpp b/src/ssl/ring_buffer_bio.cpp
index 0d96d4c20..1ee2175d5 100644
--- a/src/ssl/ring_buffer_bio.cpp
+++ b/src/ssl/ring_buffer_bio.cpp
@@ -50,22 +50,14 @@
 #define BIO_set_init(b, i) ((b)->init = i)
 #endif
 
-namespace cass {
-namespace rb {
+using namespace datastax::internal::rb;
 
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
-const BIO_METHOD RingBufferBio::method_ = {
-  BIO_TYPE_MEM,
-  "ring buffer",
-  RingBufferBio::write,
-  RingBufferBio::read,
-  RingBufferBio::puts,
-  RingBufferBio::gets,
-  RingBufferBio::ctrl,
-  RingBufferBio::create,
-  RingBufferBio::destroy,
-  NULL
-};
+const BIO_METHOD RingBufferBio::method_ = { BIO_TYPE_MEM,           "ring buffer",
+                                            RingBufferBio::write,   RingBufferBio::read,
+                                            RingBufferBio::puts,    RingBufferBio::gets,
+                                            RingBufferBio::ctrl,    RingBufferBio::create,
+                                            RingBufferBio::destroy, NULL };
 #else
 BIO_METHOD* RingBufferBio::method_ = NULL;
 
@@ -82,9 +74,7 @@ void RingBufferBio::initialize() {
   }
 }
 
-void RingBufferBio::cleanup() {
-  BIO_meth_free(method_);
-}
+void RingBufferBio::cleanup() { BIO_meth_free(method_); }
 #endif
 
 BIO* RingBufferBio::create(RingBufferState* state) {
@@ -108,8 +98,7 @@ int RingBufferBio::create(BIO* bio) {
 }
 
 int RingBufferBio::destroy(BIO* bio) {
-  if (bio == NULL)
-    return 0;
+  if (bio == NULL) return 0;
 
   return 1;
 }
@@ -138,25 +127,20 @@ int RingBufferBio::write(BIO* bio, const char* data, int len) {
   return len;
 }
 
-int RingBufferBio::puts(BIO* bio, const char* str) {
-  return write(bio, str, strlen(str));
-}
+int RingBufferBio::puts(BIO* bio, const char* str) { return write(bio, str, strlen(str)); }
 
 int RingBufferBio::gets(BIO* bio, char* out, int size) {
   RingBuffer* ring_buffer = from_bio(bio)->ring_buffer;
 
-  if (ring_buffer->length() == 0)
-    return 0;
+  if (ring_buffer->length() == 0) return 0;
 
   int i = ring_buffer->index_of('\n', size);
 
   // Include '\n', if it's there.  If not, don't read off the end.
-  if (i < size && i >= 0 && static_cast<size_t>(i) < ring_buffer->length())
-    i++;
+  if (i < size && i >= 0 && static_cast<size_t>(i) < ring_buffer->length()) i++;
 
   // Shift `i` a bit to NULL-terminate string later
-  if (size == i)
-    i--;
+  if (size == i) i--;
 
   // Flush read data
   ring_buffer->read(out, i);
@@ -181,8 +165,7 @@ long RingBufferBio::ctrl(BIO* bio, int cmd, long num, void* ptr) {
       break;
     case BIO_CTRL_INFO:
       ret = from_bio(bio)->ring_buffer->length();
-      if (ptr != NULL)
-        *reinterpret_cast<void**>(ptr) = NULL;
+      if (ptr != NULL) *reinterpret_cast<void**>(ptr) = NULL;
       break;
     case BIO_C_SET_BUF_MEM:
       assert(0 && "Can't use SET_BUF_MEM_PTR with RingBufferBio");
@@ -216,6 +199,3 @@ long RingBufferBio::ctrl(BIO* bio, int cmd, long num, void* ptr) {
   }
   return ret;
 }
-
-} // namespace rb
-} // namespace cass
diff --git a/src/ssl/ring_buffer_bio.hpp b/src/ssl/ring_buffer_bio.hpp
index 64014045e..3167fc545 100644
--- a/src/ssl/ring_buffer_bio.hpp
+++ b/src/ssl/ring_buffer_bio.hpp
@@ -39,8 +39,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#ifndef __CASS_RING_BUFFER_BIO_HPP_INCLUDED__
-#define __CASS_RING_BUFFER_BIO_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_RING_BUFFER_BIO_HPP
+#define DATASTAX_INTERNAL_RING_BUFFER_BIO_HPP
 
 #include "ring_buffer.hpp"
 
@@ -51,8 +51,7 @@
 #define BIO_get_data(b) ((b)->ptr)
 #endif
 
-namespace cass {
-namespace rb {
+namespace datastax { namespace internal { namespace rb {
 
 // This wrapper is used to contain the ring buffer state kept in the BIO's
 // user data field. OpenSSL 1.1 made the BIO's structure opaque which removed access
@@ -60,8 +59,8 @@ namespace rb {
 // is now used to track the EOF return value.
 struct RingBufferState {
   RingBufferState(RingBuffer* ring_buffer)
-    : ring_buffer(ring_buffer)
-    , ret(-1) { }
+      : ring_buffer(ring_buffer)
+      , ret(-1) {}
 
   RingBuffer* ring_buffer;
   int ret; // Used to keep track of the EOF return value
@@ -93,11 +92,10 @@ class RingBufferBio {
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
   static const BIO_METHOD method_;
 #else
-  static BIO_METHOD *method_;
+  static BIO_METHOD* method_;
 #endif
 };
 
-} // namespace rb
-} // namespace cass
+}}} // namespace datastax::internal::rb
 
 #endif
diff --git a/src/ssl/ssl_no_impl.cpp b/src/ssl/ssl_no_impl.cpp
index 3a9763cf5..5d0637e84 100644
--- a/src/ssl/ssl_no_impl.cpp
+++ b/src/ssl/ssl_no_impl.cpp
@@ -16,38 +16,30 @@
 
 #include "ssl.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 NoSslSession::NoSslSession(const Address& address, const String& hostname)
-  : SslSession(address, hostname, CASS_SSL_VERIFY_NONE) {
+    : SslSession(address, hostname, CASS_SSL_VERIFY_NONE) {
   error_code_ = CASS_ERROR_LIB_NOT_IMPLEMENTED;
   error_message_ = "SSL support not built into driver";
 }
 
-SslSession* cass::NoSslContext::create_session(const Address& address, const String& hostname) {
+SslSession* NoSslContext::create_session(const Address& address, const String& hostname) {
   return new NoSslSession(address, hostname);
 }
 
-CassError cass::NoSslContext::add_trusted_cert(const char* cert,
-                                               size_t cert_length) {
+CassError NoSslContext::add_trusted_cert(const char* cert, size_t cert_length) {
   return CASS_ERROR_LIB_NOT_IMPLEMENTED;
 }
 
-CassError cass::NoSslContext::set_cert(const char* cert,
-                                       size_t cert_length) {
+CassError NoSslContext::set_cert(const char* cert, size_t cert_length) {
   return CASS_ERROR_LIB_NOT_IMPLEMENTED;
 }
 
-CassError cass::NoSslContext::set_private_key(const char* key,
-                                              size_t key_length,
-                                              const char* password,
-                                              size_t password_length) {
+CassError NoSslContext::set_private_key(const char* key, size_t key_length, const char* password,
+                                        size_t password_length) {
   return CASS_ERROR_LIB_NOT_IMPLEMENTED;
 }
 
-SslContext::Ptr NoSslContextFactory::create() {
-  return SslContext::Ptr(new NoSslContext());
-}
-
-
-} // namespace cass
+SslContext::Ptr NoSslContextFactory::create() { return SslContext::Ptr(new NoSslContext()); }
diff --git a/src/ssl/ssl_no_impl.hpp b/src/ssl/ssl_no_impl.hpp
index cd695aabe..9a0f6dc7a 100644
--- a/src/ssl/ssl_no_impl.hpp
+++ b/src/ssl/ssl_no_impl.hpp
@@ -14,10 +14,10 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SSL_NO_IMPL_HPP_INCLUDED__
-#define __CASS_SSL_NO_IMPL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SSL_NO_IMPL_HPP
+#define DATASTAX_INTERNAL_SSL_NO_IMPL_HPP
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class NoSslSession : public SslSession {
 public:
@@ -33,28 +33,24 @@ class NoSslSession : public SslSession {
 
 class NoSslContext : public SslContext {
 public:
-
   virtual SslSession* create_session(const Address& address, const String& hostname);
 
   virtual CassError add_trusted_cert(const char* cert, size_t cert_length);
   virtual CassError set_cert(const char* cert, size_t cert_length);
-  virtual CassError set_private_key(const char* key,
-                                    size_t key_length,
-                                    const char* password,
+  virtual CassError set_private_key(const char* key, size_t key_length, const char* password,
                                     size_t password_length);
 };
 
 class NoSslContextFactory : public SslContextFactoryBase<NoSslContextFactory> {
 public:
   static SslContext::Ptr create();
-  static void internal_init() { }
-  static void internal_thread_cleanup() { }
-  static void internal_cleanup() { }
+  static void internal_init() {}
+  static void internal_thread_cleanup() {}
+  static void internal_cleanup() {}
 };
 
 typedef SslContextFactoryBase<NoSslContextFactory> SslContextFactory;
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
-
diff --git a/src/ssl/ssl_openssl_impl.cpp b/src/ssl/ssl_openssl_impl.cpp
index 725e705e7..17bb148b6 100644
--- a/src/ssl/ssl_openssl_impl.cpp
+++ b/src/ssl/ssl_openssl_impl.cpp
@@ -22,10 +22,10 @@
 #include "third_party/curl/hostcheck.hpp"
 
 #include <openssl/crypto.h>
-#include <openssl/err.h>
 #include <openssl/engine.h>
-#include <openssl/x509v3.h>
+#include <openssl/err.h>
 #include <openssl/rand.h>
+#include <openssl/x509v3.h>
 #include <string.h>
 
 #define DEBUG_SSL 0
@@ -36,17 +36,17 @@
 #define SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE SSL_F_USE_CERTIFICATE_CHAIN_FILE
 #endif
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 #if DEBUG_SSL
-#define SSL_PRINT_INFO(ssl, w, flag, msg) do { \
-    if (w & flag) {                             \
-      fprintf(stderr, "%s - %s - %s\n",        \
-              msg,                             \
-              SSL_state_string(ssl),           \
-              SSL_state_string_long(ssl));     \
-    }                                          \
- } while (0);
+#define SSL_PRINT_INFO(ssl, w, flag, msg)                                                        \
+  do {                                                                                           \
+    if (w & flag) {                                                                              \
+      fprintf(stderr, "%s - %s - %s\n", msg, SSL_state_string(ssl), SSL_state_string_long(ssl)); \
+    }                                                                                            \
+  } while (0);
 
 static void ssl_info_callback(const SSL* ssl, int where, int ret) {
   if (ret == 0) {
@@ -152,7 +152,7 @@ static int SSL_CTX_use_certificate_chain_bio(SSL_CTX* ctx, BIO* in) {
 
   x = PEM_read_bio_X509_AUX(in, NULL, pem_password_callback, NULL);
   if (x == NULL) {
-    SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_PEM_LIB);
+    SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
     goto end;
   }
 
@@ -167,7 +167,7 @@ static int SSL_CTX_use_certificate_chain_bio(SSL_CTX* ctx, BIO* in) {
     // If we could set up our certificate, now proceed to
     // the CA certificates.
 
-    X509 *ca;
+    X509* ca;
     int r;
     unsigned long err;
 
@@ -227,18 +227,14 @@ static X509* load_cert(const char* cert, size_t cert_size) {
   return x509;
 }
 
-static EVP_PKEY* load_key(const char* key,
-                          size_t key_size,
-                          const char* password) {
+static EVP_PKEY* load_key(const char* key, size_t key_size, const char* password) {
   BIO* bio = BIO_new_mem_buf(const_cast<char*>(key), key_size);
   if (bio == NULL) {
     return NULL;
   }
 
-  EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio,
-                                           NULL,
-                                           pem_password_callback,
-                                           const_cast<char*>(password));
+  EVP_PKEY* pkey =
+      PEM_read_bio_PrivateKey(bio, NULL, pem_password_callback, const_cast<char*>(password));
   if (pkey == NULL) {
     ssl_log_errors("Unable to load private key");
   }
@@ -250,12 +246,7 @@ static EVP_PKEY* load_key(const char* key,
 
 class OpenSslVerifyIdentity {
 public:
-  enum Result {
-    INVALID_CERT,
-    MATCH,
-    NO_MATCH,
-    NO_SAN_PRESENT
-  };
+  enum Result { INVALID_CERT, MATCH, NO_MATCH, NO_SAN_PRESENT };
 
   static Result match(X509* cert, const Address& address) {
     Result result = match_subject_alt_names_ipadd(cert, address);
@@ -346,8 +337,8 @@ class OpenSslVerifyIdentity {
       return NO_MATCH;
     }
 
-    STACK_OF(GENERAL_NAME)* names
-      = static_cast<STACK_OF(GENERAL_NAME)*>(X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL));
+    STACK_OF(GENERAL_NAME)* names = static_cast<STACK_OF(GENERAL_NAME)*>(
+        X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL));
     if (names == NULL) {
       return NO_SAN_PRESENT;
     }
@@ -356,7 +347,7 @@ class OpenSslVerifyIdentity {
     for (int i = 0; i < sk_GENERAL_NAME_num(names); ++i) {
       GENERAL_NAME* name = sk_GENERAL_NAME_value(names, i);
 
-      if (name->type == GEN_IPADD){
+      if (name->type == GEN_IPADD) {
         ASN1_STRING* str = name->d.iPAddress;
         if (str == NULL) {
           result = INVALID_CERT;
@@ -383,8 +374,8 @@ class OpenSslVerifyIdentity {
   }
 
   static Result match_subject_alt_names_dns(X509* cert, const String& hostname) {
-    STACK_OF(GENERAL_NAME)* names
-      = static_cast<STACK_OF(GENERAL_NAME)*>(X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL));
+    STACK_OF(GENERAL_NAME)* names = static_cast<STACK_OF(GENERAL_NAME)*>(
+        X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL));
     if (names == NULL) {
       return NO_SAN_PRESENT;
     }
@@ -393,7 +384,7 @@ class OpenSslVerifyIdentity {
     for (int i = 0; i < sk_GENERAL_NAME_num(names); ++i) {
       GENERAL_NAME* name = sk_GENERAL_NAME_value(names, i);
 
-      if (name->type == GEN_DNS){
+      if (name->type == GEN_DNS) {
         ASN1_STRING* str = name->d.dNSName;
         if (str == NULL) {
           result = INVALID_CERT;
@@ -419,16 +410,14 @@ class OpenSslVerifyIdentity {
   }
 };
 
-OpenSslSession::OpenSslSession(const Address& address,
-                               const String& hostname,
-                               int flags,
+OpenSslSession::OpenSslSession(const Address& address, const String& hostname, int flags,
                                SSL_CTX* ssl_ctx)
-  : SslSession(address, hostname, flags)
-  , ssl_(SSL_new(ssl_ctx))
-  , incoming_state_(&incoming_)
-  , outgoing_state_(&outgoing_)
-  , incoming_bio_(rb::RingBufferBio::create(&incoming_state_))
-  , outgoing_bio_(rb::RingBufferBio::create(&outgoing_state_)) {
+    : SslSession(address, hostname, flags)
+    , ssl_(SSL_new(ssl_ctx))
+    , incoming_state_(&incoming_)
+    , outgoing_state_(&outgoing_)
+    , incoming_bio_(rb::RingBufferBio::create(&incoming_state_))
+    , outgoing_bio_(rb::RingBufferBio::create(&outgoing_state_)) {
   SSL_set_bio(ssl_, incoming_bio_, outgoing_bio_);
   SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_NONE, ssl_no_verify_callback);
 #if DEBUG_SSL
@@ -437,9 +426,7 @@ OpenSslSession::OpenSslSession(const Address& address,
   SSL_set_connect_state(ssl_);
 }
 
-OpenSslSession::~OpenSslSession() {
-  SSL_free(ssl_);
-}
+OpenSslSession::~OpenSslSession() { SSL_free(ssl_); }
 
 void OpenSslSession::do_handshake() {
   int rc = SSL_connect(ssl_);
@@ -484,7 +471,8 @@ void OpenSslSession::verify() {
         X509_free(peer_cert);
         return;
     }
-  } else if (verify_flags_ & CASS_SSL_VERIFY_PEER_IDENTITY_DNS) { // Match using hostnames (including wildcards)
+  } else if (verify_flags_ &
+             CASS_SSL_VERIFY_PEER_IDENTITY_DNS) { // Match using hostnames (including wildcards)
     switch (OpenSslVerifyIdentity::match_dns(peer_cert, hostname_)) {
       case OpenSslVerifyIdentity::MATCH:
         // Success
@@ -513,7 +501,7 @@ int OpenSslSession::encrypt(const char* buf, size_t size) {
   return rc;
 }
 
-int OpenSslSession::decrypt(char* buf, size_t size)  {
+int OpenSslSession::decrypt(char* buf, size_t size) {
   int rc = SSL_read(ssl_, buf, size);
   if (rc <= 0) check_error(rc);
   return rc;
@@ -528,21 +516,18 @@ void OpenSslSession::check_error(int rc) {
 }
 
 OpenSslContext::OpenSslContext()
-  : ssl_ctx_(SSL_CTX_new(SSLv23_client_method()))
-  , trusted_store_(X509_STORE_new()) {
+    : ssl_ctx_(SSL_CTX_new(SSLv23_client_method()))
+    , trusted_store_(X509_STORE_new()) {
   SSL_CTX_set_cert_store(ssl_ctx_, trusted_store_);
 }
 
-OpenSslContext::~OpenSslContext() {
-  SSL_CTX_free(ssl_ctx_);
-}
+OpenSslContext::~OpenSslContext() { SSL_CTX_free(ssl_ctx_); }
 
 SslSession* OpenSslContext::create_session(const Address& address, const String& hostname) {
   return new OpenSslSession(address, hostname, verify_flags_, ssl_ctx_);
 }
 
-CassError OpenSslContext::add_trusted_cert(const char* cert,
-                                           size_t cert_length) {
+CassError OpenSslContext::add_trusted_cert(const char* cert, size_t cert_length) {
   X509* x509 = load_cert(cert, cert_length);
   if (x509 == NULL) {
     return CASS_ERROR_SSL_INVALID_CERT;
@@ -554,8 +539,7 @@ CassError OpenSslContext::add_trusted_cert(const char* cert,
   return CASS_OK;
 }
 
-CassError OpenSslContext::set_cert(const char* cert,
-                                   size_t cert_length) {
+CassError OpenSslContext::set_cert(const char* cert, size_t cert_length) {
   BIO* bio = BIO_new_mem_buf(const_cast<char*>(cert), cert_length);
   if (bio == NULL) {
     return CASS_ERROR_SSL_INVALID_CERT;
@@ -573,9 +557,7 @@ CassError OpenSslContext::set_cert(const char* cert,
   return CASS_OK;
 }
 
-CassError OpenSslContext::set_private_key(const char* key,
-                                          size_t key_length,
-                                          const char* password,
+CassError OpenSslContext::set_private_key(const char* key, size_t key_length, const char* password,
                                           size_t password_length) {
   // TODO: Password buffer
   EVP_PKEY* pkey = load_key(key, key_length, password);
@@ -589,42 +571,28 @@ CassError OpenSslContext::set_private_key(const char* key,
   return CASS_OK;
 }
 
-SslContext::Ptr OpenSslContextFactory::create() {
-  return SslContext::Ptr(new OpenSslContext());
-}
+SslContext::Ptr OpenSslContextFactory::create() { return SslContext::Ptr(new OpenSslContext()); }
 
 namespace openssl {
 
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
-  void* malloc(size_t size) {
-    return Memory::malloc(size);
-  }
+void* malloc(size_t size) { return Memory::malloc(size); }
 
-  void* realloc(void* ptr, size_t size) {
-    return Memory::realloc(ptr, size);
-  }
+void* realloc(void* ptr, size_t size) { return Memory::realloc(ptr, size); }
 
-  void free(void* ptr) {
-    Memory::free(ptr);
-  }
+void free(void* ptr) { Memory::free(ptr); }
 #else
-  void* malloc(size_t size, const char* file, int line) {
-    return Memory::malloc(size);
-  }
+void* malloc(size_t size, const char* file, int line) { return Memory::malloc(size); }
 
-  void* realloc(void* ptr, size_t size, const char* file, int line) {
-    return Memory::realloc(ptr, size);
-  }
+void* realloc(void* ptr, size_t size, const char* file, int line) {
+  return Memory::realloc(ptr, size);
+}
 
-  void free(void* ptr, const char* file, int line) {
-    Memory::free(ptr);
-  }
+void free(void* ptr, const char* file, int line) { Memory::free(ptr); }
 #endif
 
 } // namespace openssl
 
-
-
 void OpenSslContextFactory::internal_init() {
   CRYPTO_set_mem_functions(openssl::malloc, openssl::realloc, openssl::free);
 
@@ -690,5 +658,3 @@ void OpenSslContextFactory::internal_cleanup() {
   rb::RingBufferBio::cleanup();
 #endif
 }
-
-} // namespace cass
diff --git a/src/ssl/ssl_openssl_impl.hpp b/src/ssl/ssl_openssl_impl.hpp
index fe981bd1d..c52aeeee6 100644
--- a/src/ssl/ssl_openssl_impl.hpp
+++ b/src/ssl/ssl_openssl_impl.hpp
@@ -14,28 +14,23 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SSL_OPENSSL_IMPL_HPP_INCLUDED__
-#define __CASS_SSL_OPENSSL_IMPL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SSL_OPENSSL_IMPL_HPP
+#define DATASTAX_INTERNAL_SSL_OPENSSL_IMPL_HPP
 
 #include "ssl/ring_buffer_bio.hpp"
 
 #include <assert.h>
-#include <openssl/ssl.h>
 #include <openssl/bio.h>
+#include <openssl/ssl.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class OpenSslSession : public SslSession {
 public:
-  OpenSslSession(const Address& address,
-                 const String& hostname,
-                 int flags,
-                 SSL_CTX* ssl_ctx);
+  OpenSslSession(const Address& address, const String& hostname, int flags, SSL_CTX* ssl_ctx);
   ~OpenSslSession();
 
-  virtual bool is_handshake_done() const {
-    return SSL_is_init_finished(ssl_) != 0;
-  }
+  virtual bool is_handshake_done() const { return SSL_is_init_finished(ssl_) != 0; }
 
   virtual void do_handshake();
   virtual void verify();
@@ -62,9 +57,7 @@ class OpenSslContext : public SslContext {
   virtual SslSession* create_session(const Address& address, const String& hostname);
   virtual CassError add_trusted_cert(const char* cert, size_t cert_length);
   virtual CassError set_cert(const char* cert, size_t cert_length);
-  virtual CassError set_private_key(const char* key,
-                                    size_t key_length,
-                                    const char* password,
+  virtual CassError set_private_key(const char* key, size_t key_length, const char* password,
                                     size_t password_length);
 
 private:
@@ -82,6 +75,6 @@ class OpenSslContextFactory : public SslContextFactoryBase<OpenSslContextFactory
 
 typedef SslContextFactoryBase<OpenSslContextFactory> SslContextFactory;
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/stack.hpp b/src/stack.hpp
index db152dec6..42438d5bc 100644
--- a/src/stack.hpp
+++ b/src/stack.hpp
@@ -5,25 +5,25 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_STACK_HPP_INCLUDED__
-#define __DSE_STACK_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STACK_HPP
+#define DATASTAX_INTERNAL_STACK_HPP
 
 #include "deque.hpp"
 
 #include <stack>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T, class Container = Deque<T> >
-class Stack : public std::stack<T,  Container> {
+class Stack : public std::stack<T, Container> {
 public:
-  explicit Stack( const Container& container = Container())
-    : std::stack<T, Container>(container) { }
+  explicit Stack(const Container& container = Container())
+      : std::stack<T, Container>(container) {}
 
   Stack(const Stack& other)
-    : std::stack<T, Container>(other) { }
+      : std::stack<T, Container>(other) {}
 };
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/startup_request.cpp b/src/startup_request.cpp
index 866049560..cc9be2fc4 100644
--- a/src/startup_request.cpp
+++ b/src/startup_request.cpp
@@ -17,10 +17,10 @@
 #include "startup_request.hpp"
 #include "driver_info.hpp"
 
-namespace cass {
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
-int StartupRequest::encode(ProtocolVersion version,
-                           RequestCallback* callback,
+int StartupRequest::encode(ProtocolVersion version, RequestCallback* callback,
                            BufferVec* bufs) const {
   // <options> [string map]
   size_t length = sizeof(uint16_t);
@@ -42,16 +42,13 @@ int StartupRequest::encode(ProtocolVersion version,
     options["NO_COMPACT"] = "true";
   }
 
-  for (OptionsMap::const_iterator it = options.begin(),
-       end = options.end(); it != end; ++it) {
+  for (OptionsMap::const_iterator it = options.begin(), end = options.end(); it != end; ++it) {
     length += sizeof(uint16_t) + it->first.size();
     length += sizeof(uint16_t) + it->second.size();
-   }
+  }
 
   bufs->push_back(Buffer(length));
   bufs->back().encode_string_map(0, options);
 
   return length;
 }
-
-} // namespace cass
diff --git a/src/startup_request.hpp b/src/startup_request.hpp
index 6f64c17d3..998583a5f 100644
--- a/src/startup_request.hpp
+++ b/src/startup_request.hpp
@@ -14,28 +14,26 @@
   limitations under the License.
 */
 
-#ifndef __CASS_STARTUP_REQUEST_HPP_INCLUDED__
-#define __CASS_STARTUP_REQUEST_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STARTUP_REQUEST_HPP
+#define DATASTAX_INTERNAL_STARTUP_REQUEST_HPP
 
-#include "request.hpp"
 #include "constants.hpp"
 #include "map.hpp"
+#include "request.hpp"
 #include "scoped_ptr.hpp"
 #include "string.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class StartupRequest : public Request {
 public:
-  StartupRequest(const String& application_name,
-                 const String& application_version,
-                 const String& client_id,
-                 bool no_compact_enabled)
+  StartupRequest(const String& application_name, const String& application_version,
+                 const String& client_id, bool no_compact_enabled)
       : Request(CQL_OPCODE_STARTUP)
       , application_name_(application_name)
       , application_version_(application_version)
       , client_id_(client_id)
-      , no_compact_enabled_(no_compact_enabled) { }
+      , no_compact_enabled_(no_compact_enabled) {}
 
   const String& application_name() const { return application_name_; }
   const String& application_version() const { return application_version_; }
@@ -43,9 +41,7 @@ class StartupRequest : public Request {
   bool no_compact_enabled() const { return no_compact_enabled_; }
 
 private:
-  int encode(ProtocolVersion version,
-             RequestCallback* callback,
-             BufferVec* bufs) const;
+  int encode(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
 
 private:
   typedef Map<String, String> OptionsMap;
@@ -56,6 +52,6 @@ class StartupRequest : public Request {
   bool no_compact_enabled_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/statement.cpp b/src/statement.cpp
index 65a423adc..dc96884c1 100644
--- a/src/statement.cpp
+++ b/src/statement.cpp
@@ -31,18 +31,19 @@
 
 #include <uv.h>
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-CassStatement* cass_statement_new(const char* query,
-                                  size_t parameter_count) {
+CassStatement* cass_statement_new(const char* query, size_t parameter_count) {
   return cass_statement_new_n(query, SAFE_STRLEN(query), parameter_count);
 }
 
-CassStatement* cass_statement_new_n(const char* query,
-                                    size_t query_length,
+CassStatement* cass_statement_new_n(const char* query, size_t query_length,
                                     size_t parameter_count) {
-  cass::QueryRequest* query_request
-      = new cass::QueryRequest(query, query_length, parameter_count);
+  QueryRequest* query_request = new QueryRequest(query, query_length, parameter_count);
   query_request->inc_ref();
   return CassStatement::to(query_request);
 }
@@ -63,23 +64,19 @@ CassError cass_statement_set_keyspace(CassStatement* statement, const char* keys
   return cass_statement_set_keyspace_n(statement, keyspace, SAFE_STRLEN(keyspace));
 }
 
-CassError cass_statement_set_keyspace_n(CassStatement* statement,
-                                        const char* keyspace,
+CassError cass_statement_set_keyspace_n(CassStatement* statement, const char* keyspace,
                                         size_t keyspace_length) {
   // The keyspace is set by the prepared metadata
   if (statement->opcode() == CQL_OPCODE_EXECUTE) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
-  statement->set_keyspace(cass::String(keyspace, keyspace_length));
+  statement->set_keyspace(String(keyspace, keyspace_length));
   return CASS_OK;
 }
 
-void cass_statement_free(CassStatement* statement) {
-  statement->dec_ref();
-}
+void cass_statement_free(CassStatement* statement) { statement->dec_ref(); }
 
-CassError cass_statement_set_consistency(CassStatement* statement,
-                                         CassConsistency consistency) {
+CassError cass_statement_set_consistency(CassStatement* statement, CassConsistency consistency) {
   statement->set_consistency(consistency);
   return CASS_OK;
 }
@@ -90,45 +87,38 @@ CassError cass_statement_set_serial_consistency(CassStatement* statement,
   return CASS_OK;
 }
 
-CassError cass_statement_set_paging_size(CassStatement* statement,
-                                         int page_size) {
+CassError cass_statement_set_paging_size(CassStatement* statement, int page_size) {
   statement->set_page_size(page_size);
   return CASS_OK;
 }
 
-CassError cass_statement_set_paging_state(CassStatement* statement,
-                                          const CassResult* result) {
+CassError cass_statement_set_paging_state(CassStatement* statement, const CassResult* result) {
   statement->set_paging_state(result->paging_state().to_string());
   return CASS_OK;
 }
 
-CassError cass_statement_set_paging_state_token(CassStatement* statement,
-                                              const char* paging_state,
-                                              size_t paging_state_size) {
-  statement->set_paging_state(cass::String(paging_state, paging_state_size));
+CassError cass_statement_set_paging_state_token(CassStatement* statement, const char* paging_state,
+                                                size_t paging_state_size) {
+  statement->set_paging_state(String(paging_state, paging_state_size));
   return CASS_OK;
 }
 
-CassError cass_statement_set_retry_policy(CassStatement* statement,
-                                          CassRetryPolicy* retry_policy) {
+CassError cass_statement_set_retry_policy(CassStatement* statement, CassRetryPolicy* retry_policy) {
   statement->set_retry_policy(retry_policy);
   return CASS_OK;
 }
 
-CassError cass_statement_set_timestamp(CassStatement* statement,
-                                       cass_int64_t timestamp)  {
+CassError cass_statement_set_timestamp(CassStatement* statement, cass_int64_t timestamp) {
   statement->set_timestamp(timestamp);
   return CASS_OK;
 }
 
-CassError cass_statement_set_request_timeout(CassStatement* statement,
-                                             cass_uint64_t timeout_ms) {
+CassError cass_statement_set_request_timeout(CassStatement* statement, cass_uint64_t timeout_ms) {
   statement->set_request_timeout_ms(timeout_ms);
   return CASS_OK;
 }
 
-CassError cass_statement_set_is_idempotent(CassStatement* statement,
-                                           cass_bool_t is_idempotent) {
+CassError cass_statement_set_is_idempotent(CassStatement* statement, cass_bool_t is_idempotent) {
   statement->set_is_idempotent(is_idempotent == cass_true);
   return CASS_OK;
 }
@@ -139,79 +129,62 @@ CassError cass_statement_set_custom_payload(CassStatement* statement,
   return CASS_OK;
 }
 
-CassError cass_statement_set_execution_profile(CassStatement* statement,
-                                               const char* name) {
-  return cass_statement_set_execution_profile_n(statement,
-                                                name,
-                                                SAFE_STRLEN(name));
+CassError cass_statement_set_execution_profile(CassStatement* statement, const char* name) {
+  return cass_statement_set_execution_profile_n(statement, name, SAFE_STRLEN(name));
 }
 
-CassError cass_statement_set_execution_profile_n(CassStatement* statement,
-                                                 const char* name,
+CassError cass_statement_set_execution_profile_n(CassStatement* statement, const char* name,
                                                  size_t name_length) {
   if (name_length > 0) {
-    statement->set_execution_profile_name(cass::String(name, name_length));
+    statement->set_execution_profile_name(String(name, name_length));
   } else {
-    statement->set_execution_profile_name(cass::String());
+    statement->set_execution_profile_name(String());
   }
   return CASS_OK;
 }
 
-CassError cass_statement_set_tracing(CassStatement* statement,
-                                     cass_bool_t enabled) {
+CassError cass_statement_set_tracing(CassStatement* statement, cass_bool_t enabled) {
   statement->set_tracing(enabled == cass_true);
   return CASS_OK;
 }
 
-CassError cass_statement_set_host(CassStatement* statement,
-                                  const char* host,
-                                  int port) {
+CassError cass_statement_set_host(CassStatement* statement, const char* host, int port) {
   return cass_statement_set_host_n(statement, host, SAFE_STRLEN(host), port);
 }
 
-CassError cass_statement_set_host_n(CassStatement* statement,
-                                    const char* host,
-                                    size_t host_length,
+CassError cass_statement_set_host_n(CassStatement* statement, const char* host, size_t host_length,
                                     int port) {
-  cass::Address address;
-  if (!cass::Address::from_string(cass::String(host, host_length),
-                                  port,
-                                  &address)) {
+  Address address;
+  if (!Address::from_string(String(host, host_length), port, &address)) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
   statement->set_host(address);
   return CASS_OK;
 }
 
-CassError cass_statement_set_host_inet(CassStatement* statement,
-                                       const CassInet* host,
-                                       int port) {
-  cass::Address address;
-  if (!cass::Address::from_inet(host->address,
-                                host->address_length,
-                                port, &address)) {
+CassError cass_statement_set_host_inet(CassStatement* statement, const CassInet* host, int port) {
+  Address address;
+  if (!Address::from_inet(host->address, host->address_length, port, &address)) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
   statement->set_host(address);
   return CASS_OK;
 }
 
-#define CASS_STATEMENT_BIND(Name, Params, Value)                                \
-  CassError cass_statement_bind_##Name(CassStatement* statement,                \
-                                      size_t index Params) {                    \
-    return statement->set(index, Value);                                        \
-  }                                                                             \
-  CassError cass_statement_bind_##Name##_by_name(CassStatement* statement,      \
-                                                const char* name Params) {      \
-    return statement->set(cass::StringRef(name), Value);                        \
-  }                                                                             \
-  CassError cass_statement_bind_##Name##_by_name_n(CassStatement* statement,    \
-                                                   const char* name,            \
-                                                   size_t name_length Params) { \
-    return statement->set(cass::StringRef(name, name_length), Value);           \
+#define CASS_STATEMENT_BIND(Name, Params, Value)                                               \
+  CassError cass_statement_bind_##Name(CassStatement* statement, size_t index Params) {        \
+    return statement->set(index, Value);                                                       \
+  }                                                                                            \
+  CassError cass_statement_bind_##Name##_by_name(CassStatement* statement,                     \
+                                                 const char* name Params) {                    \
+    return statement->set(StringRef(name), Value);                                             \
+  }                                                                                            \
+  CassError cass_statement_bind_##Name##_by_name_n(CassStatement* statement, const char* name, \
+                                                   size_t name_length Params) {                \
+    return statement->set(StringRef(name, name_length), Value);                                \
   }
 
-CASS_STATEMENT_BIND(null, ZERO_PARAMS_(), cass::CassNull())
+CASS_STATEMENT_BIND(null, ZERO_PARAMS_(), CassNull())
 CASS_STATEMENT_BIND(int8, ONE_PARAM_(cass_int8_t value), value)
 CASS_STATEMENT_BIND(int16, ONE_PARAM_(cass_int16_t value), value)
 CASS_STATEMENT_BIND(int32, ONE_PARAM_(cass_int32_t value), value)
@@ -225,108 +198,81 @@ CASS_STATEMENT_BIND(inet, ONE_PARAM_(CassInet value), value)
 CASS_STATEMENT_BIND(collection, ONE_PARAM_(const CassCollection* value), value->from())
 CASS_STATEMENT_BIND(tuple, ONE_PARAM_(const CassTuple* value), value->from())
 CASS_STATEMENT_BIND(user_type, ONE_PARAM_(const CassUserType* value), value->from())
-CASS_STATEMENT_BIND(bytes,
-                    TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
-                    cass::CassBytes(value, value_size))
+CASS_STATEMENT_BIND(bytes, TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
+                    CassBytes(value, value_size))
 CASS_STATEMENT_BIND(decimal,
                     THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
-                    cass::CassDecimal(varint, varint_size, scale))
+                    CassDecimal(varint, varint_size, scale))
 CASS_STATEMENT_BIND(duration,
                     THREE_PARAMS_(cass_int32_t months, cass_int32_t days, cass_int64_t nanos),
-                    cass::CassDuration(months, days, nanos))
+                    CassDuration(months, days, nanos))
 
 #undef CASS_STATEMENT_BIND
 
-CassError cass_statement_bind_string(CassStatement* statement, size_t index,
-                                     const char* value) {
-  return cass_statement_bind_string_n(statement, index,
-                                      value, SAFE_STRLEN(value));
+CassError cass_statement_bind_string(CassStatement* statement, size_t index, const char* value) {
+  return cass_statement_bind_string_n(statement, index, value, SAFE_STRLEN(value));
 }
 
-CassError cass_statement_bind_string_n(CassStatement* statement, size_t index,
-                                       const char* value, size_t value_length) {
-  return statement->set(index, cass::CassString(value, value_length));
+CassError cass_statement_bind_string_n(CassStatement* statement, size_t index, const char* value,
+                                       size_t value_length) {
+  return statement->set(index, CassString(value, value_length));
 }
 
-CassError cass_statement_bind_string_by_name(CassStatement* statement,
-                                             const char* name,
+CassError cass_statement_bind_string_by_name(CassStatement* statement, const char* name,
                                              const char* value) {
-  return statement->set(cass::StringRef(name),
-                        cass::CassString(value, SAFE_STRLEN(value)));
+  return statement->set(StringRef(name), CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_statement_bind_string_by_name_n(CassStatement* statement,
-                                               const char* name,
-                                               size_t name_length,
-                                               const char* value,
+CassError cass_statement_bind_string_by_name_n(CassStatement* statement, const char* name,
+                                               size_t name_length, const char* value,
                                                size_t value_length) {
-  return statement->set(cass::StringRef(name, name_length),
-                        cass::CassString(value, SAFE_STRLEN(value)));
+  return statement->set(StringRef(name, name_length), CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_statement_bind_custom(CassStatement* statement,
-                                     size_t index,
-                                     const char* class_name,
-                                     const cass_byte_t* value,
-                                     size_t value_size) {
-  return statement->set(index,
-                        cass::CassCustom(cass::StringRef(class_name),
-                                         value, value_size));
+CassError cass_statement_bind_custom(CassStatement* statement, size_t index, const char* class_name,
+                                     const cass_byte_t* value, size_t value_size) {
+  return statement->set(index, CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_statement_bind_custom_n(CassStatement* statement,
-                                       size_t index,
-                                       const char* class_name,
-                                       size_t class_name_length,
-                                       const cass_byte_t* value,
-                                       size_t value_size) {
+CassError cass_statement_bind_custom_n(CassStatement* statement, size_t index,
+                                       const char* class_name, size_t class_name_length,
+                                       const cass_byte_t* value, size_t value_size) {
   return statement->set(index,
-                        cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                         value, value_size));
+                        CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
-CassError cass_statement_bind_custom_by_name(CassStatement* statement,
-                                             const char* name,
-                                             const char* class_name,
-                                             const cass_byte_t* value,
+CassError cass_statement_bind_custom_by_name(CassStatement* statement, const char* name,
+                                             const char* class_name, const cass_byte_t* value,
                                              size_t value_size) {
-  return statement->set(cass::StringRef(name),
-                        cass::CassCustom(cass::StringRef(class_name),
-                                         value, value_size));
+  return statement->set(StringRef(name), CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_statement_bind_custom_by_name_n(CassStatement* statement,
-                                               const char* name,
-                                               size_t name_length,
-                                               const char* class_name,
-                                               size_t class_name_length,
-                                               const cass_byte_t* value,
+CassError cass_statement_bind_custom_by_name_n(CassStatement* statement, const char* name,
+                                               size_t name_length, const char* class_name,
+                                               size_t class_name_length, const cass_byte_t* value,
                                                size_t value_size) {
-  return statement->set(cass::StringRef(name, name_length),
-                        cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                         value, value_size));
+  return statement->set(StringRef(name, name_length),
+                        CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
 } // extern "C"
 
-namespace cass {
-
 Statement::Statement(const char* query, size_t query_length, size_t values_count)
-  : RoutableRequest(CQL_OPCODE_QUERY)
-  , AbstractData(values_count)
-  , query_or_id_(sizeof(int32_t) + query_length)
-  , flags_(0)
-  , page_size_(-1) {
+    : RoutableRequest(CQL_OPCODE_QUERY)
+    , AbstractData(values_count)
+    , query_or_id_(sizeof(int32_t) + query_length)
+    , flags_(0)
+    , page_size_(-1) {
   // <query> [long string]
   query_or_id_.encode_long_string(0, query, query_length);
 }
 
 Statement::Statement(const Prepared* prepared)
-  : RoutableRequest(CQL_OPCODE_EXECUTE)
-  , AbstractData(prepared->result()->column_count())
-  , query_or_id_(sizeof(uint16_t) + prepared->id().size())
-  , flags_(0)
-  , page_size_(-1) {
+    : RoutableRequest(CQL_OPCODE_EXECUTE)
+    , AbstractData(prepared->result()->column_count())
+    , query_or_id_(sizeof(uint16_t) + prepared->id().size())
+    , flags_(0)
+    , page_size_(-1) {
   // <id> [short bytes] (or [string])
   const String& id = prepared->id();
   query_or_id_.encode_string(0, id.data(), id.size());
@@ -341,8 +287,7 @@ Statement::Statement(const Prepared* prepared)
 
 String Statement::query() const {
   if (opcode() == CQL_OPCODE_QUERY) {
-    return String(query_or_id_.data() + sizeof(int32_t),
-                  query_or_id_.size() - sizeof(int32_t));
+    return String(query_or_id_.data() + sizeof(int32_t), query_or_id_.size() - sizeof(int32_t));
   }
   return String();
 }
@@ -353,7 +298,8 @@ String Statement::query() const {
 // <string_or_id> is a [long string] for <string> and a [short bytes] for <id>
 // <n> is a [short]
 // <value> is a [bytes]
-int32_t Statement::encode_batch(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int32_t Statement::encode_batch(ProtocolVersion version, RequestCallback* callback,
+                                BufferVec* bufs) const {
   int32_t length = 0;
 
   { // <kind> [byte]
@@ -384,9 +330,9 @@ int32_t Statement::encode_batch(ProtocolVersion version, RequestCallback* callba
 
 bool Statement::with_keyspace(ProtocolVersion version) const {
   return version.supports_set_keyspace() &&
-      // Execute requests (bound statements) use the keyspace
-      // from the time of prepare.
-      opcode() != CQL_OPCODE_EXECUTE && !keyspace().empty();
+         // Execute requests (bound statements) use the keyspace
+         // from the time of prepare.
+         opcode() != CQL_OPCODE_EXECUTE && !keyspace().empty();
 }
 
 // For query statements the format is:
@@ -475,15 +421,16 @@ int32_t Statement::encode_begin(ProtocolVersion version, uint16_t element_count,
 // Format: [<value_1>...<value_n>]
 // where:
 // <value> is a [bytes]
-int32_t Statement::encode_values(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int32_t Statement::encode_values(ProtocolVersion version, RequestCallback* callback,
+                                 BufferVec* bufs) const {
   int32_t length = 0;
   for (size_t i = 0; i < elements().size(); ++i) {
     const Element& element = elements()[i];
     if (!element.is_unset()) {
       bufs->push_back(element.get_buffer());
-    } else  {
+    } else {
       if (version >= CASS_PROTOCOL_VERSION_V4) {
-        bufs->push_back(cass::encode_with_length(CassUnset()));
+        bufs->push_back(core::encode_with_length(CassUnset()));
       } else {
         OStringStream ss;
         ss << "Query parameter at index " << i << " was not set";
@@ -503,7 +450,8 @@ int32_t Statement::encode_values(ProtocolVersion version, RequestCallback* callb
 // <serial_consistency> is a [short]
 // <timestamp> is a [long]
 // <keyspace> is a [string]
-int32_t Statement::encode_end(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const {
+int32_t Statement::encode_end(ProtocolVersion version, RequestCallback* callback,
+                              BufferVec* bufs) const {
   int32_t length = 0;
   size_t paging_buf_size = 0;
 
@@ -560,7 +508,8 @@ int32_t Statement::encode_end(ProtocolVersion version, RequestCallback* callback
   return length;
 }
 
-bool Statement::calculate_routing_key(const Vector<size_t>& key_indices, String* routing_key) const {
+bool Statement::calculate_routing_key(const Vector<size_t>& key_indices,
+                                      String* routing_key) const {
   if (key_indices.empty()) return false;
 
   if (key_indices.size() == 1) {
@@ -570,13 +519,11 @@ bool Statement::calculate_routing_key(const Vector<size_t>& key_indices, String*
       return false;
     }
     Buffer buf(element.get_buffer());
-    routing_key->assign(buf.data() + sizeof(int32_t),
-                        buf.size() - sizeof(int32_t));
+    routing_key->assign(buf.data() + sizeof(int32_t), buf.size() - sizeof(int32_t));
   } else {
     size_t length = 0;
 
-    for (Vector<size_t>::const_iterator i = key_indices.begin();
-         i != key_indices.end(); ++i) {
+    for (Vector<size_t>::const_iterator i = key_indices.begin(); i != key_indices.end(); ++i) {
       assert(*i < elements().size());
       const AbstractData::Element& element(elements()[*i]);
       if (element.is_unset() || element.is_null()) {
@@ -589,8 +536,7 @@ bool Statement::calculate_routing_key(const Vector<size_t>& key_indices, String*
     routing_key->clear();
     routing_key->reserve(length);
 
-    for (Vector<size_t>::const_iterator i = key_indices.begin();
-         i != key_indices.end(); ++i) {
+    for (Vector<size_t>::const_iterator i = key_indices.begin(); i != key_indices.end(); ++i) {
       const AbstractData::Element& element(elements()[*i]);
       Buffer buf(element.get_buffer());
       size_t size = buf.size() - sizeof(int32_t);
@@ -605,5 +551,3 @@ bool Statement::calculate_routing_key(const Vector<size_t>& key_indices, String*
 
   return true;
 }
-
-} // namespace  cass
diff --git a/src/statement.hpp b/src/statement.hpp
index c6ef354a9..1670a5080 100644
--- a/src/statement.hpp
+++ b/src/statement.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_STATEMENT_HPP_INCLUDED__
-#define __CASS_STATEMENT_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STATEMENT_HPP
+#define DATASTAX_INTERNAL_STATEMENT_HPP
 
 #include "abstract_data.hpp"
 #include "constants.hpp"
@@ -30,20 +30,21 @@
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class RequestCallback;
 
-class Statement : public RoutableRequest, public AbstractData {
+class Statement
+    : public RoutableRequest
+    , public AbstractData {
 public:
   typedef SharedRefPtr<Statement> Ptr;
 
-  Statement(const char* query, size_t query_length,
-            size_t values_count);
+  Statement(const char* query, size_t query_length, size_t values_count);
 
   Statement(const Prepared* prepared);
 
-  virtual ~Statement() { }
+  virtual ~Statement() {}
 
   // Used to get the original query string from a simple statement. To get the
   // query from a execute request (bound statement) cast it and get it from the
@@ -58,9 +59,7 @@ class Statement : public RoutableRequest, public AbstractData {
     }
   }
 
-  bool has_names_for_values() const {
-    return flags_ & CASS_QUERY_FLAG_NAMES_FOR_VALUES;
-  }
+  bool has_names_for_values() const { return flags_ & CASS_QUERY_FLAG_NAMES_FOR_VALUES; }
 
   int32_t page_size() const { return page_size_; }
 
@@ -68,13 +67,10 @@ class Statement : public RoutableRequest, public AbstractData {
 
   const String& paging_state() const { return paging_state_; }
 
-  void set_paging_state(const String& paging_state) {
-    paging_state_ = paging_state;
-  }
+  void set_paging_state(const String& paging_state) { paging_state_ = paging_state; }
 
   uint8_t kind() const {
-    return opcode() == CQL_OPCODE_QUERY ? CASS_BATCH_KIND_QUERY
-                                        : CASS_BATCH_KIND_PREPARED;
+    return opcode() == CQL_OPCODE_QUERY ? CASS_BATCH_KIND_QUERY : CASS_BATCH_KIND_PREPARED;
   }
 
   void add_key_index(size_t index) { key_indices_.push_back(index); }
@@ -89,8 +85,8 @@ class Statement : public RoutableRequest, public AbstractData {
   bool with_keyspace(ProtocolVersion version) const;
 
   int32_t encode_query_or_id(BufferVec* bufs) const;
-  int32_t encode_begin(ProtocolVersion version, uint16_t element_count,
-                       RequestCallback* callback, BufferVec* bufs) const;
+  int32_t encode_begin(ProtocolVersion version, uint16_t element_count, RequestCallback* callback,
+                       BufferVec* bufs) const;
   int32_t encode_values(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
   int32_t encode_end(ProtocolVersion version, RequestCallback* callback, BufferVec* bufs) const;
 
@@ -107,8 +103,8 @@ class Statement : public RoutableRequest, public AbstractData {
   DISALLOW_COPY_AND_ASSIGN(Statement);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Statement, CassStatement)
+EXTERNAL_TYPE(datastax::internal::core::Statement, CassStatement)
 
 #endif
diff --git a/src/stream_manager.hpp b/src/stream_manager.hpp
index bc1d81dcc..a694599f5 100644
--- a/src/stream_manager.hpp
+++ b/src/stream_manager.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_STREAM_MANAGER_HPP_INCLUDED__
-#define __CASS_STREAM_MANAGER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STREAM_MANAGER_HPP
+#define DATASTAX_INTERNAL_STREAM_MANAGER_HPP
 
 #include "constants.hpp"
 #include "dense_hash_map.hpp"
@@ -30,12 +30,10 @@
 #include <intrin.h>
 #endif
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 struct StreamHash {
-  std::size_t operator()(int stream) const {
-    return ((stream & 0x3F) << 10) | (stream >> 6);
-  }
+  std::size_t operator()(int stream) const { return ((stream & 0x3F) << 10) | (stream >> 6); }
 };
 
 template <class T>
@@ -96,12 +94,12 @@ class StreamManager {
     return __builtin_ctzl(word);
 #elif defined(_MSC_VER)
     unsigned long index;
-#  if defined(_M_AMD64)
+#if defined(_M_AMD64)
     _BitScanForward64(&index, word);
 
-#  else
+#else
     _BitScanForward(&index, word);
-#  endif
+#endif
     return static_cast<int>(index);
 #else
 #endif
@@ -151,6 +149,6 @@ class StreamManager {
   DISALLOW_COPY_AND_ASSIGN(StreamManager);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/string.hpp b/src/string.hpp
index f8a4e7636..9827bf12c 100644
--- a/src/string.hpp
+++ b/src/string.hpp
@@ -5,90 +5,89 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_STRING_HPP_INCLUDED__
-#define __DSE_STRING_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STRING_HPP
+#define DATASTAX_INTERNAL_STRING_HPP
 
 #include "allocator.hpp"
-#include "cassconfig.hpp"
+#include "driver_config.hpp"
 #include "hash.hpp"
 
 #include <sparsehash/dense_hash_map>
-#include <string>
 #include <sstream>
+#include <string>
 
-namespace cass {
+namespace datastax {
 
-typedef std::basic_string<char, std::char_traits<char>, cass::Allocator<char> > String;
+typedef std::basic_string<char, std::char_traits<char>, internal::Allocator<char> > String;
 
-class OStringStream : public std::basic_ostream<char, std::char_traits<char> >
-{
+namespace internal {
+
+class OStringStream : public std::basic_ostream<char, std::char_traits<char> > {
 public:
-    typedef char                   char_type;
-    typedef std::char_traits<char> traits_type;
-    typedef traits_type::int_type  int_type;
-    typedef traits_type::pos_type  pos_type;
-    typedef traits_type::off_type  off_type;
-    typedef cass::Allocator<char>  allocator_type;
+  typedef char char_type;
+  typedef std::char_traits<char> traits_type;
+  typedef traits_type::int_type int_type;
+  typedef traits_type::pos_type pos_type;
+  typedef traits_type::off_type off_type;
+  typedef internal::Allocator<char> allocator_type;
 
-    typedef std::basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef std::basic_string<char_type, traits_type, allocator_type> string_type;
 
 public:
-    explicit OStringStream(std::ios_base::openmode mode = ios_base::out)
+  explicit OStringStream(std::ios_base::openmode mode = ios_base::out)
       : std::basic_ostream<char_type, traits_type>(&sb_)
-      , sb_(mode | ios_base::out) { }
+      , sb_(mode | ios_base::out) {}
 
-    explicit OStringStream(const string_type& str,
-                           std::ios_base::openmode mode = ios_base::out)
-    : std::basic_ostream<char_type, traits_type>(&sb_)
-    , sb_(str, mode | std::ios_base::out) { }
+  explicit OStringStream(const string_type& str, std::ios_base::openmode mode = ios_base::out)
+      : std::basic_ostream<char_type, traits_type>(&sb_)
+      , sb_(str, mode | std::ios_base::out) {}
 
-    std::basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
-      return const_cast<std::basic_stringbuf<char_type, traits_type, allocator_type>*>(&sb_);
-    }
+  std::basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+    return const_cast<std::basic_stringbuf<char_type, traits_type, allocator_type>*>(&sb_);
+  }
 
-    string_type str() const { return sb_.str(); }
+  string_type str() const { return sb_.str(); }
 
-    void str(const string_type& str) { sb_.str(str); }
+  void str(const string_type& str) { sb_.str(str); }
 
 private:
-  std::basic_stringbuf<char, std::char_traits<char>, cass::Allocator<char> > sb_;
+  std::basic_stringbuf<char, std::char_traits<char>, internal::Allocator<char> > sb_;
 };
 
-class IStringStream : public std::basic_istream<char, std::char_traits<char> >
-{
+class IStringStream : public std::basic_istream<char, std::char_traits<char> > {
 public:
-    typedef char                   char_type;
-    typedef std::char_traits<char> traits_type;
-    typedef traits_type::int_type  int_type;
-    typedef traits_type::pos_type  pos_type;
-    typedef traits_type::off_type  off_type;
-    typedef cass::Allocator<char>  allocator_type;
+  typedef char char_type;
+  typedef std::char_traits<char> traits_type;
+  typedef traits_type::int_type int_type;
+  typedef traits_type::pos_type pos_type;
+  typedef traits_type::off_type off_type;
+  typedef internal::Allocator<char> allocator_type;
 
-    typedef std::basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef std::basic_string<char_type, traits_type, allocator_type> string_type;
 
 public:
-    explicit IStringStream(std::ios_base::openmode mode = ios_base::in)
+  explicit IStringStream(std::ios_base::openmode mode = ios_base::in)
       : std::basic_istream<char_type, traits_type>(&sb_)
-      , sb_(mode | ios_base::in) { }
+      , sb_(mode | ios_base::in) {}
 
-    explicit IStringStream(const string_type& str,
-                           std::ios_base::openmode mode = ios_base::in)
-    : std::basic_istream<char_type, traits_type>(&sb_)
-    , sb_(str, mode | std::ios_base::in) { }
+  explicit IStringStream(const string_type& str, std::ios_base::openmode mode = ios_base::in)
+      : std::basic_istream<char_type, traits_type>(&sb_)
+      , sb_(str, mode | std::ios_base::in) {}
 
-    std::basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
-      return const_cast<std::basic_stringbuf<char_type, traits_type, allocator_type>*>(&sb_);
-    }
+  std::basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+    return const_cast<std::basic_stringbuf<char_type, traits_type, allocator_type>*>(&sb_);
+  }
 
-    string_type str() const { return sb_.str(); }
+  string_type str() const { return sb_.str(); }
 
-    void str(const string_type& str) { sb_.str(str); }
+  void str(const string_type& str) { sb_.str(str); }
 
 private:
-  std::basic_stringbuf<char, std::char_traits<char>, cass::Allocator<char> > sb_;
+  std::basic_stringbuf<char, std::char_traits<char>, internal::Allocator<char> > sb_;
 };
 
-} // namepsace cass
+} // namespace internal
+} // namespace datastax
 
 namespace std {
 
@@ -97,16 +96,16 @@ namespace tr1 {
 #endif
 
 template <>
-struct hash<cass::String> {
-  size_t operator()(const cass::String& str) const {
-    return cass::hash::fnv1a(str.data(), str.size());
+struct hash<datastax::String> {
+  size_t operator()(const datastax::String& str) const {
+    return datastax::hash::fnv1a(str.data(), str.size());
   }
 };
 
 #if defined(HASH_IN_TR1) && !defined(_WIN32)
-} //namespace tr1
+} // namespace tr1
 #endif
 
-} //namespace std
+} // namespace std
 
 #endif
diff --git a/src/string_ref.cpp b/src/string_ref.cpp
index 1fc6ac905..7e1e17352 100644
--- a/src/string_ref.cpp
+++ b/src/string_ref.cpp
@@ -16,9 +16,8 @@
 
 #include "string_ref.hpp"
 
-namespace cass {
+namespace datastax {
 
 const StringRef::size_type StringRef::npos = -1;
 
-} // namespace cass
-
+} // namespace datastax
diff --git a/src/string_ref.hpp b/src/string_ref.hpp
index b605bcd00..f0e6aa2bd 100644
--- a/src/string_ref.hpp
+++ b/src/string_ref.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_STRING_REF_HPP_INCLUDED__
-#define __CASS_STRING_REF_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_STRING_REF_HPP
+#define DATASTAX_INTERNAL_STRING_REF_HPP
 
 #include "hash.hpp"
 #include "macros.hpp"
@@ -28,11 +28,10 @@
 #include <stddef.h>
 #include <string.h>
 
-namespace cass {
+namespace datastax {
 
-template<class IsEqual>
-int compare(const char* s1,  const char* s2,
-            size_t length, IsEqual is_equal) {
+template <class IsEqual>
+int compare(const char* s1, const char* s2, size_t length, IsEqual is_equal) {
   for (size_t i = 0; i < length; ++i) {
     if (!is_equal(s1[i], s2[i])) {
       return s1[i] < s2[i] ? -1 : 1;
@@ -55,33 +54,29 @@ class StringRef {
   static const size_type npos;
 
   struct IsEqual {
-    bool operator()(char a, char b) const {
-      return a == b;
-    }
+    bool operator()(char a, char b) const { return a == b; }
   };
 
   struct IsEqualInsensitive {
-    bool operator()(char a, char b) const {
-      return std::toupper(a) == std::toupper(b);
-    }
+    bool operator()(char a, char b) const { return std::toupper(a) == std::toupper(b); }
   };
 
 public:
   StringRef()
-    : ptr_(NULL)
-    , length_(0) {}
+      : ptr_(NULL)
+      , length_(0) {}
 
   StringRef(const char* ptr, size_t length)
-    : ptr_(ptr)
-    , length_(length) {}
+      : ptr_(ptr)
+      , length_(length) {}
 
   StringRef(const char* str)
-    : ptr_(str)
-    , length_(SAFE_STRLEN(str)) {}
+      : ptr_(str)
+      , length_(SAFE_STRLEN(str)) {}
 
   StringRef(const String& str)
-    : ptr_(str.data())
-    , length_(str.size()) {}
+      : ptr_(str.data())
+      , length_(str.size()) {}
 
   const char* data() const { return ptr_; }
   size_t size() const { return length_; }
@@ -94,9 +89,7 @@ class StringRef {
   char front() const { return ptr_[0]; }
   char back() const { return ptr_[length_ - 1]; }
 
-  String to_string() const {
-    return String(ptr_, length_);
-  }
+  String to_string() const { return String(ptr_, length_); }
 
   StringRef substr(size_t pos = 0, size_t length = npos) {
     assert(pos < length_);
@@ -111,58 +104,42 @@ class StringRef {
     return i - begin();
   }
 
-  int compare(const StringRef& ref) const {
-    return compare(ref, IsEqual());
-  }
+  int compare(const StringRef& ref) const { return compare(ref, IsEqual()); }
 
-  int icompare(const StringRef& ref) const {
-    return compare(ref, IsEqualInsensitive());
-  }
+  int icompare(const StringRef& ref) const { return compare(ref, IsEqualInsensitive()); }
 
-  bool equals(const StringRef& ref) const {
-    return compare(ref) == 0;
-  }
+  bool equals(const StringRef& ref) const { return compare(ref) == 0; }
 
-  bool iequals(const StringRef& ref) const {
-    return icompare(ref) == 0;
-  }
+  bool iequals(const StringRef& ref) const { return icompare(ref) == 0; }
 
-  bool operator==(const StringRef& ref) const {
-    return equals(ref);
-  }
+  bool operator==(const StringRef& ref) const { return equals(ref); }
 
-  bool operator!=(const StringRef& ref) const {
-    return !equals(ref);
-  }
+  bool operator!=(const StringRef& ref) const { return !equals(ref); }
 
-  bool operator<(const StringRef& ref) const {
-    return compare(ref) < 0;
-  }
+  bool operator<(const StringRef& ref) const { return compare(ref) < 0; }
 
 private:
-  template<class IsEqual>
+  template <class IsEqual>
   int compare(const StringRef& ref, IsEqual is_equal) const {
     if (length_ < ref.length_) {
       return -1;
-    } else if(length_ > ref.length_) {
+    } else if (length_ > ref.length_) {
       return 1;
     }
-    return cass::compare(ptr_, ref.ptr_, length_, is_equal);
+    return datastax::compare(ptr_, ref.ptr_, length_, is_equal);
   }
 
   const char* ptr_;
   size_t length_;
 };
 
-typedef Vector<String> StringVec;
-typedef Vector<StringRef> StringRefVec;
+typedef internal::Vector<String> StringVec;
+typedef internal::Vector<StringRef> StringRefVec;
 
 inline StringVec to_strings(const StringRefVec& refs) {
   StringVec strings;
   strings.reserve(refs.size());
-  for (StringRefVec::const_iterator i = refs.begin(), end = refs.end();
-       i != end;
-       ++i) {
+  for (StringRefVec::const_iterator i = refs.begin(), end = refs.end(); i != end; ++i) {
     strings.push_back(i->to_string());
   }
   return strings;
@@ -170,19 +147,16 @@ inline StringVec to_strings(const StringRefVec& refs) {
 
 inline bool starts_with(const StringRef& input, const StringRef& target) {
   return input.length() >= target.length() &&
-      cass::compare(input.data(), target.data(), target.size(),
-                    StringRef::IsEqual()) == 0;
+         compare(input.data(), target.data(), target.size(), StringRef::IsEqual()) == 0;
 }
 
 inline bool ends_with(const StringRef& input, const StringRef& target) {
   return input.length() >= target.length() &&
-      cass::compare(input.data() + (input.length() - target.length()),
-                    target.data(), target.size(), StringRef::IsEqual()) == 0;
+         compare(input.data() + (input.length() - target.length()), target.data(), target.size(),
+                 StringRef::IsEqual()) == 0;
 }
 
-inline bool iequals(const StringRef& lhs, const StringRef& rhs) {
-  return lhs.iequals(rhs);
-}
+inline bool iequals(const StringRef& lhs, const StringRef& rhs) { return lhs.iequals(rhs); }
 
 struct StringRefIHash {
   std::size_t operator()(const StringRef& s) const {
@@ -191,11 +165,9 @@ struct StringRefIHash {
 };
 
 struct StringRefIEquals {
-  bool operator()(const StringRef& lhs, const StringRef& rhs) const {
-    return lhs.iequals(rhs);
-  }
+  bool operator()(const StringRef& lhs, const StringRef& rhs) const { return lhs.iequals(rhs); }
 };
 
-} // namespace cass
+} // namespace datastax
 
 #endif
diff --git a/src/supported_response.cpp b/src/supported_response.cpp
index 787b38e5c..daba03728 100644
--- a/src/supported_response.cpp
+++ b/src/supported_response.cpp
@@ -18,7 +18,7 @@
 
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool SupportedResponse::decode(Decoder& decoder) {
   decoder.set_type("supported");
@@ -43,5 +43,3 @@ bool SupportedResponse::decode(Decoder& decoder) {
   }
   return true;
 }
-
-} // namespace cass
diff --git a/src/supported_response.hpp b/src/supported_response.hpp
index d0b1b6be2..ddc8a1fe4 100644
--- a/src/supported_response.hpp
+++ b/src/supported_response.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_SUPPORTED_RESPONSE_HPP_INCLUDED__
-#define __CASS_SUPPORTED_RESPONSE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_SUPPORTED_RESPONSE_HPP
+#define DATASTAX_INTERNAL_SUPPORTED_RESPONSE_HPP
 
-#include "response.hpp"
 #include "constants.hpp"
+#include "response.hpp"
 #include "string.hpp"
 #include "vector.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class SupportedResponse : public Response {
 public:
@@ -41,6 +41,6 @@ class SupportedResponse : public Response {
   Vector<String> protocol_versions_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/tcp_connector.hpp b/src/tcp_connector.hpp
index 447be4a81..bf9f1a896 100644
--- a/src/tcp_connector.hpp
+++ b/src/tcp_connector.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_CONNECTOR_HPP_INCLUDED__
-#define __CASS_CONNECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_CONNECTOR_HPP
+#define DATASTAX_INTERNAL_CONNECTOR_HPP
 
 #include <uv.h>
 
@@ -23,7 +23,7 @@
 #include "callback.hpp"
 #include "ref_counted.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A wrapper for uv_connect that handles connecting a TCP connection.
@@ -32,16 +32,9 @@ class TcpConnector : public RefCounted<TcpConnector> {
 public:
   typedef SharedRefPtr<TcpConnector> Ptr;
 
-  typedef cass::Callback<void, TcpConnector*> Callback;
+  typedef internal::Callback<void, TcpConnector*> Callback;
 
-  enum Status {
-    NEW,
-    CONNECTING,
-    FAILED_BAD_PARAM,
-    FAILED_TO_CONNECT,
-    CANCELED,
-    SUCCESS
-  };
+  enum Status { NEW, CONNECTING, FAILED_BAD_PARAM, FAILED_TO_CONNECT, CANCELED, SUCCESS };
 
   /**
    * Constructor
@@ -91,7 +84,7 @@ class TcpConnector : public RefCounted<TcpConnector> {
   }
 
 public:
-  uv_loop_t* loop() { return req_.handle->loop;  }
+  uv_loop_t* loop() { return req_.handle->loop; }
 
   bool is_success() { return status_ == SUCCESS; }
   bool is_canceled() { return status_ == CANCELED; }
@@ -100,7 +93,6 @@ class TcpConnector : public RefCounted<TcpConnector> {
 
   const Address& address() { return address_; }
 
-
 private:
   static void on_connect(uv_connect_t* req, int status) {
     TcpConnector* connector = static_cast<TcpConnector*>(req->data);
@@ -125,6 +117,6 @@ class TcpConnector : public RefCounted<TcpConnector> {
   int uv_status_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/testing.cpp b/src/testing.cpp
index 7c2be1b28..c5d630c24 100644
--- a/src/testing.cpp
+++ b/src/testing.cpp
@@ -28,14 +28,15 @@
 #include "result_response.hpp"
 #include "session.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace testing {
+
+using namespace core;
 
 String get_host_from_future(CassFuture* future) {
-  if (future->type() != cass::Future::FUTURE_TYPE_RESPONSE) {
+  if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
     return "";
   }
-  cass::ResponseFuture* response_future =
-      static_cast<cass::ResponseFuture*>(future->from());
+  ResponseFuture* response_future = static_cast<ResponseFuture*>(future->from());
   return response_future->address().to_string();
 }
 
@@ -43,18 +44,14 @@ unsigned get_connect_timeout_from_cluster(CassCluster* cluster) {
   return cluster->config().connect_timeout_ms();
 }
 
-int get_port_from_cluster(CassCluster* cluster) {
-  return cluster->config().port();
-}
+int get_port_from_cluster(CassCluster* cluster) { return cluster->config().port(); }
 
 String get_contact_points_from_cluster(CassCluster* cluster) {
   String str;
 
-  const ContactPointList& contact_points
-      = cluster->config().contact_points();
+  const ContactPointList& contact_points = cluster->config().contact_points();
 
-  for (ContactPointList::const_iterator it = contact_points.begin(),
-       end = contact_points.end();
+  for (ContactPointList::const_iterator it = contact_points.begin(), end = contact_points.end();
        it != end; ++it) {
     if (str.size() > 0) {
       str.push_back(',');
@@ -65,13 +62,11 @@ String get_contact_points_from_cluster(CassCluster* cluster) {
   return str;
 }
 
-int64_t create_murmur3_hash_from_string(const String &value) {
+int64_t create_murmur3_hash_from_string(const String& value) {
   return MurmurHash3_x64_128(value.data(), value.size(), 0);
 }
 
-uint64_t get_time_since_epoch_in_ms() {
-  return cass::get_time_since_epoch_ms();
-}
+uint64_t get_time_since_epoch_in_ms() { return internal::get_time_since_epoch_ms(); }
 
 uint64_t get_host_latency_average(CassSession* session, String ip_address, int port) {
   Address address;
@@ -82,4 +77,4 @@ uint64_t get_host_latency_average(CassSession* session, String ip_address, int p
   return 0;
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::testing
diff --git a/src/testing.hpp b/src/testing.hpp
index 30325796d..b616707a0 100644
--- a/src/testing.hpp
+++ b/src/testing.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TESTING_HPP_INCLUDED__
-#define __CASS_TESTING_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TESTING_HPP
+#define DATASTAX_INTERNAL_TESTING_HPP
 
 #include "cassandra.h"
 #include "string.hpp"
@@ -23,7 +23,7 @@
 
 #include <stdint.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace testing {
 
 CASS_EXPORT String get_host_from_future(CassFuture* future);
 
@@ -33,12 +33,12 @@ CASS_EXPORT int get_port_from_cluster(CassCluster* cluster);
 
 CASS_EXPORT String get_contact_points_from_cluster(CassCluster* cluster);
 
-CASS_EXPORT int64_t create_murmur3_hash_from_string(const String &value);
+CASS_EXPORT int64_t create_murmur3_hash_from_string(const String& value);
 
 CASS_EXPORT uint64_t get_time_since_epoch_in_ms();
 
 CASS_EXPORT uint64_t get_host_latency_average(CassSession* session, String ip_address, int port);
 
-} // namespace cass
+}}} // namespace datastax::internal::testing
 
 #endif
diff --git a/src/third_party/curl/hostcheck.hpp b/src/third_party/curl/hostcheck.hpp
index 989270730..f909472a3 100644
--- a/src/third_party/curl/hostcheck.hpp
+++ b/src/third_party/curl/hostcheck.hpp
@@ -27,4 +27,3 @@
 int Curl_cert_hostcheck(const char *match_pattern, const char *hostname);
 
 #endif /* HEADER_CURL_HOSTCHECK_H */
-
diff --git a/src/timer.cpp b/src/timer.cpp
index c5039aac9..b1c88dfe4 100644
--- a/src/timer.cpp
+++ b/src/timer.cpp
@@ -16,15 +16,13 @@
 
 #include "timer.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 Timer::Timer()
-  : handle_(NULL)
-  , state_(CLOSED) { }
+    : handle_(NULL)
+    , state_(CLOSED) {}
 
-Timer::~Timer() {
-  stop();
-}
+Timer::~Timer() { stop(); }
 
 int Timer::start(uv_loop_t* loop, uint64_t timeout, const Timer::Callback& callback) {
   int rc = 0;
@@ -70,5 +68,3 @@ void Timer::handle_timeout() {
 void Timer::on_close(uv_handle_t* handle) {
   delete reinterpret_cast<AllocatedT<uv_timer_t>*>(handle);
 }
-
-} // namespace cass
diff --git a/src/timer.hpp b/src/timer.hpp
index b1d6a7ce1..592b82cb5 100644
--- a/src/timer.hpp
+++ b/src/timer.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TIMER_HPP_INCLUDED__
-#define __CASS_TIMER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TIMER_HPP
+#define DATASTAX_INTERNAL_TIMER_HPP
 
 #include "allocated.hpp"
 #include "callback.hpp"
@@ -23,11 +23,11 @@
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Timer {
 public:
-  typedef cass::Callback<void, Timer*> Callback;
+  typedef internal::Callback<void, Timer*> Callback;
 
   Timer();
   ~Timer();
@@ -46,11 +46,7 @@ class Timer {
   static void on_close(uv_handle_t* handle);
 
 private:
-  enum State {
-    CLOSED,
-    STOPPED,
-    STARTED
-  };
+  enum State { CLOSED, STOPPED, STARTED };
 
 private:
   AllocatedT<uv_timer_t>* handle_;
@@ -61,6 +57,6 @@ class Timer {
   DISALLOW_COPY_AND_ASSIGN(Timer);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/timestamp_generator.cpp b/src/timestamp_generator.cpp
index 758df3037..d186d8106 100644
--- a/src/timestamp_generator.cpp
+++ b/src/timestamp_generator.cpp
@@ -20,37 +20,34 @@
 #include "get_time.hpp"
 #include "logger.hpp"
 
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassTimestampGen* cass_timestamp_gen_server_side_new() {
-  cass::TimestampGenerator* timestamp_gen = new cass::ServerSideTimestampGenerator();
+  TimestampGenerator* timestamp_gen = new ServerSideTimestampGenerator();
   timestamp_gen->inc_ref();
   return CassTimestampGen::to(timestamp_gen);
 }
 
 CassTimestampGen* cass_timestamp_gen_monotonic_new() {
-  cass::TimestampGenerator* timestamp_gen = new cass::MonotonicTimestampGenerator();
+  TimestampGenerator* timestamp_gen = new MonotonicTimestampGenerator();
   timestamp_gen->inc_ref();
   return CassTimestampGen::to(timestamp_gen);
 }
 
 CassTimestampGen* cass_timestamp_gen_monotonic_new_with_settings(int64_t warning_threshold_us,
                                                                  int64_t warning_interval_ms) {
-  cass::TimestampGenerator* timestamp_gen
-      = new cass::MonotonicTimestampGenerator(warning_threshold_us,
-                                              warning_interval_ms);
+  TimestampGenerator* timestamp_gen =
+      new MonotonicTimestampGenerator(warning_threshold_us, warning_interval_ms);
   timestamp_gen->inc_ref();
   return CassTimestampGen::to(timestamp_gen);
 }
 
-void cass_timestamp_gen_free(CassTimestampGen* timestamp_gen) {
-  timestamp_gen->dec_ref();
-}
+void cass_timestamp_gen_free(CassTimestampGen* timestamp_gen) { timestamp_gen->dec_ref(); }
 
 } // extern "C"
 
-namespace cass {
-
 int64_t MonotonicTimestampGenerator::next() {
   while (true) {
     int64_t last = last_.load();
@@ -80,8 +77,7 @@ int64_t MonotonicTimestampGenerator::compute_next(int64_t last) {
                  "microseconds behind the last generated timestamp (%lld). "
                  "The next generated timestamp will be artificially incremented "
                  "to guarantee monotonicity.",
-                 static_cast<long long>(current),
-                 static_cast<long long>(last - current),
+                 static_cast<long long>(current), static_cast<long long>(last - current),
                  static_cast<long long>(last));
       }
     }
@@ -91,5 +87,3 @@ int64_t MonotonicTimestampGenerator::compute_next(int64_t last) {
 
   return current;
 }
-
-} // namespace cass
diff --git a/src/timestamp_generator.hpp b/src/timestamp_generator.hpp
index 5fb754494..9a3b726b4 100644
--- a/src/timestamp_generator.hpp
+++ b/src/timestamp_generator.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TIMESTAMP_GENERATOR_HPP_INCLUDED__
-#define __CASS_TIMESTAMP_GENERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TIMESTAMP_GENERATOR_HPP
+#define DATASTAX_INTERNAL_TIMESTAMP_GENERATOR_HPP
 
 #include "atomic.hpp"
 #include "constants.hpp"
@@ -26,21 +26,18 @@
 
 #include <stdint.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class TimestampGenerator : public RefCounted<TimestampGenerator> {
 public:
   typedef SharedRefPtr<TimestampGenerator> Ptr;
 
-  enum Type {
-    SERVER_SIDE,
-    MONOTONIC
-  };
+  enum Type { SERVER_SIDE, MONOTONIC };
 
   TimestampGenerator(Type type)
-    : type_(type) { }
+      : type_(type) {}
 
-  virtual ~TimestampGenerator() { }
+  virtual ~TimestampGenerator() {}
 
   Type type() const { return type_; }
 
@@ -56,7 +53,7 @@ class TimestampGenerator : public RefCounted<TimestampGenerator> {
 class ServerSideTimestampGenerator : public TimestampGenerator {
 public:
   ServerSideTimestampGenerator()
-    : TimestampGenerator(SERVER_SIDE) { }
+      : TimestampGenerator(SERVER_SIDE) {}
 
   virtual int64_t next() { return CASS_INT64_MIN; }
 };
@@ -65,12 +62,11 @@ class MonotonicTimestampGenerator : public TimestampGenerator {
 public:
   MonotonicTimestampGenerator(int64_t warning_threshold_us = 1000000,
                               int64_t warning_interval_ms = 1000)
-    : TimestampGenerator(MONOTONIC)
-    , last_(0)
-    , last_warning_(0)
-    , warning_threshold_us_(warning_threshold_us)
-    , warning_interval_ms_(warning_interval_ms < 0 ? 0
-                                                   : warning_interval_ms) { }
+      : TimestampGenerator(MONOTONIC)
+      , last_(0)
+      , last_warning_(0)
+      , warning_threshold_us_(warning_threshold_us)
+      , warning_interval_ms_(warning_interval_ms < 0 ? 0 : warning_interval_ms) {}
 
   virtual int64_t next();
 
@@ -84,9 +80,8 @@ class MonotonicTimestampGenerator : public TimestampGenerator {
   const int64_t warning_interval_ms_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::TimestampGenerator, CassTimestampGen)
+EXTERNAL_TYPE(datastax::internal::core::TimestampGenerator, CassTimestampGen)
 
 #endif
-
diff --git a/src/token_aware_policy.cpp b/src/token_aware_policy.cpp
index 56d71ce7f..bc86dc8ca 100644
--- a/src/token_aware_policy.cpp
+++ b/src/token_aware_policy.cpp
@@ -21,13 +21,14 @@
 
 #include <algorithm>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 // The number of replicas is bounded by replication factor per DC. In practice, the number
 // of replicas is fairly small so a linear search should be extremely fast.
 static inline bool contains(const CopyOnWriteHostVec& replicas, const Address& address) {
-  for (HostVec::const_iterator i = replicas->begin(),
-       end = replicas->end(); i != end; ++i) {
+  for (HostVec::const_iterator i = replicas->begin(), end = replicas->end(); i != end; ++i) {
     if ((*i)->address() == address) {
       return true;
     }
@@ -35,9 +36,7 @@ static inline bool contains(const CopyOnWriteHostVec& replicas, const Address& a
   return false;
 }
 
-void TokenAwarePolicy::init(const Host::Ptr& connected_host,
-                            const HostMap& hosts,
-                            Random* random) {
+void TokenAwarePolicy::init(const Host::Ptr& connected_host, const HostMap& hosts, Random* random) {
   if (random != NULL) {
     if (shuffle_replicas_) {
       // Store random so that it can be used to shuffle replicas.
@@ -51,14 +50,14 @@ void TokenAwarePolicy::init(const Host::Ptr& connected_host,
   ChainedLoadBalancingPolicy::init(connected_host, hosts, random);
 }
 
-QueryPlan* TokenAwarePolicy::new_query_plan(const String& keyspace,
-                                            RequestHandler* request_handler,
+QueryPlan* TokenAwarePolicy::new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                             const TokenMap* token_map) {
   if (request_handler != NULL) {
-    const RoutableRequest* request = static_cast<const RoutableRequest*>(request_handler->request());
+    const RoutableRequest* request =
+        static_cast<const RoutableRequest*>(request_handler->request());
     switch (request->opcode()) {
       {
-      case CQL_OPCODE_QUERY:
+        case CQL_OPCODE_QUERY:
         case CQL_OPCODE_EXECUTE:
         case CQL_OPCODE_BATCH:
           String routing_key;
@@ -69,12 +68,10 @@ QueryPlan* TokenAwarePolicy::new_query_plan(const String& keyspace,
                 if (random_ != NULL) {
                   random_shuffle(replicas->begin(), replicas->end(), random_);
                 }
-                return new TokenAwareQueryPlan(child_policy_.get(),
-                                               child_policy_->new_query_plan(keyspace,
-                                                                             request_handler,
-                                                                             token_map),
-                                               replicas,
-                                               index_);
+                return new TokenAwareQueryPlan(
+                    child_policy_.get(),
+                    child_policy_->new_query_plan(keyspace, request_handler, token_map), replicas,
+                    index_);
               }
             }
           }
@@ -85,12 +82,10 @@ QueryPlan* TokenAwarePolicy::new_query_plan(const String& keyspace,
         break;
     }
   }
-  return child_policy_->new_query_plan(keyspace,
-                                       request_handler,
-                                       token_map);
+  return child_policy_->new_query_plan(keyspace, request_handler, token_map);
 }
 
-Host::Ptr TokenAwarePolicy::TokenAwareQueryPlan::compute_next()  {
+Host::Ptr TokenAwarePolicy::TokenAwareQueryPlan::compute_next() {
   while (remaining_ > 0) {
     --remaining_;
     const Host::Ptr& host((*replicas_)[index_++ % replicas_->size()]);
@@ -109,5 +104,3 @@ Host::Ptr TokenAwarePolicy::TokenAwareQueryPlan::compute_next()  {
   }
   return Host::Ptr();
 }
-
-} // namespace cass
diff --git a/src/token_aware_policy.hpp b/src/token_aware_policy.hpp
index 9fbe09fcb..9f4ff0d6f 100644
--- a/src/token_aware_policy.hpp
+++ b/src/token_aware_policy.hpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TOKEN_AWARE_POLICY_HPP_INCLUDED__
-#define __CASS_TOKEN_AWARE_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TOKEN_AWARE_POLICY_HPP
+#define DATASTAX_INTERNAL_TOKEN_AWARE_POLICY_HPP
 
-#include "token_map.hpp"
-#include "load_balancing.hpp"
 #include "host.hpp"
+#include "load_balancing.hpp"
 #include "scoped_ptr.hpp"
+#include "token_map.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class TokenAwarePolicy : public ChainedLoadBalancingPolicy {
 public:
@@ -32,12 +32,11 @@ class TokenAwarePolicy : public ChainedLoadBalancingPolicy {
       , index_(0)
       , shuffle_replicas_(shuffle_replicas) {}
 
-  virtual ~TokenAwarePolicy() { }
+  virtual ~TokenAwarePolicy() {}
 
   virtual void init(const Host::Ptr& connected_host, const HostMap& hosts, Random* random);
 
-  virtual QueryPlan* new_query_plan(const String& keyspace,
-                                    RequestHandler* request_handler,
+  virtual QueryPlan* new_query_plan(const String& keyspace, RequestHandler* request_handler,
                                     const TokenMap* token_map);
 
   LoadBalancingPolicy* new_instance() {
@@ -47,15 +46,13 @@ class TokenAwarePolicy : public ChainedLoadBalancingPolicy {
 private:
   class TokenAwareQueryPlan : public QueryPlan {
   public:
-    TokenAwareQueryPlan(LoadBalancingPolicy* child_policy,
-                        QueryPlan* child_plan,
-                        const CopyOnWriteHostVec& replicas,
-                        size_t start_index)
-      : child_policy_(child_policy)
-      , child_plan_(child_plan)
-      , replicas_(replicas)
-      , index_(start_index)
-      , remaining_(replicas->size()) { }
+    TokenAwareQueryPlan(LoadBalancingPolicy* child_policy, QueryPlan* child_plan,
+                        const CopyOnWriteHostVec& replicas, size_t start_index)
+        : child_policy_(child_policy)
+        , child_plan_(child_plan)
+        , replicas_(replicas)
+        , index_(start_index)
+        , remaining_(replicas->size()) {}
 
     Host::Ptr compute_next();
 
@@ -74,6 +71,6 @@ class TokenAwarePolicy : public ChainedLoadBalancingPolicy {
 private:
   DISALLOW_COPY_AND_ASSIGN(TokenAwarePolicy);
 };
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/token_map.cpp b/src/token_map.cpp
index db7ac7d73..b7a113d54 100644
--- a/src/token_map.cpp
+++ b/src/token_map.cpp
@@ -18,7 +18,8 @@
 
 #include "token_map_impl.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 TokenMap::Ptr TokenMap::from_partitioner(StringRef partitioner) {
   if (ends_with(partitioner, Murmur3Partitioner::name())) {
@@ -32,5 +33,3 @@ TokenMap::Ptr TokenMap::from_partitioner(StringRef partitioner) {
     return Ptr();
   }
 }
-
-} // namespace cass
diff --git a/src/token_map.hpp b/src/token_map.hpp
index 5a077584a..908a16f7d 100644
--- a/src/token_map.hpp
+++ b/src/token_map.hpp
@@ -14,19 +14,19 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TOKEN_MAP_HPP_INCLUDED__
-#define __CASS_TOKEN_MAP_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TOKEN_MAP_HPP
+#define DATASTAX_INTERNAL_TOKEN_MAP_HPP
 
 #include "host.hpp"
 #include "ref_counted.hpp"
 #include "string.hpp"
+#include "string_ref.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class VersionNumber;
 class Value;
 class ResultResponse;
-class StringRef;
 
 class TokenMap : public RefCounted<TokenMap> {
 public:
@@ -34,14 +34,16 @@ class TokenMap : public RefCounted<TokenMap> {
 
   static TokenMap::Ptr from_partitioner(StringRef partitioner);
 
-  virtual ~TokenMap() { }
+  virtual ~TokenMap() {}
 
   virtual void add_host(const Host::Ptr& host) = 0;
   virtual void update_host_and_build(const Host::Ptr& host) = 0;
   virtual void remove_host_and_build(const Host::Ptr& host) = 0;
 
-  virtual void add_keyspaces(const VersionNumber& cassandra_version, const ResultResponse* result) = 0;
-  virtual void update_keyspaces_and_build(const VersionNumber& cassandra_version, const ResultResponse* result) = 0;
+  virtual void add_keyspaces(const VersionNumber& cassandra_version,
+                             const ResultResponse* result) = 0;
+  virtual void update_keyspaces_and_build(const VersionNumber& cassandra_version,
+                                          const ResultResponse* result) = 0;
   virtual void drop_keyspace(const String& keyspace_name) = 0;
 
   virtual void build() = 0;
@@ -52,6 +54,6 @@ class TokenMap : public RefCounted<TokenMap> {
                                                  const String& routing_key) const = 0;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/token_map_impl.cpp b/src/token_map_impl.cpp
index 73018c59e..e99873a08 100644
--- a/src/token_map_impl.cpp
+++ b/src/token_map_impl.cpp
@@ -19,12 +19,14 @@
 #include "md5.hpp"
 #include "murmur3.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 static int64_t parse_int64(const char* p, size_t n) {
   int c;
   const char* s = p;
-  for (; n != 0 && isspace(c = *s); ++s, --n) {}
+  for (; n != 0 && isspace(c = *s); ++s, --n) {
+  }
 
   if (n == 0) {
     return 0;
@@ -33,11 +35,12 @@ static int64_t parse_int64(const char* p, size_t n) {
   int64_t sign = 1;
   if (c == '-') {
     sign = -1;
-    ++s; --n;
+    ++s;
+    --n;
   }
 
   int64_t value = 0;
-  for (; n != 0  && isdigit(c = *s); ++s, --n) {
+  for (; n != 0 && isdigit(c = *s); ++s, --n) {
     value *= 10;
     value += c - '0';
   }
@@ -50,7 +53,8 @@ static void parse_int128(const char* p, size_t n, uint64_t* h, uint64_t* l) {
   int c;
   const char* s = p;
 
-  for (; n != 0 && isspace(c = *s); ++s, --n) {}
+  for (; n != 0 && isspace(c = *s); ++s, --n) {
+  }
 
   if (n == 0) {
     *h = *l = 0;
@@ -62,18 +66,18 @@ static void parse_int128(const char* p, size_t n, uint64_t* h, uint64_t* l) {
   uint64_t hi_tmp;
   uint64_t lo_tmp;
   uint64_t lo_tmp2;
-  for (; n != 0  && isdigit(c = *s); ++s, --n) {
+  for (; n != 0 && isdigit(c = *s); ++s, --n) {
     hi_tmp = hi;
     lo_tmp = lo;
 
-    //value *= 10;
+    // value *= 10;
     lo = lo_tmp << 1;
     hi = (lo_tmp >> 63) + (hi_tmp << 1);
     lo_tmp2 = lo;
     lo += lo_tmp << 3;
     hi += (lo_tmp >> 61) + (hi_tmp << 3) + (lo < lo_tmp2 ? 1 : 0);
 
-    //value += c - '0';
+    // value += c - '0';
     lo_tmp = lo;
     lo += c - '0';
     hi += (lo < lo_tmp) ? 1 : 0;
@@ -117,7 +121,7 @@ RandomPartitioner::Token RandomPartitioner::abs(RandomPartitioner::Token token)
     uint64_t old_lo = token.lo;
     ++token.lo;
     // Carry to "hi" if our "lo" value wrapped
-    if(token.lo < old_lo) {
+    if (token.lo < old_lo) {
       ++token.hi;
     }
   }
@@ -132,7 +136,8 @@ RandomPartitioner::Token RandomPartitioner::hash(const StringRef& str) {
   Token token;
 
   // For compatability with Cassandra we interpret the MD5 as a big-endian value:
-  // Reference: https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html#BigInteger(byte[])
+  // Reference:
+  // https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html#BigInteger(byte[])
   token.hi = encode(digest);
   token.lo = encode(digest + 8);
 
@@ -151,5 +156,3 @@ ByteOrderedPartitioner::Token ByteOrderedPartitioner::hash(const StringRef& str)
   const uint8_t* data = reinterpret_cast<const uint8_t*>(str.data());
   return Token(data, data + str.size());
 }
-
-} // namespace cass
diff --git a/src/token_map_impl.hpp b/src/token_map_impl.hpp
index 0690229c6..39fe4f6a2 100644
--- a/src/token_map_impl.hpp
+++ b/src/token_map_impl.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TOKEN_MAP_IMPL_HPP_INCLUDED__
-#define __CASS_TOKEN_MAP_IMPL_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TOKEN_MAP_IMPL_HPP
+#define DATASTAX_INTERNAL_TOKEN_MAP_IMPL_HPP
 
 #include "collection_iterator.hpp"
 #include "constants.hpp"
@@ -32,18 +32,19 @@
 #include "value.hpp"
 #include "vector.hpp"
 
-#include <assert.h>
 #include <algorithm>
+#include <assert.h>
 #include <uv.h>
 
 #define CASS_NETWORK_TOPOLOGY_STRATEGY "NetworkTopologyStrategy"
-#define CASS_SIMPLE_STRATEGY           "SimpleStrategy"
+#define CASS_SIMPLE_STRATEGY "SimpleStrategy"
 
 namespace std {
 
-template<>
-struct equal_to<cass::Host::Ptr> {
-  bool operator()(const cass::Host::Ptr& lhs, const cass::Host::Ptr& rhs) const {
+template <>
+struct equal_to<datastax::internal::core::Host::Ptr> {
+  bool operator()(const datastax::internal::core::Host::Ptr& lhs,
+                  const datastax::internal::core::Host::Ptr& rhs) const {
     if (lhs == rhs) {
       return true;
     }
@@ -56,10 +57,10 @@ struct equal_to<cass::Host::Ptr> {
 
 } // namespace std
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 struct HostHash {
-  std::size_t operator()(const cass::Host::Ptr& host) const {
+  std::size_t operator()(const Host::Ptr& host) const {
     if (!host) return 0;
     return hash(host->address());
   }
@@ -73,9 +74,7 @@ class IdGenerator {
   static const uint32_t EMPTY_KEY;
   static const uint32_t DELETED_KEY;
 
-  IdGenerator() {
-    ids_.set_empty_key(String());
-  }
+  IdGenerator() { ids_.set_empty_key(String()); }
 
   uint32_t get(const String& key) {
     if (key.empty()) {
@@ -115,9 +114,7 @@ struct RandomPartitioner {
       return hi == other.hi ? lo < other.lo : hi < other.hi;
     }
 
-    bool operator==(const Token& other) const {
-      return hi == other.hi && lo == other.lo;
-    }
+    bool operator==(const Token& other) const { return hi == other.hi && lo == other.lo; }
   };
 
   static Token abs(Token token);
@@ -155,7 +152,7 @@ class RackSet : public DenseHashSet<uint32_t> {
 
 struct Datacenter {
   Datacenter()
-    : num_nodes(0) { }
+      : num_nodes(0) {}
   size_t num_nodes;
   RackSet racks;
 };
@@ -170,7 +167,7 @@ class DatacenterMap : public DenseHashMap<uint32_t, Datacenter> {
 
 struct ReplicationFactor {
   ReplicationFactor()
-    : count(0) { }
+      : count(0) {}
   size_t count;
   String name; // Used for logging the datacenter name
   bool operator==(const ReplicationFactor& other) const {
@@ -180,8 +177,7 @@ struct ReplicationFactor {
 
 inline void build_datacenters(const HostSet& hosts, DatacenterMap& result) {
   result.clear();
-  for (HostSet::const_iterator i = hosts.begin(), end = hosts.end();
-       i != end; ++i) {
+  for (HostSet::const_iterator i = hosts.begin(), end = hosts.end(); i != end; ++i) {
     uint32_t dc = (*i)->dc_id();
     uint32_t rack = (*i)->rack_id();
     if (dc != 0 && rack != 0) {
@@ -194,9 +190,7 @@ inline void build_datacenters(const HostSet& hosts, DatacenterMap& result) {
 
 class ReplicationFactorMap : public DenseHashMap<uint32_t, ReplicationFactor> {
 public:
-  ReplicationFactorMap() {
-    set_empty_key(IdGenerator::EMPTY_KEY);
-  }
+  ReplicationFactorMap() { set_empty_key(IdGenerator::EMPTY_KEY); }
 };
 
 template <class Partitioner>
@@ -214,9 +208,9 @@ class ReplicationStrategy {
 
   struct DatacenterRackInfo {
     DatacenterRackInfo()
-      : replica_count(0)
-      , replication_factor(0)
-      , rack_count(0) { }
+        : replica_count(0)
+        , replication_factor(0)
+        , rack_count(0) {}
     size_t replica_count;
     size_t replication_factor;
     RackSet racks_observed;
@@ -226,27 +220,20 @@ class ReplicationStrategy {
 
   class DatacenterRackInfoMap : public DenseHashMap<uint32_t, DatacenterRackInfo> {
   public:
-    DatacenterRackInfoMap () {
+    DatacenterRackInfoMap() {
       DenseHashMap<uint32_t, DatacenterRackInfo>::set_empty_key(IdGenerator::EMPTY_KEY);
     }
   };
 
-  enum Type {
-    NETWORK_TOPOLOGY_STRATEGY,
-    SIMPLE_STRATEGY,
-    NON_REPLICATED
-  };
+  enum Type { NETWORK_TOPOLOGY_STRATEGY, SIMPLE_STRATEGY, NON_REPLICATED };
 
   ReplicationStrategy()
-    : type_(NON_REPLICATED) { }
+      : type_(NON_REPLICATED) {}
 
-  void init(IdGenerator& dc_ids,
-            const VersionNumber& cassandra_version,
-            const Row* row);
+  void init(IdGenerator& dc_ids, const VersionNumber& cassandra_version, const Row* row);
 
   bool operator!=(const ReplicationStrategy& other) const {
-    return type_ != other.type_ ||
-                    replication_factors_ != other.replication_factors_;
+    return type_ != other.type_ || replication_factors_ != other.replication_factors_;
   }
 
   void build_replicas(const TokenHostVec& tokens, const DatacenterMap& datacenters,
@@ -256,7 +243,7 @@ class ReplicationStrategy {
   void build_replicas_network_topology(const TokenHostVec& tokens, const DatacenterMap& datacenters,
                                        TokenReplicasVec& result) const;
   void build_replicas_simple(const TokenHostVec& tokens, const DatacenterMap& datacenters,
-                             TokenReplicasVec& result) const ;
+                             TokenReplicasVec& result) const;
   void build_replicas_non_replicated(const TokenHostVec& tokens, const DatacenterMap& datacenters,
                                      TokenReplicasVec& result) const;
 
@@ -273,8 +260,7 @@ void ReplicationStrategy<Partitioner>::init(IdGenerator& dc_ids,
 
   if (cassandra_version >= VersionNumber(3, 0, 0)) {
     const Value* value = row->get_by_name("replication");
-    if (value &&  value->is_map() &&
-        is_string_type(value->primary_value_type()) &&
+    if (value && value->is_map() && is_string_type(value->primary_value_type()) &&
         is_string_type(value->secondary_value_type())) {
       MapIterator iterator(value);
       while (iterator.next()) {
@@ -288,7 +274,7 @@ void ReplicationStrategy<Partitioner>::init(IdGenerator& dc_ids,
             ReplicationFactor replication_factor;
             replication_factor.count = count;
             replication_factor.name = key;
-            if (key == "replication_factor"){
+            if (key == "replication_factor") {
               replication_factors_[1] = replication_factor;
             } else {
               replication_factors_[dc_ids.get(key)] = replication_factor;
@@ -341,7 +327,8 @@ void ReplicationStrategy<Partitioner>::init(IdGenerator& dc_ids,
 }
 
 template <class Partitioner>
-void ReplicationStrategy<Partitioner>::build_replicas(const TokenHostVec& tokens, const DatacenterMap& datacenters,
+void ReplicationStrategy<Partitioner>::build_replicas(const TokenHostVec& tokens,
+                                                      const DatacenterMap& datacenters,
                                                       TokenReplicasVec& result) const {
   result.clear();
   result.reserve(tokens.size());
@@ -360,8 +347,8 @@ void ReplicationStrategy<Partitioner>::build_replicas(const TokenHostVec& tokens
 }
 
 template <class Partitioner>
-void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const TokenHostVec& tokens, const DatacenterMap& datacenters,
-                                                                       TokenReplicasVec& result) const {
+void ReplicationStrategy<Partitioner>::build_replicas_network_topology(
+    const TokenHostVec& tokens, const DatacenterMap& datacenters, TokenReplicasVec& result) const {
   if (replication_factors_.empty()) {
     return;
   }
@@ -376,7 +363,8 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
   // for a datacenter that doesn't exist or has no node then it will not
   // be counted.
   for (ReplicationFactorMap::const_iterator i = replication_factors_.begin(),
-       end = replication_factors_.end(); i != end; ++i) {
+                                            end = replication_factors_.end();
+       i != end; ++i) {
     DatacenterMap::const_iterator j = datacenters.find(i->first);
     // Don't include datacenters that don't exist
     if (j != datacenters.end()) {
@@ -388,7 +376,8 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
       dc_rack_info.rack_count = j->second.racks.size();
       dc_racks[j->first] = dc_rack_info;
     } else {
-      LOG_WARN("No nodes in datacenter '%s'. Check your replication strategies.", i->second.name.c_str());
+      LOG_WARN("No nodes in datacenter '%s'. Check your replication strategies.",
+               i->second.name.c_str());
     }
   }
 
@@ -396,8 +385,8 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
     return;
   }
 
-  for (typename TokenHostVec::const_iterator i = tokens.begin(),
-       end = tokens.end(); i != end; ++i) {
+  for (typename TokenHostVec::const_iterator i = tokens.begin(), end = tokens.end(); i != end;
+       ++i) {
     Token token = i->first;
     typename TokenHostVec::const_iterator token_it = i;
 
@@ -405,16 +394,16 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
     replicas->reserve(num_replicas);
 
     // Clear datacenter and rack information for the next token
-    for (typename DatacenterRackInfoMap::iterator j = dc_racks.begin(),
-         end = dc_racks.end(); j != end; ++j) {
+    for (typename DatacenterRackInfoMap::iterator j = dc_racks.begin(), end = dc_racks.end();
+         j != end; ++j) {
       j->second.replica_count = 0;
       j->second.racks_observed.clear();
       j->second.skipped_endpoints.clear();
     }
 
-    for (typename TokenHostVec::const_iterator j = tokens.begin(),
-         end = tokens.end(); j != end && replicas->size() < num_replicas; ++j) {
-      typename TokenHostVec::const_iterator  curr_token_it = token_it;
+    for (typename TokenHostVec::const_iterator j = tokens.begin(), end = tokens.end();
+         j != end && replicas->size() < num_replicas; ++j) {
+      typename TokenHostVec::const_iterator curr_token_it = token_it;
       Host* host = curr_token_it->second;
       uint32_t dc = host->dc_id();
       uint32_t rack = host->rack_id();
@@ -459,7 +448,8 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
           // Once we visited every rack in the current datacenter then starting considering
           // hosts we've already skipped.
           if (racks_observed_this_dc.size() == rack_count_this_dc) {
-            while (!skipped_endpoints_this_dc.empty() && replica_count_this_dc < replication_factor) {
+            while (!skipped_endpoints_this_dc.empty() &&
+                   replica_count_this_dc < replication_factor) {
               ++replica_count_this_dc;
               replicas->push_back(Host::Ptr(skipped_endpoints_this_dc.front()->second));
               skipped_endpoints_this_dc.pop_front();
@@ -474,15 +464,16 @@ void ReplicationStrategy<Partitioner>::build_replicas_network_topology(const Tok
 }
 
 template <class Partitioner>
-void ReplicationStrategy<Partitioner>::build_replicas_simple(const TokenHostVec& tokens, const DatacenterMap& not_used,
+void ReplicationStrategy<Partitioner>::build_replicas_simple(const TokenHostVec& tokens,
+                                                             const DatacenterMap& not_used,
                                                              TokenReplicasVec& result) const {
   ReplicationFactorMap::const_iterator it = replication_factors_.find(1);
   if (it == replication_factors_.end()) {
     return;
   }
   size_t num_replicas = std::min<size_t>(it->second.count, tokens.size());
-  for (typename TokenHostVec::const_iterator i = tokens.begin(),
-       end = tokens.end(); i != end; ++i) {
+  for (typename TokenHostVec::const_iterator i = tokens.begin(), end = tokens.end(); i != end;
+       ++i) {
     CopyOnWriteHostVec replicas(new HostVec());
     typename TokenHostVec::const_iterator token_it = i;
     do {
@@ -497,8 +488,8 @@ void ReplicationStrategy<Partitioner>::build_replicas_simple(const TokenHostVec&
 }
 
 template <class Partitioner>
-void ReplicationStrategy<Partitioner>::build_replicas_non_replicated(const TokenHostVec& tokens, const DatacenterMap& not_used,
-                                                                     TokenReplicasVec& result) const {
+void ReplicationStrategy<Partitioner>::build_replicas_non_replicated(
+    const TokenHostVec& tokens, const DatacenterMap& not_used, TokenReplicasVec& result) const {
   for (typename TokenHostVec::const_iterator i = tokens.begin(); i != tokens.end(); ++i) {
     CopyOnWriteHostVec replicas(new HostVec(1, Host::Ptr(i->second)));
     result.push_back(TokenReplicas(i->first, replicas));
@@ -521,7 +512,7 @@ class TokenMapImpl : public TokenMap {
 
   struct RemoveTokenHostIf {
     RemoveTokenHostIf(const Host::Ptr& host)
-      : host(host) { }
+        : host(host) {}
 
     bool operator()(const TokenHost& token) const {
       if (!token.second) {
@@ -546,7 +537,7 @@ class TokenMapImpl : public TokenMap {
   typedef DenseHashMap<String, ReplicationStrategy<Partitioner> > KeyspaceStrategyMap;
 
   TokenMapImpl()
-    : no_replicas_dummy_(NULL) {
+      : no_replicas_dummy_(NULL) {
     replicas_.set_empty_key(String());
     replicas_.set_deleted_key(String(1, '\0'));
     strategies_.set_empty_key(String());
@@ -554,20 +545,21 @@ class TokenMapImpl : public TokenMap {
   }
 
   TokenMapImpl(const TokenMapImpl& other)
-    : tokens_(other.tokens_)
-    , hosts_(other.hosts_)
-    , replicas_(other.replicas_)
-    , strategies_(other.strategies_)
-    , rack_ids_(other.rack_ids_)
-    , dc_ids_(other.dc_ids_)
-    , no_replicas_dummy_(NULL) { }
+      : tokens_(other.tokens_)
+      , hosts_(other.hosts_)
+      , replicas_(other.replicas_)
+      , strategies_(other.strategies_)
+      , rack_ids_(other.rack_ids_)
+      , dc_ids_(other.dc_ids_)
+      , no_replicas_dummy_(NULL) {}
 
   virtual void add_host(const Host::Ptr& host);
   virtual void update_host_and_build(const Host::Ptr& host);
   virtual void remove_host_and_build(const Host::Ptr& host);
 
   virtual void add_keyspaces(const VersionNumber& cassandra_version, const ResultResponse* result);
-  virtual void update_keyspaces_and_build(const VersionNumber& cassandra_version, const ResultResponse* result);
+  virtual void update_keyspaces_and_build(const VersionNumber& cassandra_version,
+                                          const ResultResponse* result);
   virtual void drop_keyspace(const String& keyspace_name);
 
   virtual void build();
@@ -579,16 +571,15 @@ class TokenMapImpl : public TokenMap {
 
   // Test only
   bool contains(const Token& token) const {
-    for (typename TokenHostVec::const_iterator i = tokens_.begin(),
-         end = tokens_.end(); i != end; ++i) {
+    for (typename TokenHostVec::const_iterator i = tokens_.begin(), end = tokens_.end(); i != end;
+         ++i) {
       if (token == i->first) return true;
     }
     return false;
   }
 
 private:
-  void update_keyspace(const VersionNumber& cassandra_version,
-                       const ResultResponse* result,
+  void update_keyspace(const VersionNumber& cassandra_version, const ResultResponse* result,
                        bool should_build_replicas);
   void remove_host_tokens(const Host::Ptr& host);
   void update_host_ids(const Host::Ptr& host);
@@ -611,8 +602,7 @@ void TokenMapImpl<Partitioner>::add_host(const Host::Ptr& host) {
   hosts_.insert(host);
 
   const Vector<String>& tokens(host->tokens());
-  for (Vector<String>::const_iterator it = tokens.begin(),
-       end = tokens.end(); it != end; ++it) {
+  for (Vector<String>::const_iterator it = tokens.begin(), end = tokens.end(); it != end; ++it) {
     Token token = Partitioner::from_string(*it);
     tokens_.push_back(TokenHost(token, host.get()));
   }
@@ -628,8 +618,7 @@ void TokenMapImpl<Partitioner>::update_host_and_build(const Host::Ptr& host) {
 
   TokenHostVec new_tokens;
   const Vector<String>& tokens(host->tokens());
-  for (Vector<String>::const_iterator it = tokens.begin(),
-       end = tokens.end(); it != end; ++it) {
+  for (Vector<String>::const_iterator it = tokens.begin(), end = tokens.end(); it != end; ++it) {
     Token token = Partitioner::from_string(*it);
     new_tokens.push_back(TokenHost(token, host.get()));
   }
@@ -637,17 +626,15 @@ void TokenMapImpl<Partitioner>::update_host_and_build(const Host::Ptr& host) {
   std::sort(new_tokens.begin(), new_tokens.end());
 
   TokenHostVec merged(tokens_.size() + new_tokens.size());
-  std::merge(tokens_.begin(), tokens_.end(),
-             new_tokens.begin(), new_tokens.end(),
-             merged.begin(), TokenHostCompare());
+  std::merge(tokens_.begin(), tokens_.end(), new_tokens.begin(), new_tokens.end(), merged.begin(),
+             TokenHostCompare());
   tokens_ = merged;
 
   build_replicas();
-  LOG_DEBUG("Updated token map with host %s (%u tokens). Rebuilt token map with %u hosts and %u tokens in %f ms",
-            host->address_string().c_str(),
-            (unsigned int)new_tokens.size(),
-            (unsigned int)hosts_.size(),
-            (unsigned int)tokens_.size(),
+  LOG_DEBUG("Updated token map with host %s (%u tokens). Rebuilt token map with %u hosts and %u "
+            "tokens in %f ms",
+            host->address_string().c_str(), (unsigned int)new_tokens.size(),
+            (unsigned int)hosts_.size(), (unsigned int)tokens_.size(),
             (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
 }
 
@@ -658,11 +645,10 @@ void TokenMapImpl<Partitioner>::remove_host_and_build(const Host::Ptr& host) {
   remove_host_tokens(host);
   hosts_.erase(host);
   build_replicas();
-  LOG_DEBUG("Removed host %s from token map. Rebuilt token map with %u hosts and %u tokens in %f ms",
-            host->address_string().c_str(),
-            (unsigned int)hosts_.size(),
-            (unsigned int)tokens_.size(),
-            (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
+  LOG_DEBUG(
+      "Removed host %s from token map. Rebuilt token map with %u hosts and %u tokens in %f ms",
+      host->address_string().c_str(), (unsigned int)hosts_.size(), (unsigned int)tokens_.size(),
+      (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
 }
 
 template <class Partitioner>
@@ -688,13 +674,11 @@ void TokenMapImpl<Partitioner>::build() {
   uint64_t start = uv_hrtime();
   std::sort(tokens_.begin(), tokens_.end());
   build_replicas();
-  LOG_DEBUG("Built token map with %u hosts and %u tokens in %f ms",
-            (unsigned int)hosts_.size(),
-            (unsigned int)tokens_.size(),
-            (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
+  LOG_DEBUG("Built token map with %u hosts and %u tokens in %f ms", (unsigned int)hosts_.size(),
+            (unsigned int)tokens_.size(), (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
 }
 
-template<class Partitioner>
+template <class Partitioner>
 TokenMap::Ptr TokenMapImpl<Partitioner>::copy() const {
   return Ptr(new TokenMapImpl<Partitioner>(*this));
 }
@@ -707,9 +691,9 @@ const CopyOnWriteHostVec& TokenMapImpl<Partitioner>::get_replicas(const String&
   if (ks_it != replicas_.end()) {
     Token token = Partitioner::hash(routing_key);
     const TokenReplicasVec& replicas = ks_it->second;
-    typename TokenReplicasVec::const_iterator replicas_it = std::upper_bound(replicas.begin(), replicas.end(),
-                                                                             TokenReplicas(token, no_replicas_dummy_),
-                                                                             TokenReplicasCompare());
+    typename TokenReplicasVec::const_iterator replicas_it =
+        std::upper_bound(replicas.begin(), replicas.end(), TokenReplicas(token, no_replicas_dummy_),
+                         TokenReplicasCompare());
     if (replicas_it != replicas.end()) {
       return replicas_it->second;
     } else if (!replicas.empty()) {
@@ -750,10 +734,9 @@ void TokenMapImpl<Partitioner>::update_keyspace(const VersionNumber& cassandra_v
         uint64_t start = uv_hrtime();
         build_datacenters(hosts_, datacenters_);
         strategy.build_replicas(tokens_, datacenters_, replicas_[keyspace_name]);
-        LOG_DEBUG("Updated token map with keyspace '%s'. Rebuilt token map with %u hosts and %u tokens in %f ms",
-                  keyspace_name.c_str(),
-                  (unsigned int)hosts_.size(),
-                  (unsigned int)tokens_.size(),
+        LOG_DEBUG("Updated token map with keyspace '%s'. Rebuilt token map with %u hosts and %u "
+                  "tokens in %f ms",
+                  keyspace_name.c_str(), (unsigned int)hosts_.size(), (unsigned int)tokens_.size(),
                   (double)(uv_hrtime() - start) / (1000.0 * 1000.0));
       }
     }
@@ -762,9 +745,8 @@ void TokenMapImpl<Partitioner>::update_keyspace(const VersionNumber& cassandra_v
 
 template <class Partitioner>
 void TokenMapImpl<Partitioner>::remove_host_tokens(const Host::Ptr& host) {
-  typename TokenHostVec::iterator last = std::remove_copy_if(tokens_.begin(), tokens_.end(),
-                                                             tokens_.begin(),
-                                                             RemoveTokenHostIf(host));
+  typename TokenHostVec::iterator last =
+      std::remove_copy_if(tokens_.begin(), tokens_.end(), tokens_.begin(), RemoveTokenHostIf(host));
   tokens_.resize(last - tokens_.begin());
 }
 
@@ -777,7 +759,7 @@ template <class Partitioner>
 void TokenMapImpl<Partitioner>::build_replicas() {
   build_datacenters(hosts_, datacenters_);
   for (typename KeyspaceStrategyMap::const_iterator i = strategies_.begin(),
-       end = strategies_.end();
+                                                    end = strategies_.end();
        i != end; ++i) {
     const String& keyspace_name = i->first;
     const ReplicationStrategy<Partitioner>& strategy = i->second;
@@ -785,6 +767,6 @@ void TokenMapImpl<Partitioner>::build_replicas() {
   }
 }
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/tracing_data_handler.cpp b/src/tracing_data_handler.cpp
index 517c7236f..d7e74884d 100644
--- a/src/tracing_data_handler.cpp
+++ b/src/tracing_data_handler.cpp
@@ -19,18 +19,15 @@
 #include "query_request.hpp"
 #include "result_iterator.hpp"
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
 
 TracingDataHandler::TracingDataHandler(const RequestHandler::Ptr& request_handler,
-                                       const Host::Ptr& current_host,
-                                       const Response::Ptr& response,
-                                       CassConsistency consistency,
-                                       uint64_t max_wait_time_ms,
+                                       const Host::Ptr& current_host, const Response::Ptr& response,
+                                       CassConsistency consistency, uint64_t max_wait_time_ms,
                                        uint64_t retry_wait_time_ms)
-  : WaitForHandler (request_handler, current_host,
-                    response,
-                    max_wait_time_ms, retry_wait_time_ms)
-  , consistency_(consistency) { }
+    : WaitForHandler(request_handler, current_host, response, max_wait_time_ms, retry_wait_time_ms)
+    , consistency_(consistency) {}
 
 ChainedRequestCallback::Ptr TracingDataHandler::callback() {
   WaitforRequestVec requests;
@@ -76,5 +73,3 @@ void TracingDataHandler::on_error(WaitForHandler::WaitForError code, const Strin
       break;
   }
 }
-
-} // namespace cass
diff --git a/src/tracing_data_handler.hpp b/src/tracing_data_handler.hpp
index d005295bb..9ff0f4391 100644
--- a/src/tracing_data_handler.hpp
+++ b/src/tracing_data_handler.hpp
@@ -14,17 +14,16 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TRACING_DATA_HANDLER_HPP_INCLUDED__
-#define __CASS_TRACING_DATA_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TRACING_DATA_HANDLER_HPP
+#define DATASTAX_INTERNAL_TRACING_DATA_HANDLER_HPP
 
 #include "wait_for_handler.hpp"
 
 #include <uv.h>
 
-#define SELECT_TRACES_SESSION \
-  "SELECT session_id FROM system_traces.sessions WHERE session_id = ?"
+#define SELECT_TRACES_SESSION "SELECT session_id FROM system_traces.sessions WHERE session_id = ?"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A handler that waits for tracing data to become available for a specified
@@ -47,12 +46,9 @@ class TracingDataHandler : public WaitForHandler {
    * @param retry_wait_time_ms The amount of time to wait between failed attempts
    * to retrieve tracing data.
    */
-  TracingDataHandler(const RequestHandler::Ptr& request_handler,
-                     const Host::Ptr& current_host,
-                     const Response::Ptr& response,
-                     CassConsistency consistency,
-                     uint64_t max_wait_time_ms,
-                     uint64_t retry_wait_time_ms);
+  TracingDataHandler(const RequestHandler::Ptr& request_handler, const Host::Ptr& current_host,
+                     const Response::Ptr& response, CassConsistency consistency,
+                     uint64_t max_wait_time_ms, uint64_t retry_wait_time_ms);
 
   /**
    * Gets a request callback for executing queries on behalf of the handler.
@@ -69,6 +65,6 @@ class TracingDataHandler : public WaitForHandler {
   CassConsistency consistency_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/tuple.cpp b/src/tuple.cpp
index 9b2ea37f4..48dae1ff4 100644
--- a/src/tuple.cpp
+++ b/src/tuple.cpp
@@ -25,24 +25,21 @@
 
 #include <string.h>
 
+using namespace datastax;
+using namespace datastax::internal::core;
+
 extern "C" {
 
-CassTuple* cass_tuple_new(size_t item_count) {
-  return CassTuple::to(new cass::Tuple(item_count));
-}
+CassTuple* cass_tuple_new(size_t item_count) { return CassTuple::to(new Tuple(item_count)); }
 
 CassTuple* cass_tuple_new_from_data_type(const CassDataType* data_type) {
   if (!data_type->is_tuple()) {
     return NULL;
   }
-  return CassTuple::to(
-        new cass::Tuple(
-          cass::DataType::ConstPtr(data_type)));
+  return CassTuple::to(new Tuple(DataType::ConstPtr(data_type)));
 }
 
-void cass_tuple_free(CassTuple* tuple) {
-  delete tuple->from();
-}
+void cass_tuple_free(CassTuple* tuple) { delete tuple->from(); }
 
 const CassDataType* cass_tuple_data_type(const CassTuple* tuple) {
   return CassDataType::to(tuple->data_type().get());
@@ -50,10 +47,10 @@ const CassDataType* cass_tuple_data_type(const CassTuple* tuple) {
 
 #define CASS_TUPLE_SET(Name, Params, Value)                                \
   CassError cass_tuple_set_##Name(CassTuple* tuple, size_t index Params) { \
-  return tuple->set(index, Value);                                         \
-}
+    return tuple->set(index, Value);                                       \
+  }
 
-CASS_TUPLE_SET(null, ZERO_PARAMS_(), cass::CassNull())
+CASS_TUPLE_SET(null, ZERO_PARAMS_(), CassNull())
 CASS_TUPLE_SET(int8, ONE_PARAM_(cass_int8_t value), value)
 CASS_TUPLE_SET(int16, ONE_PARAM_(cass_int16_t value), value)
 CASS_TUPLE_SET(int32, ONE_PARAM_(cass_int32_t value), value)
@@ -67,59 +64,40 @@ CASS_TUPLE_SET(inet, ONE_PARAM_(CassInet value), value)
 CASS_TUPLE_SET(collection, ONE_PARAM_(const CassCollection* value), value)
 CASS_TUPLE_SET(tuple, ONE_PARAM_(const CassTuple* value), value)
 CASS_TUPLE_SET(user_type, ONE_PARAM_(const CassUserType* value), value)
-CASS_TUPLE_SET(bytes,
-               TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
-               cass::CassBytes(value, value_size))
-CASS_TUPLE_SET(decimal,
-               THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
-               cass::CassDecimal(varint, varint_size, scale))
-CASS_TUPLE_SET(duration,
-               THREE_PARAMS_(cass_int32_t months, cass_int32_t days, cass_int64_t nanos),
-               cass::CassDuration(months, days, nanos))
+CASS_TUPLE_SET(bytes, TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
+               CassBytes(value, value_size))
+CASS_TUPLE_SET(decimal, THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
+               CassDecimal(varint, varint_size, scale))
+CASS_TUPLE_SET(duration, THREE_PARAMS_(cass_int32_t months, cass_int32_t days, cass_int64_t nanos),
+               CassDuration(months, days, nanos))
 
 #undef CASS_TUPLE_SET
 
-CassError cass_tuple_set_string(CassTuple* tuple,
-                                size_t index,
-                                const char* value) {
-  return tuple->set(index, cass::CassString(value, SAFE_STRLEN(value)));
+CassError cass_tuple_set_string(CassTuple* tuple, size_t index, const char* value) {
+  return tuple->set(index, CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_tuple_set_string_n(CassTuple* tuple,
-                                  size_t index,
-                                  const char* value,
+CassError cass_tuple_set_string_n(CassTuple* tuple, size_t index, const char* value,
                                   size_t value_length) {
-  return tuple->set(index, cass::CassString(value, value_length));
+  return tuple->set(index, CassString(value, value_length));
 }
 
-CassError cass_tuple_set_custom(CassTuple* tuple,
-                                size_t index,
-                                const char* class_name,
-                                const cass_byte_t* value,
-                                size_t value_size) {
-  return tuple->set(index,
-                    cass::CassCustom(cass::StringRef(class_name),
-                                     value, value_size));
+CassError cass_tuple_set_custom(CassTuple* tuple, size_t index, const char* class_name,
+                                const cass_byte_t* value, size_t value_size) {
+  return tuple->set(index, CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_tuple_set_custom_n(CassTuple* tuple,
-                                  size_t index,
-                                  const char* class_name,
-                                  size_t class_name_length,
-                                  const cass_byte_t* value,
+CassError cass_tuple_set_custom_n(CassTuple* tuple, size_t index, const char* class_name,
+                                  size_t class_name_length, const cass_byte_t* value,
                                   size_t value_size) {
-  return tuple->set(index,
-                    cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                     value, value_size));
+  return tuple->set(index, CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
 } // extern "C"
 
-namespace cass {
-
 CassError Tuple::set(size_t index, CassNull value) {
   CASS_TUPLE_CHECK_INDEX_AND_TYPE(index, value);
-  items_[index] = cass::encode_with_length(value);
+  items_[index] = core::encode_with_length(value);
   return CASS_OK;
 }
 
@@ -159,8 +137,7 @@ Buffer Tuple::encode_with_length() const {
 
 size_t Tuple::get_buffers_size() const {
   size_t size = 0;
-  for (BufferVec::const_iterator i = items_.begin(),
-       end = items_.end(); i != end; ++i) {
+  for (BufferVec::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) {
     if (i->size() != 0) {
       size += i->size();
     } else {
@@ -171,8 +148,7 @@ size_t Tuple::get_buffers_size() const {
 }
 
 void Tuple::encode_buffers(size_t pos, Buffer* buf) const {
-  for (BufferVec::const_iterator i = items_.begin(),
-       end = items_.end(); i != end; ++i) {
+  for (BufferVec::const_iterator i = items_.begin(), end = items_.end(); i != end; ++i) {
     if (i->size() != 0) {
       pos = buf->copy(pos, i->data(), i->size());
     } else {
@@ -180,5 +156,3 @@ void Tuple::encode_buffers(size_t pos, Buffer* buf) const {
     }
   }
 }
-
-}  // namespace cass
diff --git a/src/tuple.hpp b/src/tuple.hpp
index 943644f5c..0f2fe407a 100644
--- a/src/tuple.hpp
+++ b/src/tuple.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TUPLE_HPP_INCLUDED__
-#define __CASS_TUPLE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TUPLE_HPP
+#define DATASTAX_INTERNAL_TUPLE_HPP
 
 #include "allocated.hpp"
 #include "buffer.hpp"
@@ -26,12 +26,13 @@
 #include "ref_counted.hpp"
 #include "types.hpp"
 
-#define CASS_TUPLE_CHECK_INDEX_AND_TYPE(Index, Value) do { \
-  CassError rc = check(Index, Value);                 \
-  if (rc != CASS_OK) return rc;                \
-  } while(0)
+#define CASS_TUPLE_CHECK_INDEX_AND_TYPE(Index, Value) \
+  do {                                                \
+    CassError rc = check(Index, Value);               \
+    if (rc != CASS_OK) return rc;                     \
+  } while (0)
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Collection;
 class UserTypeValue;
@@ -39,21 +40,21 @@ class UserTypeValue;
 class Tuple : public Allocated {
 public:
   explicit Tuple(size_t item_count)
-    : data_type_(new TupleType(false))
-    , items_(item_count) { }
+      : data_type_(new TupleType(false))
+      , items_(item_count) {}
 
   explicit Tuple(const DataType::ConstPtr& data_type)
-    : data_type_(data_type)
-    , items_(data_type_->types().size()) { }
+      : data_type_(data_type)
+      , items_(data_type_->types().size()) {}
 
   const TupleType::ConstPtr& data_type() const { return data_type_; }
   const BufferVec& items() const { return items_; }
 
-#define SET_TYPE(Type)                  \
-  CassError set(size_t index, const Type value) {     \
-    CASS_TUPLE_CHECK_INDEX_AND_TYPE(index, value);     \
-    items_[index] = cass::encode_with_length(value); \
-    return CASS_OK;                        \
+#define SET_TYPE(Type)                               \
+  CassError set(size_t index, const Type value) {    \
+    CASS_TUPLE_CHECK_INDEX_AND_TYPE(index, value);   \
+    items_[index] = core::encode_with_length(value); \
+    return CASS_OK;                                  \
   }
 
   SET_TYPE(cass_int8_t)
@@ -90,8 +91,7 @@ class Tuple : public Allocated {
     }
 
     IsValidDataType<T> is_valid_type;
-    if (index < data_type()->types().size() &&
-        !is_valid_type(value, data_type_->types()[index])) {
+    if (index < data_type()->types().size() && !is_valid_type(value, data_type_->types()[index])) {
       return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
     }
 
@@ -109,9 +109,8 @@ class Tuple : public Allocated {
   DISALLOW_COPY_AND_ASSIGN(Tuple);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Tuple, CassTuple)
+EXTERNAL_TYPE(datastax::internal::core::Tuple, CassTuple)
 
 #endif
-
diff --git a/src/types.hpp b/src/types.hpp
index 14b3ecf2b..ab71f5db7 100644
--- a/src/types.hpp
+++ b/src/types.hpp
@@ -14,30 +14,31 @@
   limitations under the License.
 */
 
-#ifndef __CASS_TYPES_HPP_INCLUDED__
-#define __CASS_TYPES_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_TYPES_HPP
+#define DATASTAX_INTERNAL_TYPES_HPP
 
 #include "cassandra.h"
 #include "string_ref.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
-struct CassNull { };
+struct CassNull {};
 
-struct CassUnset { };
+struct CassUnset {};
 
 struct CassBytes {
   CassBytes(const cass_byte_t* data, size_t size)
-    : data(data), size(size) { }
+      : data(data)
+      , size(size) {}
   const cass_byte_t* data;
   size_t size;
 };
 
 struct CassCustom {
-  CassCustom(StringRef class_name,
-             const cass_byte_t* data, size_t size)
-    : class_name(class_name)
-    , data(data), size(size) { }
+  CassCustom(StringRef class_name, const cass_byte_t* data, size_t size)
+      : class_name(class_name)
+      , data(data)
+      , size(size) {}
   StringRef class_name;
   const cass_byte_t* data;
   size_t size;
@@ -45,35 +46,32 @@ struct CassCustom {
 
 struct CassString {
   CassString(const char* data, size_t length)
-    : data(data), length(length) { }
+      : data(data)
+      , length(length) {}
   const char* data;
   size_t length;
 };
 
 struct CassDecimal {
-  CassDecimal(const cass_byte_t* varint,
-              size_t varint_size,
-              int scale)
-    : varint(varint)
-    , varint_size(varint_size)
-    , scale(scale) { }
+  CassDecimal(const cass_byte_t* varint, size_t varint_size, int scale)
+      : varint(varint)
+      , varint_size(varint_size)
+      , scale(scale) {}
   const cass_byte_t* varint;
   size_t varint_size;
   cass_int32_t scale;
 };
 
 struct CassDuration {
-  CassDuration(cass_int32_t months,
-               cass_int32_t days,
-               cass_int64_t nanos)
-    : months(months)
-    , days(days)
-    , nanos(nanos) { }
+  CassDuration(cass_int32_t months, cass_int32_t days, cass_int64_t nanos)
+      : months(months)
+      , days(days)
+      , nanos(nanos) {}
   cass_int32_t months;
   cass_int32_t days;
   cass_int64_t nanos;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/user_type_field_iterator.cpp b/src/user_type_field_iterator.cpp
index 699218305..6bc4a2d93 100644
--- a/src/user_type_field_iterator.cpp
+++ b/src/user_type_field_iterator.cpp
@@ -18,7 +18,7 @@
 
 #include "serialization.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool UserTypeFieldIterator::next() {
   if (next_ == end_) {
@@ -27,5 +27,3 @@ bool UserTypeFieldIterator::next() {
   current_ = next_++;
   return decoder_.decode_value(current_->type, value_);
 }
-
-} // namespace cass
diff --git a/src/user_type_field_iterator.hpp b/src/user_type_field_iterator.hpp
index a93c4ae8e..81129f749 100644
--- a/src/user_type_field_iterator.hpp
+++ b/src/user_type_field_iterator.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_USER_TYPE_ITERATOR_HPP_INCLUDED__
-#define __CASS_USER_TYPE_ITERATOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_USER_TYPE_ITERATOR_HPP
+#define DATASTAX_INTERNAL_USER_TYPE_ITERATOR_HPP
 
 #include "cassandra.h"
 #include "data_type.hpp"
@@ -23,7 +23,7 @@
 #include "serialization.hpp"
 #include "value.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class UserTypeFieldIterator : public Iterator {
 public:
@@ -56,6 +56,6 @@ class UserTypeFieldIterator : public Iterator {
   Value value_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/user_type_value.cpp b/src/user_type_value.cpp
index e42ecd640..9ed5f0e50 100644
--- a/src/user_type_value.cpp
+++ b/src/user_type_value.cpp
@@ -17,48 +17,46 @@
 #include "user_type_value.hpp"
 
 #include "collection.hpp"
-#include "macros.hpp"
 #include "external.hpp"
+#include "macros.hpp"
 #include "tuple.hpp"
 #include "utils.hpp"
 
 #include <string.h>
 
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 extern "C" {
 
 CassUserType* cass_user_type_new_from_data_type(const CassDataType* data_type) {
   if (!data_type->is_user_type()) {
     return NULL;
   }
-  return CassUserType::to(
-        new cass::UserTypeValue(
-          cass::DataType::ConstPtr(data_type)));
+  return CassUserType::to(new UserTypeValue(DataType::ConstPtr(data_type)));
 }
 
-void cass_user_type_free(CassUserType* user_type) {
-  delete user_type->from();
-}
+void cass_user_type_free(CassUserType* user_type) { delete user_type->from(); }
 
 const CassDataType* cass_user_type_data_type(const CassUserType* user_type) {
   return CassDataType::to(user_type->data_type().get());
 }
 
-#define CASS_USER_TYPE_SET(Name, Params, Value)                                \
-  CassError cass_user_type_set_##Name(CassUserType* user_type,                 \
-                                      size_t index Params) {                   \
-    return user_type->set(index, Value);                                       \
-  }                                                                            \
-  CassError cass_user_type_set_##Name##_by_name(CassUserType* user_type,       \
-                                                const char* name Params) {     \
-    return user_type->set(cass::StringRef(name), Value);                       \
-  }                                                                            \
-  CassError cass_user_type_set_##Name##_by_name_n(CassUserType* user_type,     \
-                                                  const char* name,            \
-                                                  size_t name_length Params) { \
-    return user_type->set(cass::StringRef(name, name_length), Value);          \
+#define CASS_USER_TYPE_SET(Name, Params, Value)                                              \
+  CassError cass_user_type_set_##Name(CassUserType* user_type, size_t index Params) {        \
+    return user_type->set(index, Value);                                                     \
+  }                                                                                          \
+  CassError cass_user_type_set_##Name##_by_name(CassUserType* user_type,                     \
+                                                const char* name Params) {                   \
+    return user_type->set(StringRef(name), Value);                                           \
+  }                                                                                          \
+  CassError cass_user_type_set_##Name##_by_name_n(CassUserType* user_type, const char* name, \
+                                                  size_t name_length Params) {               \
+    return user_type->set(StringRef(name, name_length), Value);                              \
   }
 
-CASS_USER_TYPE_SET(null, ZERO_PARAMS_(), cass::CassNull())
+CASS_USER_TYPE_SET(null, ZERO_PARAMS_(), CassNull())
 CASS_USER_TYPE_SET(int8, ONE_PARAM_(cass_int8_t value), value)
 CASS_USER_TYPE_SET(int16, ONE_PARAM_(cass_int16_t value), value)
 CASS_USER_TYPE_SET(int32, ONE_PARAM_(cass_int32_t value), value)
@@ -72,88 +70,60 @@ CASS_USER_TYPE_SET(uuid, ONE_PARAM_(CassUuid value), value)
 CASS_USER_TYPE_SET(collection, ONE_PARAM_(const CassCollection* value), value)
 CASS_USER_TYPE_SET(tuple, ONE_PARAM_(const CassTuple* value), value)
 CASS_USER_TYPE_SET(user_type, ONE_PARAM_(const CassUserType* value), value)
-CASS_USER_TYPE_SET(bytes,
-                   TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
-                   cass::CassBytes(value, value_size))
-CASS_USER_TYPE_SET(decimal,
-                   THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
-                   cass::CassDecimal(varint, varint_size, scale))
+CASS_USER_TYPE_SET(bytes, TWO_PARAMS_(const cass_byte_t* value, size_t value_size),
+                   CassBytes(value, value_size))
+CASS_USER_TYPE_SET(decimal, THREE_PARAMS_(const cass_byte_t* varint, size_t varint_size, int scale),
+                   CassDecimal(varint, varint_size, scale))
 CASS_USER_TYPE_SET(duration,
                    THREE_PARAMS_(cass_int32_t months, cass_int32_t days, cass_int64_t nanos),
-                   cass::CassDuration(months, days, nanos))
+                   CassDuration(months, days, nanos))
 
 #undef CASS_USER_TYPE_SET
 
-CassError cass_user_type_set_string(CassUserType* user_type,
-                                    size_t index,
-                                    const char* value) {
-  return user_type->set(index, cass::CassString(value, SAFE_STRLEN(value)));
+CassError cass_user_type_set_string(CassUserType* user_type, size_t index, const char* value) {
+  return user_type->set(index, CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_user_type_set_string_n(CassUserType* user_type,
-                                      size_t index,
-                                      const char* value,
+CassError cass_user_type_set_string_n(CassUserType* user_type, size_t index, const char* value,
                                       size_t value_length) {
-  return user_type->set(index, cass::CassString(value, value_length));
+  return user_type->set(index, CassString(value, value_length));
 }
 
-CassError cass_user_type_set_string_by_name(CassUserType* user_type,
-                                            const char* name,
+CassError cass_user_type_set_string_by_name(CassUserType* user_type, const char* name,
                                             const char* value) {
-  return user_type->set(cass::StringRef(name),
-                        cass::CassString(value, SAFE_STRLEN(value)));
+  return user_type->set(StringRef(name), CassString(value, SAFE_STRLEN(value)));
 }
 
-CassError cass_user_type_set_string_by_name_n(CassUserType* user_type,
-                                              const char* name,
-                                              size_t name_length,
-                                              const char* value,
+CassError cass_user_type_set_string_by_name_n(CassUserType* user_type, const char* name,
+                                              size_t name_length, const char* value,
                                               size_t value_length) {
-  return user_type->set(cass::StringRef(name, name_length),
-                        cass::CassString(value, value_length));
+  return user_type->set(StringRef(name, name_length), CassString(value, value_length));
 }
 
-CassError cass_user_type_set_custom(CassUserType* user_type,
-                                    size_t index,
-                                    const char* class_name,
-                                    const cass_byte_t* value,
-                                    size_t value_size) {
-  return user_type->set(index,
-                        cass::CassCustom(cass::StringRef(class_name),
-                                         value, value_size));
+CassError cass_user_type_set_custom(CassUserType* user_type, size_t index, const char* class_name,
+                                    const cass_byte_t* value, size_t value_size) {
+  return user_type->set(index, CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_user_type_set_custom_n(CassUserType* user_type,
-                                      size_t index,
-                                      const char* class_name,
-                                      size_t class_name_length,
-                                      const cass_byte_t* value,
+CassError cass_user_type_set_custom_n(CassUserType* user_type, size_t index, const char* class_name,
+                                      size_t class_name_length, const cass_byte_t* value,
                                       size_t value_size) {
   return user_type->set(index,
-                        cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                         value, value_size));
+                        CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
-CassError cass_user_type_set_custom_by_name(CassUserType* user_type,
-                                            const char* name,
-                                            const char* class_name,
-                                            const cass_byte_t* value,
+CassError cass_user_type_set_custom_by_name(CassUserType* user_type, const char* name,
+                                            const char* class_name, const cass_byte_t* value,
                                             size_t value_size) {
-  return user_type->set(cass::StringRef(name),
-                        cass::CassCustom(cass::StringRef(class_name),
-                                         value, value_size));
+  return user_type->set(StringRef(name), CassCustom(StringRef(class_name), value, value_size));
 }
 
-CassError cass_user_type_set_custom_by_name_n(CassUserType* user_type,
-                                              const char* name,
-                                              size_t name_length,
-                                              const char* class_name,
-                                              size_t class_name_length,
-                                              const cass_byte_t* value,
+CassError cass_user_type_set_custom_by_name_n(CassUserType* user_type, const char* name,
+                                              size_t name_length, const char* class_name,
+                                              size_t class_name_length, const cass_byte_t* value,
                                               size_t value_size) {
-  return user_type->set(cass::StringRef(name, name_length),
-                        cass::CassCustom(cass::StringRef(class_name, class_name_length),
-                                         value, value_size));
+  return user_type->set(StringRef(name, name_length),
+                        CassCustom(StringRef(class_name, class_name_length), value, value_size));
 }
 
 } // extern "C"
diff --git a/src/user_type_value.hpp b/src/user_type_value.hpp
index c7dd5c64d..8b58c63c6 100644
--- a/src/user_type_value.hpp
+++ b/src/user_type_value.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_USER_TYPE_VALUE_HPP_INCLUDED__
-#define __CASS_USER_TYPE_VALUE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_USER_TYPE_VALUE_HPP
+#define DATASTAX_INTERNAL_USER_TYPE_VALUE_HPP
 
 #include "abstract_data.hpp"
 #include "cassandra.h"
@@ -23,13 +23,13 @@
 #include "external.hpp"
 #include "ref_counted.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class UserTypeValue : public AbstractData {
 public:
   UserTypeValue(const UserType::ConstPtr& data_type)
-    : AbstractData(data_type->fields().size())
-    , data_type_(data_type) { }
+      : AbstractData(data_type->fields().size())
+      , data_type_(data_type) {}
 
   const UserType::ConstPtr& data_type() const { return data_type_; }
 
@@ -49,8 +49,8 @@ class UserTypeValue : public AbstractData {
   DISALLOW_COPY_AND_ASSIGN(UserTypeValue);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::UserTypeValue, CassUserType)
+EXTERNAL_TYPE(datastax::internal::core::UserTypeValue, CassUserType)
 
 #endif
diff --git a/src/utils.cpp b/src/utils.cpp
index 425f8b8b3..fea00a33d 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -23,13 +23,13 @@
 #include <functional>
 
 #if (defined(WIN32) || defined(_WIN32))
-  #include <windows.h>
+#include <windows.h>
 #else
-  #include <sched.h>
-  #include <unistd.h>
+#include <sched.h>
+#include <unistd.h>
 #endif
 
-namespace cass {
+namespace datastax { namespace internal {
 
 String opcode_to_string(int opcode) {
   switch (opcode) {
@@ -91,8 +91,7 @@ void explode(const String& str, Vector<String>& vec, const char delimiter /* = '
 
 String implode(const Vector<String>& vec, const char delimiter /* = ' ' */) {
   String str;
-  for (Vector<String>::const_iterator it = vec.begin(),
-       end = vec.end(); it != end; ++it) {
+  for (Vector<String>::const_iterator it = vec.begin(), end = vec.end(); it != end; ++it) {
     if (!str.empty()) {
       str.push_back(delimiter);
     }
@@ -104,28 +103,24 @@ String implode(const Vector<String>& vec, const char delimiter /* = ' ' */) {
 String& trim(String& str) {
   // Trim front
   str.erase(str.begin(),
-            std::find_if(str.begin(), str.end(),
-                         std::not1(std::ptr_fun<int, int>(::isspace))));
+            std::find_if(str.begin(), str.end(), std::not1(std::ptr_fun<int, int>(::isspace))));
   // Trim back
-  str.erase(std::find_if(str.rbegin(), str.rend(),
-                         std::not1(std::ptr_fun<int, int>(::isspace))).base(),
-            str.end());
+  str.erase(
+      std::find_if(str.rbegin(), str.rend(), std::not1(std::ptr_fun<int, int>(::isspace))).base(),
+      str.end());
   return str;
 }
 
 static bool is_word_char(int c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
-         (c >= '0' && c <= '9') || c == '_';
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
 }
 
 static bool is_lower_word_char(int c) {
-  return (c >= 'a' && c <= 'z') ||
-         (c >= '0' && c <= '9') || c == '_';
+  return (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_';
 }
 
 bool is_valid_cql_id(const String& str) {
-  for (String::const_iterator i = str.begin(),
-       end = str.end(); i != end; ++i) {
+  for (String::const_iterator i = str.begin(), end = str.end(); i != end; ++i) {
     if (!is_word_char(*i)) {
       return false;
     }
@@ -138,8 +133,7 @@ bool is_valid_lower_cql_id(const String& str) {
     return false;
   }
   if (str.size() > 1) {
-    for (String::const_iterator i = str.begin() + 1,
-         end = str.end(); i != end; ++i) {
+    for (String::const_iterator i = str.begin() + 1, end = str.end(); i != end; ++i) {
       if (!is_lower_word_char(*i)) {
         return false;
       }
@@ -152,8 +146,7 @@ String& quote_id(String& str) {
   String temp(str);
   str.clear();
   str.push_back('"');
-  for (String::const_iterator i = temp.begin(),
-       end = temp.end(); i != end; ++i) {
+  for (String::const_iterator i = temp.begin(), end = temp.end(); i != end; ++i) {
     if (*i == '"') {
       str.push_back('"');
       str.push_back('"');
@@ -166,9 +159,7 @@ String& quote_id(String& str) {
   return str;
 }
 
-String& escape_id(String& str) {
-  return is_valid_lower_cql_id(str) ?  str : quote_id(str);
-}
+String& escape_id(String& str) { return is_valid_lower_cql_id(str) ? str : quote_id(str); }
 
 String& to_cql_id(String& str) {
   if (is_valid_cql_id(str)) {
@@ -197,16 +188,16 @@ void thread_yield() {
 #endif
 }
 
-// Code was taken from MSDN documentation
-// see https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
+// Code was taken from MSDN documentation see:
+// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
 #if defined(_MSC_VER) && defined(_DEBUG)
 const DWORD MS_VC_EXCEPTION = 0x406D1388;
-#pragma pack(push,8)
+#pragma pack(push, 8)
 typedef struct tagTHREADNAME_INFO {
-  DWORD dwType; // Must be 0x1000.
-  LPCSTR szName; // Pointer to name (in user addr space).
+  DWORD dwType;     // Must be 0x1000.
+  LPCSTR szName;    // Pointer to name (in user addr space).
   DWORD dwThreadID; // Thread ID (-1=caller thread).
-  DWORD dwFlags; // Reserved for future use, must be zero.
+  DWORD dwFlags;    // Reserved for future use, must be zero.
 } THREADNAME_INFO;
 #pragma pack(pop)
 #endif
@@ -218,15 +209,14 @@ void set_thread_name(const String& thread_name) {
   info.dwThreadID = -1;
   info.dwFlags = 0;
 #pragma warning(push)
-#pragma warning(disable: 6320 6322)
+#pragma warning(disable : 6320 6322)
   __try {
-    RaiseException(MS_VC_EXCEPTION,
-                   0,
-                   sizeof(info) / sizeof(ULONG_PTR),
+    RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR),
                    reinterpret_cast<ULONG_PTR*>(&info));
-  } __except (EXCEPTION_EXECUTE_HANDLER) { }
+  } __except (EXCEPTION_EXECUTE_HANDLER) {
+  }
 #pragma warning(pop)
 #endif
 }
 
-} // namespace cass
+}} // namespace datastax::internal
diff --git a/src/utils.hpp b/src/utils.hpp
index 1315b5ac5..e247f1301 100644
--- a/src/utils.hpp
+++ b/src/utils.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_COMMON_HPP_INCLUDED__
-#define __CASS_COMMON_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_COMMON_HPP
+#define DATASTAX_INTERNAL_COMMON_HPP
 
 #include "cassandra.h"
 #include "macros.hpp"
@@ -30,10 +30,7 @@
 #include <intrin.h>
 #endif
 
-namespace cass {
-
-class BufferPiece;
-class Value;
+namespace datastax { namespace internal {
 
 typedef Vector<String> ContactPointList;
 typedef Vector<String> DcList;
@@ -45,9 +42,8 @@ typedef Vector<String> DcList;
 // without violating strict aliasing and usually optimizes away on a modern
 // compiler (GCC, Clang, and MSVC).
 
-template<typename From, typename To>
-inline To copy_cast(const From& from)
-{
+template <typename From, typename To>
+inline To copy_cast(const From& from) {
   STATIC_ASSERT(sizeof(From) == sizeof(To));
 
   To to;
@@ -80,14 +76,13 @@ String& to_cql_id(String& str);
 String& escape_id(String& str);
 
 inline size_t num_leading_zeros(int64_t value) {
-  if (value == 0)
-    return 64;
+  if (value == 0) return 64;
 
 #if defined(_MSC_VER)
   unsigned long index;
-#  if defined(_M_AMD64)
+#if defined(_M_AMD64)
   _BitScanReverse64(&index, value);
-#  else
+#else
   // On 32-bit this needs to be split into two operations
   char isNonzero = _BitScanReverse(&index, (unsigned long)(value >> 32));
 
@@ -97,9 +92,9 @@ inline size_t num_leading_zeros(int64_t value) {
     index += 32;
   else {
     // Scan the last 32 bits by truncating the 64-bit value
-    _BitScanReverse(&index, (unsigned long) value);
+    _BitScanReverse(&index, (unsigned long)value);
   }
-#  endif
+#endif
   // index is the (zero based) index, counting from lsb, of the most-significant 1 bit.
   // For example, a value of 12 (b1100) would return 3. The 4th bit is set, so there are
   // 60 leading zeros.
@@ -127,6 +122,6 @@ static void set_pointer_keys(C& container) {
 
 void thread_yield();
 
-} // namespace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/uuids.cpp b/src/uuids.cpp
index f47dc51cd..c46333192 100644
--- a/src/uuids.cpp
+++ b/src/uuids.cpp
@@ -17,23 +17,24 @@
 #include "uuids.hpp"
 
 #include "cassandra.h"
+#include "external.hpp"
 #include "get_time.hpp"
 #include "logger.hpp"
 #include "md5.hpp"
-#include "serialization.hpp"
 #include "scoped_lock.hpp"
-#include "external.hpp"
+#include "serialization.hpp"
 
-#include <stdio.h>
 #include <ctype.h>
+#include <stdio.h>
 
 #define TIME_OFFSET_BETWEEN_UTC_AND_EPOCH 0x01B21DD213814000LL // Nanoseconds
 #define MIN_CLOCK_SEQ_AND_NODE 0x8080808080808080LL
 #define MAX_CLOCK_SEQ_AND_NODE 0x7f7f7f7f7f7f7f7fLL
 
-static uint64_t to_milliseconds(uint64_t timestamp) {
-  return timestamp / 10000L;
-}
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
+static uint64_t to_milliseconds(uint64_t timestamp) { return timestamp / 10000L; }
 
 static uint64_t from_unix_timestamp(uint64_t timestamp) {
   return (timestamp * 10000L) + TIME_OFFSET_BETWEEN_UTC_AND_EPOCH;
@@ -45,17 +46,13 @@ static uint64_t set_version(uint64_t timestamp, uint8_t version) {
 
 extern "C" {
 
-CassUuidGen* cass_uuid_gen_new() {
-  return CassUuidGen::to(new cass::UuidGen());
-}
+CassUuidGen* cass_uuid_gen_new() { return CassUuidGen::to(new UuidGen()); }
 
 CassUuidGen* cass_uuid_gen_new_with_node(cass_uint64_t node) {
-  return CassUuidGen::to(new cass::UuidGen(node));
+  return CassUuidGen::to(new UuidGen(node));
 }
 
-void cass_uuid_gen_free(CassUuidGen* uuid_gen) {
-  delete uuid_gen->from();
-}
+void cass_uuid_gen_free(CassUuidGen* uuid_gen) { delete uuid_gen->from(); }
 
 void cass_uuid_gen_time(CassUuidGen* uuid_gen, CassUuid* output) {
   uuid_gen->generate_time(output);
@@ -84,14 +81,12 @@ cass_uint64_t cass_uuid_timestamp(CassUuid uuid) {
   return to_milliseconds(timestamp - TIME_OFFSET_BETWEEN_UTC_AND_EPOCH);
 }
 
-cass_uint8_t cass_uuid_version(CassUuid uuid) {
-  return (uuid.time_and_version >> 60) & 0x0F;
-}
+cass_uint8_t cass_uuid_version(CassUuid uuid) { return (uuid.time_and_version >> 60) & 0x0F; }
 
 void cass_uuid_string(CassUuid uuid, char* output) {
   size_t pos = 0;
   char encoded[16];
-  cass::encode_uuid(encoded, uuid);
+  encode_uuid(encoded, uuid);
   static const char half_byte_to_hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                                            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
   for (size_t i = 0; i < 16; ++i) {
@@ -105,22 +100,19 @@ void cass_uuid_string(CassUuid uuid, char* output) {
   output[pos] = '\0';
 }
 
-CassError cass_uuid_from_string(const char* str,
-                                CassUuid* output) {
+CassError cass_uuid_from_string(const char* str, CassUuid* output) {
   if (str == NULL) {
     return CASS_ERROR_LIB_BAD_PARAMS;
   }
 
-  return cass_uuid_from_string_n(str, strlen(str),
-                                 output);
+  return cass_uuid_from_string_n(str, strlen(str), output);
 }
 
-CassError cass_uuid_from_string_n(const char* str,
-                                  size_t str_length,
-                                  CassUuid* output) {
+CassError cass_uuid_from_string_n(const char* str, size_t str_length, CassUuid* output) {
   const char* pos = str;
   char buf[16];
 
+  // clang-format off
   static const signed char hex_to_half_byte[256] = {
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
@@ -139,6 +131,7 @@ CassError cass_uuid_from_string_n(const char* str,
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
   };
+  // clang-format on
 
   if (str == NULL || str_length != 36) {
     return CASS_ERROR_LIB_BAD_PARAMS;
@@ -152,26 +145,24 @@ CassError cass_uuid_from_string_n(const char* str,
     }
     uint8_t p0 = static_cast<uint8_t>(pos[0]);
     uint8_t p1 = static_cast<uint8_t>(pos[1]);
-    if (hex_to_half_byte[p0] == -1 || hex_to_half_byte[p1] == -1)  {
+    if (hex_to_half_byte[p0] == -1 || hex_to_half_byte[p1] == -1) {
       return CASS_ERROR_LIB_BAD_PARAMS;
     }
     buf[i] = (hex_to_half_byte[p0] << 4) + hex_to_half_byte[p1];
     pos += 2;
   }
 
-  cass::decode_uuid(buf, output);
+  decode_uuid(buf, output);
 
   return CASS_OK;
 }
 
 } // extern "C"
 
-namespace cass {
-
 UuidGen::UuidGen()
-  : clock_seq_and_node_(0)
-  , last_timestamp_(0LL)
-  , ng_(get_random_seed(MT19937_64::DEFAULT_SEED)){
+    : clock_seq_and_node_(0)
+    , last_timestamp_(0LL)
+    , ng_(get_random_seed(MT19937_64::DEFAULT_SEED)) {
   uv_mutex_init(&mutex_);
 
   Md5 md5;
@@ -179,7 +170,7 @@ UuidGen::UuidGen()
   uv_interface_address_t* addresses;
   int address_count;
 
-    if (uv_interface_addresses(&addresses, &address_count) == 0) {
+  if (uv_interface_addresses(&addresses, &address_count) == 0) {
     for (int i = 0; i < address_count; ++i) {
       char buf[256];
       uv_interface_address_t address = addresses[i];
@@ -230,16 +221,14 @@ UuidGen::UuidGen()
 }
 
 UuidGen::UuidGen(uint64_t node)
-  : clock_seq_and_node_(0)
-  , last_timestamp_(0LL)
-  , ng_(get_random_seed(MT19937_64::DEFAULT_SEED)){
+    : clock_seq_and_node_(0)
+    , last_timestamp_(0LL)
+    , ng_(get_random_seed(MT19937_64::DEFAULT_SEED)) {
   uv_mutex_init(&mutex_);
   set_clock_seq_and_node(node & 0x0000FFFFFFFFFFFFLL);
 }
 
-UuidGen::~UuidGen() {
-  uv_mutex_destroy(&mutex_);
-}
+UuidGen::~UuidGen() { uv_mutex_destroy(&mutex_); }
 
 void UuidGen::generate_time(CassUuid* output) {
   output->time_and_version = set_version(monotonic_timestamp(), 1);
@@ -258,7 +247,8 @@ void UuidGen::generate_random(CassUuid* output) {
   lock.unlock();
 
   output->time_and_version = set_version(time_and_version, 4);
-  output->clock_seq_and_node = (clock_seq_and_node & 0x3FFFFFFFFFFFFFFFLL) | 0x8000000000000000LL; // RFC4122 variant
+  output->clock_seq_and_node =
+      (clock_seq_and_node & 0x3FFFFFFFFFFFFFFFLL) | 0x8000000000000000LL; // RFC4122 variant
 }
 
 void UuidGen::set_clock_seq_and_node(uint64_t node) {
@@ -289,5 +279,3 @@ uint64_t UuidGen::monotonic_timestamp() {
     }
   }
 }
-
-} // namespace cass
diff --git a/src/uuids.hpp b/src/uuids.hpp
index b5f132ece..8a4a3d953 100644
--- a/src/uuids.hpp
+++ b/src/uuids.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_UUIDS_HPP_INCLUDED__
-#define __CASS_UUIDS_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_UUIDS_HPP
+#define DATASTAX_INTERNAL_UUIDS_HPP
 
 #include "allocated.hpp"
 #include "atomic.hpp"
@@ -23,11 +23,11 @@
 #include "external.hpp"
 #include "random.hpp"
 
-#include <uv.h>
 #include <assert.h>
 #include <string.h>
+#include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class UuidGen : public Allocated {
 public:
@@ -50,8 +50,8 @@ class UuidGen : public Allocated {
   MT19937_64 ng_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::UuidGen, CassUuidGen)
+EXTERNAL_TYPE(datastax::internal::core::UuidGen, CassUuidGen)
 
 #endif
diff --git a/src/value.cpp b/src/value.cpp
index 01c656d89..daca67350 100644
--- a/src/value.cpp
+++ b/src/value.cpp
@@ -21,14 +21,20 @@
 #include "external.hpp"
 #include "serialization.hpp"
 
-#define CHECK_RESULT(result) if(!(result)) return false;
-#define CHECK_VALUE(result) do { \
-  if ((result)) { \
-    return CASS_OK; \
-  } else { \
-    return CASS_ERROR_LIB_NOT_ENOUGH_DATA; \
-  } \
-} while (0)
+#define CHECK_RESULT(result) \
+  if (!(result)) return false;
+#define CHECK_VALUE(result)                  \
+  do {                                       \
+    if ((result)) {                          \
+      return CASS_OK;                        \
+    } else {                                 \
+      return CASS_ERROR_LIB_NOT_ENOUGH_DATA; \
+    }                                        \
+  } while (0)
+
+using namespace datastax;
+using namespace datastax::internal;
+using namespace datastax::internal::core;
 
 extern "C" {
 
@@ -58,7 +64,6 @@ CassError cass_value_get_int32(const CassValue* value, cass_int32_t* output) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
   CHECK_VALUE(value->decoder().as_int32(output));
-
 }
 
 CassError cass_value_get_uint32(const CassValue* value, cass_uint32_t* output) {
@@ -71,7 +76,7 @@ CassError cass_value_get_uint32(const CassValue* value, cass_uint32_t* output) {
 
 CassError cass_value_get_int64(const CassValue* value, cass_int64_t* output) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
-  if (!cass::is_int64_type(value->value_type())) {
+  if (!is_int64_type(value->value_type())) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
   CHECK_VALUE(value->decoder().as_int64(output));
@@ -108,7 +113,7 @@ CassError cass_value_get_bool(const CassValue* value, cass_bool_t* output) {
 
 CassError cass_value_get_uuid(const CassValue* value, CassUuid* output) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
-  if (!cass::is_uuid_type(value->value_type())) {
+  if (!is_uuid_type(value->value_type())) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   }
   CHECK_VALUE(value->decoder().as_uuid(output));
@@ -125,39 +130,33 @@ CassError cass_value_get_inet(const CassValue* value, CassInet* output) {
   return CASS_OK;
 }
 
-CassError cass_value_get_string(const CassValue* value,
-                                const char** output,
+CassError cass_value_get_string(const CassValue* value, const char** output,
                                 size_t* output_length) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
-  cass::StringRef buffer = value->decoder().as_string_ref();
+  StringRef buffer = value->decoder().as_string_ref();
   *output = buffer.data();
   *output_length = buffer.size();
   return CASS_OK;
 }
 
-CassError cass_value_get_bytes(const CassValue* value,
-                               const cass_byte_t** output,
+CassError cass_value_get_bytes(const CassValue* value, const cass_byte_t** output,
                                size_t* output_size) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
-  cass::StringRef buffer = value->decoder().as_string_ref();
+  StringRef buffer = value->decoder().as_string_ref();
   *output = reinterpret_cast<const cass_byte_t*>(buffer.data());
   *output_size = buffer.size();
   return CASS_OK;
 }
 
-CassError cass_value_get_duration(const CassValue* value,
-                                  cass_int32_t* months,
-                                  cass_int32_t* days,
+CassError cass_value_get_duration(const CassValue* value, cass_int32_t* months, cass_int32_t* days,
                                   cass_int64_t* nanos) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
   if (!cass_value_is_duration(value)) return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
   CHECK_VALUE(value->decoder().as_duration(months, days, nanos));
 }
 
-CassError cass_value_get_decimal(const CassValue* value,
-                                 const cass_byte_t** varint,
-                                 size_t* varint_size,
-                                 cass_int32_t* scale) {
+CassError cass_value_get_decimal(const CassValue* value, const cass_byte_t** varint,
+                                 size_t* varint_size, cass_int32_t* scale) {
   if (value == NULL || value->is_null()) return CASS_ERROR_LIB_NULL_VALUE;
   if (value->value_type() != CASS_VALUE_TYPE_DECIMAL) {
     return CASS_ERROR_LIB_INVALID_VALUE_TYPE;
@@ -165,9 +164,7 @@ CassError cass_value_get_decimal(const CassValue* value,
   CHECK_VALUE(value->decoder().as_decimal(varint, varint_size, scale));
 }
 
-CassValueType cass_value_type(const CassValue* value) {
-  return value->value_type();
-}
+CassValueType cass_value_type(const CassValue* value) { return value->value_type(); }
 
 cass_bool_t cass_value_is_null(const CassValue* value) {
   return static_cast<cass_bool_t>(value->is_null());
@@ -178,14 +175,12 @@ cass_bool_t cass_value_is_collection(const CassValue* value) {
 }
 
 cass_bool_t cass_value_is_duration(const CassValue* value) {
-  cass::IsValidDataType<cass::CassDuration> is_valid;
-  cass::CassDuration dummy(0, 0, 0);
+  IsValidDataType<CassDuration> is_valid;
+  CassDuration dummy(0, 0, 0);
   return static_cast<cass_bool_t>(is_valid(dummy, value->data_type()));
 }
 
-size_t cass_value_item_count(const CassValue* collection) {
-  return collection->count();
-}
+size_t cass_value_item_count(const CassValue* collection) { return collection->count(); }
 
 CassValueType cass_value_primary_sub_type(const CassValue* collection) {
   return collection->primary_value_type();
@@ -197,10 +192,7 @@ CassValueType cass_value_secondary_sub_type(const CassValue* collection) {
 
 } // extern "C"
 
-
-namespace cass {
-
-Value::Value(const DataType::ConstPtr &data_type, Decoder decoder)
+Value::Value(const DataType::ConstPtr& data_type, Decoder decoder)
     : data_type_(data_type)
     , count_(0)
     , decoder_(decoder)
@@ -236,8 +228,8 @@ int32_t Value::as_int32() const {
 }
 
 CassUuid Value::as_uuid() const {
-  assert(!is_null() && (value_type() == CASS_VALUE_TYPE_UUID ||
-                        value_type() == CASS_VALUE_TYPE_TIMEUUID));
+  assert(!is_null() &&
+         (value_type() == CASS_VALUE_TYPE_UUID || value_type() == CASS_VALUE_TYPE_TIMEUUID));
   CassUuid value = { 0, 0 };
   bool result = decoder_.as_uuid(&value);
   UNUSED_(result);
@@ -246,8 +238,8 @@ CassUuid Value::as_uuid() const {
 }
 
 StringVec Value::as_stringlist() const {
-  assert(!is_null() && (value_type() == CASS_VALUE_TYPE_LIST ||
-                        value_type() == CASS_VALUE_TYPE_SET) &&
+  assert(!is_null() &&
+         (value_type() == CASS_VALUE_TYPE_LIST || value_type() == CASS_VALUE_TYPE_SET) &&
          primary_value_type() == CASS_VALUE_TYPE_VARCHAR);
   StringVec stringlist;
   CollectionIterator iterator(this);
@@ -256,5 +248,3 @@ StringVec Value::as_stringlist() const {
   }
   return stringlist;
 }
-
-} // namespace cass
diff --git a/src/value.hpp b/src/value.hpp
index 45e3380a1..8c9890f99 100644
--- a/src/value.hpp
+++ b/src/value.hpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#ifndef __CASS_VALUE_HPP_INCLUDED__
-#define __CASS_VALUE_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_VALUE_HPP
+#define DATASTAX_INTERNAL_VALUE_HPP
 
 #include "cassandra.h"
 #include "decoder.hpp"
@@ -23,30 +23,29 @@
 #include "result_metadata.hpp"
 #include "string_ref.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class Value {
 public:
   Value()
       : count_(0)
-      , is_null_(false) { }
+      , is_null_(false) {}
 
   // Used for "null" values
   Value(const DataType::ConstPtr& data_type)
       : data_type_(data_type)
       , count_(0)
-      , is_null_(true) { }
+      , is_null_(true) {}
 
   // Used for regular values, tuples, and UDTs
   Value(const DataType::ConstPtr& data_type, Decoder decoder);
 
   // Used for collections and schema metadata collections (converted from JSON)
-  Value(const DataType::ConstPtr& data_type,
-        int32_t count, Decoder decoder)
+  Value(const DataType::ConstPtr& data_type, int32_t count, Decoder decoder)
       : data_type_(data_type)
       , count_(count)
       , decoder_(decoder)
-      , is_null_(false) { }
+      , is_null_(false) {}
 
   Decoder decoder() const { return decoder_; }
   ProtocolVersion protocol_version() const { return decoder_.protocol_version(); }
@@ -59,9 +58,7 @@ class Value {
     return data_type_->value_type();
   }
 
-  const DataType::ConstPtr& data_type() const {
-    return data_type_;
-  }
+  const DataType::ConstPtr& data_type() const { return data_type_; }
 
   CassValueType primary_value_type() const {
     const DataType::ConstPtr& primary(primary_data_type());
@@ -101,9 +98,7 @@ class Value {
     return collection_type->types()[1];
   }
 
-  bool is_null() const {
-    return is_null_;
-  }
+  bool is_null() const { return is_null_; }
 
   bool is_collection() const {
     if (!data_type_) return false;
@@ -125,18 +120,14 @@ class Value {
     return data_type_->is_user_type();
   }
 
-  int32_t count() const {
-    return count_;
-  }
+  int32_t count() const { return count_; }
 
   StringRef to_string_ref() const {
     if (is_null()) return StringRef();
     return decoder_.as_string_ref();
   }
 
-  String to_string() const {
-    return to_string_ref().to_string();
-  }
+  String to_string() const { return to_string_ref().to_string(); }
 
   bool as_bool() const;
   int32_t as_int32() const;
@@ -152,8 +143,8 @@ class Value {
 
 typedef Vector<Value> OutputValueVec;
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
-EXTERNAL_TYPE(cass::Value, CassValue)
+EXTERNAL_TYPE(datastax::internal::core::Value, CassValue)
 
 #endif
diff --git a/src/vector.hpp b/src/vector.hpp
index e6fd2b14f..71114c75a 100644
--- a/src/vector.hpp
+++ b/src/vector.hpp
@@ -5,37 +5,37 @@
   license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
 */
 
-#ifndef __DSE_VECTOR_HPP_INCLUDED__
-#define __DSE_VECTOR_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_VECTOR_HPP
+#define DATASTAX_INTERNAL_VECTOR_HPP
 
 #include "allocated.hpp"
 #include "allocator.hpp"
 
 #include <vector>
 
-namespace cass {
+namespace datastax { namespace internal {
 
 template <class T>
 class Vector
     : public Allocated
-    , public std::vector<T, cass::Allocator<T> > {
+    , public std::vector<T, internal::Allocator<T> > {
 public:
-  typedef cass::Allocator<T> Allocator;
+  typedef internal::Allocator<T> Allocator;
 
   explicit Vector(const Allocator& alloc = Allocator())
-    : std::vector<T, Allocator>(alloc) { }
+      : std::vector<T, Allocator>(alloc) {}
 
   explicit Vector(size_t count, const T& value = T())
-    : std::vector<T, Allocator>(count, value) { }
+      : std::vector<T, Allocator>(count, value) {}
 
   Vector(const Vector& other)
-    : std::vector<T, Allocator>(other) { }
+      : std::vector<T, Allocator>(other) {}
 
-  template<class InputIt>
+  template <class InputIt>
   Vector(InputIt first, InputIt last)
-    : std::vector<T, Allocator>(first, last) { }
+      : std::vector<T, Allocator>(first, last) {}
 };
 
-} // namepsace cass
+}} // namespace datastax::internal
 
 #endif
diff --git a/src/wait_for_handler.cpp b/src/wait_for_handler.cpp
index 5268b5088..a5c5d58b4 100644
--- a/src/wait_for_handler.cpp
+++ b/src/wait_for_handler.cpp
@@ -21,7 +21,10 @@
 
 #include <iomanip>
 
-namespace cass {
+using namespace datastax;
+using namespace datastax::internal::core;
+
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A callback that handles a chain of requests on behalf of the wait handler.
@@ -30,11 +33,11 @@ class WaitForCallback : public ChainedRequestCallback {
 public:
   WaitForCallback(const String& key, const Request::ConstPtr& request,
                   const WaitForHandler::Ptr& handler)
-    : ChainedRequestCallback(key, request)
-    , handler_(handler) { }
+      : ChainedRequestCallback(key, request)
+      , handler_(handler) {}
 
 private:
-  virtual void on_chain_write(Connection *connection);
+  virtual void on_chain_write(Connection* connection);
   virtual void on_chain_set();
   virtual void on_chain_error(CassError code, const String& message);
   virtual void on_chain_timeout();
@@ -43,9 +46,9 @@ class WaitForCallback : public ChainedRequestCallback {
   WaitForHandler::Ptr handler_;
 };
 
-void WaitForCallback::on_chain_write(Connection* connection) {
-  handler_->start(connection);
-}
+void WaitForCallback::on_chain_write(Connection* connection) { handler_->start(connection); }
+
+}}} // namespace datastax::internal::core
 
 void WaitForCallback::on_chain_set() {
   if (handler_->on_set(Ptr(this))) {
@@ -57,8 +60,8 @@ void WaitForCallback::on_chain_set() {
 
 void WaitForCallback::on_chain_error(CassError code, const String& message) {
   OStringStream ss;
-  ss << message
-     << " (0x" << std::hex << std::uppercase << std::setw(8) << std::setfill('0') << code << ")";
+  ss << message << " (0x" << std::hex << std::uppercase << std::setw(8) << std::setfill('0') << code
+     << ")";
   handler_->on_error(WaitForHandler::WAIT_FOR_ERROR_REQUEST_ERROR, ss.str());
   handler_->finish();
 }
@@ -71,8 +74,8 @@ void WaitForCallback::on_chain_timeout() {
 ChainedRequestCallback::Ptr WaitForHandler::callback(const WaitforRequestVec& requests) {
   requests_ = requests;
   ChainedRequestCallback::Ptr chain;
-  for (WaitforRequestVec::const_iterator it = requests.begin(),
-       end = requests.end(); it != end; ++it) {
+  for (WaitforRequestVec::const_iterator it = requests.begin(), end = requests.end(); it != end;
+       ++it) {
     if (!chain) {
       chain.reset(new WaitForCallback(it->first, it->second, Ptr(this)));
     } else {
@@ -82,7 +85,8 @@ ChainedRequestCallback::Ptr WaitForHandler::callback(const WaitforRequestVec& re
   return chain;
 }
 
-WaitForHandler::WaitForRequest WaitForHandler::make_request(const String& key, const String& query) {
+WaitForHandler::WaitForRequest WaitForHandler::make_request(const String& key,
+                                                            const String& query) {
   QueryRequest::Ptr request(new QueryRequest(query));
   request->set_request_timeout_ms(request_timeout_ms());
   return WaitForRequest(key, request);
@@ -90,7 +94,7 @@ WaitForHandler::WaitForRequest WaitForHandler::make_request(const String& key, c
 
 void WaitForHandler::start(Connection* connection) {
   if (!connection_ && !is_finished_) { // Start only once
-    inc_ref(); // Reference for the event loop
+    inc_ref();                         // Reference for the event loop
     connection_.reset(connection);
     timer_.start(connection_->loop(), max_wait_time_ms_,
                  bind_callback(&WaitForHandler::on_timeout, this));
@@ -122,7 +126,7 @@ void WaitForHandler::on_retry_timeout(Timer* timer) {
     on_error(WaitForHandler::WAIT_FOR_ERROR_CONNECTION_CLOSED, "Connection closed");
     finish();
   } else if (connection_->write_and_flush(callback(requests_)) ==
-             cass::Request::REQUEST_ERROR_NO_AVAILABLE_STREAM_IDS) {
+             core::Request::REQUEST_ERROR_NO_AVAILABLE_STREAM_IDS) {
     on_error(WaitForHandler::WAIT_FOR_ERROR_NO_STREAMS, "Connection closed");
     finish();
   }
@@ -134,16 +138,12 @@ void WaitForHandler::on_timeout(Timer* timer) {
 }
 
 WaitForHandler::WaitForHandler(const RequestHandler::Ptr& request_handler,
-                               const Host::Ptr& current_host,
-                               const Response::Ptr& response,
-                               uint64_t max_wait_time_ms,
-                               uint64_t retry_wait_time_ms)
-  : is_finished_(false)
-  , start_time_ms_(get_time_since_epoch_ms())
-  , max_wait_time_ms_(max_wait_time_ms)
-  , retry_wait_time_ms_(retry_wait_time_ms)
-  , request_handler_(request_handler)
-  , current_host_(current_host)
-  , response_(response) { }
-
-} // namespace cass
+                               const Host::Ptr& current_host, const Response::Ptr& response,
+                               uint64_t max_wait_time_ms, uint64_t retry_wait_time_ms)
+    : is_finished_(false)
+    , start_time_ms_(get_time_since_epoch_ms())
+    , max_wait_time_ms_(max_wait_time_ms)
+    , retry_wait_time_ms_(retry_wait_time_ms)
+    , request_handler_(request_handler)
+    , current_host_(current_host)
+    , response_(response) {}
diff --git a/src/wait_for_handler.hpp b/src/wait_for_handler.hpp
index a36a357bd..e9454f6d2 100644
--- a/src/wait_for_handler.hpp
+++ b/src/wait_for_handler.hpp
@@ -14,18 +14,18 @@
   limitations under the License.
 */
 
-#ifndef __CASS_WAIT_FOR_HANDLER_HPP_INCLUDED__
-#define __CASS_WAIT_FOR_HANDLER_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_WAIT_FOR_HANDLER_HPP
+#define DATASTAX_INTERNAL_WAIT_FOR_HANDLER_HPP
 
 #include "connection.hpp"
 #include "ref_counted.hpp"
-#include "request_handler.hpp"
 #include "request_callback.hpp"
+#include "request_handler.hpp"
 #include "response.hpp"
 
 #include <uv.h>
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 /**
  * A handler that waits for server-side data by running queries and verifying
@@ -57,13 +57,11 @@ class WaitForHandler : public RefCounted<WaitForHandler> {
    * @param retry_wait_time_ms The amount of time to wait between failed
    * attempts.
    */
-  WaitForHandler(const RequestHandler::Ptr& request_handler,
-                 const Host::Ptr& current_host,
-                 const Response::Ptr& response,
-                 uint64_t max_wait_time_ms,
+  WaitForHandler(const RequestHandler::Ptr& request_handler, const Host::Ptr& current_host,
+                 const Response::Ptr& response, uint64_t max_wait_time_ms,
                  uint64_t retry_wait_time_ms);
 
-  virtual ~WaitForHandler() { }
+  virtual ~WaitForHandler() {}
 
 protected:
   /**
@@ -129,6 +127,6 @@ class WaitForHandler : public RefCounted<WaitForHandler> {
   const Response::Ptr response_;
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/whitelist_dc_policy.cpp b/src/whitelist_dc_policy.cpp
index 1d5366946..d7817647e 100644
--- a/src/whitelist_dc_policy.cpp
+++ b/src/whitelist_dc_policy.cpp
@@ -16,17 +16,14 @@
 
 #include "whitelist_dc_policy.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool WhitelistDCPolicy::is_valid_host(const Host::Ptr& host) const {
   const String& host_dc = host->dc();
-  for (DcList::const_iterator it = dcs_.begin(),
-      end = dcs_.end(); it != end; ++it) {
+  for (DcList::const_iterator it = dcs_.begin(), end = dcs_.end(); it != end; ++it) {
     if (host_dc.compare(*it) == 0) {
       return true;
     }
   }
   return false;
 }
-
-} // namespace cass
diff --git a/src/whitelist_dc_policy.hpp b/src/whitelist_dc_policy.hpp
index b31f61c3b..796659026 100644
--- a/src/whitelist_dc_policy.hpp
+++ b/src/whitelist_dc_policy.hpp
@@ -14,22 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_WHITELIST_DC_POLICY_HPP_INCLUDED__
-#define __CASS_WHITELIST_DC_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_WHITELIST_DC_POLICY_HPP
+#define DATASTAX_INTERNAL_WHITELIST_DC_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
-#include "scoped_ptr.hpp"
 #include "list_policy.hpp"
+#include "load_balancing.hpp"
+#include "scoped_ptr.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class WhitelistDCPolicy : public ListPolicy {
 public:
-  WhitelistDCPolicy(LoadBalancingPolicy* child_policy,
-                    const DcList& dcs)
-    : ListPolicy(child_policy)
-    , dcs_(dcs) {}
+  WhitelistDCPolicy(LoadBalancingPolicy* child_policy, const DcList& dcs)
+      : ListPolicy(child_policy)
+      , dcs_(dcs) {}
 
   virtual ~WhitelistDCPolicy() {}
 
@@ -46,6 +45,6 @@ class WhitelistDCPolicy : public ListPolicy {
   DISALLOW_COPY_AND_ASSIGN(WhitelistDCPolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/src/whitelist_policy.cpp b/src/whitelist_policy.cpp
index 53c0d07b7..c6531e558 100644
--- a/src/whitelist_policy.cpp
+++ b/src/whitelist_policy.cpp
@@ -16,18 +16,14 @@
 
 #include "whitelist_policy.hpp"
 
-namespace cass {
+using namespace datastax::internal::core;
 
 bool WhitelistPolicy::is_valid_host(const Host::Ptr& host) const {
   const String& host_address = host->address().to_string(false);
-  for (ContactPointList::const_iterator it = hosts_.begin(),
-                                                end = hosts_.end();
-       it != end; ++it) {
+  for (ContactPointList::const_iterator it = hosts_.begin(), end = hosts_.end(); it != end; ++it) {
     if (host_address.compare(*it) == 0) {
       return true;
     }
   }
   return false;
 }
-
-} // namespace cass
diff --git a/src/whitelist_policy.hpp b/src/whitelist_policy.hpp
index 7f1a68d1d..cc1060be2 100644
--- a/src/whitelist_policy.hpp
+++ b/src/whitelist_policy.hpp
@@ -14,22 +14,21 @@
   limitations under the License.
 */
 
-#ifndef __CASS_WHITELIST_POLICY_HPP_INCLUDED__
-#define __CASS_WHITELIST_POLICY_HPP_INCLUDED__
+#ifndef DATASTAX_INTERNAL_WHITELIST_POLICY_HPP
+#define DATASTAX_INTERNAL_WHITELIST_POLICY_HPP
 
-#include "load_balancing.hpp"
 #include "host.hpp"
-#include "scoped_ptr.hpp"
 #include "list_policy.hpp"
+#include "load_balancing.hpp"
+#include "scoped_ptr.hpp"
 
-namespace cass {
+namespace datastax { namespace internal { namespace core {
 
 class WhitelistPolicy : public ListPolicy {
 public:
-  WhitelistPolicy(LoadBalancingPolicy* child_policy,
-                  const ContactPointList& hosts)
-    : ListPolicy(child_policy)
-    , hosts_(hosts) {}
+  WhitelistPolicy(LoadBalancingPolicy* child_policy, const ContactPointList& hosts)
+      : ListPolicy(child_policy)
+      , hosts_(hosts) {}
 
   virtual ~WhitelistPolicy() {}
 
@@ -46,6 +45,6 @@ class WhitelistPolicy : public ListPolicy {
   DISALLOW_COPY_AND_ASSIGN(WhitelistPolicy);
 };
 
-} // namespace cass
+}}} // namespace datastax::internal::core
 
 #endif
diff --git a/test/ccm_bridge/data/config.txt b/test/ccm_bridge/data/config.txt
index 10b2fe7be..24b5b55e9 100644
--- a/test/ccm_bridge/data/config.txt
+++ b/test/ccm_bridge/data/config.txt
@@ -13,7 +13,7 @@
 #
 # Uncomment to specify Cassandra version
 ##
-#CASSANDRA_VERSION=3.11.3
+#CASSANDRA_VERSION=3.11.4
 ##
 # Flag to determine if Cassandra/DSE version should be obtained from ASF/GitHub
 #
@@ -68,7 +68,7 @@
 #
 # Uncomment to specify DSE version
 ##
-#DSE_VERSION=6.0.4
+#DSE_VERSION=6.0.8
 ##
 # CCM DSE Credentials Type (username_password|ini_file)
 #
diff --git a/test/ccm_bridge/src/authentication_type.cpp b/test/ccm_bridge/src/authentication_type.cpp
index 064af7af2..16a2d9c2f 100644
--- a/test/ccm_bridge/src/authentication_type.cpp
+++ b/test/ccm_bridge/src/authentication_type.cpp
@@ -21,29 +21,23 @@
 using namespace CCM;
 
 // Constant value definitions for authentication type
-const AuthenticationType AuthenticationType::USERNAME_PASSWORD("USERNAME_PASSWORD", 0, "Username and Password");
+const AuthenticationType AuthenticationType::USERNAME_PASSWORD("USERNAME_PASSWORD", 0,
+                                                               "Username and Password");
 const AuthenticationType AuthenticationType::PUBLIC_KEY("PUBLIC_KEY", 1, "Public Key");
 
 // Static declarations for authentication type
 std::set<AuthenticationType> AuthenticationType::constants_;
 
 AuthenticationType::AuthenticationType()
- : name_("INVALID")
- , ordinal_(-1)
- , display_name_("Invalid authentication") {
-}
+    : name_("INVALID")
+    , ordinal_(-1)
+    , display_name_("Invalid authentication") {}
 
-const std::string& AuthenticationType::name() const {
-  return name_;
-}
+const std::string& AuthenticationType::name() const { return name_; }
 
-short AuthenticationType::ordinal() const {
-  return ordinal_;
-}
+short AuthenticationType::ordinal() const { return ordinal_; }
 
-const std::string& AuthenticationType::to_string() const {
-  return display_name_;
-}
+const std::string& AuthenticationType::to_string() const { return display_name_; }
 
 const std::set<AuthenticationType>& AuthenticationType::get_constants() {
   if (constants_.empty()) {
@@ -54,14 +48,13 @@ const std::set<AuthenticationType>& AuthenticationType::get_constants() {
   return constants_;
 }
 
-AuthenticationType::AuthenticationType(const std::string &name, int ordinal, const std::string &display_name)
-  : name_(name)
-  , ordinal_(ordinal)
-  , display_name_(display_name) {}
+AuthenticationType::AuthenticationType(const std::string& name, int ordinal,
+                                       const std::string& display_name)
+    : name_(name)
+    , ordinal_(ordinal)
+    , display_name_(display_name) {}
 
-std::set<AuthenticationType>::iterator AuthenticationType::end() {
-  return get_constants().end();
-}
+std::set<AuthenticationType>::iterator AuthenticationType::end() { return get_constants().end(); }
 
 std::set<AuthenticationType>::iterator AuthenticationType::begin() {
   return get_constants().begin();
diff --git a/test/ccm_bridge/src/authentication_type.hpp b/test/ccm_bridge/src/authentication_type.hpp
index d2faad42b..9c61c68ca 100644
--- a/test/ccm_bridge/src/authentication_type.hpp
+++ b/test/ccm_bridge/src/authentication_type.hpp
@@ -22,120 +22,120 @@
 
 namespace CCM {
 
+/**
+ * Authentication type indicating how SSH authentication should be handled
+ */
+class AuthenticationType {
+public:
   /**
-   * Authentication type indicating how SSH authentication should be handled
-   */
-  class AuthenticationType {
-  public:
-    /**
-     * Iterator for authentication type constants
-     */
-    typedef std::set<AuthenticationType>::iterator iterator;
-
-    /**
-     * Username/Password authentication type; SSH process is authenticated via
-     * plain text username and password
-     */
-    static const AuthenticationType USERNAME_PASSWORD;
-    /**
-     * Public key authentication type; SSH process is authenticated via public
-     * key
-     */
-    static const AuthenticationType PUBLIC_KEY;
-
-    /**
-     * Name of constant
-     *
-     * @return Name of constant
-     */
-    const std::string& name() const;
-    /**
-     * Ordinal of constant
-     *
-     * @return Ordinal of constant
-     */
-    short ordinal() const;
-    /**
-     * Get the display name
-     *
-     * @return Display name of authentication type
-     */
-    const std::string& to_string() const;
-
-    /**
-     * Less than (can be used for sorting)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS < RHS; false otherwise
-     */
-    bool operator<(const AuthenticationType& object) const;
-    /**
-     * Equal to
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const AuthenticationType& object) const;
-    /**
-     * Equal to (case-incentive string comparison)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const std::string& object) const;
-
-    /**
-     * First item in the authentication constants
-     *
-     * @return Iterator pointing to the first element in the set
-     */
-    static std::set<AuthenticationType>::iterator begin();
-    /**
-     * Last item in the authentication constants
-     *
-     * @return Iterator pointing to the last element in the set
-     */
-    static std::set<AuthenticationType>::iterator end();
-
-    /**
-     * Default constructor to handle issues with static initialization of
-     * constant authentication types
-     */
-    AuthenticationType();
-
-  private:
-    /**
-     * Authentication type constants
-     */
-    static std::set<AuthenticationType> constants_;
-    /**
-     * Name of constant
-     */
-    std::string name_;
-    /**
-     * Ordinal of constant
-     */
-    short ordinal_;
-    /**
-     * Display name for constant
-     */
-    std::string display_name_;
-
-    /**
-     * Constructor
-     *
-     * @param name Name for authentication type
-     * @param display_name Display name for authentication type
-     */
-    AuthenticationType(const std::string& name, int ordinal, const std::string& display_name);
-    /**
-     * Get the authentication type constants
-     *
-     * @return List of authentication type constants
-     */
-    static const std::set<AuthenticationType>& get_constants();
-  };
-
-}
+   * Iterator for authentication type constants
+   */
+  typedef std::set<AuthenticationType>::iterator iterator;
+
+  /**
+   * Username/Password authentication type; SSH process is authenticated via
+   * plain text username and password
+   */
+  static const AuthenticationType USERNAME_PASSWORD;
+  /**
+   * Public key authentication type; SSH process is authenticated via public
+   * key
+   */
+  static const AuthenticationType PUBLIC_KEY;
+
+  /**
+   * Name of constant
+   *
+   * @return Name of constant
+   */
+  const std::string& name() const;
+  /**
+   * Ordinal of constant
+   *
+   * @return Ordinal of constant
+   */
+  short ordinal() const;
+  /**
+   * Get the display name
+   *
+   * @return Display name of authentication type
+   */
+  const std::string& to_string() const;
+
+  /**
+   * Less than (can be used for sorting)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS < RHS; false otherwise
+   */
+  bool operator<(const AuthenticationType& object) const;
+  /**
+   * Equal to
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const AuthenticationType& object) const;
+  /**
+   * Equal to (case-incentive string comparison)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const std::string& object) const;
+
+  /**
+   * First item in the authentication constants
+   *
+   * @return Iterator pointing to the first element in the set
+   */
+  static std::set<AuthenticationType>::iterator begin();
+  /**
+   * Last item in the authentication constants
+   *
+   * @return Iterator pointing to the last element in the set
+   */
+  static std::set<AuthenticationType>::iterator end();
+
+  /**
+   * Default constructor to handle issues with static initialization of
+   * constant authentication types
+   */
+  AuthenticationType();
+
+private:
+  /**
+   * Authentication type constants
+   */
+  static std::set<AuthenticationType> constants_;
+  /**
+   * Name of constant
+   */
+  std::string name_;
+  /**
+   * Ordinal of constant
+   */
+  short ordinal_;
+  /**
+   * Display name for constant
+   */
+  std::string display_name_;
+
+  /**
+   * Constructor
+   *
+   * @param name Name for authentication type
+   * @param display_name Display name for authentication type
+   */
+  AuthenticationType(const std::string& name, int ordinal, const std::string& display_name);
+  /**
+   * Get the authentication type constants
+   *
+   * @return List of authentication type constants
+   */
+  static const std::set<AuthenticationType>& get_constants();
+};
+
+} // namespace CCM
 
 #endif // __CCM_AUTHENTICATION_TYPE_HPP__
diff --git a/test/ccm_bridge/src/bridge.cpp b/test/ccm_bridge/src/bridge.cpp
index cf8718f8e..1cf4758f1 100644
--- a/test/ccm_bridge/src/bridge.cpp
+++ b/test/ccm_bridge/src/bridge.cpp
@@ -16,38 +16,38 @@
 
 #ifdef _WIN32
 // Enable memory leak detection
-#  define _CRTDBG_MAP_ALLOC
-#  include <stdlib.h>
-#  include <crtdbg.h>
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#include <stdlib.h>
 
 // Enable memory leak detection for new operator
-#  ifdef _DEBUG
-#    ifndef DBG_NEW
-#      define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
-#      define new DBG_NEW
-#    endif
-#  endif
+#ifdef _DEBUG
+#ifndef DBG_NEW
+#define DBG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
+#define new DBG_NEW
+#endif
+#endif
 #else
-#  include <unistd.h>
+#include <unistd.h>
 #endif
 #include "bridge.hpp"
 
 #ifdef CASS_USE_LIBSSH2
-#  include <libssh2.h>
-#  define LIBSSH2_INIT_ALL 0
-#  ifndef LIBSSH2_NO_OPENSSL
-#    ifdef OPENSSL_CLEANUP
-#      define PID_UNKNOWN 0
-#      include <openssl/ssl.h>
-#      include <openssl/rand.h>
-#      include <openssl/engine.h>
-#      include <openssl/conf.h>
-#    endif
-#  endif
+#include <libssh2.h>
+#define LIBSSH2_INIT_ALL 0
+#ifndef LIBSSH2_NO_OPENSSL
+#ifdef OPENSSL_CLEANUP
+#define PID_UNKNOWN 0
+#include <openssl/conf.h>
+#include <openssl/engine.h>
+#include <openssl/rand.h>
+#include <openssl/ssl.h>
+#endif
+#endif
 #endif
 
-#include <errno.h>
 #include <ctype.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
@@ -58,18 +58,19 @@
 #include <sstream>
 
 // Create simple console logging functions
-#define LOG_MESSAGE(message, is_output) if (is_output) { \
-  std::cerr << "ccm> " << message << std::endl; \
-}
+#define LOG_MESSAGE(message, is_output)           \
+  if (is_output) {                                \
+    std::cerr << "ccm> " << message << std::endl; \
+  }
 #define LOG(message) LOG_MESSAGE(message, is_verbose_)
 #define LOG_ERROR(message) LOG_MESSAGE(message, true)
 
 // Create FALSE/TRUE defines for easier code readability
 #ifndef FALSE
-#  define FALSE 0
+#define FALSE 0
 #endif
 #ifndef TRUE
-#  define TRUE 1
+#define TRUE 1
 #endif
 
 #define TRIM_DELIMETERS " \f\n\r\t\v"
@@ -107,76 +108,61 @@
 #define CCM_CONFIGURATION_KEY_SSH_PRIVATE_KEY "ssh_private_key"
 
 // Workload value initialization
-const std::string DSE_WORKLOADS[] = {
-  "cassandra",
-  "cfs",
-  "dsefs",
-  "graph",
-  "hadoop",
-  "solr",
-  "spark"
-};
-const std::vector<std::string> CCM::Bridge::dse_workloads_(DSE_WORKLOADS,
-  DSE_WORKLOADS + sizeof(DSE_WORKLOADS) / sizeof(DSE_WORKLOADS[0]));
-const CCM::DseWorkload DEFAULT_WORKLOAD[] = {
-  CCM::DSE_WORKLOAD_CASSANDRA
-};
+const std::string DSE_WORKLOADS[] = { "cassandra", "cfs",  "dsefs", "graph",
+                                      "hadoop",    "solr", "spark" };
+const std::vector<std::string>
+    CCM::Bridge::dse_workloads_(DSE_WORKLOADS,
+                                DSE_WORKLOADS + sizeof(DSE_WORKLOADS) / sizeof(DSE_WORKLOADS[0]));
+const CCM::DseWorkload DEFAULT_WORKLOAD[] = { CCM::DSE_WORKLOAD_CASSANDRA };
 const std::vector<CCM::DseWorkload> CCM::Bridge::DEFAULT_DSE_WORKLOAD(
-  DEFAULT_WORKLOAD, DEFAULT_WORKLOAD +
-  sizeof(DEFAULT_WORKLOAD) / sizeof(DEFAULT_WORKLOAD[0]));
+    DEFAULT_WORKLOAD, DEFAULT_WORKLOAD + sizeof(DEFAULT_WORKLOAD) / sizeof(DEFAULT_WORKLOAD[0]));
 
 using namespace CCM;
 
-CCM::Bridge::Bridge(CassVersion server_version /*= DEFAULT_CASSANDRA_VERSION*/,
-  bool use_git /*= DEFAULT_USE_GIT*/,
-  const std::string& branch_tag /* ""*/,
-  bool use_install_dir /*=DEFAULT_USE_INSTALL_DIR*/,
-  const std::string& install_dir /*=""*/,
-  bool use_dse /*= DEFAULT_USE_DSE*/,
-  std::vector<DseWorkload> dse_workload /*= DEFAULT_DSE_WORKLOAD*/,
-  const std::string& cluster_prefix /*= DEFAULT_CLUSTER_PREFIX*/,
-  DseCredentialsType dse_credentials_type /*= DEFAULT_DSE_CREDENTIALS*/,
-  const std::string& dse_username /*= ""*/,
-  const std::string& dse_password /*= ""*/,
-  DeploymentType deployment_type /*= DEFAULT_DEPLOYMENT*/,
-  AuthenticationType authentication_type /*= DEFAULT_AUTHENTICATION*/,
-  const std::string& host /*= DEFAULT_HOST*/,
-  short port /*= DEFAULT_REMOTE_DEPLOYMENT_PORT*/,
-  const std::string& username /*= DEFAULT_USERNAME*/,
-  const std::string& password /*= DEFAULT_PASSWORD*/,
-  const std::string& public_key /*= ""*/,
-  const std::string& private_key /*= ""*/,
-  bool is_verbose /*= DEFAULT_IS_VERBOSE*/)
-  : cassandra_version_(server_version)
-  , dse_version_(DEFAULT_DSE_VERSION)
-  , use_git_(use_git)
-  , branch_tag_(branch_tag)
-  , use_install_dir_(use_install_dir)
-  , install_dir_(install_dir)
-  , use_dse_(use_dse)
-  , dse_workload_(dse_workload)
-  , cluster_prefix_(cluster_prefix)
-  , authentication_type_(authentication_type)
-  , dse_credentials_type_(dse_credentials_type)
-  , dse_username_(dse_username)
-  , dse_password_(dse_password)
+CCM::Bridge::Bridge(
+    CassVersion server_version /*= DEFAULT_CASSANDRA_VERSION*/, bool use_git /*= DEFAULT_USE_GIT*/,
+    const std::string& branch_tag /* ""*/, bool use_install_dir /*=DEFAULT_USE_INSTALL_DIR*/,
+    const std::string& install_dir /*=""*/, bool use_dse /*= DEFAULT_USE_DSE*/,
+    std::vector<DseWorkload> dse_workload /*= DEFAULT_DSE_WORKLOAD*/,
+    const std::string& cluster_prefix /*= DEFAULT_CLUSTER_PREFIX*/,
+    DseCredentialsType dse_credentials_type /*= DEFAULT_DSE_CREDENTIALS*/,
+    const std::string& dse_username /*= ""*/, const std::string& dse_password /*= ""*/,
+    DeploymentType deployment_type /*= DEFAULT_DEPLOYMENT*/,
+    AuthenticationType authentication_type /*= DEFAULT_AUTHENTICATION*/,
+    const std::string& host /*= DEFAULT_HOST*/, short port /*= DEFAULT_REMOTE_DEPLOYMENT_PORT*/,
+    const std::string& username /*= DEFAULT_USERNAME*/,
+    const std::string& password /*= DEFAULT_PASSWORD*/, const std::string& public_key /*= ""*/,
+    const std::string& private_key /*= ""*/, bool is_verbose /*= DEFAULT_IS_VERBOSE*/)
+    : cassandra_version_(server_version)
+    , dse_version_(DEFAULT_DSE_VERSION)
+    , use_git_(use_git)
+    , branch_tag_(branch_tag)
+    , use_install_dir_(use_install_dir)
+    , install_dir_(install_dir)
+    , use_dse_(use_dse)
+    , dse_workload_(dse_workload)
+    , cluster_prefix_(cluster_prefix)
+    , authentication_type_(authentication_type)
+    , dse_credentials_type_(dse_credentials_type)
+    , dse_username_(dse_username)
+    , dse_password_(dse_password)
 #ifdef CASS_USE_LIBSSH2
-  , deployment_type_(deployment_type)
-  , host_(host)
-  , session_(NULL)
-  , channel_(NULL)
-  , socket_(NULL)
+    , deployment_type_(deployment_type)
+    , host_(host)
+    , session_(NULL)
+    , channel_(NULL)
+    , socket_(NULL)
 #else
-  // Force local deployment only
-  , deployment_type_(DeploymentType::LOCAL)
-  , host_("127.0.0.1")
+    // Force local deployment only
+    , deployment_type_(DeploymentType::LOCAL)
+    , host_("127.0.0.1")
 #endif
-  , is_verbose_(is_verbose) {
+    , is_verbose_(is_verbose) {
 #ifdef _WIN32
-# ifdef _DEBUG
+#ifdef _DEBUG
   // Enable automatic execution of the memory leak detection upon exit
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
-# endif
+#endif
 #endif
   // Determine if DSE is being used
   if (use_dse_) {
@@ -194,7 +180,7 @@ CCM::Bridge::Bridge(CassVersion server_version /*= DEFAULT_CASSANDRA_VERSION*/,
     // Initialize the socket
     try {
       initialize_socket(host_, port);
-    } catch (SocketException &se) {
+    } catch (SocketException& se) {
       // Re-throw the exception as a BridgeException
       finalize_libssh2();
       throw BridgeException(se.what());
@@ -210,27 +196,27 @@ CCM::Bridge::Bridge(CassVersion server_version /*= DEFAULT_CASSANDRA_VERSION*/,
 }
 
 CCM::Bridge::Bridge(const std::string& configuration_file)
-  : cassandra_version_(DEFAULT_CASSANDRA_VERSION)
-  , dse_version_(DEFAULT_DSE_VERSION)
-  , use_git_(DEFAULT_USE_GIT)
-  , use_install_dir_(DEFAULT_USE_INSTALL_DIR)
-  , use_dse_(DEFAULT_USE_DSE)
-  , dse_workload_(DEFAULT_DSE_WORKLOAD)
-  , cluster_prefix_(DEFAULT_CLUSTER_PREFIX)
-  , authentication_type_(DEFAULT_AUTHENTICATION)
-  , dse_credentials_type_(DEFAULT_DSE_CREDENTIALS)
+    : cassandra_version_(DEFAULT_CASSANDRA_VERSION)
+    , dse_version_(DEFAULT_DSE_VERSION)
+    , use_git_(DEFAULT_USE_GIT)
+    , use_install_dir_(DEFAULT_USE_INSTALL_DIR)
+    , use_dse_(DEFAULT_USE_DSE)
+    , dse_workload_(DEFAULT_DSE_WORKLOAD)
+    , cluster_prefix_(DEFAULT_CLUSTER_PREFIX)
+    , authentication_type_(DEFAULT_AUTHENTICATION)
+    , dse_credentials_type_(DEFAULT_DSE_CREDENTIALS)
 #ifdef CASS_USE_LIBSSH2
-  , deployment_type_(DEFAULT_DEPLOYMENT)
-  , host_(DEFAULT_HOST)
-  , session_(NULL)
-  , channel_(NULL)
-  , socket_(NULL)
+    , deployment_type_(DEFAULT_DEPLOYMENT)
+    , host_(DEFAULT_HOST)
+    , session_(NULL)
+    , channel_(NULL)
+    , socket_(NULL)
 #else
-  // Force local
-  , deployment_type_(DeploymentType::LOCAL)
-  , host_("127.0.0.1")
+    // Force local
+    , deployment_type_(DeploymentType::LOCAL)
+    , host_("127.0.0.1")
 #endif
-  , is_verbose_(DEFAULT_IS_VERBOSE) {
+    , is_verbose_(DEFAULT_IS_VERBOSE) {
   // Initialize the default remote configuration settings
   short port = DEFAULT_REMOTE_DEPLOYMENT_PORT;
   std::string username = DEFAULT_REMOTE_DEPLOYMENT_USERNAME;
@@ -258,46 +244,47 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
           } else if (key.compare(CCM_CONFIGURATION_KEY_DSE_VERSION) == 0) {
             dse_version_ = DseVersion(value);
           } else if (key.compare(CCM_CONFIGURATION_KEY_USE_GIT) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> std::boolalpha >> use_git_).fail()) {
               continue;
             } else {
-              LOG_ERROR("Invalid flag \"" << value << "\" for "
-                        << CCM_CONFIGURATION_KEY_USE_GIT << "; defaulting to \""
-                        << (DEFAULT_USE_GIT ? "true" : "false") << "\"");
+              LOG_ERROR("Invalid flag \"" << value << "\" for " << CCM_CONFIGURATION_KEY_USE_GIT
+                                          << "; defaulting to \""
+                                          << (DEFAULT_USE_GIT ? "true" : "false") << "\"");
               use_git_ = DEFAULT_USE_GIT;
             }
           } else if (key.compare(CCM_CONFIGURATION_KEY_BRANCH_TAG) == 0) {
             branch_tag_ = value;
           } else if (key.compare(CCM_CONFIGURATION_KEY_USE_INSTALL_DIR) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> std::boolalpha >> use_install_dir_).fail()) {
               continue;
             } else {
-              LOG_ERROR("Invalid flag \"" << value << "\" for "
-                        << CCM_CONFIGURATION_KEY_USE_INSTALL_DIR
-                        << "; defaulting to \""
-                        << (DEFAULT_USE_INSTALL_DIR ? "true" : "false") << "\"");
+              LOG_ERROR("Invalid flag \""
+                        << value << "\" for " << CCM_CONFIGURATION_KEY_USE_INSTALL_DIR
+                        << "; defaulting to \"" << (DEFAULT_USE_INSTALL_DIR ? "true" : "false")
+                        << "\"");
               use_install_dir_ = DEFAULT_USE_INSTALL_DIR;
             }
           } else if (key.compare(CCM_CONFIGURATION_KEY_INSTALL_DIR) == 0) {
             install_dir_ = value;
           } else if (key.compare(CCM_CONFIGURATION_KEY_USE_DSE) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> std::boolalpha >> use_dse_).fail()) {
               continue;
             } else {
-              LOG_ERROR("Invalid flag \"" << value << "\" for "
-                        << CCM_CONFIGURATION_KEY_USE_DSE << "; defaulting to \""
-                        << (DEFAULT_USE_DSE ? "true" : "false") << "\"");
+              LOG_ERROR("Invalid flag \"" << value << "\" for " << CCM_CONFIGURATION_KEY_USE_DSE
+                                          << "; defaulting to \""
+                                          << (DEFAULT_USE_DSE ? "true" : "false") << "\"");
               use_dse_ = DEFAULT_USE_DSE;
             }
           } else if (key.compare(CCM_CONFIGURATION_KEY_DSE_CREDENTIALS_TYPE) == 0) {
             // Determine the DSE credentials type
-            for (DseCredentialsType::iterator iterator = DseCredentialsType::begin(); iterator != DseCredentialsType::end(); ++iterator) {
+            for (DseCredentialsType::iterator iterator = DseCredentialsType::begin();
+                 iterator != DseCredentialsType::end(); ++iterator) {
               if (*iterator == value) {
                 dse_credentials_type_ = *iterator;
                 break;
@@ -312,7 +299,8 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
 #ifdef CASS_USE_LIBSSH2
           } else if (key.compare(CCM_CONFIGURATION_KEY_DEPLOYMENT_TYPE) == 0) {
             // Determine the deployment type
-            for (DeploymentType::iterator iterator = DeploymentType::begin(); iterator != DeploymentType::end(); ++iterator) {
+            for (DeploymentType::iterator iterator = DeploymentType::begin();
+                 iterator != DeploymentType::end(); ++iterator) {
               if (*iterator == value) {
                 deployment_type_ = *iterator;
                 break;
@@ -323,7 +311,8 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
 #endif
           } else if (key.compare(CCM_CONFIGURATION_KEY_AUTHENTICATION_TYPE) == 0) {
             // Determine the authentication type
-            for (AuthenticationType::iterator iterator = AuthenticationType::begin(); iterator != AuthenticationType::end(); ++iterator) {
+            for (AuthenticationType::iterator iterator = AuthenticationType::begin();
+                 iterator != AuthenticationType::end(); ++iterator) {
               if (*iterator == value) {
                 authentication_type_ = *iterator;
                 break;
@@ -336,13 +325,13 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
             host_ = value;
 #endif
           } else if (key.compare(CCM_CONFIGURATION_KEY_SSH_PORT) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> port).fail()) {
               continue;
             } else {
               LOG_ERROR("Invalid port \"" << value << "\"; defaulting to \""
-                        << DEFAULT_REMOTE_DEPLOYMENT_PORT << "\"");
+                                          << DEFAULT_REMOTE_DEPLOYMENT_PORT << "\"");
               port = DEFAULT_REMOTE_DEPLOYMENT_PORT;
             }
 #ifdef CASS_USE_LIBSSH2
@@ -356,14 +345,14 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
             private_key = value;
 #endif
           } else if (key.compare(CCM_CONFIGURATION_KEY_VERBOSE) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> std::boolalpha >> is_verbose_).fail()) {
               continue;
             } else {
-              LOG_ERROR("Invalid flag \"" << value << "\" for "
-                        << CCM_CONFIGURATION_KEY_VERBOSE << "; defaulting to \""
-                        << (DEFAULT_IS_VERBOSE ? "true" : "false") << "\"");
+              LOG_ERROR("Invalid flag \"" << value << "\" for " << CCM_CONFIGURATION_KEY_VERBOSE
+                                          << "; defaulting to \""
+                                          << (DEFAULT_IS_VERBOSE ? "true" : "false") << "\"");
               is_verbose_ = DEFAULT_IS_VERBOSE;
             }
           } else {
@@ -376,7 +365,7 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
     }
   } else {
     LOG_ERROR("Unable to open configuration file \"" << configuration_file
-              << "\"; defaults will be used");
+                                                     << "\"; defaults will be used");
   }
 
   // Determine if DSE is being used
@@ -418,10 +407,10 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
 #endif
 
 #ifdef _WIN32
-# ifdef _DEBUG
+#ifdef _DEBUG
   // Enable automatic execution of the memory leak detection upon exit
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
-# endif
+#endif
 #endif
 #ifdef CASS_USE_LIBSSH2
   // Determine if libssh2 needs to be initialized
@@ -429,8 +418,7 @@ CCM::Bridge::Bridge(const std::string& configuration_file)
     // Initialize the socket
     try {
       initialize_socket(host_, port);
-    }
-    catch (SocketException &se) {
+    } catch (SocketException& se) {
       // Re-throw the exception as a BridgeException
       finalize_libssh2();
       throw BridgeException(se.what());
@@ -484,7 +472,7 @@ std::string CCM::Bridge::cluster_contact_points(bool is_all /*= true*/) {
 
 std::vector<std::string> CCM::Bridge::cluster_ip_addresses(bool is_all /*= true*/) {
   // Get and sort the IPv4 addresses and return the array/vector
-  std::vector <std::string> ip_addresses = explode(cluster_contact_points(is_all), ',');
+  std::vector<std::string> ip_addresses = explode(cluster_contact_points(is_all), ',');
   std::sort(ip_addresses.begin(), ip_addresses.end());
   return ip_addresses;
 }
@@ -520,11 +508,13 @@ ClusterStatus CCM::Bridge::cluster_status() {
 
           // Determine the status being updated
           if (node_status.compare(CCM_NODE_STATUS_DECOMMISSIONED) == 0 ||
-              node_status.compare("decommisionned") == 0) { // Handle misspelling of decommissioned for older CCM versions
+              node_status.compare("decommisionned") ==
+                  0) { // Handle misspelling of decommissioned for older CCM versions
             status.nodes_decommissioned.push_back(node_ip_address);
           } else if (node_status.compare(CCM_NODE_STATUS_DOWN) == 0) {
             // Determine if the node is actually uninitialized
-            if (tokens.size() == 4 && (tokens[2] + " " + tokens[3]).compare(CCM_NODE_STATUS_UNINITIALIZED) == 0) {
+            if (tokens.size() == 4 &&
+                (tokens[2] + " " + tokens[3]).compare(CCM_NODE_STATUS_UNINITIALIZED) == 0) {
               status.nodes_uninitialized.push_back(node_ip_address);
             } else {
               status.nodes_down.push_back(node_ip_address);
@@ -535,8 +525,8 @@ ClusterStatus CCM::Bridge::cluster_status() {
             LOG_ERROR("Node status \"" << node_status << "\" is not valid");
           }
         } else {
-          LOG_ERROR("To many tokens detected in \"" << current_line <<
-                        "\" to determine node status");
+          LOG_ERROR("To many tokens detected in \"" << current_line
+                                                    << "\" to determine node status");
         }
       }
     }
@@ -551,14 +541,11 @@ bool CCM::Bridge::create_cluster(std::vector<unsigned short> data_center_nodes,
                                  bool is_client_authentication /*= false*/) {
   // Generate the cluster name and determine if it needs to be created
   std::string active_cluster_name = get_active_cluster();
-  std::string cluster_name = generate_cluster_name(cassandra_version_,
-                                                   data_center_nodes,
-                                                   with_vnodes,
-                                                   is_password_authenticator,
-                                                   is_ssl,
-                                                   is_client_authentication);
+  std::string cluster_name =
+      generate_cluster_name(cassandra_version_, data_center_nodes, with_vnodes,
+                            is_password_authenticator, is_ssl, is_client_authentication);
   for (std::vector<DseWorkload>::iterator iterator = dse_workload_.begin();
-    iterator != dse_workload_.end(); ++iterator) {
+       iterator != dse_workload_.end(); ++iterator) {
     if (use_dse_ && *iterator != DSE_WORKLOAD_CASSANDRA) {
       cluster_name.append("-").append(dse_workloads_[*iterator]);
     }
@@ -652,8 +639,7 @@ bool CCM::Bridge::create_cluster(std::vector<unsigned short> data_center_nodes,
     }
 
     // Set the DSE workload (if applicable)
-    if (use_dse_ &&
-      !(dse_workload_.size() == 1 && dse_workload_[0] == DSE_WORKLOAD_CASSANDRA)) {
+    if (use_dse_ && !(dse_workload_.size() == 1 && dse_workload_[0] == DSE_WORKLOAD_CASSANDRA)) {
       set_dse_workloads(dse_workload_);
     }
   }
@@ -664,19 +650,16 @@ bool CCM::Bridge::create_cluster(std::vector<unsigned short> data_center_nodes,
 
 bool CCM::Bridge::create_cluster(unsigned short data_center_one_nodes /*= 1*/,
                                  unsigned short data_center_two_nodes /*= 0*/,
-                                 bool with_vnodes /*= false*/,
-                                 bool is_ssl /*= false*/,
+                                 bool with_vnodes /*= false*/, bool is_ssl /*= false*/,
                                  bool is_client_authentication /*= false*/) {
   // Create the data center nodes from the two data centers
   std::vector<unsigned short> data_center_nodes;
   data_center_nodes.push_back(data_center_one_nodes);
   data_center_nodes.push_back(data_center_two_nodes);
 
-  return create_cluster(data_center_nodes,
-                        with_vnodes,
+  return create_cluster(data_center_nodes, with_vnodes,
                         false, // Not valid for deprecated create cluster (Boost tests)
-                        is_ssl,
-                        is_client_authentication);
+                        is_ssl, is_client_authentication);
 }
 
 bool CCM::Bridge::is_cluster_down() {
@@ -718,13 +701,9 @@ bool CCM::Bridge::hang_up_cluster() {
   return is_cluster_down();
 }
 
-bool CCM::Bridge::kill_cluster() {
-  return stop_cluster(true);
-}
+bool CCM::Bridge::kill_cluster() { return stop_cluster(true); }
 
-void CCM::Bridge::remove_cluster() {
-  remove_cluster(get_active_cluster());
-}
+void CCM::Bridge::remove_cluster() { remove_cluster(get_active_cluster()); }
 
 void CCM::Bridge::remove_cluster(const std::string& cluster_name) {
   // Create the cluster remove command and execute
@@ -737,18 +716,19 @@ void CCM::Bridge::remove_cluster(const std::string& cluster_name) {
 void CCM::Bridge::remove_all_clusters(bool is_all /*= false*/) {
   // Iterate through all the available clusters
   std::vector<std::string> clusters = get_available_clusters();
-  for (std::vector<std::string>::const_iterator iterator = clusters.begin(); iterator != clusters.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = clusters.begin();
+       iterator != clusters.end(); ++iterator) {
     // Determine if the cluster should be removed
     bool is_valid_cluster = is_all;
-    if (!is_valid_cluster &&
-       (*iterator).compare(0, cluster_prefix_.size(), cluster_prefix_) != 0) {
+    if (!is_valid_cluster && (*iterator).compare(0, cluster_prefix_.size(), cluster_prefix_) != 0) {
       continue;
     }
     remove_cluster(*iterator);
   }
 }
 
-bool  CCM::Bridge::start_cluster(std::vector<std::string> jvm_arguments /*= DEFAULT_JVM_ARGUMENTS*/) {
+bool CCM::Bridge::start_cluster(
+    std::vector<std::string> jvm_arguments /*= DEFAULT_JVM_ARGUMENTS*/) {
   // Create the cluster start command and execute
   std::vector<std::string> start_command;
   start_command.push_back("start");
@@ -761,7 +741,8 @@ bool  CCM::Bridge::start_cluster(std::vector<std::string> jvm_arguments /*= DEFA
     }
   }
 #endif
-  for (std::vector<std::string>::const_iterator iterator = jvm_arguments.begin(); iterator != jvm_arguments.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = jvm_arguments.begin();
+       iterator != jvm_arguments.end(); ++iterator) {
     std::string jvm_argument = trim(*iterator);
     if (!jvm_argument.empty()) {
       start_command.push_back("--jvm_arg=" + *iterator);
@@ -825,11 +806,11 @@ bool CCM::Bridge::switch_cluster(const std::string& cluster_name) {
 }
 
 void CCM::Bridge::update_cluster_configuration(std::vector<std::string> key_value_pairs,
-  bool is_dse /*= false*/, bool is_yaml /*= false*/) {
+                                               bool is_dse /*= false*/, bool is_yaml /*= false*/) {
   // Create the update configuration command
   if (is_yaml) {
     for (std::vector<std::string>::const_iterator iterator = key_value_pairs.begin();
-      iterator != key_value_pairs.end(); ++iterator) {
+         iterator != key_value_pairs.end(); ++iterator) {
       update_cluster_configuration_yaml(*iterator, is_dse);
     }
   } else {
@@ -838,7 +819,8 @@ void CCM::Bridge::update_cluster_configuration(std::vector<std::string> key_valu
   }
 }
 
-void CCM::Bridge::update_cluster_configuration(const std::string& key, const std::string& value, bool is_dse /*= false*/) {
+void CCM::Bridge::update_cluster_configuration(const std::string& key, const std::string& value,
+                                               bool is_dse /*= false*/) {
   // Create the configuration to be updated
   std::stringstream configuration;
   configuration << key << ":" << value;
@@ -850,7 +832,8 @@ void CCM::Bridge::update_cluster_configuration(const std::string& key, const std
   execute_ccm_command(updateconf_command);
 }
 
-void CCM::Bridge::update_cluster_configuration_yaml(const std::string& yaml, bool is_dse /*= false*/) {
+void CCM::Bridge::update_cluster_configuration_yaml(const std::string& yaml,
+                                                    bool is_dse /*= false*/) {
   // Create the update configuration command for a literal YAML
   std::vector<std::string> updateconf_command;
   updateconf_command.push_back(is_dse ? "updatedseconf" : "updateconf");
@@ -859,14 +842,16 @@ void CCM::Bridge::update_cluster_configuration_yaml(const std::string& yaml, boo
   execute_ccm_command(updateconf_command);
 }
 
-void CCM::Bridge::update_node_configuration(unsigned int node, std::vector<std::string> key_value_pairs) {
+void CCM::Bridge::update_node_configuration(unsigned int node,
+                                            std::vector<std::string> key_value_pairs) {
   // Create the update configuration command
   key_value_pairs.insert(key_value_pairs.begin(), generate_node_name(node));
   key_value_pairs.insert(key_value_pairs.begin(), "updateconf");
   execute_ccm_command(key_value_pairs);
 }
 
-void CCM::Bridge::update_node_configuration(unsigned int node, const std::string& key, const std::string& value) {
+void CCM::Bridge::update_node_configuration(unsigned int node, const std::string& key,
+                                            const std::string& value) {
   // Create the configuration to be updated
   std::stringstream configuration;
   configuration << key << ":" << value;
@@ -932,9 +917,8 @@ bool CCM::Bridge::decommission_node(unsigned int node, bool is_force /*= false*/
   std::vector<std::string> decommission_node_command;
   decommission_node_command.push_back(generate_node_name(node));
   decommission_node_command.push_back("decommission");
-  if (is_force &&
-      ((!use_dse_ && cassandra_version_ >= "3.12") || // Cassandra v3.12+
-       (use_dse_ && dse_version_ >= "5.1.0"))) { // DataStax Enterprise v5.1.0+
+  if (is_force && ((!use_dse_ && cassandra_version_ >= "3.12") || // Cassandra v3.12+
+                   (use_dse_ && dse_version_ >= "5.1.0"))) {      // DataStax Enterprise v5.1.0+
     decommission_node_command.push_back("--force");
   }
   execute_ccm_command(decommission_node_command);
@@ -1029,9 +1013,7 @@ bool CCM::Bridge::hang_up_node(unsigned int node) {
   return is_node_down(node);
 }
 
-bool CCM::Bridge::kill_node(unsigned int node) {
-  return stop_node(node, true);
-}
+bool CCM::Bridge::kill_node(unsigned int node) { return stop_node(node, true); }
 
 void CCM::Bridge::pause_node(unsigned int node) {
   // Create the node pause command and execute
@@ -1049,8 +1031,8 @@ void CCM::Bridge::resume_node(unsigned int node) {
   execute_ccm_command(resume_node_command);
 }
 
-bool CCM::Bridge::start_node(unsigned int node,
-                             const std::vector<std::string>& jvm_arguments /*= DEFAULT_JVM_ARGUMENTS*/) {
+bool CCM::Bridge::start_node(
+    unsigned int node, const std::vector<std::string>& jvm_arguments /*= DEFAULT_JVM_ARGUMENTS*/) {
   // Create the node start command and execute
   std::vector<std::string> start_node_command;
   start_node_command.push_back(generate_node_name(node));
@@ -1098,9 +1080,7 @@ bool CCM::Bridge::stop_node(unsigned int node, bool is_kill /*= false*/) {
   return is_node_down(node);
 }
 
-std::string CCM::Bridge::get_ip_prefix() {
-  return host_.substr(0, host_.size() - 1);
-}
+std::string CCM::Bridge::get_ip_prefix() { return host_.substr(0, host_.size() - 1); }
 
 std::string CCM::Bridge::get_ip_prefix(const std::string& configuration_file) {
   // Open the file and parse each configuration line looking for the version
@@ -1127,7 +1107,8 @@ std::string CCM::Bridge::get_ip_prefix(const std::string& configuration_file) {
   }
 
   // Return the IPv4 prefix
-  return ip_prefix.substr(0, ip_prefix.size() - 1);;
+  return ip_prefix.substr(0, ip_prefix.size() - 1);
+  ;
 }
 
 CassVersion CCM::Bridge::get_cassandra_version() {
@@ -1172,7 +1153,7 @@ CassVersion CCM::Bridge::get_cassandra_version(const std::string& configuration_
           } else if (key.compare(CCM_CONFIGURATION_KEY_DSE_VERSION) == 0) {
             dse_version = DseVersion(value);
           } else if (key.compare(CCM_CONFIGURATION_KEY_USE_DSE) == 0) {
-            //Convert the value
+            // Convert the value
             std::stringstream ss(value);
             if (!(ss >> std::boolalpha >> use_dse).fail()) {
               continue;
@@ -1238,14 +1219,14 @@ DseVersion CCM::Bridge::get_dse_version(const std::string& configuration_file) {
 }
 
 bool CCM::Bridge::set_dse_workload(unsigned int node, DseWorkload workload,
-  bool is_kill /*= false */) {
+                                   bool is_kill /*= false */) {
   std::vector<DseWorkload> workloads;
   workloads.push_back(workload);
   return set_dse_workloads(1, workloads, is_kill);
 }
 
-bool CCM::Bridge::set_dse_workloads(unsigned int node,
-  std::vector<DseWorkload> workloads, bool is_kill /*= false */) {
+bool CCM::Bridge::set_dse_workloads(unsigned int node, std::vector<DseWorkload> workloads,
+                                    bool is_kill /*= false */) {
   // Ensure the workloads can be processed
   if (workloads.empty()) {
     throw BridgeException("No workloads to assign");
@@ -1259,8 +1240,8 @@ bool CCM::Bridge::set_dse_workloads(unsigned int node,
   // Determine if the node is currently active/up
   bool was_node_active = false;
   if (!is_node_down(node)) {
-    LOG("Stopping active node \"" << node << "\" and assigning workload(s) \""
-        << dse_workloads << "\"");
+    LOG("Stopping active node \"" << node << "\" and assigning workload(s) \"" << dse_workloads
+                                  << "\"");
     stop_node(node, is_kill);
     was_node_active = true;
   }
@@ -1274,23 +1255,20 @@ bool CCM::Bridge::set_dse_workloads(unsigned int node,
 
   // Determine if the node should be restarted
   if (was_node_active) {
-    LOG("Restarting node \"" << node << "\" to applying workload(s) \""
-        << dse_workloads << "\"");
+    LOG("Restarting node \"" << node << "\" to applying workload(s) \"" << dse_workloads << "\"");
     start_node(node);
   }
 
   return was_node_active;
 }
 
-bool CCM::Bridge::set_dse_workload(DseWorkload workload,
-  bool is_kill /*= false */) {
+bool CCM::Bridge::set_dse_workload(DseWorkload workload, bool is_kill /*= false */) {
   std::vector<DseWorkload> workloads;
   workloads.push_back(workload);
   return set_dse_workloads(workloads, is_kill);
 }
 
-bool CCM::Bridge::set_dse_workloads(std::vector<DseWorkload> workloads,
-  bool is_kill /*= false */) {
+bool CCM::Bridge::set_dse_workloads(std::vector<DseWorkload> workloads, bool is_kill /*= false */) {
   // Ensure the workloads can be processed
   if (workloads.empty()) {
     throw BridgeException("No workloads to assign");
@@ -1300,9 +1278,8 @@ bool CCM::Bridge::set_dse_workloads(std::vector<DseWorkload> workloads,
   bool was_cluster_active = false;
   std::string cluster = get_active_cluster();
   if (!is_cluster_down()) {
-    LOG("Stopping active cluster \"" << cluster
-        << "\" and assigning workload(s) \""
-        << generate_dse_workloads(workloads) << "\"");
+    LOG("Stopping active cluster \"" << cluster << "\" and assigning workload(s) \""
+                                     << generate_dse_workloads(workloads) << "\"");
     stop_cluster(is_kill);
     was_cluster_active = true;
   }
@@ -1315,9 +1292,8 @@ bool CCM::Bridge::set_dse_workloads(std::vector<DseWorkload> workloads,
 
   // Determine if the cluster should be restarted
   if (was_cluster_active) {
-    LOG("Restarting cluster \"" << cluster
-        << "\" and applying workload(s) \""
-        << generate_dse_workloads(workloads) << "\"");
+    LOG("Restarting cluster \"" << cluster << "\" and applying workload(s) \""
+                                << generate_dse_workloads(workloads) << "\"");
     start_cluster();
   }
 
@@ -1329,7 +1305,8 @@ bool CCM::Bridge::is_node_decommissioned(unsigned int node) {
   std::stringstream node_ip_address;
   node_ip_address << get_ip_prefix() << node;
   std::vector<std::string> nodes = cluster_status().nodes_decommissioned;
-  for (std::vector<std::string>::const_iterator iterator = nodes.begin(); iterator < nodes.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = nodes.begin(); iterator < nodes.end();
+       ++iterator) {
     if (node_ip_address.str().compare(*iterator) == 0) {
       return true;
     }
@@ -1350,8 +1327,10 @@ bool CCM::Bridge::is_node_down(unsigned int node, bool is_quick_check /*= false*
       return true;
     } else {
       std::string cluster = get_active_cluster();
-      LOG("[#" << number_of_retries << "] - Attempting to recheck node down "
-          "status for node \"" << node << "\" in cluster \"" << cluster << "\"");
+      LOG("[#" << number_of_retries
+               << "] - Attempting to recheck node down "
+                  "status for node \""
+               << node << "\" in cluster \"" << cluster << "\"");
       msleep(CCM_NAP);
     }
   }
@@ -1371,8 +1350,10 @@ bool CCM::Bridge::is_node_up(unsigned int node, bool is_quick_check /*= false*/)
       return true;
     } else {
       std::string cluster = get_active_cluster();
-      LOG("[#" << number_of_retries << "] - Attempting to recheck node up "
-          "status for node \"" << node << "\" in cluster \"" << cluster << "\"");
+      LOG("[#" << number_of_retries
+               << "] - Attempting to recheck node up "
+                  "status for node \""
+               << node << "\" in cluster \"" << cluster << "\"");
       msleep(CCM_NAP);
     }
   }
@@ -1427,7 +1408,8 @@ void CCM::Bridge::initialize_libssh2() {
   libssh2_session_set_blocking(session_, FALSE);
 
   // Perform the session handshake; trade banners, exchange keys, setup cyrpto
-  while ((rc = libssh2_session_handshake(session_, socket_->get_handle())) == LIBSSH2_ERROR_EAGAIN) {
+  while ((rc = libssh2_session_handshake(session_, socket_->get_handle())) ==
+         LIBSSH2_ERROR_EAGAIN) {
     ; // no-op
   }
   if (rc) {
@@ -1463,19 +1445,24 @@ void CCM::Bridge::initialize_libssh2() {
 }
 
 void CCM::Bridge::establish_libssh2_connection(AuthenticationType authentication_type,
-  const std::string& username, const std::string& password,
-  const std::string& public_key, const std::string& private_key) {
+                                               const std::string& username,
+                                               const std::string& password,
+                                               const std::string& public_key,
+                                               const std::string& private_key) {
   int rc = 0;
 
   // Determine authentication mechanism
   if (authentication_type == AuthenticationType::USERNAME_PASSWORD) {
     // Perform username and password authentication
-    while ((rc = libssh2_userauth_password(session_, username.c_str(), password.c_str())) == LIBSSH2_ERROR_EAGAIN) {
+    while ((rc = libssh2_userauth_password(session_, username.c_str(), password.c_str())) ==
+           LIBSSH2_ERROR_EAGAIN) {
       ; // no-op
     }
   } else {
-    while ((rc = libssh2_userauth_publickey_fromfile(session_, username.c_str(), public_key.c_str(), private_key.c_str(), "")) == LIBSSH2_ERROR_EAGAIN) {
-      ; //no-op
+    while ((rc = libssh2_userauth_publickey_fromfile(session_, username.c_str(), public_key.c_str(),
+                                                     private_key.c_str(), "")) ==
+           LIBSSH2_ERROR_EAGAIN) {
+      ; // no-op
     }
   }
 
@@ -1484,32 +1471,32 @@ void CCM::Bridge::establish_libssh2_connection(AuthenticationType authentication
     std::stringstream message;
     message << "[libssh2] Failed username/password authentication with error ";
     switch (rc) {
-    case LIBSSH2_ERROR_ALLOC:
-      message << "\"an internal memory allocation call failed\"";
-      break;
-    case LIBSSH2_ERROR_SOCKET_SEND:
-      message << "\"unable to send data on socket\"";
-      break;
-    case LIBSSH2_ERROR_SOCKET_TIMEOUT:
-      message << "\"timed out waiting for response\"";
-      break;
-    case LIBSSH2_ERROR_PASSWORD_EXPIRED:
-      message << "\"password has expired\"";
-      break;
-    case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:
-      message << "\"the username/public key combination was invalid\"";
-      break;
-    case LIBSSH2_ERROR_AUTHENTICATION_FAILED:
-      // Ensure error message is displayed for the authentication type
-      if (authentication_type == AuthenticationType::USERNAME_PASSWORD) {
-        message << "\"invalid username/password\"";
-      } else {
-        message << "\"authentication using the supplied public key was not accepted\"";
-      }
-      break;
-    default:
-      message << "code \"" << rc << "\"";
-      break;
+      case LIBSSH2_ERROR_ALLOC:
+        message << "\"an internal memory allocation call failed\"";
+        break;
+      case LIBSSH2_ERROR_SOCKET_SEND:
+        message << "\"unable to send data on socket\"";
+        break;
+      case LIBSSH2_ERROR_SOCKET_TIMEOUT:
+        message << "\"timed out waiting for response\"";
+        break;
+      case LIBSSH2_ERROR_PASSWORD_EXPIRED:
+        message << "\"password has expired\"";
+        break;
+      case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:
+        message << "\"the username/public key combination was invalid\"";
+        break;
+      case LIBSSH2_ERROR_AUTHENTICATION_FAILED:
+        // Ensure error message is displayed for the authentication type
+        if (authentication_type == AuthenticationType::USERNAME_PASSWORD) {
+          message << "\"invalid username/password\"";
+        } else {
+          message << "\"authentication using the supplied public key was not accepted\"";
+        }
+        break;
+      default:
+        message << "code \"" << rc << "\"";
+        break;
     }
     finalize_libssh2();
     throw BridgeException(message.str());
@@ -1518,8 +1505,8 @@ void CCM::Bridge::establish_libssh2_connection(AuthenticationType authentication
 
 void CCM::Bridge::open_libssh2_terminal() {
   // Open a channel; request a shell
-  while (session_ != NULL && (channel_ = libssh2_channel_open_session(session_)) == NULL
-    && libssh2_session_last_error(session_, NULL, NULL, FALSE) == LIBSSH2_ERROR_EAGAIN) {
+  while (session_ != NULL && (channel_ = libssh2_channel_open_session(session_)) == NULL &&
+         libssh2_session_last_error(session_, NULL, NULL, FALSE) == LIBSSH2_ERROR_EAGAIN) {
     synchronize_socket();
   }
   if (!channel_) {
@@ -1554,13 +1541,11 @@ void CCM::Bridge::close_libssh2_terminal() {
       libssh2_channel_get_exit_status(channel_);
       libssh2_channel_get_exit_signal(channel_, &exit_signal, NULL, NULL, NULL, NULL, NULL);
       if (exit_signal) {
-        LOG_ERROR("[libssh2] Failed to close channel with exit signal \""
-                  << exit_signal << "\"");
+        LOG_ERROR("[libssh2] Failed to close channel with exit signal \"" << exit_signal << "\"");
       }
     }
     if (rc) {
-      LOG_ERROR("[libssh2] Failed to close channel with error code \""
-                << rc << "\"");
+      LOG_ERROR("[libssh2] Failed to close channel with error code \"" << rc << "\"");
     }
 
     // Free the channel/terminal resources
@@ -1568,8 +1553,7 @@ void CCM::Bridge::close_libssh2_terminal() {
       ; // no-op
     }
     if (rc) {
-      LOG_ERROR("[libssh2] Failed to free channel resources with error code \""
-                << rc << "\"");
+      LOG_ERROR("[libssh2] Failed to free channel resources with error code \"" << rc << "\"");
     }
     channel_ = NULL;
   }
@@ -1580,19 +1564,18 @@ void CCM::Bridge::finalize_libssh2() {
   if (session_) {
     // Perform session disconnection
     int rc = 0;
-    while ((rc = libssh2_session_disconnect(session_, "Shutting down libssh2 CCM bridge session")) == LIBSSH2_ERROR_EAGAIN) {
+    while ((rc = libssh2_session_disconnect(
+                session_, "Shutting down libssh2 CCM bridge session")) == LIBSSH2_ERROR_EAGAIN) {
       ; // no-op
     }
     if (rc) {
-      LOG_ERROR("[libssh2] Failed to disconnect session with error code \""
-                << rc << "\"");
+      LOG_ERROR("[libssh2] Failed to disconnect session with error code \"" << rc << "\"");
     }
     while ((rc = libssh2_session_free(session_)) == LIBSSH2_ERROR_EAGAIN) {
       ; // no-op
     }
     if (rc) {
-      LOG_ERROR("[libssh2] Failed to free session resources with error code \""
-                << rc << "\"");
+      LOG_ERROR("[libssh2] Failed to free session resources with error code \"" << rc << "\"");
     }
     session_ = NULL;
   }
@@ -1605,7 +1588,7 @@ void CCM::Bridge::finalize_libssh2() {
   libssh2_exit();
 
 #ifndef LIBSSH2_NO_OPENSSL
-#  ifdef OPENSSL_CLEANUP
+#ifdef OPENSSL_CLEANUP
   // Free OpenSSL resources
   RAND_cleanup();
   ENGINE_cleanup();
@@ -1615,7 +1598,7 @@ void CCM::Bridge::finalize_libssh2() {
   ERR_free_strings();
   ERR_remove_state(PID_UNKNOWN);
   CRYPTO_cleanup_all_ex_data();
-#  endif
+#endif
 #endif
 }
 
@@ -1716,8 +1699,8 @@ std::string CCM::Bridge::execute_ccm_command(const std::vector<std::string>& com
   if (deployment_type_ == DeploymentType::LOCAL) {
 #ifdef _WIN32
     if (use_dse_) {
-      throw BridgeException("DSE v" + dse_version_.to_string()
-                            + " cannot be launched on Windows platform");
+      throw BridgeException("DSE v" + dse_version_.to_string() +
+                            " cannot be launched on Windows platform");
     }
 #endif
     utils::Process::Result result = utils::Process::execute(ccm_command);
@@ -1754,7 +1737,8 @@ std::vector<std::string> CCM::Bridge::get_available_clusters(std::string& active
 
   // Determine the active cluster and correct the cluster array
   int index = 0;
-  for (std::vector<std::string>::const_iterator iterator = clusters.begin(); iterator < clusters.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = clusters.begin();
+       iterator < clusters.end(); ++iterator) {
     std::string cluster = *iterator;
     if (cluster.compare(0, 1, "*") == 0) {
       cluster.erase(std::remove(cluster.begin(), cluster.end(), '*'), cluster.end());
@@ -1768,15 +1752,13 @@ std::vector<std::string> CCM::Bridge::get_available_clusters(std::string& active
 
 std::string CCM::Bridge::generate_cluster_name(CassVersion cassandra_version,
                                                std::vector<unsigned short> data_center_nodes,
-                                               bool with_vnodes,
-                                               bool is_password_authenticator,
-                                               bool is_ssl,
-                                               bool is_client_authentication) {
+                                               bool with_vnodes, bool is_password_authenticator,
+                                               bool is_ssl, bool is_client_authentication) {
   std::stringstream cluster_name;
-  std::string server_version = use_dse_ ? dse_version_.to_string(false) : cassandra_version.to_string(false);
+  std::string server_version =
+      use_dse_ ? dse_version_.to_string(false) : cassandra_version.to_string(false);
   std::replace(server_version.begin(), server_version.end(), '.', '-');
-  cluster_name << cluster_prefix_ << "_"
-               << server_version << "_"
+  cluster_name << cluster_prefix_ << "_" << server_version << "_"
                << generate_cluster_nodes(data_center_nodes, '-');
   if (with_vnodes) {
     cluster_name << "-vnodes";
@@ -1794,10 +1776,10 @@ std::string CCM::Bridge::generate_cluster_name(CassVersion cassandra_version,
 }
 
 std::string CCM::Bridge::generate_cluster_nodes(std::vector<unsigned short> data_center_nodes,
-  char separator /* = ':'*/) {
+                                                char separator /* = ':'*/) {
   std::stringstream cluster_nodes;
   for (std::vector<unsigned short>::iterator iterator = data_center_nodes.begin();
-    iterator != data_center_nodes.end(); ++iterator) {
+       iterator != data_center_nodes.end(); ++iterator) {
     cluster_nodes << *iterator;
     if ((iterator + 1) != data_center_nodes.end()) {
       cluster_nodes << separator;
@@ -1806,8 +1788,9 @@ std::string CCM::Bridge::generate_cluster_nodes(std::vector<unsigned short> data
   return cluster_nodes.str();
 }
 
-std::vector<std::string> CCM::Bridge::generate_create_updateconf_command(CassVersion cassandra_version) {
-  //TODO: Add SSL setup and client authentication
+std::vector<std::string>
+CCM::Bridge::generate_create_updateconf_command(CassVersion cassandra_version) {
+  // TODO: Add SSL setup and client authentication
   // Create the update configuration command (common updates)
   std::vector<std::string> updateconf_command;
   updateconf_command.push_back("updateconf");
@@ -1846,7 +1829,6 @@ std::vector<std::string> CCM::Bridge::generate_create_updateconf_command(CassVer
       updateconf_command.push_back("in_memory_compaction_limit_in_mb:1");
     }
 
-
     // Create Cassandra version specific updates (C* < v4.0)
     if (cassandra_version < "4.0.0") {
       updateconf_command.push_back("rpc_min_threads:1");
@@ -1869,8 +1851,8 @@ std::vector<std::string> CCM::Bridge::generate_create_updateconf_command(CassVer
 
 std::string CCM::Bridge::generate_dse_workloads(std::vector<DseWorkload> workloads) {
   std::string dse_workloads;
-  for (std::vector<DseWorkload>::iterator iterator = workloads.begin();
-    iterator != workloads.end(); ++iterator) {
+  for (std::vector<DseWorkload>::iterator iterator = workloads.begin(); iterator != workloads.end();
+       ++iterator) {
     dse_workloads += dse_workloads_[*iterator];
     if ((iterator + 1) != workloads.end()) {
       dse_workloads += ",";
@@ -1890,8 +1872,8 @@ unsigned int CCM::Bridge::get_next_available_node() {
   unsigned int next_available_node = status.node_count + 1;
   if (next_available_node > CLUSTER_NODE_LIMIT) {
     std::stringstream message;
-    message << "Failed to get next available node; cluster limit of \"" <<
-               CLUSTER_NODE_LIMIT << "\" nodes reached";
+    message << "Failed to get next available node; cluster limit of \"" << CLUSTER_NODE_LIMIT
+            << "\" nodes reached";
     throw BridgeException(message.str());
   }
 
@@ -1935,10 +1917,12 @@ std::string CCM::Bridge::trim(const std::string& input) {
   return result;
 }
 
-std::string CCM::Bridge::implode(const std::vector<std::string>& elements, const char delimiter /*= ' '*/) {
+std::string CCM::Bridge::implode(const std::vector<std::string>& elements,
+                                 const char delimiter /*= ' '*/) {
   // Iterate through each element in the vector and concatenate the string
   std::string result;
-  for (std::vector<std::string>::const_iterator iterator = elements.begin(); iterator < elements.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = elements.begin();
+       iterator < elements.end(); ++iterator) {
     result += *iterator;
     if ((iterator + 1) != elements.end()) {
       result += delimiter;
@@ -1947,7 +1931,8 @@ std::string CCM::Bridge::implode(const std::vector<std::string>& elements, const
   return result;
 }
 
-std::vector<std::string> CCM::Bridge::explode(const std::string& input, const char delimiter /*= ' '*/) {
+std::vector<std::string> CCM::Bridge::explode(const std::string& input,
+                                              const char delimiter /*= ' '*/) {
   // Iterate over the input line and parse the tokens
   std::vector<std::string> result;
   std::istringstream parser(input);
@@ -1963,11 +1948,11 @@ void CCM::Bridge::msleep(unsigned int milliseconds) {
 #ifdef _WIN32
   Sleep(milliseconds);
 #else
-  //Convert the milliseconds into a proper timespec structure
+  // Convert the milliseconds into a proper timespec structure
   time_t seconds = static_cast<int>(milliseconds / 1000);
   long int nanoseconds = static_cast<long int>((milliseconds - (seconds * 1000)) * 1000000);
 
-  //Assign the requested time and perform sleep
+  // Assign the requested time and perform sleep
   struct timespec requested;
   requested.tv_sec = seconds;
   requested.tv_nsec = nanoseconds;
@@ -1976,4 +1961,3 @@ void CCM::Bridge::msleep(unsigned int milliseconds) {
   }
 #endif
 }
-
diff --git a/test/ccm_bridge/src/bridge.hpp b/test/ccm_bridge/src/bridge.hpp
index 662e22657..1ae7aaa0d 100644
--- a/test/ccm_bridge/src/bridge.hpp
+++ b/test/ccm_bridge/src/bridge.hpp
@@ -36,16 +36,16 @@ typedef struct _LIBSSH2_CHANNEL LIBSSH2_CHANNEL;
 #endif
 
 #if defined(_MSC_VER)
-#  define CCM_BRIDGE_DEPRECATED(func) __declspec(deprecated) func
+#define CCM_BRIDGE_DEPRECATED(func) __declspec(deprecated) func
 #elif defined(__GNUC__) || defined(__INTEL_COMPILER)
-#  define CCM_BRIDGE_DEPRECATED(func) func __attribute__((deprecated))
+#define CCM_BRIDGE_DEPRECATED(func) func __attribute__((deprecated))
 #else
-#  define CCM_BRIDGE_DEPRECATED(func) func
+#define CCM_BRIDGE_DEPRECATED(func) func
 #endif
 
 // Default values
-#define DEFAULT_CASSANDRA_VERSION CassVersion("3.11.3")
-#define DEFAULT_DSE_VERSION DseVersion("6.0.4")
+#define DEFAULT_CASSANDRA_VERSION CassVersion("3.11.4")
+#define DEFAULT_DSE_VERSION DseVersion("6.0.8")
 #define DEFAULT_USE_GIT false
 #define DEFAULT_USE_INSTALL_DIR false
 #define DEFAULT_USE_DSE false
@@ -92,1004 +92,996 @@ struct ClusterStatus {
    * Constructor
    */
   ClusterStatus()
-    : node_count(0) { }
+      : node_count(0) {}
 };
 
 namespace CCM {
+/**
+ * Enumeration for a DSE workload
+ */
+enum DseWorkload {
+  /**
+   * Cassandra
+   */
+  DSE_WORKLOAD_CASSANDRA = 0,
+  /**
+   * CFS - Cassandra file system (Hadoop Distributed File System (HDFS)
+   * replacement
+   */
+  DSE_WORKLOAD_CFS,
+  /**
+   * DSEFS - DataStax Enterprise file system (Spark streaming and Write Ahead
+   * Logging (WAL))
+   */
+  DSE_WORKLOAD_DSEFS,
+  /**
+   * Graph
+   */
+  DSE_WORKLOAD_GRAPH,
+  /**
+   * Hadoop
+   */
+  DSE_WORKLOAD_HADOOP,
+  /**
+   * Solr
+   */
+  DSE_WORKLOAD_SOLR,
+  /**
+   * Spark
+   */
+  DSE_WORKLOAD_SPARK
+};
+
+class Bridge {
+public:
+  /**
+   * Default DSE workload to apply (Cassandra)
+   */
+  static const std::vector<DseWorkload> DEFAULT_DSE_WORKLOAD;
+
+  /**
+   * Constructor
+   *
+   * @param cassandra_version Cassandra version to use
+   *                          (default: DEFAULT_CASSANDRA_VERSION)
+   * @param use_git True if version should be obtained from ASF/GitHub; false
+   *                otherwise (default: DEFAULT_USE_GIT). Prepends
+   *                `cassandra-` to version when creating cluster through CCM
+   *                if using Cassandra; otherwise passes version information
+   *                to CCM for git download of DSE. Set branch_tag to
+   *                override default action.
+   * @param branch_tag Branch/Tag to use when use_git is enabled
+   *                   (default: Empty). This value is independent of the
+   *                   version specified.
+   * @param use_install_dir True if CCM should use a particular installation
+   *                        directory; false otherwise
+   *                        (default: DEAFAULT_USE_INSTALL_DIR)
+   * @param install_dir Installation directory to use when use_install_dir is
+   *                    enabled (default: Empty)
+   * @param use_dse True if CCM should load DSE for provided version; false
+   *               otherwise (default: DEFAULT_USE_DSE)
+   * @param dse_workload DSE workload to utilize
+   *                     (default: DEFAULT_DSE_WORKLOAD)
+   * @param cluster_prefix Prefix to use when creating a cluster name
+   *                       (default: DEFAULT_CLUSTER_PREFIX)
+   * @param dse_credentials_type Username|Password/INI file credentials
+   *                             (default: DEFAULT_DSE_CREDENTIALS)
+   * @param dse_username Username for DSE download authentication; empty if
+   *                     using INI file credentials (default: Empty)
+   * @param dse_password Password for DSE download authentication; empty if
+   *                     using INI file credentials (default: Empty)
+   * @param deployment_type Local|Remote deployment (execute command locally
+   *                        or remote (default: DEFAULT_DEPLOYMENT)
+   * @param authentication_type Username|Password/Public key authentication
+   *                            (default: DEFAULT_AUTHENTICATION)
+   * @param host Host/IP address for CCM cluster and/or SSH connection
+   *             (default: DEFAULT_HOST)
+   * @param port TCP/IP port for SSH connection
+   *             (default: DEFAULT_REMOTE_DEPLOYMENT_PORT)
+   * @param username Username for SSH authentication
+   *                 (default: DEFAULT_REMOTE_DEPLOYMENT_USERNAME)
+   * @param password Password for SSH authentication; Empty if using public
+   *                 key (default: DEFAULT_REMOTE_DEPLOYMENT_PASSWORD)
+   * @param public_key Public key for authentication; Empty if using username
+   *                   and password authentication (default: Empty)
+   * @param private_key Private key for authentication; Empty if using
+   *                   username and password authentication (default: Empty)
+   * @param is_verbose True if verbose output should be enabled; false
+   *                   otherwise (default: false)
+   * @throws BridgeException
+   */
+  Bridge(CassVersion cassandra_version = DEFAULT_CASSANDRA_VERSION, bool use_git = DEFAULT_USE_GIT,
+         const std::string& branch_tag = "", bool use_install_dir = DEFAULT_USE_INSTALL_DIR,
+         const std::string& install_dir = "", bool use_dse = DEFAULT_USE_DSE,
+         std::vector<DseWorkload> dse_workload = DEFAULT_DSE_WORKLOAD,
+         const std::string& cluster_prefix = DEFAULT_CLUSTER_PREFIX,
+         DseCredentialsType dse_credentials_type = DEFAULT_DSE_CREDENTIALS,
+         const std::string& dse_username = "", const std::string& dse_password = "",
+         DeploymentType deployment_type = DEFAULT_DEPLOYMENT,
+         AuthenticationType authentication_type = DEFAULT_AUTHENTICATION,
+         const std::string& host = DEFAULT_HOST, short port = DEFAULT_REMOTE_DEPLOYMENT_PORT,
+         const std::string& username = DEFAULT_REMOTE_DEPLOYMENT_USERNAME,
+         const std::string& password = DEFAULT_REMOTE_DEPLOYMENT_PASSWORD,
+         const std::string& public_key = "", const std::string& private_key = "",
+         bool is_verbose = DEFAULT_IS_VERBOSE);
+
+  /**
+   * Constructor
+   *
+   * @param configuration_file Full path to configuration file
+   * @throws BridgeException
+   * @deprecated Configuration file will be removed after new test framework
+   *             is fully implemented
+   */
+  CCM_BRIDGE_DEPRECATED(Bridge(const std::string& configuration_file));
+
+  /**
+   * Destructor
+   */
+  ~Bridge();
+
+  /**
+   * Clear the data on the active cluster; as a side effect the cluster is
+   * also stopped
+   */
+  void clear_cluster_data();
+
+  /**
+   * Get a comma separated list of IPv4 addresses for nodes in the active
+   * Cassandra cluster
+   *
+   * @param is_all True if all node IPv4 addresses should be returned; false
+   *               if only the `UP` nodes (default: true)
+   * @return Comma separated list of IPv4 addresses
+   */
+  std::string cluster_contact_points(bool is_all = true);
+
+  /**
+   * Get the list of IPv4 addresses for node in the active Cassandra cluster
+   *
+   * @param is_all True if all node IPv4 addresses should be returned; false
+   *               if only the `UP` nodes (default: true)
+   * @return Array/Vector of IPv4 addresses
+   */
+  std::vector<std::string> cluster_ip_addresses(bool is_all = true);
+
+  /**
+   * Get the status for the active cluster
+   *
+   * @return Status of the nodes in the active cluster
+   */
+  ClusterStatus cluster_status();
+
+  /**
+   * Create a Cassandra cluster with nodes in multiple data centers
+   *
+   * @param data_center_nodes Vector of data center nodes
+   * @param with_vnodes True if vnodes tokens should be used; false otherwise
+   *                   (default: false)
+   * @param is_password_authenticator True if password authenticator is
+   *                                  enabled; false otherwise
+   *                                  (default: false)
+   * @param is_ssl True if SSL should be enabled; false otherwise
+   *               (default: false)
+   * @param is_client_authentication True if client authentication should be
+   *                                enabled; false otherwise (default: false)
+   * @return True if cluster was created or switched; false otherwise
+   * @throws BridgeException
+   */
+  bool create_cluster(std::vector<unsigned short> data_center_nodes, bool with_vnodes = false,
+                      bool is_password_authenticator = false, bool is_ssl = false,
+                      bool is_client_authentication = false);
+
+  /**
+   * Create a Cassandra cluster
+   *
+   * @param data_center_one_nodes Number of nodes for DC1 (default: 1)
+   * @param data_center_two_nodes Number of nodes for DC2 (default: 0)
+   * @param with_vnodes True if vnodes tokens should be used; false otherwise
+   *                   (default: false)
+   * @param is_ssl True if SSL should be enabled; false otherwise
+   *               (default: false)
+   * @param is_client_authentication True if client authentication should be
+   *                                enabled; false otherwise (default: false)
+   * @return True if cluster was created or switched; false otherwise
+   * @deprecated More than two data centers are needed; will be removed after
+   *             refactor of test harness
+   */
+  bool CCM_BRIDGE_DEPRECATED(create_cluster(unsigned short data_center_one_nodes = 1,
+                                            unsigned short data_center_two_nodes = 0,
+                                            bool with_vnodes = false, bool is_ssl = false,
+                                            bool is_client_authentication = false));
+
+  /**
+   * Check to see if the active cluster is no longer accepting connections
+   *
+   * NOTE: This method may check the status of the nodes in the cluster
+   *       multiple times
+   *
+   * @return True if cluster is no longer accepting connections; false
+   *    otherwise
+   */
+  bool is_cluster_down();
+
+  /**
+   * Check to see if the active cluster is ready to accept connections
+   *
+   * NOTE: This method may check the status of the nodes in the cluster
+   *       multiple times
+   *
+   * @return True if cluster is ready to accept connections; false otherwise
+   */
+  bool is_cluster_up();
+
+  /**
+   * "Hang up" the active Cassandra cluster (SIGHUP)
+   *
+   * @return True if cluster is down; false otherwise
+   */
+  bool hang_up_cluster();
+
+  /**
+   * Kill the active Cassandra cluster (SIGKILL)
+   *
+   * @return True if cluster is down; false otherwise
+   */
+  bool kill_cluster();
+
+  /**
+   * Remove active cluster
+   */
+  void remove_cluster();
+
+  /**
+   * Remove a cluster
+   *
+   * @param cluster_name Cluster name to remove
+   */
+  void remove_cluster(const std::string& cluster_name);
+
+  /**
+   * Remove all the available clusters
+   * (default deletes generated bridge clusters)
+   *
+   * @param is_all If true all CCM clusters are removed; otherwise false to
+   *               delete bridge generated clusters (default: false)
+   */
+  void remove_all_clusters(bool is_all = false);
+
+  /**
+   * Start the active Cassandra cluster
+   *
+   * @param jvm_arguments Array/Vector of JVM arguments to apply during
+   *                     cluster start
+   * @return True if cluster is up; false otherwise
+   */
+  bool start_cluster(std::vector<std::string> jvm_arguments);
+
+  /**
+   * Start the active Cassandra cluster
+   *
+   * @param jvm_argument JVM argument to apply during cluster start (optional)
+   * @return True if cluster is down; false otherwise
+   */
+  bool start_cluster(std::string jvm_argument = "");
+
+  /**
+   * Stop the active Cassandra cluster
+   *
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if cluster is down; false otherwise
+   */
+  bool stop_cluster(bool is_kill = false);
+
+  /**
+   * Switch to another available cluster
+   *
+   * @param cluster_name Cluster name to switch to
+   * @return True if switched or is currently active cluster; false otherwise
+   */
+  bool switch_cluster(const std::string& cluster_name);
+
+  /**
+   * Update the cluster configuration
+   *
+   * @param key_value_pairs Key:Value to update
+   * @param is_dse True if key/value pair should update the dse.yaml file;
+   *               otherwise false (default: false; update cassandra.yaml)
+   * @param is_yaml True if key_value_pairs is a YAML string; otherwise false
+   *                (default: false)
+   *                NOTE: key_value_pairs in this instance must be a vector
+   *                      of strings for use with CCM literal YAML updates.
+   *                      These strings are single or multi-line YAML
+   *                      configurations; multi-line YAML must contain EOL
+   *                      marker at the end of each line (e.g. \n)
+   */
+  void update_cluster_configuration(std::vector<std::string> key_value_pairs, bool is_dse = false,
+                                    bool is_yaml = false);
+
+  /**
+   * Update the cluster configuration
+   *
+   * @param key Key to update
+   * @param value Value to apply to key configuration
+   * @param is_dse True if key/value pair should update the dse.yaml file;
+   *               otherwise false (default: false; update cassandra.yaml)
+   */
+  void update_cluster_configuration(const std::string& key, const std::string& value,
+                                    bool is_dse = false);
+
+  /**
+   * Update the cluster configuration using a YAML configuration
+   *
+   * @param yaml YAML configuration to apply to the cluster
+   *             NOTE: These strings are single or multi-line YAML
+   *                   configurations; multi-line YAML must contain EOL
+   *                   marker at the end of each line (e.g. \n)
+   * @param is_dse True if yaml configuration should update the dse.yaml file;
+   *               otherwise false (default: false; update cassandra.yaml)
+   */
+  void update_cluster_configuration_yaml(const std::string& yaml, bool is_dse = false);
+
+  /**
+   * Update the node configuration
+   *
+   * @param node Node to update configuration on
+   * @param key_value_pairs Key:Value to update
+   */
+  void update_node_configuration(unsigned int node, std::vector<std::string> key_value_pairs);
+
+  /**
+   * Update the node configuration
+   *
+   * @param node Node to update configuration on
+   * @param key Key to update
+   * @param value Value to apply to key configuration
+   */
+  void update_node_configuration(unsigned int node, const std::string& key,
+                                 const std::string& value);
+
+  /**
+   * Add a node on the active Cassandra cluster
+   *
+   * @param data_center If provided add the node to the data center; otherwise
+   *                    add node normally (default: no data center)
+   * @return Node added to cluster
+   * @throws BridgeException
+   */
+  unsigned int add_node(const std::string& data_center = "");
+
+  /**
+   * Bootstrap (add and start) a node on the active cluster
+   *
+   * @param jvm_arguments JVM arguments to apply during node start
+   * @param data_center If provided add the node to the data center; otherwise
+   *                    add node normally (default: no data center)
+   * @return Node added to cluster
+   * @throws BridgeException
+   */
+  unsigned int bootstrap_node(const std::vector<std::string>& jvm_arguments,
+                              const std::string& data_center = "");
+
+  /**
+   * Bootstrap (add and start) a node on the active cluster
+   *
+   * @param jvm_argument JVM argument to apply during node start
+   *                     (default: no JVM argument)
+   * @param data_center If provided add the node to the data center; otherwise
+   *                    add node normally (default: no data center)
+   * @return Node added to cluster
+   * @throws BridgeException
+   */
+  unsigned int bootstrap_node(const std::string& jvm_argument = "",
+                              const std::string& data_center = "");
+
+  /**
+   * Decommission a node on the active Cassandra cluster
+   *
+   * @param node Node to decommission
+   * @oaram is_force True if decommission should be forced; false otherwise
+   *                 (default: false)
+   * @return True if node was decommissioned; false otherwise
+   */
+  bool decommission_node(unsigned int node, bool is_force = false);
+
+  /**
+   * Disable binary protocol for a node on the active Cassandra cluster
+   *
+   * @param node Node to disable binary protocol
+   */
+  void disable_node_binary_protocol(unsigned int node);
+
+  /**
+   * Disable gossip for a node on the active Cassandra cluster
+   *
+   * @param node Node to disable gossip
+   */
+  void disable_node_gossip(unsigned int node);
+
+  /**
+   * Disable trace for a node on the active Cassandra cluster
+   *
+   * @param node Node to disable tracing
+   */
+  void disable_node_trace(unsigned int node);
+
+  /**
+   * Enable binary protocol for a node on the active Cassandra cluster
+   *
+   * @param node Node to enable binary protocol
+   */
+  void enable_node_binary_protocol(unsigned int node);
+
+  /**
+   * Enable gossip for a node on the active Cassandra cluster
+   *
+   * @param node Node to enable gossip
+   */
+  void enable_node_gossip(unsigned int node);
+
+  /**
+   * Enable trace for a node on the active Cassandra cluster
+   *
+   * @param node Node to enable tracing
+   */
+  void enable_node_trace(unsigned int node);
+
+  /**
+   * Execute a CQL statement on a particular node
+   *
+   * @param node Node to execute CQL statement on
+   * @param cql CQL statement to execute
+   */
+  void execute_cql_on_node(unsigned int node, const std::string& cql);
+
+  CCM_BRIDGE_DEPRECATED(bool is_dse() { return use_dse_; })
+
+  /**
+   * Force decommission of a node on the active Cassandra cluster
+   *
+   * NOTE: Alias for decommission_node(node, true)
+   *
+   * @param node Node to decommission
+   * @return True if node was decommissioned; false otherwise
+   */
+  bool force_decommission_node(unsigned int node);
+
+  /**
+   * "Hang up" a node on the active Cassandra cluster (SIGHUP)
+   *
+   * @param node Node send SIGHUP signal to
+   * @return True if node is down; false otherwise
+   */
+  bool hang_up_node(unsigned int node);
+
+  /**
+   * Kill a node on the active Cassandra cluster (SIGKILL)
+   *
+   * @param node Node to kill
+   * @return True if node is down; false otherwise
+   */
+  bool kill_node(unsigned int node);
+
+  /**
+   * Pause a node on the active Cassandra cluster
+   *
+   * @param node Node to pause
+   */
+  void pause_node(unsigned int node);
+
+  /**
+   * Resume a node on the active Cassandra cluster
+   *
+   * @param node Node to resume
+   */
+  void resume_node(unsigned int node);
+
+  /**
+   * Start a node on the active Cassandra cluster
+   *
+   * @param node Node to start
+   * @param jvm_arguments Array/Vector of JVM arguments to apply during node
+   *                      start (default: DEFAULT_JVM_ARGUMENTS)
+   * @return True if node is up; false otherwise
+   */
+  bool start_node(unsigned int node,
+                  const std::vector<std::string>& jvm_arguments = DEFAULT_JVM_ARGUMENTS);
+
+  /**
+   * Start a node on the active Cassandra cluster with an additional JVM
+   * argument
+   *
+   * @param node Node to start
+   * @param jvm_argument JVM argument to apply during node start
+   * @return True if node is up; false otherwise
+   */
+  bool start_node(unsigned int node, const std::string& jvm_argument);
+
+  /**
+   * Stop a node on the active Cassandra cluster
+   *
+   * @param node Node to stop
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if node is down; false otherwise
+   */
+  bool stop_node(unsigned int node, bool is_kill = false);
+
+  /**
+   * Get the IP address prefix from the host IP address
+   *
+   * @return IP address prefix
+   */
+  std::string get_ip_prefix();
+
+  /**
+   * Get the IP prefix indicated by the `HOST` setting in the configuration
+   * file
+   *
+   * @param configuration_file Full path to configuration file
+   * @return IP prefix from the configuration file
+   * @deprecated Configuration file will be removed after new test framework
+   *             is fully implemented
+   */
+  CCM_BRIDGE_DEPRECATED(static std::string get_ip_prefix(const std::string& configuration_file));
+
+  /**
+   * Get the Cassandra version from the active cluster
+   *
+   * @return Cassandra version
+   * @throws BridgeException
+   */
+  CassVersion get_cassandra_version();
+
+  /**
+   * Get the Cassandra version indicated in the configuration file
+   *
+   * @param configuration_file Full path to configuration file
+   * @return Cassandra version from the configuration file
+   * @deprecated Configuration file will be removed after new test framework
+   *             is fully implemented
+   */
+  CCM_BRIDGE_DEPRECATED(
+      static CassVersion get_cassandra_version(const std::string& configuration_file));
+
+  /**
+   * Get the DSE version from the active cluster
+   *
+   * @return DSE version
+   * @throws BridgeException
+   */
+  DseVersion get_dse_version();
+
+  /**
+   * Get the DSE version indicated in the configuration file
+   *
+   * @param configuration_file Full path to configuration file
+   * @return DSE version from the configuration file
+   * @deprecated Configuration file will be removed after new test framework
+   *             is fully implemented
+   */
+  CCM_BRIDGE_DEPRECATED(static DseVersion get_dse_version(const std::string& configuration_file));
+
+  /**
+   * Set the DSE workload on a node
+   *
+   * NOTE: This operation should be performed before starting the node;
+   *       otherwise the node will be stopped and restarted
+   *
+   * @param node Node to set DSE workload on
+   * @param workload Workload to be set
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if node was restarted; false otherwise
+   */
+  bool set_dse_workload(unsigned int node, DseWorkload workload, bool is_kill = false);
+
+  /**
+   * Set the DSE workloads on a node
+   *
+   * NOTE: This operation should be performed before starting the node;
+   *       otherwise the node will be stopped and restarted
+   *
+   * @param node Node to set DSE workload on
+   * @param workloads Workloads to be set
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if node was restarted; false otherwise
+   */
+  bool set_dse_workloads(unsigned int node, std::vector<DseWorkload> workloads,
+                         bool is_kill = false);
+
+  /**
+   * Set the DSE workload on the cluster
+   *
+   * NOTE: This operation should be performed before starting the cluster;
+   *       otherwise the cluster will be stopped and restarted
+   *
+   * @param workload Workload to be set
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if cluster was restarted; false otherwise
+   */
+  bool set_dse_workload(DseWorkload workload, bool is_kill = false);
+
+  /**
+   * Set the DSE workloads on the cluster
+   *
+   * NOTE: This operation should be performed before starting the cluster;
+   *       otherwise the cluster will be stopped and restarted
+   *
+   * @param workloads Workloads to be set
+   * @param is_kill True if forced termination requested; false otherwise
+   *                (default: false)
+   * @return True if cluster was restarted; false otherwise
+   */
+  bool set_dse_workloads(std::vector<DseWorkload> workloads, bool is_kill = false);
+
+  /**
+   * Check to see if a node has been decommissioned
+   *
+   * @param node Node to check `DECOMMISSION` status
+   * @return True if node is decommissioned; false otherwise
+   */
+  bool is_node_decommissioned(unsigned int node);
+
+  /**
+   * Check to see if a node will no longer accept connections
+   *
+   * NOTE: This method may check the status of the node multiple times
+   *
+   * @param node Node to check `DOWN` status
+   * @param is_quick_check True if `DOWN` status is checked once; false
+   *        otherwise (default: false)
+   * @return True if node is no longer accepting connections; false otherwise
+   */
+  bool is_node_down(unsigned int node, bool is_quick_check = false);
+
+  /**
+   * Check to see if a node is ready to accept connections
+   *
+   * NOTE: This method may check the status of the node multiple times
+   *
+   * @param node Node to check `UP` status
+   * @param is_quick_check True if `UP` status is checked once; false
+   *        otherwise (default: false)
+   * @return True if node is ready to accept connections; false otherwise
+   */
+  bool is_node_up(unsigned int node, bool is_quick_check = false);
+
+private:
+  /**
+   * Cassandra version to use
+   */
+  CassVersion cassandra_version_;
+  /**
+   * DSE version to use
+   */
+  DseVersion dse_version_;
+  /**
+   * Flag to determine if Cassandra/DSE should be built from ASF/GitHub
+   */
+  bool use_git_;
+  /**
+   * Branch/Tag to retrieve from ASF/GitHub
+   */
+  std::string branch_tag_;
+  /**
+   * Flag to determine if installation directory should be used (passed to
+   * CCM)
+   */
+  bool use_install_dir_;
+  /**
+   * Installation directory to pass to CCM
+   */
+  std::string install_dir_;
+  /**
+   * Flag to determine if DSE is being used
+   */
+  bool use_dse_;
   /**
-   * Enumeration for a DSE workload
-   */
-  enum DseWorkload {
-    /**
-     * Cassandra
-     */
-    DSE_WORKLOAD_CASSANDRA = 0,
-    /**
-     * CFS - Cassandra file system (Hadoop Distributed File System (HDFS)
-     * replacement
-     */
-    DSE_WORKLOAD_CFS,
-    /**
-     * DSEFS - DataStax Enterprise file system (Spark streaming and Write Ahead
-     * Logging (WAL))
-     */
-    DSE_WORKLOAD_DSEFS,
-    /**
-     * Graph
-     */
-    DSE_WORKLOAD_GRAPH,
-    /**
-     * Hadoop
-     */
-    DSE_WORKLOAD_HADOOP,
-    /**
-     * Solr
-     */
-    DSE_WORKLOAD_SOLR,
-    /**
-     * Spark
-     */
-    DSE_WORKLOAD_SPARK
-  };
-
-  class Bridge {
-  public:
-    /**
-     * Default DSE workload to apply (Cassandra)
-     */
-    static const std::vector<DseWorkload> DEFAULT_DSE_WORKLOAD;
-
-    /**
-     * Constructor
-     *
-     * @param cassandra_version Cassandra version to use
-     *                          (default: DEFAULT_CASSANDRA_VERSION)
-     * @param use_git True if version should be obtained from ASF/GitHub; false
-     *                otherwise (default: DEFAULT_USE_GIT). Prepends
-     *                `cassandra-` to version when creating cluster through CCM
-     *                if using Cassandra; otherwise passes version information
-     *                to CCM for git download of DSE. Set branch_tag to
-     *                override default action.
-     * @param branch_tag Branch/Tag to use when use_git is enabled
-     *                   (default: Empty). This value is independent of the
-     *                   version specified.
-     * @param use_install_dir True if CCM should use a particular installation
-     *                        directory; false otherwise
-     *                        (default: DEAFAULT_USE_INSTALL_DIR)
-     * @param install_dir Installation directory to use when use_install_dir is
-     *                    enabled (default: Empty)
-     * @param use_dse True if CCM should load DSE for provided version; false
-     *               otherwise (default: DEFAULT_USE_DSE)
-     * @param dse_workload DSE workload to utilize
-     *                     (default: DEFAULT_DSE_WORKLOAD)
-     * @param cluster_prefix Prefix to use when creating a cluster name
-     *                       (default: DEFAULT_CLUSTER_PREFIX)
-     * @param dse_credentials_type Username|Password/INI file credentials
-     *                             (default: DEFAULT_DSE_CREDENTIALS)
-     * @param dse_username Username for DSE download authentication; empty if
-     *                     using INI file credentials (default: Empty)
-     * @param dse_password Password for DSE download authentication; empty if
-     *                     using INI file credentials (default: Empty)
-     * @param deployment_type Local|Remote deployment (execute command locally
-     *                        or remote (default: DEFAULT_DEPLOYMENT)
-     * @param authentication_type Username|Password/Public key authentication
-     *                            (default: DEFAULT_AUTHENTICATION)
-     * @param host Host/IP address for CCM cluster and/or SSH connection
-     *             (default: DEFAULT_HOST)
-     * @param port TCP/IP port for SSH connection
-     *             (default: DEFAULT_REMOTE_DEPLOYMENT_PORT)
-     * @param username Username for SSH authentication
-     *                 (default: DEFAULT_REMOTE_DEPLOYMENT_USERNAME)
-     * @param password Password for SSH authentication; Empty if using public
-     *                 key (default: DEFAULT_REMOTE_DEPLOYMENT_PASSWORD)
-     * @param public_key Public key for authentication; Empty if using username
-     *                   and password authentication (default: Empty)
-     * @param private_key Private key for authentication; Empty if using
-     *                   username and password authentication (default: Empty)
-     * @param is_verbose True if verbose output should be enabled; false
-     *                   otherwise (default: false)
-     * @throws BridgeException
-     */
-    Bridge(CassVersion cassandra_version = DEFAULT_CASSANDRA_VERSION,
-      bool use_git = DEFAULT_USE_GIT,
-      const std::string& branch_tag = "",
-      bool use_install_dir = DEFAULT_USE_INSTALL_DIR,
-      const std::string& install_dir = "",
-      bool use_dse = DEFAULT_USE_DSE,
-      std::vector<DseWorkload> dse_workload = DEFAULT_DSE_WORKLOAD,
-      const std::string& cluster_prefix = DEFAULT_CLUSTER_PREFIX,
-      DseCredentialsType dse_credentials_type = DEFAULT_DSE_CREDENTIALS,
-      const std::string& dse_username = "",
-      const std::string& dse_password = "",
-      DeploymentType deployment_type = DEFAULT_DEPLOYMENT,
-      AuthenticationType authentication_type = DEFAULT_AUTHENTICATION,
-      const std::string& host = DEFAULT_HOST,
-      short port = DEFAULT_REMOTE_DEPLOYMENT_PORT,
-      const std::string& username = DEFAULT_REMOTE_DEPLOYMENT_USERNAME,
-      const std::string& password = DEFAULT_REMOTE_DEPLOYMENT_PASSWORD,
-      const std::string& public_key = "",
-      const std::string& private_key = "",
-      bool is_verbose = DEFAULT_IS_VERBOSE);
-
-    /**
-     * Constructor
-     *
-     * @param configuration_file Full path to configuration file
-     * @throws BridgeException
-     * @deprecated Configuration file will be removed after new test framework
-     *             is fully implemented
-     */
-    CCM_BRIDGE_DEPRECATED(Bridge(const std::string& configuration_file));
-
-    /**
-     * Destructor
-     */
-    ~Bridge();
-
-    /**
-     * Clear the data on the active cluster; as a side effect the cluster is
-     * also stopped
-     */
-    void clear_cluster_data();
-
-    /**
-     * Get a comma separated list of IPv4 addresses for nodes in the active
-     * Cassandra cluster
-     *
-     * @param is_all True if all node IPv4 addresses should be returned; false
-     *               if only the `UP` nodes (default: true)
-     * @return Comma separated list of IPv4 addresses
-     */
-    std::string cluster_contact_points(bool is_all = true);
-
-    /**
-     * Get the list of IPv4 addresses for node in the active Cassandra cluster
-     *
-     * @param is_all True if all node IPv4 addresses should be returned; false
-     *               if only the `UP` nodes (default: true)
-     * @return Array/Vector of IPv4 addresses
-     */
-    std::vector<std::string> cluster_ip_addresses(bool is_all = true);
-
-    /**
-     * Get the status for the active cluster
-     *
-     * @return Status of the nodes in the active cluster
-     */
-    ClusterStatus cluster_status();
-
-    /**
-     * Create a Cassandra cluster with nodes in multiple data centers
-     *
-     * @param data_center_nodes Vector of data center nodes
-     * @param with_vnodes True if vnodes tokens should be used; false otherwise
-     *                   (default: false)
-     * @param is_password_authenticator True if password authenticator is
-     *                                  enabled; false otherwise
-     *                                  (default: false)
-     * @param is_ssl True if SSL should be enabled; false otherwise
-     *               (default: false)
-     * @param is_client_authentication True if client authentication should be
-     *                                enabled; false otherwise (default: false)
-     * @return True if cluster was created or switched; false otherwise
-     * @throws BridgeException
-     */
-    bool create_cluster(std::vector<unsigned short> data_center_nodes,
-                        bool with_vnodes = false,
-                        bool is_password_authenticator = false,
-                        bool is_ssl = false,
-                        bool is_client_authentication = false);
-
-    /**
-     * Create a Cassandra cluster
-     *
-     * @param data_center_one_nodes Number of nodes for DC1 (default: 1)
-     * @param data_center_two_nodes Number of nodes for DC2 (default: 0)
-     * @param with_vnodes True if vnodes tokens should be used; false otherwise
-     *                   (default: false)
-     * @param is_ssl True if SSL should be enabled; false otherwise
-     *               (default: false)
-     * @param is_client_authentication True if client authentication should be
-     *                                enabled; false otherwise (default: false)
-     * @return True if cluster was created or switched; false otherwise
-     * @deprecated More than two data centers are needed; will be removed after
-     *             refactor of test harness
-     */
-    bool CCM_BRIDGE_DEPRECATED(create_cluster(unsigned short data_center_one_nodes = 1,
-      unsigned short data_center_two_nodes = 0, bool with_vnodes = false,
-      bool is_ssl = false, bool is_client_authentication = false));
-
-    /**
-     * Check to see if the active cluster is no longer accepting connections
-     *
-     * NOTE: This method may check the status of the nodes in the cluster
-     *       multiple times
-     *
-     * @return True if cluster is no longer accepting connections; false
-     *    otherwise
-     */
-    bool is_cluster_down();
-
-    /**
-     * Check to see if the active cluster is ready to accept connections
-     *
-     * NOTE: This method may check the status of the nodes in the cluster
-     *       multiple times
-     *
-     * @return True if cluster is ready to accept connections; false otherwise
-     */
-    bool is_cluster_up();
-
-    /**
-     * "Hang up" the active Cassandra cluster (SIGHUP)
-     *
-     * @return True if cluster is down; false otherwise
-     */
-    bool hang_up_cluster();
-
-    /**
-     * Kill the active Cassandra cluster (SIGKILL)
-     *
-     * @return True if cluster is down; false otherwise
-     */
-    bool kill_cluster();
-
-    /**
-     * Remove active cluster
-     */
-    void remove_cluster();
-
-    /**
-     * Remove a cluster
-     *
-     * @param cluster_name Cluster name to remove
-     */
-    void remove_cluster(const std::string& cluster_name);
-
-    /**
-     * Remove all the available clusters
-     * (default deletes generated bridge clusters)
-     *
-     * @param is_all If true all CCM clusters are removed; otherwise false to
-     *               delete bridge generated clusters (default: false)
-     */
-    void remove_all_clusters(bool is_all = false);
-
-    /**
-     * Start the active Cassandra cluster
-     *
-     * @param jvm_arguments Array/Vector of JVM arguments to apply during
-     *                     cluster start
-     * @return True if cluster is up; false otherwise
-     */
-    bool start_cluster(std::vector<std::string> jvm_arguments);
-
-    /**
-     * Start the active Cassandra cluster
-     *
-     * @param jvm_argument JVM argument to apply during cluster start (optional)
-     * @return True if cluster is down; false otherwise
-     */
-    bool start_cluster(std::string jvm_argument = "");
-
-    /**
-     * Stop the active Cassandra cluster
-     *
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if cluster is down; false otherwise
-     */
-    bool stop_cluster(bool is_kill = false);
-
-    /**
-     * Switch to another available cluster
-     *
-     * @param cluster_name Cluster name to switch to
-     * @return True if switched or is currently active cluster; false otherwise
-     */
-    bool switch_cluster(const std::string& cluster_name);
-
-    /**
-     * Update the cluster configuration
-     *
-     * @param key_value_pairs Key:Value to update
-     * @param is_dse True if key/value pair should update the dse.yaml file;
-     *               otherwise false (default: false; update cassandra.yaml)
-     * @param is_yaml True if key_value_pairs is a YAML string; otherwise false
-     *                (default: false)
-     *                NOTE: key_value_pairs in this instance must be a vector
-     *                      of strings for use with CCM literal YAML updates.
-     *                      These strings are single or multi-line YAML
-     *                      configurations; multi-line YAML must contain EOL
-     *                      marker at the end of each line (e.g. \n)
-     */
-    void update_cluster_configuration(std::vector<std::string> key_value_pairs,
-      bool is_dse = false, bool is_yaml = false);
-
-    /**
-     * Update the cluster configuration
-     *
-     * @param key Key to update
-     * @param value Value to apply to key configuration
-     * @param is_dse True if key/value pair should update the dse.yaml file;
-     *               otherwise false (default: false; update cassandra.yaml)
-     */
-    void update_cluster_configuration(const std::string& key, const std::string& value,
-      bool is_dse = false);
-
-    /**
-     * Update the cluster configuration using a YAML configuration
-     *
-     * @param yaml YAML configuration to apply to the cluster
-     *             NOTE: These strings are single or multi-line YAML
-     *                   configurations; multi-line YAML must contain EOL
-     *                   marker at the end of each line (e.g. \n)
-     * @param is_dse True if yaml configuration should update the dse.yaml file;
-     *               otherwise false (default: false; update cassandra.yaml)
-     */
-    void update_cluster_configuration_yaml(const std::string& yaml, bool is_dse = false);
-
-    /**
-     * Update the node configuration
-     *
-     * @param node Node to update configuration on
-     * @param key_value_pairs Key:Value to update
-     */
-    void update_node_configuration(unsigned int node, std::vector<std::string> key_value_pairs);
-
-    /**
-     * Update the node configuration
-     *
-     * @param node Node to update configuration on
-     * @param key Key to update
-     * @param value Value to apply to key configuration
-     */
-    void update_node_configuration(unsigned int node, const std::string& key, const std::string& value);
-
-    /**
-     * Add a node on the active Cassandra cluster
-     *
-     * @param data_center If provided add the node to the data center; otherwise
-     *                    add node normally (default: no data center)
-     * @return Node added to cluster
-     * @throws BridgeException
-     */
-    unsigned int add_node(const std::string& data_center = "");
-
-    /**
-     * Bootstrap (add and start) a node on the active cluster
-     *
-     * @param jvm_arguments JVM arguments to apply during node start
-     * @param data_center If provided add the node to the data center; otherwise
-     *                    add node normally (default: no data center)
-     * @return Node added to cluster
-     * @throws BridgeException
-     */
-    unsigned int bootstrap_node(const std::vector<std::string>& jvm_arguments,
-                                const std::string& data_center = "");
-
-    /**
-     * Bootstrap (add and start) a node on the active cluster
-     *
-     * @param jvm_argument JVM argument to apply during node start
-     *                     (default: no JVM argument)
-     * @param data_center If provided add the node to the data center; otherwise
-     *                    add node normally (default: no data center)
-     * @return Node added to cluster
-     * @throws BridgeException
-     */
-    unsigned int bootstrap_node(const std::string& jvm_argument = "",
-                                const std::string& data_center = "");
-
-    /**
-     * Decommission a node on the active Cassandra cluster
-     *
-     * @param node Node to decommission
-     * @oaram is_force True if decommission should be forced; false otherwise
-     *                 (default: false)
-     * @return True if node was decommissioned; false otherwise
-     */
-    bool decommission_node(unsigned int node, bool is_force = false);
-
-    /**
-     * Disable binary protocol for a node on the active Cassandra cluster
-     *
-     * @param node Node to disable binary protocol
-     */
-    void disable_node_binary_protocol(unsigned int node);
-
-    /**
-     * Disable gossip for a node on the active Cassandra cluster
-     *
-     * @param node Node to disable gossip
-     */
-    void disable_node_gossip(unsigned int node);
-
-    /**
-     * Disable trace for a node on the active Cassandra cluster
-     *
-     * @param node Node to disable tracing
-     */
-    void disable_node_trace(unsigned int node);
-
-    /**
-     * Enable binary protocol for a node on the active Cassandra cluster
-     *
-     * @param node Node to enable binary protocol
-     */
-    void enable_node_binary_protocol(unsigned int node);
-
-    /**
-     * Enable gossip for a node on the active Cassandra cluster
-     *
-     * @param node Node to enable gossip
-     */
-    void enable_node_gossip(unsigned int node);
-
-    /**
-     * Enable trace for a node on the active Cassandra cluster
-     *
-     * @param node Node to enable tracing
-     */
-    void enable_node_trace(unsigned int node);
-
-    /**
-     * Execute a CQL statement on a particular node
-     *
-     * @param node Node to execute CQL statement on
-     * @param cql CQL statement to execute
-     */
-    void execute_cql_on_node(unsigned int node, const std::string& cql);
-
-    CCM_BRIDGE_DEPRECATED(bool is_dse() { return use_dse_; })
-
-    /**
-     * Force decommission of a node on the active Cassandra cluster
-     *
-     * NOTE: Alias for decommission_node(node, true)
-     *
-     * @param node Node to decommission
-     * @return True if node was decommissioned; false otherwise
-     */
-    bool force_decommission_node(unsigned int node);
-
-    /**
-     * "Hang up" a node on the active Cassandra cluster (SIGHUP)
-     *
-     * @param node Node send SIGHUP signal to
-     * @return True if node is down; false otherwise
-     */
-    bool hang_up_node(unsigned int node);
-
-    /**
-     * Kill a node on the active Cassandra cluster (SIGKILL)
-     *
-     * @param node Node to kill
-     * @return True if node is down; false otherwise
-     */
-    bool kill_node(unsigned int node);
-
-    /**
-     * Pause a node on the active Cassandra cluster
-     *
-     * @param node Node to pause
-     */
-    void pause_node(unsigned int node);
-
-    /**
-     * Resume a node on the active Cassandra cluster
-     *
-     * @param node Node to resume
-     */
-    void resume_node(unsigned int node);
-
-    /**
-     * Start a node on the active Cassandra cluster
-     *
-     * @param node Node to start
-     * @param jvm_arguments Array/Vector of JVM arguments to apply during node
-     *                      start (default: DEFAULT_JVM_ARGUMENTS)
-     * @return True if node is up; false otherwise
-     */
-    bool start_node(unsigned int node,
-                    const std::vector<std::string>& jvm_arguments = DEFAULT_JVM_ARGUMENTS);
-
-    /**
-     * Start a node on the active Cassandra cluster with an additional JVM
-     * argument
-     *
-     * @param node Node to start
-     * @param jvm_argument JVM argument to apply during node start
-     * @return True if node is up; false otherwise
-     */
-    bool start_node(unsigned int node, const std::string& jvm_argument);
-
-    /**
-     * Stop a node on the active Cassandra cluster
-     *
-     * @param node Node to stop
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if node is down; false otherwise
-     */
-    bool stop_node(unsigned int node, bool is_kill = false);
-
-    /**
-     * Get the IP address prefix from the host IP address
-     *
-     * @return IP address prefix
-     */
-    std::string get_ip_prefix();
-
-    /**
-     * Get the IP prefix indicated by the `HOST` setting in the configuration
-     * file
-     *
-     * @param configuration_file Full path to configuration file
-     * @return IP prefix from the configuration file
-     * @deprecated Configuration file will be removed after new test framework
-     *             is fully implemented
-     */
-    CCM_BRIDGE_DEPRECATED(static std::string get_ip_prefix(const std::string& configuration_file));
-
-    /**
-     * Get the Cassandra version from the active cluster
-     *
-     * @return Cassandra version
-     * @throws BridgeException
-     */
-    CassVersion get_cassandra_version();
-
-    /**
-     * Get the Cassandra version indicated in the configuration file
-     *
-     * @param configuration_file Full path to configuration file
-     * @return Cassandra version from the configuration file
-     * @deprecated Configuration file will be removed after new test framework
-     *             is fully implemented
-     */
-    CCM_BRIDGE_DEPRECATED(static CassVersion get_cassandra_version(const std::string& configuration_file));
-
-    /**
-     * Get the DSE version from the active cluster
-     *
-     * @return DSE version
-     * @throws BridgeException
-     */
-    DseVersion get_dse_version();
-
-    /**
-     * Get the DSE version indicated in the configuration file
-     *
-     * @param configuration_file Full path to configuration file
-     * @return DSE version from the configuration file
-     * @deprecated Configuration file will be removed after new test framework
-     *             is fully implemented
-     */
-    CCM_BRIDGE_DEPRECATED(static DseVersion get_dse_version(const std::string& configuration_file));
-
-    /**
-     * Set the DSE workload on a node
-     *
-     * NOTE: This operation should be performed before starting the node;
-     *       otherwise the node will be stopped and restarted
-     *
-     * @param node Node to set DSE workload on
-     * @param workload Workload to be set
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if node was restarted; false otherwise
-     */
-    bool set_dse_workload(unsigned int node, DseWorkload workload, bool is_kill = false);
-
-    /**
-     * Set the DSE workloads on a node
-     *
-     * NOTE: This operation should be performed before starting the node;
-     *       otherwise the node will be stopped and restarted
-     *
-     * @param node Node to set DSE workload on
-     * @param workloads Workloads to be set
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if node was restarted; false otherwise
-     */
-    bool set_dse_workloads(unsigned int node, std::vector<DseWorkload> workloads,
-      bool is_kill = false);
-
-    /**
-     * Set the DSE workload on the cluster
-     *
-     * NOTE: This operation should be performed before starting the cluster;
-     *       otherwise the cluster will be stopped and restarted
-     *
-     * @param workload Workload to be set
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if cluster was restarted; false otherwise
-     */
-    bool set_dse_workload(DseWorkload workload, bool is_kill = false);
-
-    /**
-     * Set the DSE workloads on the cluster
-     *
-     * NOTE: This operation should be performed before starting the cluster;
-     *       otherwise the cluster will be stopped and restarted
-     *
-     * @param workloads Workloads to be set
-     * @param is_kill True if forced termination requested; false otherwise
-     *                (default: false)
-     * @return True if cluster was restarted; false otherwise
-     */
-    bool set_dse_workloads(std::vector<DseWorkload> workloads,
-      bool is_kill = false);
-
-    /**
-     * Check to see if a node has been decommissioned
-     *
-     * @param node Node to check `DECOMMISSION` status
-     * @return True if node is decommissioned; false otherwise
-     */
-    bool is_node_decommissioned(unsigned int node);
-
-    /**
-     * Check to see if a node will no longer accept connections
-     *
-     * NOTE: This method may check the status of the node multiple times
-     *
-     * @param node Node to check `DOWN` status
-     * @param is_quick_check True if `DOWN` status is checked once; false
-     *        otherwise (default: false)
-     * @return True if node is no longer accepting connections; false otherwise
-     */
-    bool is_node_down(unsigned int node, bool is_quick_check = false);
-
-    /**
-     * Check to see if a node is ready to accept connections
-     *
-     * NOTE: This method may check the status of the node multiple times
-     *
-     * @param node Node to check `UP` status
-     * @param is_quick_check True if `UP` status is checked once; false
-     *        otherwise (default: false)
-     * @return True if node is ready to accept connections; false otherwise
-     */
-    bool is_node_up(unsigned int node, bool is_quick_check = false);
-
-  private:
-    /**
-     * Cassandra version to use
-     */
-    CassVersion cassandra_version_;
-    /**
-     * DSE version to use
-     */
-    DseVersion dse_version_;
-    /**
-     * Flag to determine if Cassandra/DSE should be built from ASF/GitHub
-     */
-    bool use_git_;
-    /**
-     * Branch/Tag to retrieve from ASF/GitHub
-     */
-    std::string branch_tag_;
-    /**
-     * Flag to determine if installation directory should be used (passed to
-     * CCM)
-     */
-    bool use_install_dir_;
-    /**
-     * Installation directory to pass to CCM
-     */
-    std::string install_dir_;
-    /**
-     * Flag to determine if DSE is being used
-     */
-    bool use_dse_;
-    /**
-     * Workload to apply to the DSE cluster
-     *
-     * NOTE: Multiple workloads will be applied simultaneously via CCM
-     */
-    std::vector<DseWorkload> dse_workload_;
-    /**
-     * Cluster prefix to apply to cluster name during create command
-     */
-    std::string cluster_prefix_;
-    /**
-     * Authentication type (username|password/public key)
-     *
-     * Flag to indicate how SSH authentication should be established
-     */
-    AuthenticationType authentication_type_;
-    /**
-     * DSE credentials type (username|password/INI file)
-     *
-     * Flag to indicate how DSE credentials should be obtained
-     */
-    DseCredentialsType dse_credentials_type_;
-    /**
-     * Username to use when authenticating download access for DSE
-     */
-    std::string dse_username_;
-    /**
-     * Password to use when authenticating download access for DSE
-     */
-    std::string dse_password_;
-    /**
-     * Deployment type (local|ssh)
-     *
-     * Flag to indicate how CCM commands should be executed
-     */
-    DeploymentType deployment_type_;
-    /**
-     * IP address to use when establishing SSH connection for remote CCM
-     * command execution and/or IP address to use for server connection IP
-     * generation
-     */
-    std::string host_;
-    /**
-     * Flag to determine if verbose output is enabled
-     */
-    bool is_verbose_;
+   * Workload to apply to the DSE cluster
+   *
+   * NOTE: Multiple workloads will be applied simultaneously via CCM
+   */
+  std::vector<DseWorkload> dse_workload_;
+  /**
+   * Cluster prefix to apply to cluster name during create command
+   */
+  std::string cluster_prefix_;
+  /**
+   * Authentication type (username|password/public key)
+   *
+   * Flag to indicate how SSH authentication should be established
+   */
+  AuthenticationType authentication_type_;
+  /**
+   * DSE credentials type (username|password/INI file)
+   *
+   * Flag to indicate how DSE credentials should be obtained
+   */
+  DseCredentialsType dse_credentials_type_;
+  /**
+   * Username to use when authenticating download access for DSE
+   */
+  std::string dse_username_;
+  /**
+   * Password to use when authenticating download access for DSE
+   */
+  std::string dse_password_;
+  /**
+   * Deployment type (local|ssh)
+   *
+   * Flag to indicate how CCM commands should be executed
+   */
+  DeploymentType deployment_type_;
+  /**
+   * IP address to use when establishing SSH connection for remote CCM
+   * command execution and/or IP address to use for server connection IP
+   * generation
+   */
+  std::string host_;
+  /**
+   * Flag to determine if verbose output is enabled
+   */
+  bool is_verbose_;
 #ifdef CASS_USE_LIBSSH2
-    /**
-     * SSH session handle for establishing connection
-     */
-    LIBSSH2_SESSION* session_;
-    /**
-     * SSH channel handle for interacting with the session
-     */
-    LIBSSH2_CHANNEL* channel_;
-    /**
-     * Socket instance
-     */
-    Socket* socket_;
+  /**
+   * SSH session handle for establishing connection
+   */
+  LIBSSH2_SESSION* session_;
+  /**
+   * SSH channel handle for interacting with the session
+   */
+  LIBSSH2_CHANNEL* channel_;
+  /**
+   * Socket instance
+   */
+  Socket* socket_;
 #endif
-    /**
-     * Workload values to use when setting the workload via CCM
-     */
-    static const std::vector<std::string> dse_workloads_;
+  /**
+   * Workload values to use when setting the workload via CCM
+   */
+  static const std::vector<std::string> dse_workloads_;
 
 #ifdef CASS_USE_LIBSSH2
-    /**
-     * Initialize the socket
-     *
-     * @param host Host/IP address for SSH connection
-     * @param port TCP/IP port for SSH connection
-     * @throws SocketException
-     */
-    void initialize_socket(const std::string& host, short port);
-
-    /**
-     * Synchronize the socket based on the direction of the libssh2 session
-     *
-     * @throws BridgeException
-     * @throws SocketException
-     */
-    void synchronize_socket();
-
-    /**
-     * Initialize the libssh2 connection
-     *
-     * @throws BridgeException
-     */
-    void initialize_libssh2();
-
-    /**
-     * Establish connection via libssh2
-     *
-     * @param authentication_type Username|Password/Public key authentication
-     * @param username Username for SSH authentication
-     * @param password Password for SSH authentication; NULL if using public
-     *                 key
-     * @param public_key Public key for authentication; Empty if using username
-     *                   and password authentication
-     * @param private_key Private key for authentication; Empty if using
-     *                   username and password authentication
-     * @throws BridgeException
-     */
-    void establish_libssh2_connection(AuthenticationType authentication_type,
-      const std::string& username, const std::string& password,
-      const std::string& public_key, const std::string& private_key);
-
-    /**
-     * Create/Open the libssh2 terminal
-     *
-     * @throws BridgeException
-     */
-    void open_libssh2_terminal();
-
-    /**
-     * Terminate/Close the libssh2 terminal
-     *
-     * @throws BridgeException
-     */
-    void close_libssh2_terminal();
-
-    /**
-     * Execute a remote command on the libssh2 connection
-     *
-     * @param command Command array to execute ([0] = command, [1-n] arguments)
-     * @return Output from executed command
-     */
-    std::string execute_libssh2_command(const std::vector<std::string>& command);
+  /**
+   * Initialize the socket
+   *
+   * @param host Host/IP address for SSH connection
+   * @param port TCP/IP port for SSH connection
+   * @throws SocketException
+   */
+  void initialize_socket(const std::string& host, short port);
+
+  /**
+   * Synchronize the socket based on the direction of the libssh2 session
+   *
+   * @throws BridgeException
+   * @throws SocketException
+   */
+  void synchronize_socket();
+
+  /**
+   * Initialize the libssh2 connection
+   *
+   * @throws BridgeException
+   */
+  void initialize_libssh2();
+
+  /**
+   * Establish connection via libssh2
+   *
+   * @param authentication_type Username|Password/Public key authentication
+   * @param username Username for SSH authentication
+   * @param password Password for SSH authentication; NULL if using public
+   *                 key
+   * @param public_key Public key for authentication; Empty if using username
+   *                   and password authentication
+   * @param private_key Private key for authentication; Empty if using
+   *                   username and password authentication
+   * @throws BridgeException
+   */
+  void establish_libssh2_connection(AuthenticationType authentication_type,
+                                    const std::string& username, const std::string& password,
+                                    const std::string& public_key, const std::string& private_key);
+
+  /**
+   * Create/Open the libssh2 terminal
+   *
+   * @throws BridgeException
+   */
+  void open_libssh2_terminal();
+
+  /**
+   * Terminate/Close the libssh2 terminal
+   *
+   * @throws BridgeException
+   */
+  void close_libssh2_terminal();
+
+  /**
+   * Execute a remote command on the libssh2 connection
+   *
+   * @param command Command array to execute ([0] = command, [1-n] arguments)
+   * @return Output from executed command
+   */
+  std::string execute_libssh2_command(const std::vector<std::string>& command);
 #endif
 
 #ifdef CASS_USE_LIBSSH2
-    /**
-     * Read the output (stdout and stderr) from the libssh2 terminal
-     *
-     * @return Output from the terminal (may not be in order)
-     */
-    std::string read_libssh2_terminal();
-
-    /**
-     * Finalize the libssh2 library usage and socket used by libssh2
-     */
-    void finalize_libssh2();
+  /**
+   * Read the output (stdout and stderr) from the libssh2 terminal
+   *
+   * @return Output from the terminal (may not be in order)
+   */
+  std::string read_libssh2_terminal();
+
+  /**
+   * Finalize the libssh2 library usage and socket used by libssh2
+   */
+  void finalize_libssh2();
 #endif
 
-    /**
-     * Execute the CCM command
-     *
-     * @param command Command array to execute ([0] = CCM command,
-     *                [1-n] arguments)
-     * @return Output from executing CCM command
-     */
-    std::string execute_ccm_command(const std::vector<std::string>& command);
-
-    /**
-     * Get the active Cassandra cluster
-     *
-     * @return Currently active Cassandra cluster
-     */
-    std::string get_active_cluster();
-
-    /**
-     * Get the list of available Cassandra clusters
-     *
-     * @return Array/Vector of available Cassandra clusters
-     */
-    std::vector<std::string> get_available_clusters();
-
-    /**
-     * Get the list of available Cassandra clusters
-     *
-     * @param [out] active_cluster Current active cluster in the list
-     * @return Array/Vector of available Cassandra clusters
-     */
-    std::vector<std::string> get_available_clusters(std::string& active_cluster);
-
-    /**
-     * Generate the name of the Cassandra cluster based on the number of nodes
-     * in each data center
-     *
-     * @param cassandra_version Cassandra version being used
-     * @param data_center_nodes Vector of nodes for each data center
-     * @param with_vnodes True if vnodes are enabled; false otherwise
-     * @param is_password_authenticator True if password authenticator is
-     *                                  enabled; false otherwise
-     * @param is_ssl True if SSL is enabled; false otherwise
-     * @param is_client_authentication True if client authentication is enabled;
-     *                                false otherwise
-     * @return Cluster name
-     */
-    std::string generate_cluster_name(CassVersion cassandra_version,
-                                      std::vector<unsigned short> data_center_nodes,
-                                      bool with_vnodes,
-                                      bool is_password_authenticator,
-                                      bool is_ssl,
-                                      bool is_client_authentication);
-
-    /**
-     * Generate the nodes parameter for theCassandra cluster based on the number
-     * of nodes in each data center
-     *
-     * @param data_center_nodes Vector of nodes for each data center
-     * @param separator Separator to use between cluster nodes
-     * @return String of nodes separated by separator
-     */
-    std::string generate_cluster_nodes(std::vector<unsigned short> data_center_nodes,
-      char separator = ':');
-
-    /**
-     * Generate the CCM update configuration command based on the Cassandra
-     * version requested
-     *
-     * @param cassandra_version Cassandra version to use
-     * @return Array/Vector containing the updateconf command
-     */
-    std::vector<std::string> generate_create_updateconf_command(CassVersion cassandra_version);
-
-    /**
-     * Generate the command separated list for have a single or multiple
-     * workloads for the CCM setworkload command
-     *
-     * @param workloads Workloads to be set
-     * @return String representing the workloads for the setworkload command
-     */
-    std::string generate_dse_workloads(std::vector<DseWorkload> workloads);
-
-    /**
-     * Get the next available node
-     *
-     * @return Next available node
-     * @throws BridgeException
-     * @see CLUSTER_NODE_LIMIT
-     */
-    unsigned int get_next_available_node();
-
-    /**
-     * Generate the node name based on the node requested
-     *
-     * @param node Node to use
-     * @return Name of the node for CCM node commands
-     */
-    std::string generate_node_name(unsigned int node);
-
-    /**
-     * Determine if a node is available
-     *
-     * @param node Cassandra node to check
-     * @return True if node is available; false otherwise
-     */
-    bool is_node_availabe(unsigned int node);
-
-    /**
-     * Determine if a node is available
-     *
-     * @param ip_address IPv4 address of the Cassandra node
-     * @return True if node is available; false otherwise
-     */
-    bool is_node_availabe(const std::string& ip_address);
-
-    /**
-     * Convert a string to lowercase
-     *
-     * @param input String to convert to lowercase
-     *
-     * TODO: Remove static declaration after deprecations are removed
-     */
-    static std::string to_lower(const std::string& input);
-
-    /**
-     * Remove the leading and trailing whitespace from a string
-     *
-     * @param input String to trim
-     * @return Trimmed string
-     *
-     * TODO: Remove static declaration after deprecations are removed
-     */
-    static std::string trim(const std::string& input);
-
-    /**
-     * Concatenate an array/vector into a string
-     *
-     * @param elements Array/Vector elements to concatenate
-     * @param delimiter Character to use between elements (default: <space>)
-     * @return A string representation of all the array/vector elements
-     */
-    std::string implode(const std::vector<std::string>& elements, const char delimiter = ' ');
-
-    /**
-     * Split a string into an array/vector
-     *
-     * @param input String to convert to array/vector
-     * @param delimiter Character to use split into elements (default: <space>)
-     * @return An array/vector representation of the string
-     *
-     * TODO: Remove static declaration after deprecations are removed
-     */
-    static std::vector<std::string> explode(const std::string& input, const char delimiter = ' ');
-
-    /**
-     * Cross platform millisecond granularity sleep
-     *
-     * @param milliseconds Time in milliseconds to sleep
-     */
-    void msleep(unsigned int milliseconds);
-  };
-}
+  /**
+   * Execute the CCM command
+   *
+   * @param command Command array to execute ([0] = CCM command,
+   *                [1-n] arguments)
+   * @return Output from executing CCM command
+   */
+  std::string execute_ccm_command(const std::vector<std::string>& command);
+
+  /**
+   * Get the active Cassandra cluster
+   *
+   * @return Currently active Cassandra cluster
+   */
+  std::string get_active_cluster();
+
+  /**
+   * Get the list of available Cassandra clusters
+   *
+   * @return Array/Vector of available Cassandra clusters
+   */
+  std::vector<std::string> get_available_clusters();
+
+  /**
+   * Get the list of available Cassandra clusters
+   *
+   * @param [out] active_cluster Current active cluster in the list
+   * @return Array/Vector of available Cassandra clusters
+   */
+  std::vector<std::string> get_available_clusters(std::string& active_cluster);
+
+  /**
+   * Generate the name of the Cassandra cluster based on the number of nodes
+   * in each data center
+   *
+   * @param cassandra_version Cassandra version being used
+   * @param data_center_nodes Vector of nodes for each data center
+   * @param with_vnodes True if vnodes are enabled; false otherwise
+   * @param is_password_authenticator True if password authenticator is
+   *                                  enabled; false otherwise
+   * @param is_ssl True if SSL is enabled; false otherwise
+   * @param is_client_authentication True if client authentication is enabled;
+   *                                false otherwise
+   * @return Cluster name
+   */
+  std::string generate_cluster_name(CassVersion cassandra_version,
+                                    std::vector<unsigned short> data_center_nodes, bool with_vnodes,
+                                    bool is_password_authenticator, bool is_ssl,
+                                    bool is_client_authentication);
+
+  /**
+   * Generate the nodes parameter for theCassandra cluster based on the number
+   * of nodes in each data center
+   *
+   * @param data_center_nodes Vector of nodes for each data center
+   * @param separator Separator to use between cluster nodes
+   * @return String of nodes separated by separator
+   */
+  std::string generate_cluster_nodes(std::vector<unsigned short> data_center_nodes,
+                                     char separator = ':');
+
+  /**
+   * Generate the CCM update configuration command based on the Cassandra
+   * version requested
+   *
+   * @param cassandra_version Cassandra version to use
+   * @return Array/Vector containing the updateconf command
+   */
+  std::vector<std::string> generate_create_updateconf_command(CassVersion cassandra_version);
+
+  /**
+   * Generate the command separated list for have a single or multiple
+   * workloads for the CCM setworkload command
+   *
+   * @param workloads Workloads to be set
+   * @return String representing the workloads for the setworkload command
+   */
+  std::string generate_dse_workloads(std::vector<DseWorkload> workloads);
+
+  /**
+   * Get the next available node
+   *
+   * @return Next available node
+   * @throws BridgeException
+   * @see CLUSTER_NODE_LIMIT
+   */
+  unsigned int get_next_available_node();
+
+  /**
+   * Generate the node name based on the node requested
+   *
+   * @param node Node to use
+   * @return Name of the node for CCM node commands
+   */
+  std::string generate_node_name(unsigned int node);
+
+  /**
+   * Determine if a node is available
+   *
+   * @param node Cassandra node to check
+   * @return True if node is available; false otherwise
+   */
+  bool is_node_availabe(unsigned int node);
+
+  /**
+   * Determine if a node is available
+   *
+   * @param ip_address IPv4 address of the Cassandra node
+   * @return True if node is available; false otherwise
+   */
+  bool is_node_availabe(const std::string& ip_address);
+
+  /**
+   * Convert a string to lowercase
+   *
+   * @param input String to convert to lowercase
+   *
+   * TODO: Remove static declaration after deprecations are removed
+   */
+  static std::string to_lower(const std::string& input);
+
+  /**
+   * Remove the leading and trailing whitespace from a string
+   *
+   * @param input String to trim
+   * @return Trimmed string
+   *
+   * TODO: Remove static declaration after deprecations are removed
+   */
+  static std::string trim(const std::string& input);
+
+  /**
+   * Concatenate an array/vector into a string
+   *
+   * @param elements Array/Vector elements to concatenate
+   * @param delimiter Character to use between elements (default: <space>)
+   * @return A string representation of all the array/vector elements
+   */
+  std::string implode(const std::vector<std::string>& elements, const char delimiter = ' ');
+
+  /**
+   * Split a string into an array/vector
+   *
+   * @param input String to convert to array/vector
+   * @param delimiter Character to use split into elements (default: <space>)
+   * @return An array/vector representation of the string
+   *
+   * TODO: Remove static declaration after deprecations are removed
+   */
+  static std::vector<std::string> explode(const std::string& input, const char delimiter = ' ');
+
+  /**
+   * Cross platform millisecond granularity sleep
+   *
+   * @param milliseconds Time in milliseconds to sleep
+   */
+  void msleep(unsigned int milliseconds);
+};
+} // namespace CCM
 
 #endif // __CCM_BRIDGE_HPP__
diff --git a/test/ccm_bridge/src/bridge_exception.hpp b/test/ccm_bridge/src/bridge_exception.hpp
index 2d1df3334..79831773a 100644
--- a/test/ccm_bridge/src/bridge_exception.hpp
+++ b/test/ccm_bridge/src/bridge_exception.hpp
@@ -22,45 +22,47 @@
 
 namespace CCM {
 
+/**
+ * Exception mechanism for the CCM bridge class
+ */
+class BridgeException : public std::exception {
+public:
+#ifdef _WIN32
   /**
-   * Exception mechanism for the CCM bridge class
+   * CCM bridge exception class
+   *
+   * @param message BridgeException message
    */
-  class BridgeException : public std::exception {
-  public:
-#ifdef _WIN32
-    /**
-     * CCM bridge exception class
-     *
-     * @param message BridgeException message
-     */
-    BridgeException(const std::string &message) : std::exception(message.c_str()) {}
+  BridgeException(const std::string& message)
+      : std::exception(message.c_str()) {}
 #else
-    /**
-     * CCM bridge exception class
-     *
-     * @param message Exception message
-     */
-    BridgeException(const std::string& message) : message_(message) {}
-    /**
-     * Destructor
-     */
-    ~BridgeException() throw() {}
+  /**
+   * CCM bridge exception class
+   *
+   * @param message Exception message
+   */
+  BridgeException(const std::string& message)
+      : message_(message) {}
+  /**
+   * Destructor
+   */
+  ~BridgeException() throw() {}
 
-    /**
-     * Get the exception message
-     *
-     * @return Exception message
-     */
-    const char* what() const throw() { return message_.c_str(); }
+  /**
+   * Get the exception message
+   *
+   * @return Exception message
+   */
+  const char* what() const throw() { return message_.c_str(); }
 
-  private:
-    /**
-     * Message to display for exception
-     */
-    std::string message_;
+private:
+  /**
+   * Message to display for exception
+   */
+  std::string message_;
 #endif
-  };
+};
 
-}
+} // namespace CCM
 
 #endif // __CCM_BRIDGE_EXCEPTION_HPP__
diff --git a/test/ccm_bridge/src/cass_version.hpp b/test/ccm_bridge/src/cass_version.hpp
index ecd94d4cc..c3f93eb55 100644
--- a/test/ccm_bridge/src/cass_version.hpp
+++ b/test/ccm_bridge/src/cass_version.hpp
@@ -24,498 +24,477 @@
 
 namespace CCM {
 
+/**
+ * Cassandra release version number
+ */
+class CassVersion {
+public:
   /**
-   * Cassandra release version number
+   * Major portion of version number
    */
-  class CassVersion {
-  public:
-    /**
-     * Major portion of version number
-     */
-    unsigned short major_version;
-    /**
-     * Minor portion of version number
-     */
-    unsigned short minor_version;
-    /**
-     * Patch portion of version number
-     */
-    unsigned short patch_version;
-    /**
-     * Extra portion of version number
-     */
-    std::string extra;
-
-    /**
-     * Create the CassVersion from a human readable string
-     *
-     * @param version_string String representation to convert
-     */
-    CassVersion(const std::string& version_string)
+  unsigned short major_version;
+  /**
+   * Minor portion of version number
+   */
+  unsigned short minor_version;
+  /**
+   * Patch portion of version number
+   */
+  unsigned short patch_version;
+  /**
+   * Extra portion of version number
+   */
+  std::string extra;
+
+  /**
+   * Create the CassVersion from a human readable string
+   *
+   * @param version_string String representation to convert
+   */
+  CassVersion(const std::string& version_string)
       : major_version(0)
       , minor_version(0)
       , patch_version(0)
       , extra("") {
-      from_string(version_string);
-    }
+    from_string(version_string);
+  }
 
-    /**
-     * Compare Cassandra version
-     *
-     * @param rhs Cassandra version for compare
-     * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
-     */
-    int compare(const CassVersion& rhs) {
-      if (major_version < rhs.major_version) return -1;
-      if (major_version > rhs.major_version) return  1;
+  /**
+   * Compare Cassandra version
+   *
+   * @param rhs Cassandra version for compare
+   * @return -1 if LHS < RHS, 1 if LHS > RHS, and 0 if equal
+   */
+  int compare(const CassVersion& rhs) {
+    if (major_version < rhs.major_version) return -1;
+    if (major_version > rhs.major_version) return 1;
 
-      if (minor_version < rhs.minor_version) return -1;
-      if (minor_version > rhs.minor_version) return  1;
+    if (minor_version < rhs.minor_version) return -1;
+    if (minor_version > rhs.minor_version) return 1;
 
-      if (patch_version < rhs.patch_version) return -1;
-      if (patch_version > rhs.patch_version) return  1;
+    if (patch_version < rhs.patch_version) return -1;
+    if (patch_version > rhs.patch_version) return 1;
 
-      return 0;
-    }
+    return 0;
+  }
 
-    /**
-     * Equal comparison operator overload
-     *
-     * Determine if a Cassandra version is equal to another Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra version for compare
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator ==(const CassVersion& rhs) {
-      return compare(rhs) == 0;
-    }
+  /**
+   * Equal comparison operator overload
+   *
+   * Determine if a Cassandra version is equal to another Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra version for compare
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const CassVersion& rhs) { return compare(rhs) == 0; }
 
-    /**
-     * Equal comparison operator overload
-     *
-     * Determine if a Cassandra version is equal to another Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator ==(const std::string& version) {
-      // Check version properties for equality (except extra property)
-      return compare(CassVersion(version)) == 0;
-    }
+  /**
+   * Equal comparison operator overload
+   *
+   * Determine if a Cassandra version is equal to another Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const std::string& version) {
+    // Check version properties for equality (except extra property)
+    return compare(CassVersion(version)) == 0;
+  }
 
-    /**
-     * Not equal comparison operator overload
-     *
-     * Determine if a Cassandra version is not equal to another Cassandra
-     * version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra version for compare
-     * @return True if LHS != RHS; false otherwise
-     */
-    bool operator !=(const CassVersion& rhs) {
-      return compare(rhs) != 0;
-    }
+  /**
+   * Not equal comparison operator overload
+   *
+   * Determine if a Cassandra version is not equal to another Cassandra
+   * version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra version for compare
+   * @return True if LHS != RHS; false otherwise
+   */
+  bool operator!=(const CassVersion& rhs) { return compare(rhs) != 0; }
 
-    /**
-     * Not equal comparison operator overload
-     *
-     * Determine if a Cassandra version is not equal to another Cassandra
-     * version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS != RHS; false otherwise
-     */
-    bool operator !=(const std::string& version) {
-      return compare(CassVersion(version)) != 0;
-    }
+  /**
+   * Not equal comparison operator overload
+   *
+   * Determine if a Cassandra version is not equal to another Cassandra
+   * version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS != RHS; false otherwise
+   */
+  bool operator!=(const std::string& version) { return compare(CassVersion(version)) != 0; }
 
-    /**
-     * Less-than comparison operator overload
-     *
-     * Determine if a Cassandra version is less-than another Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra Version to compare
-     * @return True if LHS < RHS; false otherwise
-     */
-    bool operator <(const CassVersion& rhs) {
-      return compare(rhs) < 0;
-    }
+  /**
+   * Less-than comparison operator overload
+   *
+   * Determine if a Cassandra version is less-than another Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra Version to compare
+   * @return True if LHS < RHS; false otherwise
+   */
+  bool operator<(const CassVersion& rhs) { return compare(rhs) < 0; }
 
-    /**
-     * Less-than comparison operator overload
-     *
-     * Determine if a Cassandra version is less-than another Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS < RHS; false otherwise
-     */
-    bool operator <(const std::string& version) {
-      return compare(CassVersion(version)) < 0;
-    }
+  /**
+   * Less-than comparison operator overload
+   *
+   * Determine if a Cassandra version is less-than another Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS < RHS; false otherwise
+   */
+  bool operator<(const std::string& version) { return compare(CassVersion(version)) < 0; }
 
-    /**
-     * Greater-than comparison operator overload
-     *
-     * Determine if a Cassandra version is greater-than another Cassandra
-     * version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra Version to compare
-     * @return True if LHS > RHS; false otherwise
-     */
-    bool operator >(const CassVersion& rhs) {
-      return compare(rhs) > 0;
-    }
+  /**
+   * Greater-than comparison operator overload
+   *
+   * Determine if a Cassandra version is greater-than another Cassandra
+   * version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra Version to compare
+   * @return True if LHS > RHS; false otherwise
+   */
+  bool operator>(const CassVersion& rhs) { return compare(rhs) > 0; }
 
-    /**
-     * Greater-than comparison operator overload
-     *
-     * Determine if a Cassandra version is greater-than another Cassandra
-     * version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS > RHS; false otherwise
-     */
-    bool operator >(const std::string& version) {
-      return compare(CassVersion(version)) > 0;
-    }
+  /**
+   * Greater-than comparison operator overload
+   *
+   * Determine if a Cassandra version is greater-than another Cassandra
+   * version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS > RHS; false otherwise
+   */
+  bool operator>(const std::string& version) { return compare(CassVersion(version)) > 0; }
 
-    /**
-     * Less-than or equal to comparison operator overload
-     *
-     * Determine if a Cassandra version is less-than or equal to another
-     * Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra Version to compare
-     * @return True if LHS <= RHS; false otherwise
-     */
-    bool operator <=(const CassVersion& rhs) {
-      return compare(rhs) <= 0;
-    }
+  /**
+   * Less-than or equal to comparison operator overload
+   *
+   * Determine if a Cassandra version is less-than or equal to another
+   * Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra Version to compare
+   * @return True if LHS <= RHS; false otherwise
+   */
+  bool operator<=(const CassVersion& rhs) { return compare(rhs) <= 0; }
 
-    /**
-     * Less-than or equal to comparison operator overload
-     *
-     * Determine if a Cassandra version is less-than or equal to another
-     * Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS <= RHS; false otherwise
-     */
-    bool operator <=(const std::string& version) {
-      return compare(CassVersion(version)) <= 0;
-    }
+  /**
+   * Less-than or equal to comparison operator overload
+   *
+   * Determine if a Cassandra version is less-than or equal to another
+   * Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS <= RHS; false otherwise
+   */
+  bool operator<=(const std::string& version) { return compare(CassVersion(version)) <= 0; }
 
-    /**
-     * Greater-than or equal to comparison operator overload
-     *
-     * Determine if a Cassandra version is greater-than or equal to another
-     * Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param rhs Cassandra Version to compare
-     * @return True if LHS >= RHS; false otherwise
-     */
-    bool operator >=(const CassVersion& rhs) {
-      return compare(rhs) >= 0;
-    }
+  /**
+   * Greater-than or equal to comparison operator overload
+   *
+   * Determine if a Cassandra version is greater-than or equal to another
+   * Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param rhs Cassandra Version to compare
+   * @return True if LHS >= RHS; false otherwise
+   */
+  bool operator>=(const CassVersion& rhs) { return compare(rhs) >= 0; }
 
-    /**
-     * Greater-than or equal to comparison operator overload
-     *
-     * Determine if a Cassandra version is greater-than or equal to another
-     * Cassandra version
-     *
-     * NOTE: Extra property is not involved in comparison
-     *
-     * @param version Cassandra string version for compare
-     * @return True if LHS >= RHS; false otherwise
-     */
-    bool operator >=(const std::string& version) {
-      return compare(CassVersion(version)) >= 0;
-    }
+  /**
+   * Greater-than or equal to comparison operator overload
+   *
+   * Determine if a Cassandra version is greater-than or equal to another
+   * Cassandra version
+   *
+   * NOTE: Extra property is not involved in comparison
+   *
+   * @param version Cassandra string version for compare
+   * @return True if LHS >= RHS; false otherwise
+   */
+  bool operator>=(const std::string& version) { return compare(CassVersion(version)) >= 0; }
 
-    /**
-     * Convert the version into a human readable string
-     *
-     * @param is_extra_requested True if extra field should be added to version
-     *                           string (iff !empty); false to disregard extra
-     *                           field (default: true)
-     */
-    virtual std::string to_string(bool is_extra_requested = true) {
-      std::stringstream version_string;
-      // Determine if tick-tock release should be handled
-      if (*this > "3.0.0" && *this < "3.11.0" &&
-          patch_version == 0 && extra.empty()) {
-        version_string << major_version << "." << minor_version;
-      } else {
-        version_string << major_version << "." << minor_version << "." << patch_version;
-      }
+  /**
+   * Convert the version into a human readable string
+   *
+   * @param is_extra_requested True if extra field should be added to version
+   *                           string (iff !empty); false to disregard extra
+   *                           field (default: true)
+   */
+  virtual std::string to_string(bool is_extra_requested = true) {
+    std::stringstream version_string;
+    // Determine if tick-tock release should be handled
+    if (*this > "3.0.0" && *this < "3.11.0" && patch_version == 0 && extra.empty()) {
+      version_string << major_version << "." << minor_version;
+    } else {
+      version_string << major_version << "." << minor_version << "." << patch_version;
+    }
 
-      // Determine if the extra version information should be added
-      if (is_extra_requested && !extra.empty()) {
-        version_string << "-" << extra;
-      }
-      return version_string.str();
+    // Determine if the extra version information should be added
+    if (is_extra_requested && !extra.empty()) {
+      version_string << "-" << extra;
     }
+    return version_string.str();
+  }
 
-  private:
-    /**
-     * Convert the version from human readable string to version parameters
-     *
-     * @param version_string String representation to convert
-     */
-    void from_string(const std::string& version_string) {
-      // Clean up the string for tokens
-      std::string version(version_string);
-      std::replace(version.begin(), version.end(), '.', ' ');
-      std::size_t found = version.find("-");
-      if (found != std::string::npos) {
-        version.replace(found, 1, " ");
-      }
+private:
+  /**
+   * Convert the version from human readable string to version parameters
+   *
+   * @param version_string String representation to convert
+   */
+  void from_string(const std::string& version_string) {
+    // Clean up the string for tokens
+    std::string version(version_string);
+    std::replace(version.begin(), version.end(), '.', ' ');
+    std::size_t found = version.find("-");
+    if (found != std::string::npos) {
+      version.replace(found, 1, " ");
+    }
 
-      // Convert to tokens and assign version parameters
-      std::istringstream tokens(version);
-      if (tokens >> major_version) {
-        if (tokens >> minor_version) {
-          if (tokens >> patch_version) {
-            tokens >> extra;
-          }
+    // Convert to tokens and assign version parameters
+    std::istringstream tokens(version);
+    if (tokens >> major_version) {
+      if (tokens >> minor_version) {
+        if (tokens >> patch_version) {
+          tokens >> extra;
         }
       }
     }
-  };
-
-  class DseVersion : public CassVersion {
-  public:
-    /**
-     * Create the DseVersion from the CassVersion parent type
-     *
-     * @param version CassVersion to convert to DseVersion type
-     */
-    DseVersion(CassVersion version)
+  }
+};
+
+class DseVersion : public CassVersion {
+public:
+  /**
+   * Create the DseVersion from the CassVersion parent type
+   *
+   * @param version CassVersion to convert to DseVersion type
+   */
+  DseVersion(CassVersion version)
       : CassVersion(version) {}
 
-    /**
-     * Create the CassVersion from a human readable string
-     *
-     * @param version_string String representation to convert
-     */
-    DseVersion(const std::string& version_string)
+  /**
+   * Create the CassVersion from a human readable string
+   *
+   * @param version_string String representation to convert
+   */
+  DseVersion(const std::string& version_string)
       : CassVersion(version_string) {}
 
-    /**
-     * Convert the version into a human readable string
-     *
-     * @param is_extra_requested True if extra field should be added to version
-     *                           string (iff !empty); false to disregard extra
-     *                           field (default: true)
-     */
-    std::string to_string(bool is_extra_requested = true) {
-      std::stringstream version_string;
-      version_string << major_version << "." << minor_version << "." << patch_version;
+  /**
+   * Convert the version into a human readable string
+   *
+   * @param is_extra_requested True if extra field should be added to version
+   *                           string (iff !empty); false to disregard extra
+   *                           field (default: true)
+   */
+  std::string to_string(bool is_extra_requested = true) {
+    std::stringstream version_string;
+    version_string << major_version << "." << minor_version << "." << patch_version;
 
-      // Determine if the extra version information should be added
-      if (is_extra_requested && !extra.empty()) {
-        version_string << "-" << extra;
-      }
-      return version_string.str();
+    // Determine if the extra version information should be added
+    if (is_extra_requested && !extra.empty()) {
+      version_string << "-" << extra;
     }
-
-    CassVersion get_cass_version() {
-      // Map the DSE version to the appropriate Cassandra version
-      if (*this == "4.5.0" || *this == "4.5.1") {
-        return CassVersion("2.0.8-39");
-      } else if (*this == "4.5.2") {
-        return CassVersion("2.0.10-71");
-      } else if (*this == "4.5.3") {
-        return CassVersion("2.0.11-82");
-      } else if (*this == "4.5.4") {
-        return CassVersion("2.0.11-92");
-      } else if (*this == "4.5.5") {
-        return CassVersion("2.0.12-156");
-      } else if (*this == "4.5.6") {
-        return CassVersion("2.0.12-200");
-      } else if (*this == "4.5.7") {
-        return CassVersion("2.0.12-201");
-      } else if (*this == "4.5.8") {
-        return CassVersion("2.0.14-352");
-      } else if (*this == "4.5.9") {
-        return CassVersion("2.0.16-762");
-      } else if (*this == "4.6.0") {
-        return CassVersion("2.0.11-83");
-      } else if (*this == "4.6.1") {
-        return CassVersion("2.0.12-200");
-      } else if (*this == "4.6.2") {
-        return CassVersion("2.0.12-274");
-      } else if (*this == "4.6.3") {
-        return CassVersion("2.0.12-275");
-      } else if (*this == "4.6.4") {
-        return CassVersion("2.0.14-348");
-      } else if (*this == "4.6.5") {
-        return CassVersion("2.0.14-352");
-      } else if (*this == "4.6.6") {
-        return CassVersion("2.0.14-425");
-      } else if (*this == "4.6.7") {
-        return CassVersion("2.0.14-459");
-      } else if (*this == "4.6.8" || *this == "4.6.9") {
-        return CassVersion("2.0.16-678");
-      } else if (*this == "4.6.10") {
-        return CassVersion("2.0.16-762");
-      } else if (*this == "4.6.11") {
-        return CassVersion("2.0.17-858");
-      } else if (*this == "4.6.12") {
-        return CassVersion("2.0.17-903");
-      } else if (*this == "4.6.13") {
-        return CassVersion("2.0.17-1420");
-      } else if (*this == "4.7.0") {
-        return CassVersion("2.1.5-469");
-      } else if (*this == "4.7.1" || *this == "4.7.2") {
-        return CassVersion("2.1.8-621");
-      } else if (*this == "4.7.3") {
-        return CassVersion("2.1.8-689");
-      } else if (*this == "4.7.4") {
-        return CassVersion("2.1.11-872");
-      } else if (*this == "4.7.5") {
-        return CassVersion("2.1.11-908");
-      } else if (*this == "4.7.6") {
-        return CassVersion("2.1.11-969");
-      } else if (*this == "4.7.7") {
-        return CassVersion("2.1.12-1049");
-      } else if (*this == "4.7.8") {
-        return CassVersion("2.1.13-1218");
-      }  else if (*this == "4.7.9") {
-        return CassVersion("2.1.15-1416");
-      } else if (*this == "4.8.0") {
-        return CassVersion("2.1.9-791");
-      } else if (*this == "4.8.1") {
-        return CassVersion("2.1.11-872");
-      } else if (*this == "4.8.2") {
-        return CassVersion("2.1.11-908");
-      } else if (*this == "4.8.3") {
-        return CassVersion("2.1.11-969");
-      } else if (*this == "4.8.4") {
-        return CassVersion("2.1.12-1046");
-      } else if (*this == "4.8.5") {
-        return CassVersion("2.1.13-1131");
-      } else if (*this == "4.8.6") {
-        return CassVersion("2.1.13-1218");
-      } else if (*this == "4.8.7") {
-        return CassVersion("2.1.14-1272");
-      } else if (*this == "4.8.8") {
-        return CassVersion("2.1.14-1346");
-      } else if (*this == "4.8.9") {
-        return CassVersion("2.1.15-1403");
-      } else if (*this == "4.8.10") {
-        return CassVersion("2.1.15-1423");
-      } else if (*this == "4.8.11") {
-        return CassVersion("2.1.17-1428");
-      } else if (*this == "4.8.12") {
-        return CassVersion("2.1.17-1439");
-      } else if (*this == "4.8.13") {
-        return CassVersion("2.1.17-1448");
-      } else if (*this == "4.8.14" || *this == "4.8.15") {
-        return CassVersion("2.1.18-1463");
-      } else if (*this >= "4.8.16" && *this < "5.0.0") {
-        if (*this > "4.8.16") {
-          std::cerr << "Cassandra Version is not Defined: "
-            << "Add Cassandra version for DSE v" << this->to_string()
-            << std::endl;
-        }
-        return CassVersion("2.1.19-1484");
-      } else if (*this == "5.0.0") {
-        return CassVersion("3.0.7.1158");
-      } else if (*this == "5.0.1") {
-        return CassVersion("3.0.7.1159");
-      } else if (*this == "5.0.2") {
-        return CassVersion("3.0.8-1293");
-      } else if (*this == "5.0.3") {
-        return CassVersion("3.0.9-1346");
-      } else if (*this == "5.0.4") {
-        return CassVersion("3.0.10-1443");
-      } else if (*this == "5.0.5") {
-        return CassVersion("3.0.11-1485");
-      } else if (*this == "5.0.6") {
-        return CassVersion("3.0.11-1564");
-      } else if (*this == "5.0.7") {
-        return CassVersion("3.0.12-1586");
-      } else if (*this == "5.0.8") {
-        return CassVersion("3.0.12-1656");
-      } else if (*this == "5.0.9") {
-        return CassVersion("3.0.13-1735");
-      } else if (*this == "5.0.10" || *this == "5.0.11") {
-        return CassVersion("3.0.14-1862");
-      } else if (*this == "5.0.12" || *this == "5.0.13") {
-        return CassVersion("3.0.15-2128");
-      } else if (*this == "5.0.14") {
-        return CassVersion("3.0.15-2269");
-      } else if (*this >= "5.0.15" && *this < "5.1.0") {
-        if (*this > "5.0.15") {
-          std::cerr << "Cassandra Version is not Defined: "
-            << "Add Cassandra version for DSE v" << this->to_string()
-            << std::endl;
-        }
-        return CassVersion("3.0.16-5015");
-      } else if (*this == "5.1.0") {
-        return CassVersion("3.10.0-1652");
-      } else if (*this == "5.1.1") {
-        return CassVersion("3.10.0-1695");
-      } else if (*this == "5.1.2") {
-        return CassVersion("3.11.0-1758");
-      } else if (*this == "5.1.3") {
-        return CassVersion("3.11.0-1855");
-      } else if (*this == "5.1.4" || *this == "5.1.5") {
-        return CassVersion("3.11.0-1900");
-      } else if (*this == "5.1.6") {
-        return CassVersion("3.11.1-2070");
-      } else if (*this == "5.1.7") {
-        return CassVersion("3.11.1-2130");
-      } else if (*this == "5.1.8" || *this == "5.1.9") {
-        return CassVersion("3.11.1-2261");
-      } else if (*this == "5.1.10") {
-        return CassVersion("3.11.1-2323");
-      } else if (*this == "5.1.11") {
-        return CassVersion("3.11.2-5111");
-      } else if (*this == "5.1.12") {
-        return CassVersion("3.11.2-5112");
-      } else if (*this >= "5.1.13" && *this < "6.0.0") {
-        if (*this > "5.1.13") {
-          std::cerr << "Cassandra Version is not Defined: "
-            << "Add Cassandra version for DSE v" << this->to_string()
-            << std::endl;
-        }
-        return CassVersion("3.11.2-5113");
-      } else if (*this >= "6.0.0" && *this < "6.7.0") {
-        return CassVersion("3.11.2-5111"); // Versions before DSE 6.7 erroneously return they support Cassandra 4.0.0
-      } else if (*this >= "6.7.0" && *this < "7.0.0") {
-        return CassVersion("4.0.0");
+    return version_string.str();
+  }
+
+  CassVersion get_cass_version() {
+    // Map the DSE version to the appropriate Cassandra version
+    if (*this == "4.5.0" || *this == "4.5.1") {
+      return CassVersion("2.0.8-39");
+    } else if (*this == "4.5.2") {
+      return CassVersion("2.0.10-71");
+    } else if (*this == "4.5.3") {
+      return CassVersion("2.0.11-82");
+    } else if (*this == "4.5.4") {
+      return CassVersion("2.0.11-92");
+    } else if (*this == "4.5.5") {
+      return CassVersion("2.0.12-156");
+    } else if (*this == "4.5.6") {
+      return CassVersion("2.0.12-200");
+    } else if (*this == "4.5.7") {
+      return CassVersion("2.0.12-201");
+    } else if (*this == "4.5.8") {
+      return CassVersion("2.0.14-352");
+    } else if (*this == "4.5.9") {
+      return CassVersion("2.0.16-762");
+    } else if (*this == "4.6.0") {
+      return CassVersion("2.0.11-83");
+    } else if (*this == "4.6.1") {
+      return CassVersion("2.0.12-200");
+    } else if (*this == "4.6.2") {
+      return CassVersion("2.0.12-274");
+    } else if (*this == "4.6.3") {
+      return CassVersion("2.0.12-275");
+    } else if (*this == "4.6.4") {
+      return CassVersion("2.0.14-348");
+    } else if (*this == "4.6.5") {
+      return CassVersion("2.0.14-352");
+    } else if (*this == "4.6.6") {
+      return CassVersion("2.0.14-425");
+    } else if (*this == "4.6.7") {
+      return CassVersion("2.0.14-459");
+    } else if (*this == "4.6.8" || *this == "4.6.9") {
+      return CassVersion("2.0.16-678");
+    } else if (*this == "4.6.10") {
+      return CassVersion("2.0.16-762");
+    } else if (*this == "4.6.11") {
+      return CassVersion("2.0.17-858");
+    } else if (*this == "4.6.12") {
+      return CassVersion("2.0.17-903");
+    } else if (*this == "4.6.13") {
+      return CassVersion("2.0.17-1420");
+    } else if (*this == "4.7.0") {
+      return CassVersion("2.1.5-469");
+    } else if (*this == "4.7.1" || *this == "4.7.2") {
+      return CassVersion("2.1.8-621");
+    } else if (*this == "4.7.3") {
+      return CassVersion("2.1.8-689");
+    } else if (*this == "4.7.4") {
+      return CassVersion("2.1.11-872");
+    } else if (*this == "4.7.5") {
+      return CassVersion("2.1.11-908");
+    } else if (*this == "4.7.6") {
+      return CassVersion("2.1.11-969");
+    } else if (*this == "4.7.7") {
+      return CassVersion("2.1.12-1049");
+    } else if (*this == "4.7.8") {
+      return CassVersion("2.1.13-1218");
+    } else if (*this == "4.7.9") {
+      return CassVersion("2.1.15-1416");
+    } else if (*this == "4.8.0") {
+      return CassVersion("2.1.9-791");
+    } else if (*this == "4.8.1") {
+      return CassVersion("2.1.11-872");
+    } else if (*this == "4.8.2") {
+      return CassVersion("2.1.11-908");
+    } else if (*this == "4.8.3") {
+      return CassVersion("2.1.11-969");
+    } else if (*this == "4.8.4") {
+      return CassVersion("2.1.12-1046");
+    } else if (*this == "4.8.5") {
+      return CassVersion("2.1.13-1131");
+    } else if (*this == "4.8.6") {
+      return CassVersion("2.1.13-1218");
+    } else if (*this == "4.8.7") {
+      return CassVersion("2.1.14-1272");
+    } else if (*this == "4.8.8") {
+      return CassVersion("2.1.14-1346");
+    } else if (*this == "4.8.9") {
+      return CassVersion("2.1.15-1403");
+    } else if (*this == "4.8.10") {
+      return CassVersion("2.1.15-1423");
+    } else if (*this == "4.8.11") {
+      return CassVersion("2.1.17-1428");
+    } else if (*this == "4.8.12") {
+      return CassVersion("2.1.17-1439");
+    } else if (*this == "4.8.13") {
+      return CassVersion("2.1.17-1448");
+    } else if (*this == "4.8.14" || *this == "4.8.15") {
+      return CassVersion("2.1.18-1463");
+    } else if (*this >= "4.8.16" && *this < "5.0.0") {
+      if (*this > "4.8.16") {
+        std::cerr << "Cassandra Version is not Defined: "
+                  << "Add Cassandra version for DSE v" << this->to_string() << std::endl;
       }
-
-      // DSE version does not correspond to a valid Cassandra version
-      return CassVersion("0.0.0");
+      return CassVersion("2.1.19-1484");
+    } else if (*this == "5.0.0") {
+      return CassVersion("3.0.7.1158");
+    } else if (*this == "5.0.1") {
+      return CassVersion("3.0.7.1159");
+    } else if (*this == "5.0.2") {
+      return CassVersion("3.0.8-1293");
+    } else if (*this == "5.0.3") {
+      return CassVersion("3.0.9-1346");
+    } else if (*this == "5.0.4") {
+      return CassVersion("3.0.10-1443");
+    } else if (*this == "5.0.5") {
+      return CassVersion("3.0.11-1485");
+    } else if (*this == "5.0.6") {
+      return CassVersion("3.0.11-1564");
+    } else if (*this == "5.0.7") {
+      return CassVersion("3.0.12-1586");
+    } else if (*this == "5.0.8") {
+      return CassVersion("3.0.12-1656");
+    } else if (*this == "5.0.9") {
+      return CassVersion("3.0.13-1735");
+    } else if (*this == "5.0.10" || *this == "5.0.11") {
+      return CassVersion("3.0.14-1862");
+    } else if (*this == "5.0.12" || *this == "5.0.13") {
+      return CassVersion("3.0.15-2128");
+    } else if (*this == "5.0.14") {
+      return CassVersion("3.0.15-2269");
+    } else if (*this >= "5.0.15" && *this < "5.1.0") {
+      if (*this > "5.0.15") {
+        std::cerr << "Cassandra Version is not Defined: "
+                  << "Add Cassandra version for DSE v" << this->to_string() << std::endl;
+      }
+      return CassVersion("3.0.16-5015");
+    } else if (*this == "5.1.0") {
+      return CassVersion("3.10.0-1652");
+    } else if (*this == "5.1.1") {
+      return CassVersion("3.10.0-1695");
+    } else if (*this == "5.1.2") {
+      return CassVersion("3.11.0-1758");
+    } else if (*this == "5.1.3") {
+      return CassVersion("3.11.0-1855");
+    } else if (*this == "5.1.4" || *this == "5.1.5") {
+      return CassVersion("3.11.0-1900");
+    } else if (*this == "5.1.6") {
+      return CassVersion("3.11.1-2070");
+    } else if (*this == "5.1.7") {
+      return CassVersion("3.11.1-2130");
+    } else if (*this == "5.1.8" || *this == "5.1.9") {
+      return CassVersion("3.11.1-2261");
+    } else if (*this == "5.1.10") {
+      return CassVersion("3.11.1-2323");
+    } else if (*this == "5.1.11") {
+      return CassVersion("3.11.2-5111");
+    } else if (*this == "5.1.12") {
+      return CassVersion("3.11.3-5112");
+    } else if (*this == "5.1.13") {
+      return CassVersion("3.11.3-5113");
+    } else if (*this == "5.1.14") {
+      return CassVersion("3.11.3-5114");
+    } else if (*this >= "5.1.15" && *this < "6.0.0") {
+      if (*this > "5.1.15") {
+        std::cerr << "Cassandra Version is not Defined: "
+                  << "Add Cassandra version for DSE v" << this->to_string() << std::endl;
+      }
+      return CassVersion("3.11.3-5115");
+    } else if (*this >= "6.0.0" && *this < "6.7.0") {
+      return CassVersion(
+          "3.11.2-5111"); // Versions before DSE 6.7 erroneously return they support Cassandra 4.0.0
+    } else if (*this >= "6.7.0" && *this < "7.0.0") {
+      return CassVersion("4.0.0");
     }
-  };
 
-}
+    // DSE version does not correspond to a valid Cassandra version
+    return CassVersion("0.0.0");
+  }
+};
+
+} // namespace CCM
 
 #endif // __CCM_CASS_VERSION_HPP__
diff --git a/test/ccm_bridge/src/deployment_type.cpp b/test/ccm_bridge/src/deployment_type.cpp
index aa34168d5..780934d5f 100644
--- a/test/ccm_bridge/src/deployment_type.cpp
+++ b/test/ccm_bridge/src/deployment_type.cpp
@@ -30,22 +30,15 @@ const DeploymentType DeploymentType::REMOTE("REMOTE", 1, "Remote");
 std::set<DeploymentType> DeploymentType::constants_;
 
 DeploymentType::DeploymentType()
- : name_("INVALID")
- , ordinal_(-1)
- , display_name_("Invalid deployment") {
-}
+    : name_("INVALID")
+    , ordinal_(-1)
+    , display_name_("Invalid deployment") {}
 
-const std::string& DeploymentType::name() const {
-  return name_;
-}
+const std::string& DeploymentType::name() const { return name_; }
 
-short DeploymentType::ordinal() const {
-  return ordinal_;
-}
+short DeploymentType::ordinal() const { return ordinal_; }
 
-const std::string& DeploymentType::to_string() const {
-  return display_name_;
-}
+const std::string& DeploymentType::to_string() const { return display_name_; }
 
 const std::set<DeploymentType>& DeploymentType::get_constants() {
   if (constants_.empty()) {
@@ -58,18 +51,15 @@ const std::set<DeploymentType>& DeploymentType::get_constants() {
   return constants_;
 }
 
-DeploymentType::DeploymentType(const std::string &name, int ordinal, const std::string &display_name)
-  : name_(name)
-  , ordinal_(ordinal)
-  , display_name_(display_name) {}
+DeploymentType::DeploymentType(const std::string& name, int ordinal,
+                               const std::string& display_name)
+    : name_(name)
+    , ordinal_(ordinal)
+    , display_name_(display_name) {}
 
-std::set<DeploymentType>::iterator DeploymentType::end() {
-  return get_constants().end();
-}
+std::set<DeploymentType>::iterator DeploymentType::end() { return get_constants().end(); }
 
-std::set<DeploymentType>::iterator DeploymentType::begin() {
-  return get_constants().begin();
-}
+std::set<DeploymentType>::iterator DeploymentType::begin() { return get_constants().begin(); }
 
 bool DeploymentType::operator<(const DeploymentType& object) const {
   return ordinal_ < object.ordinal_;
diff --git a/test/ccm_bridge/src/deployment_type.hpp b/test/ccm_bridge/src/deployment_type.hpp
index 9f0c479d8..1ee60330e 100644
--- a/test/ccm_bridge/src/deployment_type.hpp
+++ b/test/ccm_bridge/src/deployment_type.hpp
@@ -22,120 +22,120 @@
 
 namespace CCM {
 
+/**
+ * Deployment type indicating how CCM commands should be executed
+ */
+class DeploymentType {
+public:
   /**
-   * Deployment type indicating how CCM commands should be executed
+   * Iterator for deployment type constants
    */
-  class DeploymentType {
-  public:
-    /**
-     * Iterator for deployment type constants
-     */
-    typedef std::set<DeploymentType>::iterator iterator;
+  typedef std::set<DeploymentType>::iterator iterator;
 
-    /**
-     * Local deployment type; commands are executed through local process
-     */
-    static const DeploymentType LOCAL;
+  /**
+   * Local deployment type; commands are executed through local process
+   */
+  static const DeploymentType LOCAL;
 #ifdef CASS_USE_LIBSSH2
-    /**
-     * Remote deployment type; commands are executed though libssh2
-     */
-    static const DeploymentType REMOTE;
+  /**
+   * Remote deployment type; commands are executed though libssh2
+   */
+  static const DeploymentType REMOTE;
 #endif
 
-    /**
-     * Name of constant
-     *
-     * @return Name of constant
-     */
-    const std::string& name() const;
-    /**
-     * Ordinal of constant
-     *
-     * @return Ordinal of constant
-     */
-    short ordinal() const;
-    /**
-     * Get the display name
-     *
-     * @return Display name of deployment type
-     */
-    const std::string& to_string() const;
-
-    /**
-     * Less than (can be used for sorting)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS < RHS; false otherwise
-     */
-    bool operator<(const DeploymentType& object) const;
-    /**
-     * Equal to
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const DeploymentType& object) const;
-    /**
-     * Equal to (case-incentive string comparison)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const std::string& object) const;
-
-    /**
-     * First item in the deployment constants
-     *
-     * @return Iterator pointing to the first element in the set
-     */
-    static std::set<DeploymentType>::iterator begin();
-    /**
-     * Last item in the deployment constants
-     *
-     * @return Iterator pointing to the last element in the set
-     */
-    static std::set<DeploymentType>::iterator end();
-
-    /**
-     * Default constructor to handle issues with static initialization of
-     * constant deployment types
-     */
-    DeploymentType();
-
-  private:
-    /**
-     * Deployment type constants
-     */
-    static std::set<DeploymentType> constants_;
-    /**
-     * Name of constant
-     */
-    std::string name_;
-    /**
-     * Ordinal of constant
-     */
-    short ordinal_;
-    /**
-     * Display name for constant
-     */
-    std::string display_name_;
-
-    /**
-     * Constructor
-     *
-     * @param name Name for deployment type
-     * @param display_name Display name for deployment type
-     */
-    DeploymentType(const std::string &name, int ordinal, const std::string &display_name);
-    /**
-     * Get the deployment type constants
-     *
-     * @return List of deployment type constants
-     */
-    static const std::set<DeploymentType>& get_constants();
-  };
-
-}
+  /**
+   * Name of constant
+   *
+   * @return Name of constant
+   */
+  const std::string& name() const;
+  /**
+   * Ordinal of constant
+   *
+   * @return Ordinal of constant
+   */
+  short ordinal() const;
+  /**
+   * Get the display name
+   *
+   * @return Display name of deployment type
+   */
+  const std::string& to_string() const;
+
+  /**
+   * Less than (can be used for sorting)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS < RHS; false otherwise
+   */
+  bool operator<(const DeploymentType& object) const;
+  /**
+   * Equal to
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const DeploymentType& object) const;
+  /**
+   * Equal to (case-incentive string comparison)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const std::string& object) const;
+
+  /**
+   * First item in the deployment constants
+   *
+   * @return Iterator pointing to the first element in the set
+   */
+  static std::set<DeploymentType>::iterator begin();
+  /**
+   * Last item in the deployment constants
+   *
+   * @return Iterator pointing to the last element in the set
+   */
+  static std::set<DeploymentType>::iterator end();
+
+  /**
+   * Default constructor to handle issues with static initialization of
+   * constant deployment types
+   */
+  DeploymentType();
+
+private:
+  /**
+   * Deployment type constants
+   */
+  static std::set<DeploymentType> constants_;
+  /**
+   * Name of constant
+   */
+  std::string name_;
+  /**
+   * Ordinal of constant
+   */
+  short ordinal_;
+  /**
+   * Display name for constant
+   */
+  std::string display_name_;
+
+  /**
+   * Constructor
+   *
+   * @param name Name for deployment type
+   * @param display_name Display name for deployment type
+   */
+  DeploymentType(const std::string& name, int ordinal, const std::string& display_name);
+  /**
+   * Get the deployment type constants
+   *
+   * @return List of deployment type constants
+   */
+  static const std::set<DeploymentType>& get_constants();
+};
+
+} // namespace CCM
 
 #endif // __CCM_DEPLOYMENT_TYPE_HPP__
diff --git a/test/ccm_bridge/src/dse_credentials_type.cpp b/test/ccm_bridge/src/dse_credentials_type.cpp
index 5ac5793c8..53563e538 100644
--- a/test/ccm_bridge/src/dse_credentials_type.cpp
+++ b/test/ccm_bridge/src/dse_credentials_type.cpp
@@ -21,29 +21,23 @@
 using namespace CCM;
 
 // Constant value definitions for DSE credentials type
-const DseCredentialsType DseCredentialsType::USERNAME_PASSWORD("USERNAME_PASSWORD", 0, "Username and Password");
+const DseCredentialsType DseCredentialsType::USERNAME_PASSWORD("USERNAME_PASSWORD", 0,
+                                                               "Username and Password");
 const DseCredentialsType DseCredentialsType::INI_FILE("INI_FILE", 1, "INI Credentials File");
 
 // Static declarations for DSE credentials type
 std::set<DseCredentialsType> DseCredentialsType::constants_;
 
 DseCredentialsType::DseCredentialsType()
-  : name_("INVALID")
-  , ordinal_(-1)
-  , display_name_("Invalid DSE credentials") {
-}
+    : name_("INVALID")
+    , ordinal_(-1)
+    , display_name_("Invalid DSE credentials") {}
 
-const std::string& DseCredentialsType::name() const {
-  return name_;
-}
+const std::string& DseCredentialsType::name() const { return name_; }
 
-short DseCredentialsType::ordinal() const {
-  return ordinal_;
-}
+short DseCredentialsType::ordinal() const { return ordinal_; }
 
-const std::string& DseCredentialsType::to_string() const {
-  return display_name_;
-}
+const std::string& DseCredentialsType::to_string() const { return display_name_; }
 
 const std::set<DseCredentialsType>& DseCredentialsType::get_constants() {
   if (constants_.empty()) {
@@ -54,14 +48,13 @@ const std::set<DseCredentialsType>& DseCredentialsType::get_constants() {
   return constants_;
 }
 
-DseCredentialsType::DseCredentialsType(const std::string &name, int ordinal, const std::string &display_name)
-  : name_(name)
-  , ordinal_(ordinal)
-  , display_name_(display_name) {}
+DseCredentialsType::DseCredentialsType(const std::string& name, int ordinal,
+                                       const std::string& display_name)
+    : name_(name)
+    , ordinal_(ordinal)
+    , display_name_(display_name) {}
 
-std::set<DseCredentialsType>::iterator DseCredentialsType::end() {
-  return get_constants().end();
-}
+std::set<DseCredentialsType>::iterator DseCredentialsType::end() { return get_constants().end(); }
 
 std::set<DseCredentialsType>::iterator DseCredentialsType::begin() {
   return get_constants().begin();
diff --git a/test/ccm_bridge/src/dse_credentials_type.hpp b/test/ccm_bridge/src/dse_credentials_type.hpp
index b5a96ae7c..e70f20c5b 100644
--- a/test/ccm_bridge/src/dse_credentials_type.hpp
+++ b/test/ccm_bridge/src/dse_credentials_type.hpp
@@ -22,121 +22,121 @@
 
 namespace CCM {
 
+/**
+ * DSE credential stype indicating how authentication for DSE downloads is
+ * performed through CCM
+ */
+class DseCredentialsType {
+public:
   /**
-   * DSE credential stype indicating how authentication for DSE downloads is
-   * performed through CCM
-   */
-  class DseCredentialsType {
-  public:
-    /**
-     * Iterator for DSE credentials type constants
-     */
-    typedef std::set<DseCredentialsType>::iterator iterator;
-
-    /**
-     * Username/Password credentials type; DSE download process is authenticated
-     * via plain text username and password
-     */
-    static const DseCredentialsType USERNAME_PASSWORD;
-    /**
-     * File credentials type; DSE download process is authenticated via the
-     * CCM DSE credentials default file location (e.g. ~/.ccm/.dse.ini)
-     */
-    static const DseCredentialsType INI_FILE;
-
-    /**
-     * Name of constant
-     *
-     * @return Name of constant
-     */
-    const std::string& name() const;
-    /**
-     * Ordinal of constant
-     *
-     * @return Ordinal of constant
-     */
-    short ordinal() const;
-    /**
-     * Get the display name
-     *
-     * @return Display name of DSE credentials type
-     */
-    const std::string& to_string() const;
-
-    /**
-     * Less than (can be used for sorting)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS < RHS; false otherwise
-     */
-    bool operator<(const DseCredentialsType& object) const;
-    /**
-     * Equal to
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const DseCredentialsType& object) const;
-    /**
-     * Equal to (case-incentive string comparison)
-     *
-     * @param object Right hand side comparison object
-     * @return True if LHS == RHS; false otherwise
-     */
-    bool operator==(const std::string& object) const;
-
-    /**
-     * First item in the DSE credentials constants
-     *
-     * @return Iterator pointing to the first element in the set
-     */
-    static std::set<DseCredentialsType>::iterator begin();
-    /**
-     * Last item in the DSE credentials constants
-     *
-     * @return Iterator pointing to the last element in the set
-     */
-    static std::set<DseCredentialsType>::iterator end();
-
-    /**
-     * Default constructor to handle issues with static initialization of
-     * constant DSE credentials types
-     */
-    DseCredentialsType();
-
-  private:
-    /**
-     * DSE credentials type constants
-     */
-    static std::set<DseCredentialsType> constants_;
-    /**
-     * Name of constant
-     */
-    std::string name_;
-    /**
-     * Ordinal of constant
-     */
-    short ordinal_;
-    /**
-     * Display name for constant
-     */
-    std::string display_name_;
-
-    /**
-     * Constructor
-     *
-     * @param name Name for DSE credentials type
-     * @param display_name Display name for DSE credentials type
-     */
-    DseCredentialsType(const std::string& name, int ordinal, const std::string& display_name);
-    /**
-     * Get the DSE credential type constants
-     *
-     * @return List of DSE credentials type constants
-     */
-    static const std::set<DseCredentialsType>& get_constants();
-  };
-
-}
+   * Iterator for DSE credentials type constants
+   */
+  typedef std::set<DseCredentialsType>::iterator iterator;
+
+  /**
+   * Username/Password credentials type; DSE download process is authenticated
+   * via plain text username and password
+   */
+  static const DseCredentialsType USERNAME_PASSWORD;
+  /**
+   * File credentials type; DSE download process is authenticated via the
+   * CCM DSE credentials default file location (e.g. ~/.ccm/.dse.ini)
+   */
+  static const DseCredentialsType INI_FILE;
+
+  /**
+   * Name of constant
+   *
+   * @return Name of constant
+   */
+  const std::string& name() const;
+  /**
+   * Ordinal of constant
+   *
+   * @return Ordinal of constant
+   */
+  short ordinal() const;
+  /**
+   * Get the display name
+   *
+   * @return Display name of DSE credentials type
+   */
+  const std::string& to_string() const;
+
+  /**
+   * Less than (can be used for sorting)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS < RHS; false otherwise
+   */
+  bool operator<(const DseCredentialsType& object) const;
+  /**
+   * Equal to
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const DseCredentialsType& object) const;
+  /**
+   * Equal to (case-incentive string comparison)
+   *
+   * @param object Right hand side comparison object
+   * @return True if LHS == RHS; false otherwise
+   */
+  bool operator==(const std::string& object) const;
+
+  /**
+   * First item in the DSE credentials constants
+   *
+   * @return Iterator pointing to the first element in the set
+   */
+  static std::set<DseCredentialsType>::iterator begin();
+  /**
+   * Last item in the DSE credentials constants
+   *
+   * @return Iterator pointing to the last element in the set
+   */
+  static std::set<DseCredentialsType>::iterator end();
+
+  /**
+   * Default constructor to handle issues with static initialization of
+   * constant DSE credentials types
+   */
+  DseCredentialsType();
+
+private:
+  /**
+   * DSE credentials type constants
+   */
+  static std::set<DseCredentialsType> constants_;
+  /**
+   * Name of constant
+   */
+  std::string name_;
+  /**
+   * Ordinal of constant
+   */
+  short ordinal_;
+  /**
+   * Display name for constant
+   */
+  std::string display_name_;
+
+  /**
+   * Constructor
+   *
+   * @param name Name for DSE credentials type
+   * @param display_name Display name for DSE credentials type
+   */
+  DseCredentialsType(const std::string& name, int ordinal, const std::string& display_name);
+  /**
+   * Get the DSE credential type constants
+   *
+   * @return List of DSE credentials type constants
+   */
+  static const std::set<DseCredentialsType>& get_constants();
+};
+
+} // namespace CCM
 
 #endif // __CCM_DSE_CREDENTIALS_TYPE_HPP__
diff --git a/test/ccm_bridge/src/process.cpp b/test/ccm_bridge/src/process.cpp
index f789394e8..42d0741cc 100644
--- a/test/ccm_bridge/src/process.cpp
+++ b/test/ccm_bridge/src/process.cpp
@@ -16,16 +16,17 @@
 
 #include "process.hpp"
 
-#include <string.h>
 #include <iostream>
 #include <sstream>
+#include <string.h>
 
 #include <uv.h>
 
 // Create simple console logging functions
-#define LOG_MESSAGE(message, is_output) if (is_output) { \
-  std::cerr << "process> " << message << std::endl; \
-}
+#define LOG_MESSAGE(message, is_output)               \
+  if (is_output) {                                    \
+    std::cerr << "process> " << message << std::endl; \
+  }
 #define LOG_ERROR(message) LOG_MESSAGE(message, true)
 
 namespace utils {
@@ -55,8 +56,7 @@ Process::Result Process::execute(const Args& command) {
 
   // Create the options for the process
   std::vector<const char*> args;
-  for (Args::const_iterator it = command.begin(), end = command.end();
-       it != end; ++it) {
+  for (Args::const_iterator it = command.begin(), end = command.end(); it != end; ++it) {
     args.push_back(it->c_str());
   }
   args.push_back(NULL);
@@ -75,12 +75,10 @@ Process::Result Process::execute(const Args& command) {
     standard_error.data = &result.standard_error;
 
     // Start the output thread loops
-    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_output),
-                                                 Process::on_allocate,
-                                                 Process::on_read);
-    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_error),
-                                                 Process::on_allocate,
-                                                 Process::on_read);
+    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_output), Process::on_allocate,
+                  Process::on_read);
+    uv_read_start(reinterpret_cast<uv_stream_t*>(&standard_error), Process::on_allocate,
+                  Process::on_read);
 
     // Start the process loop
     uv_run(&loop, UV_RUN_DEFAULT);
@@ -130,4 +128,3 @@ void Process::on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
 }
 
 }; // namespace utils
-
diff --git a/test/ccm_bridge/src/process.hpp b/test/ccm_bridge/src/process.hpp
index c400411ed..fbdfa98f7 100644
--- a/test/ccm_bridge/src/process.hpp
+++ b/test/ccm_bridge/src/process.hpp
@@ -18,8 +18,8 @@
 #define __PROCESS_HPP__
 
 #include <assert.h>
-#include <stdint.h>
 #include <exception>
+#include <stdint.h>
 #include <string>
 #include <vector>
 
@@ -29,13 +29,13 @@ typedef struct uv_handle_s uv_handle_t;
 typedef struct uv_process_s uv_process_t;
 typedef struct uv_stream_s uv_stream_t;
 #ifdef _MSC_VER
-# include <basetsd.h>
-# ifndef _SSIZE_T_DEFINED
-    typedef SSIZE_T ssize_t;
-#   define _SSIZE_T_DEFINED
-# endif
+#include <basetsd.h>
+#ifndef _SSIZE_T_DEFINED
+typedef SSIZE_T ssize_t;
+#define _SSIZE_T_DEFINED
+#endif
 #else
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 namespace utils {
@@ -52,7 +52,7 @@ class Process {
    */
   struct Result {
     Result()
-      : exit_status(-1) { }
+        : exit_status(-1) {}
 
     /**
      * Exit status
@@ -77,7 +77,7 @@ class Process {
   static Result execute(const Args& command);
 
 private:
-  Process() { }
+  Process() {}
 
   /**
    * uv_exit_cb for handling the completion of the process
@@ -112,6 +112,4 @@ class Process {
 
 } // namespace utils
 
-
 #endif // __PROCESS_HPP__
-
diff --git a/test/ccm_bridge/src/socket_exception.hpp b/test/ccm_bridge/src/socket_exception.hpp
index 65334abf8..e51fbbaf8 100644
--- a/test/ccm_bridge/src/socket_exception.hpp
+++ b/test/ccm_bridge/src/socket_exception.hpp
@@ -31,14 +31,16 @@ class SocketException : public std::exception {
    *
    * @param message SocketException message
    */
-  SocketException(const std::string &message) : std::exception(message.c_str()) {}
+  SocketException(const std::string& message)
+      : std::exception(message.c_str()) {}
 #else
   /**
    * Socket exception class
    *
    * @param message Exception message
    */
-  SocketException(const std::string& message) : message_(message) {}
+  SocketException(const std::string& message)
+      : message_(message) {}
   /**
    * Destructor
    */
diff --git a/test/ccm_bridge/src/tsocket.cpp b/test/ccm_bridge/src/tsocket.cpp
index 9b6860cde..b61e0045f 100644
--- a/test/ccm_bridge/src/tsocket.cpp
+++ b/test/ccm_bridge/src/tsocket.cpp
@@ -19,19 +19,19 @@
 #include <sstream>
 
 #ifndef _WIN32
-# include <arpa/inet.h>
-# include <cstring>
-# include <errno.h>
-# include <netinet/in.h>
-# include <sys/socket.h>
-# include <unistd.h>
-
-# define INVALID_SOCKET -1
-# define SOCKET_ERROR -1
+#include <arpa/inet.h>
+#include <cstring>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
 #endif
 
 Socket::Socket(long timeout /*= SOCKET_TIMEOUT_IN_SECONDS*/)
-  : timeout_(timeout) {
+    : timeout_(timeout) {
 #ifdef _WIN32
   initialize_sockets();
 #endif
@@ -46,9 +46,7 @@ Socket::~Socket() {
 #endif
 }
 
-SOCKET_HANDLE Socket::get_handle() {
-  return handle_;
-}
+SOCKET_HANDLE Socket::get_handle() { return handle_; }
 
 #ifdef _WIN32
 void Socket::initialize_sockets() {
@@ -66,9 +64,9 @@ std::string Socket::get_error_message(int error_code) const {
   std::stringstream message;
 #ifdef _WIN32
   LPVOID error_string;
-  int size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-    NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-    (LPTSTR) &error_string, 0, NULL);
+  int size =
+      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, error_code,
+                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&error_string, 0, NULL);
 
   // Ensure the message could be retrieved and update the return message
   if (size) {
@@ -88,8 +86,8 @@ void Socket::synchronize(bool is_read, bool is_write) {
   FD_SET(handle_, &socket);
 
   // Determine current read/write direction of the session
-  fd_set *read = NULL;
-  fd_set *write = NULL;
+  fd_set* read = NULL;
+  fd_set* write = NULL;
   if (is_read) {
     read = &socket;
   }
@@ -112,7 +110,7 @@ void Socket::synchronize(bool is_read, bool is_write) {
   }
 }
 
-void Socket::establish_connection(const std::string &ip_address, unsigned short port) {
+void Socket::establish_connection(const std::string& ip_address, unsigned short port) {
   handle_ = socket(AF_INET, SOCK_STREAM, 0);
   if (handle_ == INVALID_SOCKET) {
     std::string message = "Failed to Create Socket: ";
@@ -128,7 +126,7 @@ void Socket::establish_connection(const std::string &ip_address, unsigned short
   ipv4_socket_address.sin_family = AF_INET;
   ipv4_socket_address.sin_port = htons(port);
   ipv4_socket_address.sin_addr.s_addr = inet_addr(ip_address.c_str());
-  if (connect(handle_, (struct sockaddr*) (&ipv4_socket_address), sizeof(struct sockaddr_in)) != 0) {
+  if (connect(handle_, (struct sockaddr*)(&ipv4_socket_address), sizeof(struct sockaddr_in)) != 0) {
     std::string message = "Failed to Establish Connection: ";
 #ifdef _WIN32
     message += get_error_message(GetLastError());
diff --git a/test/ccm_bridge/src/tsocket.hpp b/test/ccm_bridge/src/tsocket.hpp
index 7838aaaf9..77ef82121 100644
--- a/test/ccm_bridge/src/tsocket.hpp
+++ b/test/ccm_bridge/src/tsocket.hpp
@@ -18,10 +18,10 @@
 #define __TSOCKET_HPP__
 
 #ifdef _WIN32
-# include <winsock2.h>
-# define SOCKET_HANDLE SOCKET
+#include <winsock2.h>
+#define SOCKET_HANDLE SOCKET
 #else
-# define SOCKET_HANDLE int
+#define SOCKET_HANDLE int
 #endif
 
 #include "socket_exception.hpp"
@@ -48,7 +48,7 @@ class Socket {
    * @param ip_address IP address to connect to
    * @param port Port number to establish connection on
    */
-  void establish_connection(const std::string &ip_address, unsigned short port);
+  void establish_connection(const std::string& ip_address, unsigned short port);
   /**
    * Get the socket handle
    *
diff --git a/test/integration_tests/src/main.cpp b/test/integration_tests/src/main.cpp
index 239e48d77..ed107c28c 100644
--- a/test/integration_tests/src/main.cpp
+++ b/test/integration_tests/src/main.cpp
@@ -62,7 +62,8 @@ BOOST_GLOBAL_FIXTURE(CCMCleanUp);
  */
 struct EnableTestCaseOutput {
   EnableTestCaseOutput() {
-    boost::unit_test::unit_test_log_t::instance().set_threshold_level(boost::unit_test::log_test_units);
+    boost::unit_test::unit_test_log_t::instance().set_threshold_level(
+        boost::unit_test::log_test_units);
   }
 };
 BOOST_GLOBAL_FIXTURE(EnableTestCaseOutput);
diff --git a/test/integration_tests/src/policy_tools.cpp b/test/integration_tests/src/policy_tools.cpp
index 57cb6706e..d57ddd6c8 100644
--- a/test/integration_tests/src/policy_tools.cpp
+++ b/test/integration_tests/src/policy_tools.cpp
@@ -14,90 +14,86 @@
   limitations under the License.
 */
 
-#include <boost/test/test_tools.hpp>
+#include <boost/format.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/test_tools.hpp>
 #include <boost/thread.hpp>
-#include <boost/format.hpp>
 
-#include "testing.hpp"
 #include "policy_tools.hpp"
+#include "testing.hpp"
+
+using namespace datastax::internal::testing;
 
-void PolicyTool::show_coordinators()	// show what queries went to what nodes IP.
+void PolicyTool::show_coordinators() // show what queries went to what nodes IP.
 {
-  for (std::map<std::string, int>::const_iterator p = coordinators.begin(); p != coordinators.end(); ++p) {
+  for (std::map<std::string, int>::const_iterator p = coordinators.begin(); p != coordinators.end();
+       ++p) {
     std::cout << p->first << " : " << p->second << std::endl;
   }
 }
 
-void PolicyTool::reset_coordinators()
-{
-  coordinators.clear();
-}
+void PolicyTool::reset_coordinators() { coordinators.clear(); }
 
-void PolicyTool::create_schema(CassSession* session, int replicationFactor)
-{
-  test_utils::execute_query(session,
-                            str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % replicationFactor));
+void PolicyTool::create_schema(CassSession* session, int replicationFactor) {
+  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                         test_utils::SIMPLE_KEYSPACE % replicationFactor));
   test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
-  test_utils::execute_query(session,
-                            str(boost::format("CREATE TABLE %s (k int PRIMARY KEY, i int)") % test_utils::SIMPLE_TABLE));
+  test_utils::execute_query(
+      session,
+      str(boost::format("CREATE TABLE %s (k int PRIMARY KEY, i int)") % test_utils::SIMPLE_TABLE));
 }
 
-void PolicyTool::create_schema(CassSession* session, int dc1, int dc2)
-{
-  test_utils::execute_query(session,
-                            str(boost::format(test_utils::CREATE_KEYSPACE_NETWORK_FORMAT) % test_utils::SIMPLE_KEYSPACE % dc1 % dc2));
+void PolicyTool::create_schema(CassSession* session, int dc1, int dc2) {
+  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_NETWORK_FORMAT) %
+                                         test_utils::SIMPLE_KEYSPACE % dc1 % dc2));
   test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
-  test_utils::execute_query(session,
-                            str(boost::format("CREATE TABLE %s (k int PRIMARY KEY, i int)") % test_utils::SIMPLE_TABLE));
+  test_utils::execute_query(
+      session,
+      str(boost::format("CREATE TABLE %s (k int PRIMARY KEY, i int)") % test_utils::SIMPLE_TABLE));
 }
 
 void PolicyTool::drop_schema(CassSession* session) {
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session,
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % test_utils::SIMPLE_KEYSPACE));
+  test_utils::execute_query_with_error(
+      session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
 }
 
-void PolicyTool::init(CassSession* session, int n, CassConsistency cl, bool batch)
-{
-  std::string query = str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE);
+void PolicyTool::init(CassSession* session, int n, CassConsistency cl, bool batch) {
+  std::string query =
+      str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE);
 
   if (batch) {
     std::string bth;
     bth.append("BEGIN BATCH ");
-    bth.append(str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE));
+    bth.append(
+        str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE));
     bth.append(" APPLY BATCH");
     query = bth;
   }
 
   for (int i = 0; i < n; ++i) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session,
-                              query,
-                              &result,
-                              cl);
+    test_utils::execute_query(session, query, &result, cl);
   }
 }
 
-CassError PolicyTool::init_return_error(CassSession* session, int n, CassConsistency cl, bool batch)
-{
-  std::string query = str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE);
+CassError PolicyTool::init_return_error(CassSession* session, int n, CassConsistency cl,
+                                        bool batch) {
+  std::string query =
+      str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE);
 
   if (batch) {
     std::string batch_query;
     batch_query.append("BEGIN BATCH ");
-    batch_query.append(str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE));
+    batch_query.append(
+        str(boost::format("INSERT INTO %s (k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE));
     batch_query.append(" APPLY BATCH");
     query = batch_query;
   }
 
   for (int i = 0; i < n; ++i) {
     test_utils::CassResultPtr result;
-    CassError rc = test_utils::execute_query_with_error(session,
-                                                        query,
-                                                        &result,
-                                                        cl);
+    CassError rc = test_utils::execute_query_with_error(session, query, &result, cl);
     if (rc != CASS_OK) {
       return rc;
     }
@@ -105,8 +101,7 @@ CassError PolicyTool::init_return_error(CassSession* session, int n, CassConsist
   return CASS_OK;
 }
 
-void PolicyTool::add_coordinator(std::string address)
-{
+void PolicyTool::add_coordinator(std::string address) {
   if (coordinators.count(address) == 0) {
     coordinators.insert(std::make_pair(address, 1));
   } else {
@@ -114,8 +109,7 @@ void PolicyTool::add_coordinator(std::string address)
   }
 }
 
-void PolicyTool::assert_queried(std::string address, int n)
-{
+void PolicyTool::assert_queried(std::string address, int n) {
   if (coordinators.count(address) != 0) {
     int c = coordinators[address];
     BOOST_REQUIRE(c == n);
@@ -124,30 +118,30 @@ void PolicyTool::assert_queried(std::string address, int n)
   }
 }
 
-void PolicyTool::assertQueriedAtLeast(std::string address, int n)
-{
+void PolicyTool::assertQueriedAtLeast(std::string address, int n) {
   int queried = coordinators[address];
   BOOST_REQUIRE(queried >= n);
 }
 
-void PolicyTool::query(CassSession* session, int n, CassConsistency cl)
-{
-  std::string select_query = str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE);
+void PolicyTool::query(CassSession* session, int n, CassConsistency cl) {
+  std::string select_query =
+      str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE);
   for (int i = 0; i < n; ++i) {
-    test_utils::CassStatementPtr statement(cass_statement_new_n(select_query.data(), select_query.size(), 0));
+    test_utils::CassStatementPtr statement(
+        cass_statement_new_n(select_query.data(), select_query.size(), 0));
     cass_statement_set_consistency(statement.get(), cl);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
-    add_coordinator(cass::get_host_from_future(future.get()).c_str());
+    add_coordinator(get_host_from_future(future.get()).c_str());
   }
 }
 
-CassError PolicyTool::query_return_error(CassSession* session, int n, CassConsistency cl)
-{
-  std::string select_query = str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE);
+CassError PolicyTool::query_return_error(CassSession* session, int n, CassConsistency cl) {
+  std::string select_query =
+      str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE);
   for (int i = 0; i < n; ++i) {
-    test_utils::CassStatementPtr statement
-        (cass_statement_new_n(select_query.data(), select_query.size(), 0));
+    test_utils::CassStatementPtr statement(
+        cass_statement_new_n(select_query.data(), select_query.size(), 0));
     cass_statement_set_consistency(statement.get(), cl);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     CassError rc = test_utils::wait_and_return_error(future.get());
@@ -155,7 +149,7 @@ CassError PolicyTool::query_return_error(CassSession* session, int n, CassConsis
     if (rc != CASS_OK) {
       return rc;
     }
-    add_coordinator(cass::get_host_from_future(future.get()).c_str());
+    add_coordinator(get_host_from_future(future.get()).c_str());
   }
   return CASS_OK;
 }
diff --git a/test/integration_tests/src/policy_tools.hpp b/test/integration_tests/src/policy_tools.hpp
index 4403fc8b9..40838e6f9 100644
--- a/test/integration_tests/src/policy_tools.hpp
+++ b/test/integration_tests/src/policy_tools.hpp
@@ -22,24 +22,16 @@ struct PolicyTool {
 
   std::map<std::string, int> coordinators;
 
-  void show_coordinators();	// show what queries went to what node IP.
+  void show_coordinators(); // show what queries went to what node IP.
   void reset_coordinators();
 
-  void init(CassSession* session,
-            int n,
-            CassConsistency cl,
-            bool batch = false);
+  void init(CassSession* session, int n, CassConsistency cl, bool batch = false);
 
-  CassError init_return_error(CassSession* session,
-                              int n,
-                              CassConsistency cl,
-                              bool batch = false);
+  CassError init_return_error(CassSession* session, int n, CassConsistency cl, bool batch = false);
 
-  void create_schema(CassSession* session,
-                     int replicationFactor);
+  void create_schema(CassSession* session, int replicationFactor);
 
-  void create_schema(CassSession* session,
-                     int dc1, int dc2);
+  void create_schema(CassSession* session, int dc1, int dc2);
 
   void drop_schema(CassSession* session);
 
@@ -51,7 +43,5 @@ struct PolicyTool {
 
   void query(CassSession* session, int n, CassConsistency cl);
 
-  CassError query_return_error(CassSession* session,
-                               int n,
-                               CassConsistency cl);
+  CassError query_return_error(CassSession* session, int n, CassConsistency cl);
 };
diff --git a/test/integration_tests/src/pretty_print.cpp b/test/integration_tests/src/pretty_print.cpp
index 296e02edd..b19cc833d 100644
--- a/test/integration_tests/src/pretty_print.cpp
+++ b/test/integration_tests/src/pretty_print.cpp
@@ -15,11 +15,7 @@
 */
 #include "pretty_print.hpp"
 
-namespace boost {
-
-namespace test_tools {
-
-namespace tt_detail {
+namespace boost { namespace test_tools { namespace tt_detail {
 
 void print_log_value<CassError>::operator()(std::ostream& output_stream,
                                             const CassError& error_code) {
@@ -294,8 +290,4 @@ void print_log_value<CassValueType>::operator()(std::ostream& output_stream,
   }
 }
 
-} // namespace tt_detail
-
-} // namespace test_tools
-
-} // namespace boost
+}}} // namespace boost::test_tools::tt_detail
diff --git a/test/integration_tests/src/pretty_print.hpp b/test/integration_tests/src/pretty_print.hpp
index d5b017aa5..c3d794e3d 100644
--- a/test/integration_tests/src/pretty_print.hpp
+++ b/test/integration_tests/src/pretty_print.hpp
@@ -21,13 +21,9 @@
 
 #include "cassandra.h"
 
-namespace boost {
+namespace boost { namespace test_tools { namespace tt_detail {
 
-namespace test_tools {
-
-namespace tt_detail {
-
-template<>
+template <>
 struct print_log_value<CassError> {
   /**
    * Pretty print CassError values
@@ -38,7 +34,7 @@ struct print_log_value<CassError> {
   void operator()(std::ostream& output_stream, const CassError& error_code);
 };
 
-template<>
+template <>
 struct print_log_value<CassValueType> {
   /**
    * Pretty print CassValueType values
@@ -46,14 +42,9 @@ struct print_log_value<CassValueType> {
    * @param output_stream Output stream to pretty print value to
    * @param value_type CassValueType value to pretty print
    */
-  void operator()(std::ostream& output_stream,
-                  const CassValueType& value_type);
+  void operator()(std::ostream& output_stream, const CassValueType& value_type);
 };
 
-} // namespace tt_detail
-
-} // namespace test_tools
-
-} // namespace boost
+}}} // namespace boost::test_tools::tt_detail
 
 #endif // __PRETTY_PRINT_HPP__
\ No newline at end of file
diff --git a/test/integration_tests/src/test_async.cpp b/test/integration_tests/src/test_async.cpp
index f50f987a0..80d718b06 100644
--- a/test/integration_tests/src/test_async.cpp
+++ b/test/integration_tests/src/test_async.cpp
@@ -14,40 +14,44 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 struct AsyncTests : public test_utils::SingleSessionTest {
-  AsyncTests() : test_utils::SingleSessionTest(3, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "3"));
+  AsyncTests()
+      : test_utils::SingleSessionTest(3, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "3"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~AsyncTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
-  static std::vector<CassUuid> insert_async(CassSession* session,
-                                            CassUuidGen* uuid_gen,
+  static std::vector<CassUuid> insert_async(CassSession* session, CassUuidGen* uuid_gen,
                                             const std::string& table_name,
                                             size_t num_concurrent_requests,
                                             std::vector<test_utils::CassFuturePtr>* futures) {
-    std::string create_table_query = str(boost::format("CREATE TABLE %s (id timeuuid PRIMARY KEY, num int, str text);") % table_name);
+    std::string create_table_query =
+        str(boost::format("CREATE TABLE %s (id timeuuid PRIMARY KEY, num int, str text);") %
+            table_name);
 
     test_utils::execute_query(session, create_table_query);
 
-    std::string insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(?, ?, ?)") % table_name);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (id, num, str) VALUES(?, ?, ?)") % table_name);
 
     std::vector<CassUuid> ids;
     for (size_t i = 0; i < num_concurrent_requests; ++i) {
@@ -56,7 +60,8 @@ struct AsyncTests : public test_utils::SingleSessionTest {
 
       // Determine if bound parameters can be used based on C* version
       if (version.major_version == 1) {
-        insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(%s, %s, 'row%s')") % table_name % test_utils::Value<CassUuid>::to_string(id) % i % i);
+        insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(%s, %s, 'row%s')") %
+                           table_name % test_utils::Value<CassUuid>::to_string(id) % i % i);
         statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
       } else {
         BOOST_REQUIRE(cass_statement_bind_uuid(statement.get(), 0, id) == CASS_OK);
@@ -73,10 +78,8 @@ struct AsyncTests : public test_utils::SingleSessionTest {
     return ids;
   }
 
-  void validate_results(const std::string& table_name,
-                        size_t num_concurrent_requests,
-                        const std::vector<CassUuid>& ids)
-  {
+  void validate_results(const std::string& table_name, size_t num_concurrent_requests,
+                        const std::vector<CassUuid>& ids) {
     std::string select_query = str(boost::format("SELECT * FROM %s;") % table_name);
     test_utils::CassResultPtr result;
     test_utils::execute_query(session, select_query, &result, CASS_CONSISTENCY_QUORUM);
@@ -95,33 +98,36 @@ struct AsyncTests : public test_utils::SingleSessionTest {
 
 BOOST_FIXTURE_TEST_SUITE(async, AsyncTests)
 
-BOOST_AUTO_TEST_CASE(simple)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(simple) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
   const size_t num_concurrent_requests = 4096;
 
   std::vector<test_utils::CassFuturePtr> futures;
-  std::vector<CassUuid> ids = insert_async(session, uuid_gen, table_name, num_concurrent_requests, &futures);
+  std::vector<CassUuid> ids =
+      insert_async(session, uuid_gen, table_name, num_concurrent_requests, &futures);
 
-  for (std::vector<test_utils::CassFuturePtr>::iterator it = futures.begin(),
-      end = futures.end(); it != end; ++it) {
+  for (std::vector<test_utils::CassFuturePtr>::iterator it = futures.begin(), end = futures.end();
+       it != end; ++it) {
     test_utils::wait_and_check_error(it->get());
   }
 
   validate_results(table_name, num_concurrent_requests, ids);
 }
 
-BOOST_AUTO_TEST_CASE(close)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(close) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
   const size_t num_concurrent_requests = 4096;
 
   test_utils::CassSessionPtr temp_session(test_utils::create_session(cluster));
 
-  test_utils::execute_query(temp_session.get(), str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
+  test_utils::execute_query(temp_session.get(),
+                            str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
   std::vector<test_utils::CassFuturePtr> futures;
-  std::vector<CassUuid> ids = insert_async(temp_session.get(), uuid_gen, table_name, num_concurrent_requests, &futures);
+  std::vector<CassUuid> ids =
+      insert_async(temp_session.get(), uuid_gen, table_name, num_concurrent_requests, &futures);
 
   // Close session, this should wait for all pending requests to finish
 
diff --git a/test/integration_tests/src/test_authentication.cpp b/test/integration_tests/src/test_authentication.cpp
index 581c0641b..ee0cdb131 100644
--- a/test/integration_tests/src/test_authentication.cpp
+++ b/test/integration_tests/src/test_authentication.cpp
@@ -19,28 +19,29 @@
 
 #include <sstream>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
-#include <boost/thread.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
 
 struct AuthenticationTests {
   AuthenticationTests()
-    : cluster(cass_cluster_new())
-    , ccm(new CCM::Bridge("config.txt"))
-    , version(test_utils::get_version()) {
+      : cluster(cass_cluster_new())
+      , ccm(new CCM::Bridge("config.txt"))
+      , version(test_utils::get_version()) {
     ccm->create_cluster();
     ccm->kill_cluster();
     ccm->update_cluster_configuration("authenticator", "PasswordAuthenticator");
     ccm->start_cluster("-Dcassandra.superuser_setup_delay_ms=0");
-    test_utils::initialize_contact_points(cluster.get(), CCM::Bridge::get_ip_prefix("config.txt"), 1);
+    test_utils::initialize_contact_points(cluster.get(), CCM::Bridge::get_ip_prefix("config.txt"),
+                                          1);
   }
 
   ~AuthenticationTests() {
-    //TODO: Add name generation for simple auth tests
+    // TODO: Add name generation for simple auth tests
     ccm->remove_cluster();
   }
 
@@ -52,15 +53,15 @@ struct AuthenticationTests {
 
     test_utils::CassResultPtr result;
     std::stringstream query;
-    query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
+    query << "SELECT * FROM "
+          << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
     test_utils::execute_query(session.get(), query.str().c_str(), &result);
 
     BOOST_CHECK(cass_result_row_count(result.get()) > 0);
   }
 
-  void invalid_credentials(int protocol_version, const char* username,
-                           const char* password, const char* expected_error,
-                           CassError expected_code) {
+  void invalid_credentials(int protocol_version, const char* username, const char* password,
+                           const char* expected_error, CassError expected_code) {
     test_utils::CassLog::reset(expected_error);
     cass_cluster_set_protocol_version(cluster.get(), protocol_version);
     cass_cluster_set_credentials(cluster.get(), username, password);
@@ -78,26 +79,22 @@ struct AuthenticationTests {
 };
 
 // Authenticator callback used in AuthenticatorSetErrorNullError test
-void on_auth_initial(CassAuthenticator* auth,
-                     void* data) {
+void on_auth_initial(CassAuthenticator* auth, void* data) {
   cass_authenticator_set_error(auth, NULL);
 }
 
 BOOST_FIXTURE_TEST_SUITE(authentication, AuthenticationTests)
 
-BOOST_AUTO_TEST_CASE(protocol_versions)
-{
+BOOST_AUTO_TEST_CASE(protocol_versions) {
   auth(3);
   auth(4);
 }
 
-BOOST_AUTO_TEST_CASE(empty_credentials)
-{
+BOOST_AUTO_TEST_CASE(empty_credentials) {
   // This is a case that could be guarded in the API entry point, or errored in connection. However,
   // auth is subject to major changes and this is just a simple form.
   // This test serves to characterize what is there presently.
-  const char* expected_error
-      = "Key may not be empty";
+  const char* expected_error = "Key may not be empty";
   // Handle deprecated and removed protocol versions [CASSANDRA-10146]
   // https://issues.apache.org/jira/browse/CASSANDRA-10146
   if (version < "2.2.0") {
@@ -114,8 +111,7 @@ BOOST_AUTO_TEST_CASE(empty_credentials)
   invalid_credentials(4, "user", NULL, expected_error, CASS_ERROR_SERVER_BAD_CREDENTIALS);
 }
 
-BOOST_AUTO_TEST_CASE(bad_credentials)
-{
+BOOST_AUTO_TEST_CASE(bad_credentials) {
   std::string expected_error = "Username and/or password are incorrect";
   if (version >= "3.10") {
     expected_error = "Provided username invalid and/or password are incorrect";
@@ -123,11 +119,15 @@ BOOST_AUTO_TEST_CASE(bad_credentials)
   // Handle deprecated and removed protocol versions [CASSANDRA-10146]
   // https://issues.apache.org/jira/browse/CASSANDRA-10146
   if (version < "2.2.0") {
-    invalid_credentials(1, "invalid", "invalid", expected_error.c_str(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
-    invalid_credentials(2, "invalid", "invalid", expected_error.c_str(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
+    invalid_credentials(1, "invalid", "invalid", expected_error.c_str(),
+                        CASS_ERROR_SERVER_BAD_CREDENTIALS);
+    invalid_credentials(2, "invalid", "invalid", expected_error.c_str(),
+                        CASS_ERROR_SERVER_BAD_CREDENTIALS);
   }
-  invalid_credentials(3, "invalid", "invalid", expected_error.c_str(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
-  invalid_credentials(4, "invalid", "invalid", expected_error.c_str(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
+  invalid_credentials(3, "invalid", "invalid", expected_error.c_str(),
+                      CASS_ERROR_SERVER_BAD_CREDENTIALS);
+  invalid_credentials(4, "invalid", "invalid", expected_error.c_str(),
+                      CASS_ERROR_SERVER_BAD_CREDENTIALS);
 }
 
 /**
@@ -144,11 +144,11 @@ BOOST_AUTO_TEST_CASE(authenticator_set_error_null_error) {
     expected_error = "Provided username invalid and/or password are incorrect";
   }
 
-  CassAuthenticatorCallbacks auth_callbacks = {on_auth_initial, NULL, NULL, NULL };
-  BOOST_CHECK_EQUAL(CASS_OK,
-    cass_cluster_set_authenticator_callbacks(cluster.get(),
-                                             &auth_callbacks, NULL, NULL));
-  invalid_credentials(4, "invalid", "invalid", expected_error.c_str(), CASS_ERROR_SERVER_BAD_CREDENTIALS);
+  CassAuthenticatorCallbacks auth_callbacks = { on_auth_initial, NULL, NULL, NULL };
+  BOOST_CHECK_EQUAL(CASS_OK, cass_cluster_set_authenticator_callbacks(cluster.get(),
+                                                                      &auth_callbacks, NULL, NULL));
+  invalid_credentials(4, "invalid", "invalid", expected_error.c_str(),
+                      CASS_ERROR_SERVER_BAD_CREDENTIALS);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_basics.cpp b/test/integration_tests/src/test_basics.cpp
index 2a725ce26..0109107cd 100644
--- a/test/integration_tests/src/test_basics.cpp
+++ b/test/integration_tests/src/test_basics.cpp
@@ -17,40 +17,44 @@
 #include <algorithm>
 #include <cmath>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
 
 #include "cassandra.h"
 #include "constants.hpp"
 #include "test_utils.hpp"
 
 struct BasicTests : public test_utils::SingleSessionTest {
-  BasicTests() : SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  BasicTests()
+      : SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
 
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~BasicTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-        % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   template <class T>
   void insert_single_value(CassValueType type, T value) {
-    std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+    std::string table_name =
+        str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
     std::string type_name = test_utils::get_value_type(type);
 
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, test_val %s)")
-                                           % table_name % type_name));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, test_val %s)") %
+                     table_name % type_name));
 
     /*
      * Bound parameters or prepared statement validation
@@ -58,7 +62,8 @@ struct BasicTests : public test_utils::SingleSessionTest {
 
     // Create insert statement for bound parameters
     CassUuid tweet_id = test_utils::generate_random_uuid(uuid_gen);
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?)") % table_name);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?)") % table_name);
     test_utils::CassStatementPtr insert_statement(cass_statement_new(insert_query.c_str(), 2));
 
     // Determine if bound parameters can be used based on C* version
@@ -73,7 +78,8 @@ struct BasicTests : public test_utils::SingleSessionTest {
     test_utils::wait_and_check_error(insert_future.get());
 
     // Create select statement for bound parameters
-    std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
+    std::string select_query =
+        str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
     test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
@@ -112,14 +118,18 @@ struct BasicTests : public test_utils::SingleSessionTest {
       value_string = "'" + value_string + "'";
     }
 
-    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s")) % tweet_id_string % value_string);
+    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s")) %
+                       tweet_id_string % value_string);
     insert_statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
-    insert_future = test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
+    insert_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
     test_utils::wait_and_check_error(insert_future.get());
 
-    select_query = str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
+    select_query =
+        str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
     select_statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0));
-    select_future = test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
+    select_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
     test_utils::wait_and_check_error(select_future.get());
 
     result = test_utils::CassResultPtr(cass_future_get_result(select_future.get()));
@@ -134,11 +144,14 @@ struct BasicTests : public test_utils::SingleSessionTest {
 
   template <class T>
   void insert_min_max_value(CassValueType type) {
-    std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+    std::string table_name =
+        str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
     std::string type_name = test_utils::get_value_type(type);
 
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, min_val %s, max_val %s)")
-                                           % table_name % type_name % type_name));
+    test_utils::execute_query(
+        session,
+        str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, min_val %s, max_val %s)") %
+            table_name % type_name % type_name));
 
     /*
      * Bound parameters or prepared statement validation
@@ -146,7 +159,8 @@ struct BasicTests : public test_utils::SingleSessionTest {
 
     // Create insert statement for bound parameters
     CassUuid tweet_id = test_utils::generate_random_uuid(uuid_gen);
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, min_val, max_val) VALUES(?, ?, ?);") % table_name);
+    std::string insert_query = str(
+        boost::format("INSERT INTO %s (tweet_id, min_val, max_val) VALUES(?, ?, ?);") % table_name);
     test_utils::CassStatementPtr insert_statement(cass_statement_new(insert_query.c_str(), 3));
 
     // Determine if bound parameters can be used based on C* version
@@ -156,13 +170,16 @@ struct BasicTests : public test_utils::SingleSessionTest {
     }
 
     BOOST_REQUIRE(cass_statement_bind_uuid(insert_statement.get(), 0, tweet_id) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::bind(insert_statement.get(), 1, test_utils::Value<T>::min_value()) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::bind(insert_statement.get(), 2, test_utils::Value<T>::max_value()) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::bind(insert_statement.get(), 1,
+                                             test_utils::Value<T>::min_value()) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::bind(insert_statement.get(), 2,
+                                             test_utils::Value<T>::max_value()) == CASS_OK);
     test_utils::CassFuturePtr result_future(cass_session_execute(session, insert_statement.get()));
     test_utils::wait_and_check_error(result_future.get());
 
     // Create select statement for bound parameters
-    std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
+    std::string select_query =
+        str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
     test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
@@ -180,12 +197,16 @@ struct BasicTests : public test_utils::SingleSessionTest {
     BOOST_REQUIRE(cass_result_column_count(result.get()) == 3);
 
     T min_value;
-    BOOST_REQUIRE(test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 2), &min_value) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::equal(min_value,  test_utils::Value<T>::min_value()));
+    BOOST_REQUIRE(
+        test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 2),
+                                  &min_value) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::equal(min_value, test_utils::Value<T>::min_value()));
 
     T max_value;
-    BOOST_REQUIRE(test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 1), &max_value) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::equal(max_value,  test_utils::Value<T>::max_value()));
+    BOOST_REQUIRE(
+        test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 1),
+                                  &max_value) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::equal(max_value, test_utils::Value<T>::max_value()));
 
     /*
      * Simple statement validation
@@ -193,38 +214,48 @@ struct BasicTests : public test_utils::SingleSessionTest {
 
     // Generate the appropriate formatted strings for the simple statement
     std::string tweet_id_string = test_utils::generate_random_uuid_str(uuid_gen);
-    std::string min_value_string = test_utils::Value<T>::to_string(test_utils::Value<T>::min_value());
-    std::string max_value_string = test_utils::Value<T>::to_string(test_utils::Value<T>::max_value());
+    std::string min_value_string =
+        test_utils::Value<T>::to_string(test_utils::Value<T>::min_value());
+    std::string max_value_string =
+        test_utils::Value<T>::to_string(test_utils::Value<T>::max_value());
     if (type == CASS_VALUE_TYPE_INET) {
       min_value_string = "'" + min_value_string + "'";
       max_value_string = "'" + max_value_string + "'";
     }
 
-    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s"))
-                               % tweet_id_string % min_value_string % max_value_string);
+    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s")) %
+                       tweet_id_string % min_value_string % max_value_string);
     insert_statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
-    result_future = test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
+    result_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
     test_utils::wait_and_check_error(result_future.get());
 
-    select_query = str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
+    select_query =
+        str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
     select_statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0));
-    select_future = test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
+    select_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
     test_utils::wait_and_check_error(select_future.get());
 
     result = test_utils::CassResultPtr(cass_future_get_result(select_future.get()));
     BOOST_REQUIRE(cass_result_row_count(result.get()) == 1);
     BOOST_REQUIRE(cass_result_column_count(result.get()) == 3);
 
-    BOOST_REQUIRE(test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 2), &min_value) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::equal(min_value,  test_utils::Value<T>::min_value()));
+    BOOST_REQUIRE(
+        test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 2),
+                                  &min_value) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::equal(min_value, test_utils::Value<T>::min_value()));
 
-    BOOST_REQUIRE(test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 1), &max_value) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<T>::equal(max_value,  test_utils::Value<T>::max_value()));
+    BOOST_REQUIRE(
+        test_utils::Value<T>::get(cass_row_get_column(cass_result_first_row(result.get()), 1),
+                                  &max_value) == CASS_OK);
+    BOOST_REQUIRE(test_utils::Value<T>::equal(max_value, test_utils::Value<T>::max_value()));
   }
 
   template <class T>
   void insert_null_value(CassValueType type) {
-    std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+    std::string table_name =
+        str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
     std::string type_name = test_utils::get_value_type(type);
 
     if (type == CASS_VALUE_TYPE_LIST || type == CASS_VALUE_TYPE_SET) {
@@ -233,16 +264,18 @@ struct BasicTests : public test_utils::SingleSessionTest {
       type_name.append("<text, text>");
     }
 
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, test_val %s)")
-                                           % table_name % type_name));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, test_val %s)") %
+                     table_name % type_name));
 
     /*
-    * Bound parameters or prepared statement validation
-    */
+     * Bound parameters or prepared statement validation
+     */
 
     // Create insert statement for bound parameters
     CassUuid tweet_id = test_utils::generate_random_uuid(uuid_gen);
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") % table_name);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") % table_name);
     test_utils::CassStatementPtr insert_statement(cass_statement_new(insert_query.c_str(), 2));
 
     // Determine if bound parameters can be used based on C* version
@@ -257,7 +290,8 @@ struct BasicTests : public test_utils::SingleSessionTest {
     test_utils::wait_and_check_error(insert_future.get());
 
     // Create select statement for bound parameters
-    std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
+    std::string select_query =
+        str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
     test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
@@ -294,14 +328,18 @@ struct BasicTests : public test_utils::SingleSessionTest {
     // Generate the appropriate formatted strings for the simple statement
     std::string tweet_id_string = test_utils::generate_random_uuid_str(uuid_gen);
 
-    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s")) % tweet_id_string % "NULL");
+    insert_query = str(boost::format(test_utils::replaceAll(insert_query, "?", "%s")) %
+                       tweet_id_string % "NULL");
     insert_statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
-    insert_future = test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
+    insert_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, insert_statement.get()));
     test_utils::wait_and_check_error(insert_future.get());
 
-    select_query = str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
+    select_query =
+        str(boost::format(test_utils::replaceAll(select_query, "?", "%s")) % tweet_id_string);
     select_statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0));
-    select_future = test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
+    select_future =
+        test_utils::CassFuturePtr(cass_session_execute(session, select_statement.get()));
     test_utils::wait_and_check_error(select_future.get());
 
     result = test_utils::CassResultPtr(cass_future_get_result(select_future.get()));
@@ -336,13 +374,12 @@ struct BasicTests : public test_utils::SingleSessionTest {
 
 BOOST_FIXTURE_TEST_SUITE(basics, BasicTests)
 
-
-BOOST_AUTO_TEST_CASE(basic_types)
-{
+BOOST_AUTO_TEST_CASE(basic_types) {
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     insert_single_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123);
     insert_single_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123);
-    insert_single_value<CassDate>(CASS_VALUE_TYPE_DATE, test_utils::Value<CassDate>::min_value() + 1u);
+    insert_single_value<CassDate>(CASS_VALUE_TYPE_DATE,
+                                  test_utils::Value<CassDate>::min_value() + 1u);
     insert_single_value<CassTime>(CASS_VALUE_TYPE_TIME, 123);
   }
   insert_single_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123);
@@ -364,7 +401,8 @@ BOOST_AUTO_TEST_CASE(basic_types)
   }
 
   {
-    CassBytes value = test_utils::bytes_from_string("012345678900123456789001234567890012345678900123456789001234567890");
+    CassBytes value = test_utils::bytes_from_string(
+        "012345678900123456789001234567890012345678900123456789001234567890");
     insert_single_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value);
     insert_single_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value);
   }
@@ -389,9 +427,10 @@ BOOST_AUTO_TEST_CASE(basic_types)
   {
     // Pi to a 100 digits
     const cass_int32_t scale = 100;
-    const cass_uint8_t varint[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-                                    112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-                                    84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+    const cass_uint8_t varint[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,
+                                    25,  32,  135, 129, 180, 112, 176, 158, 120, 246, 235,
+                                    29,  145, 238, 50,  108, 239, 219, 100, 250, 84,  6,
+                                    186, 148, 76,  230, 46,  181, 89,  239, 247 };
     CassDecimal value(varint, sizeof(varint), scale);
     insert_single_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value);
   }
@@ -408,8 +447,7 @@ BOOST_AUTO_TEST_CASE(basic_types)
   }
 }
 
-BOOST_AUTO_TEST_CASE(min_max)
-{
+BOOST_AUTO_TEST_CASE(min_max) {
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     insert_min_max_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT);
     insert_min_max_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT);
@@ -442,8 +480,7 @@ BOOST_AUTO_TEST_CASE(min_max)
   }
 }
 
-BOOST_AUTO_TEST_CASE(null)
-{
+BOOST_AUTO_TEST_CASE(null) {
   insert_null_value<CassString>(CASS_VALUE_TYPE_ASCII);
   insert_null_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT);
   insert_null_value<CassBytes>(CASS_VALUE_TYPE_BLOB);
@@ -473,8 +510,7 @@ BOOST_AUTO_TEST_CASE(null)
   insert_null_value<CassBytes>(CASS_VALUE_TYPE_SET);
 }
 
-BOOST_AUTO_TEST_CASE(timestamp)
-{
+BOOST_AUTO_TEST_CASE(timestamp) {
   test_utils::execute_query(session, "CREATE TABLE test(tweet_id int PRIMARY KEY, test_val int);");
 
   test_utils::execute_query(session, "INSERT INTO test(tweet_id, test_val) VALUES(0, 42);");
@@ -493,30 +529,33 @@ BOOST_AUTO_TEST_CASE(timestamp)
   BOOST_REQUIRE(cass_result_column_count(timestamp_result2.get()) == 1);
 
   cass_int64_t timestamp1 = 0;
-  cass_value_get_int64(cass_row_get_column(cass_result_first_row(timestamp_result1.get()), 0), &timestamp1);
+  cass_value_get_int64(cass_row_get_column(cass_result_first_row(timestamp_result1.get()), 0),
+                       &timestamp1);
 
   cass_int64_t timestamp2 = 0;
-  cass_value_get_int64(cass_row_get_column(cass_result_first_row(timestamp_result2.get()), 0), &timestamp2);
+  cass_value_get_int64(cass_row_get_column(cass_result_first_row(timestamp_result2.get()), 0),
+                       &timestamp2);
 
   BOOST_REQUIRE(timestamp1 != 0 && timestamp2 != 0);
   BOOST_REQUIRE(std::abs(timestamp2 - timestamp1 - pause_duration) < 100000); // Tolerance
 }
 
-BOOST_AUTO_TEST_CASE(counters)
-{
-  test_utils::execute_query(session, "CREATE TABLE test(tweet_id int PRIMARY KEY, incdec counter);");
+BOOST_AUTO_TEST_CASE(counters) {
+  test_utils::execute_query(session,
+                            "CREATE TABLE test(tweet_id int PRIMARY KEY, incdec counter);");
 
   int tweet_id = 0;
   for (int i = 0; i < 100; ++i) {
     // Create update statement for bound parameters
-    std::string update_query = str(boost::format("UPDATE %s SET incdec = incdec %s ? WHERE tweet_id = %d;")
-        % test_utils::SIMPLE_TABLE % ((i % 2) == 0 ? "-" : "+") % tweet_id);
+    std::string update_query =
+        str(boost::format("UPDATE %s SET incdec = incdec %s ? WHERE tweet_id = %d;") %
+            test_utils::SIMPLE_TABLE % ((i % 2) == 0 ? "-" : "+") % tweet_id);
     test_utils::CassStatementPtr statement(cass_statement_new(update_query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
     if (version.major_version == 1) {
-      update_query = str(boost::format("UPDATE %s SET incdec = incdec %s %d WHERE tweet_id = %d;")
-          % test_utils::SIMPLE_TABLE % ((i % 2) == 0 ? "-" : "+") % i % tweet_id);
+      update_query = str(boost::format("UPDATE %s SET incdec = incdec %s %d WHERE tweet_id = %d;") %
+                         test_utils::SIMPLE_TABLE % ((i % 2) == 0 ? "-" : "+") % i % tweet_id);
       statement = test_utils::CassStatementPtr(cass_statement_new(update_query.c_str(), 0));
     } else {
       BOOST_REQUIRE(cass_statement_bind_int64(statement.get(), 0, i) == CASS_OK);
@@ -528,28 +567,33 @@ BOOST_AUTO_TEST_CASE(counters)
 
   std::string select_query = str(boost::format("SELECT * FROM %s;") % test_utils::SIMPLE_TABLE);
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, select_query,  &result);
+  test_utils::execute_query(session, select_query, &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) == 1);
   BOOST_REQUIRE(cass_result_column_count(result.get()) > 0);
 
   cass_int64_t counter_value;
-  BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(cass_result_first_row(result.get()), 1), &counter_value) == CASS_OK);
+  BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(cass_result_first_row(result.get()), 1),
+                                     &counter_value) == CASS_OK);
   BOOST_REQUIRE(counter_value == 50);
 }
 
-BOOST_AUTO_TEST_CASE(rows_in_rows_out)
-{
+BOOST_AUTO_TEST_CASE(rows_in_rows_out) {
   CassConsistency consistency = CASS_CONSISTENCY_ONE;
 
   // TODO(mpenick): In "master" were there more tests planned here?
 
   {
-    test_utils::execute_query(session,
-                              str(boost::format("CREATE TABLE %s (tweet_id bigint PRIMARY KEY, t1 bigint, t2 bigint, t3 bigint);") % test_utils::SIMPLE_TABLE),
-                              NULL, consistency);
+    test_utils::execute_query(
+        session,
+        str(boost::format(
+                "CREATE TABLE %s (tweet_id bigint PRIMARY KEY, t1 bigint, t2 bigint, t3 bigint);") %
+            test_utils::SIMPLE_TABLE),
+        NULL, consistency);
 
     // Create insert statement for bound parameters
-    std::string insert_query(boost::str(boost::format("INSERT INTO %s (tweet_id, t1, t2, t3) VALUES (?, ?, ?, ?);") % test_utils::SIMPLE_TABLE));
+    std::string insert_query(
+        boost::str(boost::format("INSERT INTO %s (tweet_id, t1, t2, t3) VALUES (?, ?, ?, ?);") %
+                   test_utils::SIMPLE_TABLE));
 
     const size_t num_rows = 1000;
     for (size_t i = 0; i < num_rows; ++i) {
@@ -557,8 +601,9 @@ BOOST_AUTO_TEST_CASE(rows_in_rows_out)
 
       // Determine if bound parameters can be used based on C* version
       if (version.major_version == 1) {
-        std::string insert_query(boost::str(boost::format("INSERT INTO %s (tweet_id, t1, t2, t3) VALUES (%s, %s, %s, %s);") % test_utils::SIMPLE_TABLE
-                                          % i % (i + 1) % (i + 2) % (i + 3)));
+        std::string insert_query(boost::str(
+            boost::format("INSERT INTO %s (tweet_id, t1, t2, t3) VALUES (%s, %s, %s, %s);") %
+            test_utils::SIMPLE_TABLE % i % (i + 1) % (i + 2) % (i + 3)));
         statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
       } else {
         BOOST_REQUIRE(test_utils::Value<cass_int64_t>::bind(statement.get(), 0, i) == CASS_OK);
@@ -572,8 +617,8 @@ BOOST_AUTO_TEST_CASE(rows_in_rows_out)
       test_utils::wait_and_check_error(result_future.get(), 30 * test_utils::ONE_SECOND_IN_MICROS);
     }
 
-
-    std::string select_query(str(boost::format("SELECT tweet_id, t1, t2, t3 FROM %s LIMIT %d;") % test_utils::SIMPLE_TABLE % num_rows));
+    std::string select_query(str(boost::format("SELECT tweet_id, t1, t2, t3 FROM %s LIMIT %d;") %
+                                 test_utils::SIMPLE_TABLE % num_rows));
     test_utils::CassResultPtr result;
     test_utils::execute_query(session, select_query, &result, consistency);
     BOOST_REQUIRE(cass_result_row_count(result.get()) == num_rows);
@@ -584,10 +629,18 @@ BOOST_AUTO_TEST_CASE(rows_in_rows_out)
     while (cass_iterator_next(iterator.get())) {
       cass_int64_t tweet_id = 0;
       cass_int64_t t1 = 0, t2 = 0, t3 = 0;
-      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(cass_row_get_column(cass_iterator_get_row(iterator.get()), 0), &tweet_id) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(cass_row_get_column(cass_iterator_get_row(iterator.get()), 1), &t1) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(cass_row_get_column(cass_iterator_get_row(iterator.get()), 2), &t2) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(cass_row_get_column(cass_iterator_get_row(iterator.get()), 3), &t3) == CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(
+                        cass_row_get_column(cass_iterator_get_row(iterator.get()), 0), &tweet_id) ==
+                    CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(
+                        cass_row_get_column(cass_iterator_get_row(iterator.get()), 1), &t1) ==
+                    CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(
+                        cass_row_get_column(cass_iterator_get_row(iterator.get()), 2), &t2) ==
+                    CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<cass_int64_t>::get(
+                        cass_row_get_column(cass_iterator_get_row(iterator.get()), 3), &t3) ==
+                    CASS_OK);
       BOOST_REQUIRE(t1 == tweet_id + 1 && t2 == tweet_id + 2 && t3 == tweet_id + 3);
       row_count++;
     }
@@ -596,10 +649,11 @@ BOOST_AUTO_TEST_CASE(rows_in_rows_out)
   }
 }
 
-BOOST_AUTO_TEST_CASE(column_name)
-{
-  test_utils::execute_query(session, "CREATE TABLE test (key int PRIMARY KEY, v1 text, v2 int, v3 bigint, v4 float);");
-  test_utils::execute_query(session, "INSERT INTO test (key, v1, v2, v3, v4) VALUES (0, 'abc', 123, 456, 0.123456);");
+BOOST_AUTO_TEST_CASE(column_name) {
+  test_utils::execute_query(
+      session, "CREATE TABLE test (key int PRIMARY KEY, v1 text, v2 int, v3 bigint, v4 float);");
+  test_utils::execute_query(
+      session, "INSERT INTO test (key, v1, v2, v3, v4) VALUES (0, 'abc', 123, 456, 0.123456);");
 
   test_utils::CassResultPtr result;
   test_utils::execute_query(session, "SELECT * FROM test;", &result);
@@ -630,10 +684,10 @@ BOOST_AUTO_TEST_CASE(column_name)
  * @test_category basic
  *
  */
-BOOST_AUTO_TEST_CASE(empty_results)
-{
+BOOST_AUTO_TEST_CASE(empty_results) {
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, "CREATE TABLE test (key int, value int, PRIMARY KEY (key))", &result);
+  test_utils::execute_query(session, "CREATE TABLE test (key int, value int, PRIMARY KEY (key))",
+                            &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) == 0);
   BOOST_REQUIRE(is_result_empty(result.get()));
 
@@ -663,14 +717,16 @@ BOOST_AUTO_TEST_CASE(empty_results)
  * @test_category basic
  *
  */
-BOOST_AUTO_TEST_CASE(unset_parameters)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(unset_parameters) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
 
-  test_utils::execute_query(session,
-                            str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value text)") % table_name));
+  test_utils::execute_query(
+      session,
+      str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value text)") % table_name));
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES(?, ?)") % table_name);
+  std::string insert_query =
+      str(boost::format("INSERT INTO %s (key, value) VALUES(?, ?)") % table_name);
   test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
 
   // Determine if bound parameters can be used based on C* version
@@ -680,8 +736,9 @@ BOOST_AUTO_TEST_CASE(unset_parameters)
   }
 
   // Insert known values
-  test_utils::execute_query(session,
-                            str(boost::format("INSERT INTO %s (key, value) VALUES ('key1', 'value1')") % table_name));
+  test_utils::execute_query(
+      session,
+      str(boost::format("INSERT INTO %s (key, value) VALUES ('key1', 'value1')") % table_name));
 
   cass_statement_bind_string(statement.get(), 0, "key1");
 
@@ -699,8 +756,7 @@ BOOST_AUTO_TEST_CASE(unset_parameters)
   }
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session,
-                            str(boost::format("SELECT * FROM %s") % table_name), &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
 
   // Check to make sure the known values are still present
   CassString key;
@@ -722,18 +778,21 @@ BOOST_AUTO_TEST_CASE(unset_parameters)
  * @test_category basic
  *
  */
-BOOST_AUTO_TEST_CASE(bind_blob_as_string)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(bind_blob_as_string) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
 
-  test_utils::execute_query(session,
-                            str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value blob)") % table_name));
+  test_utils::execute_query(
+      session,
+      str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value blob)") % table_name));
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES(?, ?)") % table_name);
+  std::string insert_query =
+      str(boost::format("INSERT INTO %s (key, value) VALUES(?, ?)") % table_name);
 
   // Prepared needed to validate bind type information
   test_utils::CassPreparedPtr prepared = test_utils::prepare(session, insert_query);
-  test_utils::CassStatementPtr statement(test_utils::CassStatementPtr(cass_prepared_bind(prepared.get())));
+  test_utils::CassStatementPtr statement(
+      test_utils::CassStatementPtr(cass_prepared_bind(prepared.get())));
 
   BOOST_CHECK_EQUAL(cass_statement_bind_string(statement.get(), 0, "key1"), CASS_OK);
 
@@ -746,8 +805,7 @@ BOOST_AUTO_TEST_CASE(bind_blob_as_string)
   BOOST_REQUIRE(rc == CASS_OK);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session,
-                            str(boost::format("SELECT * FROM %s") % table_name), &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
 
   // Check to make sure the known values are still present
   CassString key;
diff --git a/test/integration_tests/src/test_batch.cpp b/test/integration_tests/src/test_batch.cpp
index 5f0c8c864..25683c4ff 100644
--- a/test/integration_tests/src/test_batch.cpp
+++ b/test/integration_tests/src/test_batch.cpp
@@ -18,40 +18,48 @@
 #include "test_utils.hpp"
 
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 struct BatchTests : public test_utils::SingleSessionTest {
   static const char* SIMPLE_TABLE_NAME;
   static const char* COUNTER_TABLE_NAME;
 
-  BatchTests() : SingleSessionTest(3,0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  BatchTests()
+      : SingleSessionTest(3, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val text);") % SIMPLE_TABLE_NAME));
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val counter);") % COUNTER_TABLE_NAME));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val text);") %
+                     SIMPLE_TABLE_NAME));
+    test_utils::execute_query(
+        session,
+        str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val counter);") %
+            COUNTER_TABLE_NAME));
   }
 
   ~BatchTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-        % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   void validate_results(int num_rows) {
-    std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % BatchTests::SIMPLE_TABLE_NAME);
+    std::string select_query =
+        str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % BatchTests::SIMPLE_TABLE_NAME);
 
-    for (int y = 0; y < num_rows; y++)
-    {
+    for (int y = 0; y < num_rows; y++) {
       test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE(cass_statement_bind_int32(select_statement.get(), 0, y) == CASS_OK);
-      test_utils::CassFuturePtr select_future(cass_session_execute(session, select_statement.get()));
+      test_utils::CassFuturePtr select_future(
+          cass_session_execute(session, select_statement.get()));
       test_utils::wait_and_check_error(select_future.get());
       test_utils::CassResultPtr result(cass_future_get_result(select_future.get()));
       const CassValue* column = cass_row_get_column(cass_result_first_row(result.get()), 1);
@@ -59,7 +67,8 @@ struct BatchTests : public test_utils::SingleSessionTest {
       CassString result_value;
       BOOST_REQUIRE(cass_value_type(column) == CASS_VALUE_TYPE_VARCHAR);
       BOOST_REQUIRE(test_utils::Value<CassString>::get(column, &result_value) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<CassString>::equal(result_value, str(boost::format("test data %s") % y).c_str()));
+      BOOST_REQUIRE(test_utils::Value<CassString>::equal(
+          result_value, str(boost::format("test data %s") % y).c_str()));
     }
   }
 };
@@ -69,105 +78,121 @@ const char* BatchTests::COUNTER_TABLE_NAME = "counter_batch_testing_table";
 
 BOOST_AUTO_TEST_SUITE(batch)
 
-BOOST_AUTO_TEST_CASE(prepared)
-{
+BOOST_AUTO_TEST_CASE(prepared) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     BatchTests tester;
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") % BatchTests::SIMPLE_TABLE_NAME);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") %
+            BatchTests::SIMPLE_TABLE_NAME);
 
-    test_utils::CassFuturePtr prepared_future(cass_session_prepare(tester.session, insert_query.c_str()));
+    test_utils::CassFuturePtr prepared_future(
+        cass_session_prepare(tester.session, insert_query.c_str()));
     test_utils::wait_and_check_error(prepared_future.get());
     test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
-    for (int x = 0; x < 4; x++)
-    {
+    for (int x = 0; x < 4; x++) {
       test_utils::CassStatementPtr insert_statement(cass_prepared_bind(prepared.get()));
       BOOST_REQUIRE(cass_statement_bind_int32(insert_statement.get(), 0, x) == CASS_OK);
-      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1, str(boost::format("test data %s") % x).c_str()) == CASS_OK);
+      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1,
+                                               str(boost::format("test data %s") % x).c_str()) ==
+                    CASS_OK);
       cass_batch_add_statement(batch.get(), insert_statement.get());
     }
 
-    test_utils::CassFuturePtr insert_future(cass_session_execute_batch(tester.session, batch.get()));
+    test_utils::CassFuturePtr insert_future(
+        cass_session_execute_batch(tester.session, batch.get()));
     test_utils::wait_and_check_error(insert_future.get());
 
     tester.validate_results(4);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping batch/prepared" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping batch/prepared" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(simple)
-{
+BOOST_AUTO_TEST_CASE(simple) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     BatchTests tester;
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") % BatchTests::SIMPLE_TABLE_NAME);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") %
+            BatchTests::SIMPLE_TABLE_NAME);
 
-    for (int x = 0; x < 4; x++)
-    {
+    for (int x = 0; x < 4; x++) {
       test_utils::CassStatementPtr insert_statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE(cass_statement_bind_int32(insert_statement.get(), 0, x) == CASS_OK);
-      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1, str(boost::format("test data %s") % x).c_str()) == CASS_OK);
+      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1,
+                                               str(boost::format("test data %s") % x).c_str()) ==
+                    CASS_OK);
       cass_batch_add_statement(batch.get(), insert_statement.get());
     }
 
-    test_utils::CassFuturePtr insert_future(cass_session_execute_batch(tester.session, batch.get()));
+    test_utils::CassFuturePtr insert_future(
+        cass_session_execute_batch(tester.session, batch.get()));
     test_utils::wait_and_check_error(insert_future.get());
 
     tester.validate_results(4);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping batch/simple" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping batch/simple" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(mixed)
-{
+BOOST_AUTO_TEST_CASE(mixed) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     BatchTests tester;
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") % BatchTests::SIMPLE_TABLE_NAME);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(?, ?);") %
+            BatchTests::SIMPLE_TABLE_NAME);
 
-    test_utils::CassFuturePtr prepared_future(cass_session_prepare(tester.session, insert_query.c_str()));
+    test_utils::CassFuturePtr prepared_future(
+        cass_session_prepare(tester.session, insert_query.c_str()));
     test_utils::wait_and_check_error(prepared_future.get());
     test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
     int batch_size = (version >= "2.2.0" ? 100 : 1000);
-    for (int x = 0; x < batch_size; x++)
-    {
+    for (int x = 0; x < batch_size; x++) {
       test_utils::CassStatementPtr insert_statement;
       if (x % 2 == 0) {
         insert_statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
       } else {
-        insert_statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 2));
+        insert_statement =
+            test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 2));
       }
       BOOST_REQUIRE(cass_statement_bind_int32(insert_statement.get(), 0, x) == CASS_OK);
-      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1, str(boost::format("test data %s") % x).c_str()) == CASS_OK);
+      BOOST_REQUIRE(cass_statement_bind_string(insert_statement.get(), 1,
+                                               str(boost::format("test data %s") % x).c_str()) ==
+                    CASS_OK);
       cass_batch_add_statement(batch.get(), insert_statement.get());
     }
 
-    test_utils::CassFuturePtr insert_future(cass_session_execute_batch(tester.session, batch.get()));
+    test_utils::CassFuturePtr insert_future(
+        cass_session_execute_batch(tester.session, batch.get()));
     test_utils::wait_and_check_error(insert_future.get());
 
     tester.validate_results(batch_size);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping batch/mixed" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping batch/mixed" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(invalid_batch_type)
-{
+BOOST_AUTO_TEST_CASE(invalid_batch_type) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     BatchTests tester;
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
-    std::string update_query = str(boost::format("UPDATE %s SET test_val = test_val + ? WHERE tweet_id = ?;") % BatchTests::COUNTER_TABLE_NAME);
+    std::string update_query =
+        str(boost::format("UPDATE %s SET test_val = test_val + ? WHERE tweet_id = ?;") %
+            BatchTests::COUNTER_TABLE_NAME);
 
     test_utils::CassStatementPtr update_statement(cass_statement_new(update_query.c_str(), 2));
 
@@ -176,34 +201,38 @@ BOOST_AUTO_TEST_CASE(invalid_batch_type)
     BOOST_REQUIRE(cass_statement_bind_int32(update_statement.get(), 1, some_value) == CASS_OK);
     cass_batch_add_statement(batch.get(), update_statement.get());
 
-    test_utils::CassFuturePtr update_future(cass_session_execute_batch(tester.session, batch.get()));
+    test_utils::CassFuturePtr update_future(
+        cass_session_execute_batch(tester.session, batch.get()));
     BOOST_REQUIRE(cass_future_error_code(update_future.get()) == CASS_ERROR_SERVER_INVALID_QUERY);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping batch/invalid_batch_type" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping batch/invalid_batch_type" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(counter_mixed)
-{
+BOOST_AUTO_TEST_CASE(counter_mixed) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     BatchTests tester;
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_COUNTER));
-    std::string update_query = str(boost::format("UPDATE %s SET test_val = test_val + ? WHERE tweet_id = ?;") % BatchTests::COUNTER_TABLE_NAME);
+    std::string update_query =
+        str(boost::format("UPDATE %s SET test_val = test_val + ? WHERE tweet_id = ?;") %
+            BatchTests::COUNTER_TABLE_NAME);
 
-    test_utils::CassFuturePtr prepared_future(cass_session_prepare(tester.session, update_query.c_str()));
+    test_utils::CassFuturePtr prepared_future(
+        cass_session_prepare(tester.session, update_query.c_str()));
     test_utils::wait_and_check_error(prepared_future.get());
     test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
     unsigned int batch_size = (version >= "2.2.0" ? 100 : 1000);
-    for (unsigned int x = 0; x < batch_size; x++)
-    {
+    for (unsigned int x = 0; x < batch_size; x++) {
       test_utils::CassStatementPtr update_statement;
       if (x % 2 == 0) {
         update_statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
       } else {
-        update_statement = test_utils::CassStatementPtr(cass_statement_new(update_query.c_str(), 2));
+        update_statement =
+            test_utils::CassStatementPtr(cass_statement_new(update_query.c_str(), 2));
       }
       cass_statement_set_consistency(update_statement.get(), CASS_CONSISTENCY_QUORUM);
       BOOST_REQUIRE(cass_statement_bind_int64(update_statement.get(), 0, x) == CASS_OK);
@@ -211,10 +240,12 @@ BOOST_AUTO_TEST_CASE(counter_mixed)
       cass_batch_add_statement(batch.get(), update_statement.get());
     }
 
-    test_utils::CassFuturePtr update_future(cass_session_execute_batch(tester.session, batch.get()));
+    test_utils::CassFuturePtr update_future(
+        cass_session_execute_batch(tester.session, batch.get()));
     test_utils::wait_and_check_error(update_future.get());
 
-    std::string select_query = str(boost::format("SELECT * FROM %s;") % BatchTests::COUNTER_TABLE_NAME);
+    std::string select_query =
+        str(boost::format("SELECT * FROM %s;") % BatchTests::COUNTER_TABLE_NAME);
 
     test_utils::CassResultPtr result;
 
@@ -239,7 +270,8 @@ BOOST_AUTO_TEST_CASE(counter_mixed)
       BOOST_REQUIRE(tweet_id == test_val);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping batch/counter_mixed" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping batch/counter_mixed" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_by_name.cpp b/test/integration_tests/src/test_by_name.cpp
index b4d164833..f166a3701 100644
--- a/test/integration_tests/src/test_by_name.cpp
+++ b/test/integration_tests/src/test_by_name.cpp
@@ -14,42 +14,48 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 #define INSERT_BY_NAME "INSERT INTO by_name (key, a, b, c) VALUES (?, ?, ?, ?)"
-#define INSERT_BY_NAME_CASE_SENSITIVE "INSERT INTO by_name (key, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?)"
-#define INSERT_BY_NAME_NULL "INSERT INTO by_name (key, a, b, c, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?, ?, ?, ?)"
+#define INSERT_BY_NAME_CASE_SENSITIVE \
+  "INSERT INTO by_name (key, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?)"
+#define INSERT_BY_NAME_NULL \
+  "INSERT INTO by_name (key, a, b, c, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?, ?, ?, ?)"
 
 struct ByNameTests : public test_utils::SingleSessionTest {
-  ByNameTests() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  ByNameTests()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
-    test_utils::execute_query(session, "CREATE TABLE by_name (key uuid PRIMARY KEY, a int, b boolean, c text, abc float, \"ABC\" float, \"aBc\" float)");
+    test_utils::execute_query(session, "CREATE TABLE by_name (key uuid PRIMARY KEY, a int, b "
+                                       "boolean, c text, abc float, \"ABC\" float, \"aBc\" float)");
 
-    test_utils::execute_query(session, "CREATE TABLE bytes_by_name (key uuid PRIMARY KEY, blobs blob, varints varint)");
+    test_utils::execute_query(
+        session, "CREATE TABLE bytes_by_name (key uuid PRIMARY KEY, blobs blob, varints varint)");
   }
 
   ~ByNameTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-        % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   test_utils::CassResultPtr select_all_from_by_name() {
     test_utils::CassResultPtr result;
     test_utils::execute_query(session, "SELECT * FROM by_name", &result);
-    BOOST_REQUIRE(cass_result_column_count(result.get()) ==  7);
+    BOOST_REQUIRE(cass_result_column_count(result.get()) == 7);
     BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
     return result;
   }
@@ -112,9 +118,12 @@ struct ByNameTests : public test_utils::SingleSessionTest {
     CassUuid key = test_utils::generate_time_uuid(uuid_gen);
 
     BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "key", key), CASS_OK);
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"abc\"", 1.1f), CASS_OK);
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"ABC\"", 2.2f), CASS_OK);
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"aBc\"", 3.3f), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"abc\"", 1.1f),
+                        CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"ABC\"", 2.2f),
+                        CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"aBc\"", 3.3f),
+                        CASS_OK);
 
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
@@ -179,45 +188,44 @@ struct ByNameTests : public test_utils::SingleSessionTest {
 
 BOOST_FIXTURE_TEST_SUITE(by_name, ByNameTests)
 
-BOOST_AUTO_TEST_CASE(bind_and_get_prepared)
-{
+BOOST_AUTO_TEST_CASE(bind_and_get_prepared) {
   test_utils::CassPreparedPtr prepared = test_utils::prepare(session, INSERT_BY_NAME);
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
   test_bind_and_get(statement);
 }
 
-BOOST_AUTO_TEST_CASE(bind_and_get)
-{
+BOOST_AUTO_TEST_CASE(bind_and_get) {
   if (version >= "2.1.0") {
     test_utils::CassStatementPtr statement(cass_statement_new(INSERT_BY_NAME, 4));
     test_bind_and_get(statement);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping by_name/bind_and_get" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping by_name/bind_and_get" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(bind_and_get_case_sensitive_prepared)
-{
-  test_utils::CassPreparedPtr prepared = test_utils::prepare(session, INSERT_BY_NAME_CASE_SENSITIVE);
+BOOST_AUTO_TEST_CASE(bind_and_get_case_sensitive_prepared) {
+  test_utils::CassPreparedPtr prepared =
+      test_utils::prepare(session, INSERT_BY_NAME_CASE_SENSITIVE);
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
   test_bind_and_get_case_sensitive(statement);
 }
 
-BOOST_AUTO_TEST_CASE(bind_and_get_case_sensitive)
-{
+BOOST_AUTO_TEST_CASE(bind_and_get_case_sensitive) {
   if (version >= "2.1.0") {
     test_utils::CassStatementPtr statement(cass_statement_new(INSERT_BY_NAME_CASE_SENSITIVE, 4));
     test_bind_and_get_case_sensitive(statement);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping by_name/bind_and_get_case_sensitive" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping by_name/bind_and_get_case_sensitive" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(bind_multiple_columns)
-{
-  test_utils::CassPreparedPtr prepared = test_utils::prepare(session, "INSERT INTO by_name (key, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?)");
+BOOST_AUTO_TEST_CASE(bind_multiple_columns) {
+  test_utils::CassPreparedPtr prepared = test_utils::prepare(
+      session, "INSERT INTO by_name (key, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?)");
 
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
 
@@ -262,19 +270,22 @@ BOOST_AUTO_TEST_CASE(bind_multiple_columns)
   BOOST_CHECK(abc == 1.23f);
 }
 
-BOOST_AUTO_TEST_CASE(bind_invalid_name)
-{
-  test_utils::CassPreparedPtr prepared = test_utils::prepare(session, "INSERT INTO by_name (key, a, b, c, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?, ?, ?, ?)");
+BOOST_AUTO_TEST_CASE(bind_invalid_name) {
+  test_utils::CassPreparedPtr prepared = test_utils::prepare(
+      session,
+      "INSERT INTO by_name (key, a, b, c, abc, \"ABC\", \"aBc\") VALUES (?, ?, ?, ?, ?, ?, ?)");
 
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
 
-  BOOST_REQUIRE_EQUAL(cass_statement_bind_int32_by_name(statement.get(), "d", 0), CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
-  BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"aBC\"", 0.0), CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
-  BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"abC\"", 0.0), CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
+  BOOST_REQUIRE_EQUAL(cass_statement_bind_int32_by_name(statement.get(), "d", 0),
+                      CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
+  BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"aBC\"", 0.0),
+                      CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
+  BOOST_REQUIRE_EQUAL(cass_statement_bind_float_by_name(statement.get(), "\"abC\"", 0.0),
+                      CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
 }
 
-BOOST_AUTO_TEST_CASE(get_invalid_name)
-{
+BOOST_AUTO_TEST_CASE(get_invalid_name) {
   // Create insert statement for bound parameters
   std::string insert_query = "INSERT INTO by_name (key, a) VALUES (?, ?)";
   test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
@@ -302,20 +313,19 @@ BOOST_AUTO_TEST_CASE(get_invalid_name)
   BOOST_CHECK(cass_row_get_column_by_name(row, "\"abC\"") == NULL);
 }
 
-BOOST_AUTO_TEST_CASE(null_prepared)
-{
+BOOST_AUTO_TEST_CASE(null_prepared) {
   test_utils::CassPreparedPtr prepared = test_utils::prepare(session, INSERT_BY_NAME_NULL);
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
   test_null(statement);
 }
 
-BOOST_AUTO_TEST_CASE(null)
-{
+BOOST_AUTO_TEST_CASE(null) {
   if (version >= "2.1.0") {
     test_utils::CassStatementPtr statement(cass_statement_new(INSERT_BY_NAME_NULL, 7));
     test_null(statement);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping by_name/null" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping by_name/null" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -330,22 +340,28 @@ BOOST_AUTO_TEST_CASE(null)
  * @test_category prepared_statements:binding
  * @jira_ticket CPP-272 [https://datastax-oss.atlassian.net/browse/CPP-272]
  */
-BOOST_AUTO_TEST_CASE(bind_bytes_by_name)
-{
-  test_utils::CassPreparedPtr prepared = test_utils::prepare(session, "INSERT INTO bytes_by_name (key, blobs, varints) VALUES (?, ?, ?)");
+BOOST_AUTO_TEST_CASE(bind_bytes_by_name) {
+  test_utils::CassPreparedPtr prepared = test_utils::prepare(
+      session, "INSERT INTO bytes_by_name (key, blobs, varints) VALUES (?, ?, ?)");
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
 
   CassUuid key = test_utils::generate_time_uuid(uuid_gen);
   CassBytes blob;
-  blob.data = reinterpret_cast<const cass_byte_t *>("68971169783116971203269110116101114112114105115101329911211245100114105118101114");
+  blob.data = reinterpret_cast<const cass_byte_t*>(
+      "68971169783116971203269110116101114112114105115101329911211245100114105118101114");
   blob.size = strlen(reinterpret_cast<const char*>(blob.data));
   CassBytes varint;
-  varint.data = reinterpret_cast<const cass_byte_t *>("1234567890123456789012345678901234567890");
+  varint.data = reinterpret_cast<const cass_byte_t*>("1234567890123456789012345678901234567890");
   varint.size = strlen(reinterpret_cast<const char*>(varint.data));
 
   BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "key", key), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_statement_bind_bytes_by_name(statement.get(), "blobs", const_cast<cass_byte_t *>(blob.data), blob.size), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_statement_bind_bytes_by_name(statement.get(), "varints", const_cast<cass_byte_t *>(varint.data), varint.size), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_statement_bind_bytes_by_name(
+                          statement.get(), "blobs", const_cast<cass_byte_t*>(blob.data), blob.size),
+                      CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_statement_bind_bytes_by_name(statement.get(), "varints",
+                                                        const_cast<cass_byte_t*>(varint.data),
+                                                        varint.size),
+                      CASS_OK);
 
   test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
   test_utils::wait_and_check_error(future.get());
@@ -367,7 +383,8 @@ BOOST_AUTO_TEST_CASE(bind_bytes_by_name)
   value = cass_row_get_column_by_name(row, "varints");
   CassBytes result_varint;
   BOOST_REQUIRE(value != NULL);
-  BOOST_REQUIRE_EQUAL(cass_value_get_bytes(value, &result_varint.data, &result_varint.size), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_value_get_bytes(value, &result_varint.data, &result_varint.size),
+                      CASS_OK);
   BOOST_REQUIRE(test_utils::Value<CassBytes>::equal(varint, result_varint));
 }
 
diff --git a/test/integration_tests/src/test_collections.cpp b/test/integration_tests/src/test_collections.cpp
index 8ec9336c6..6397156c2 100644
--- a/test/integration_tests/src/test_collections.cpp
+++ b/test/integration_tests/src/test_collections.cpp
@@ -19,32 +19,39 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 struct CollectionsTests : public test_utils::MultipleNodesTest {
-  CollectionsTests() : MultipleNodesTest(1, 0) {}
-
-  template<class T>
-  void insert_collection_value(CassSession* session, CassValueType type, CassValueType primary_type, const std::vector<T>& values) {
-    std::string table_name = str(boost::format("%s_%s") % test_utils::SIMPLE_TABLE % test_utils::get_value_type(primary_type));
-    std::string type_name = str(boost::format("%s<%s>") % test_utils::get_value_type(type) % test_utils::get_value_type(primary_type));
-
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val %s);")
-      % table_name % type_name));
-
-    test_utils::CassCollectionPtr input(cass_collection_new(static_cast<CassCollectionType>(type), values.size()));
-
-    for (typename std::vector<T>::const_iterator it = values.begin(),
-      end = values.end(); it != end; ++it) {
+  CollectionsTests()
+      : MultipleNodesTest(1, 0) {}
+
+  template <class T>
+  void insert_collection_value(CassSession* session, CassValueType type, CassValueType primary_type,
+                               const std::vector<T>& values) {
+    std::string table_name = str(boost::format("%s_%s") % test_utils::SIMPLE_TABLE %
+                                 test_utils::get_value_type(primary_type));
+    std::string type_name = str(boost::format("%s<%s>") % test_utils::get_value_type(type) %
+                                test_utils::get_value_type(primary_type));
+
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val %s);") %
+                     table_name % type_name));
+
+    test_utils::CassCollectionPtr input(
+        cass_collection_new(static_cast<CassCollectionType>(type), values.size()));
+
+    for (typename std::vector<T>::const_iterator it = values.begin(), end = values.end(); it != end;
+         ++it) {
       test_utils::Value<T>::append(input.get(), *it);
     }
 
-    std::string query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(0, ?);") % table_name);
+    std::string query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(0, ?);") % table_name);
     test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
@@ -59,7 +66,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
     test_utils::wait_and_check_error(result_future.get());
 
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session, str(boost::format("SELECT * FROM %s WHERE tweet_id = 0;") % table_name), &result);
+    test_utils::execute_query(
+        session, str(boost::format("SELECT * FROM %s WHERE tweet_id = 0;") % table_name), &result);
     BOOST_REQUIRE(cass_result_row_count(result.get()) == 1);
     BOOST_REQUIRE(cass_result_column_count(result.get()) > 0);
 
@@ -76,7 +84,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       size_t i = 0;
       while (cass_iterator_next(iterator.get())) {
         T result_value;
-        BOOST_REQUIRE(test_utils::Value<T>::get(cass_iterator_get_value(iterator.get()), &result_value) == CASS_OK);
+        BOOST_REQUIRE(test_utils::Value<T>::get(cass_iterator_get_value(iterator.get()),
+                                                &result_value) == CASS_OK);
         BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) == primary_type);
         BOOST_REQUIRE(test_utils::Value<T>::equal(result_value, values[i++]));
       }
@@ -84,7 +93,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
     } else if (type == CASS_VALUE_TYPE_SET) {
       while (cass_iterator_next(iterator.get())) {
         T result_value;
-        BOOST_REQUIRE(test_utils::Value<T>::get(cass_iterator_get_value(iterator.get()), &result_value) == CASS_OK);
+        BOOST_REQUIRE(test_utils::Value<T>::get(cass_iterator_get_value(iterator.get()),
+                                                &result_value) == CASS_OK);
         BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) == primary_type);
         BOOST_REQUIRE(std::find(values.begin(), values.end(), result_value) != values.end());
       }
@@ -96,42 +106,51 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
   void insert_collection_all_types(CassValueType type) {
     test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-    test_utils::execute_query(session.get(), str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                                 % test_utils::SIMPLE_KEYSPACE % "1"));
+    test_utils::execute_query(session.get(),
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
 
-    test_utils::execute_query(session.get(), str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query(session.get(),
+                              str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
     if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
       {
         std::vector<cass_int8_t> values;
-        for (cass_int8_t i = 1; i <= 3; ++i) values.push_back(i);
+        for (cass_int8_t i = 1; i <= 3; ++i)
+          values.push_back(i);
         insert_collection_value<cass_int8_t>(session.get(), type, CASS_VALUE_TYPE_TINY_INT, values);
       }
       {
         std::vector<cass_int16_t> values;
-        for (cass_int16_t i = 1; i <= 3; ++i) values.push_back(i);
-        insert_collection_value<cass_int16_t>(session.get(), type, CASS_VALUE_TYPE_SMALL_INT, values);
+        for (cass_int16_t i = 1; i <= 3; ++i)
+          values.push_back(i);
+        insert_collection_value<cass_int16_t>(session.get(), type, CASS_VALUE_TYPE_SMALL_INT,
+                                              values);
       }
       {
         std::vector<CassDate> values;
         cass_uint32_t min = test_utils::Value<CassDate>::min_value();
-        for (cass_uint32_t i = 0; i <= 3; ++i) values.push_back(min + i);
+        for (cass_uint32_t i = 0; i <= 3; ++i)
+          values.push_back(min + i);
         insert_collection_value<CassDate>(session.get(), type, CASS_VALUE_TYPE_DATE, values);
       }
       {
         std::vector<CassTime> values;
-        for (cass_int64_t i = 0; i <= 3; ++i) values.push_back(i);
+        for (cass_int64_t i = 0; i <= 3; ++i)
+          values.push_back(i);
         insert_collection_value<CassTime>(session.get(), type, CASS_VALUE_TYPE_TIME, values);
       }
     }
     {
       std::vector<cass_int32_t> values;
-      for (cass_int32_t i = 1; i <= 3; ++i) values.push_back(i);
+      for (cass_int32_t i = 1; i <= 3; ++i)
+        values.push_back(i);
       insert_collection_value<cass_int32_t>(session.get(), type, CASS_VALUE_TYPE_INT, values);
     }
     {
       std::vector<cass_int64_t> values;
-      for (cass_int64_t i = 1LL; i <= 3LL; ++i) values.push_back(i);
+      for (cass_int64_t i = 1LL; i <= 3LL; ++i)
+        values.push_back(i);
       insert_collection_value<cass_int64_t>(session.get(), type, CASS_VALUE_TYPE_BIGINT, values);
     }
     {
@@ -154,33 +173,35 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values.push_back(CassString("def"));
       values.push_back(CassString("ghi"));
       insert_collection_value<CassString>(session.get(), type, CASS_VALUE_TYPE_ASCII, values);
-      insert_collection_value<CassString>(session.get(), type, CASS_VALUE_TYPE_VARCHAR,  values); // NOTE: text is alias for varchar
+      insert_collection_value<CassString>(session.get(), type, CASS_VALUE_TYPE_VARCHAR,
+                                          values); // NOTE: text is alias for varchar
     }
     {
       std::vector<CassBytes> values;
       values.push_back(test_utils::bytes_from_string("123"));
       values.push_back(test_utils::bytes_from_string("456"));
       values.push_back(test_utils::bytes_from_string("789"));
-      insert_collection_value<CassBytes>(session.get(), type, CASS_VALUE_TYPE_BLOB,  values);
+      insert_collection_value<CassBytes>(session.get(), type, CASS_VALUE_TYPE_BLOB, values);
     }
     {
       std::vector<CassInet> values;
       values.push_back(test_utils::inet_v4_from_int(16777343));
       values.push_back(test_utils::inet_v4_from_int(16777344));
       values.push_back(test_utils::inet_v4_from_int(16777345));
-      insert_collection_value<CassInet>(session.get(), type, CASS_VALUE_TYPE_INET,  values);
+      insert_collection_value<CassInet>(session.get(), type, CASS_VALUE_TYPE_INET, values);
     }
     {
       std::vector<CassUuid> values;
       for (int i = 0; i < 3; ++i) {
         values.push_back(test_utils::generate_time_uuid(uuid_gen));
       }
-      insert_collection_value<CassUuid>(session.get(), type, CASS_VALUE_TYPE_UUID,  values);
+      insert_collection_value<CassUuid>(session.get(), type, CASS_VALUE_TYPE_UUID, values);
     }
     {
-      const cass_uint8_t varint[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-                                      112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-                                      84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+      const cass_uint8_t varint[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,
+                                      25,  32,  135, 129, 180, 112, 176, 158, 120, 246, 235,
+                                      29,  145, 238, 50,  108, 239, 219, 100, 250, 84,  6,
+                                      186, 148, 76,  230, 46,  181, 89,  239, 247 };
       std::vector<CassDecimal> values;
       for (int i = 0; i < 3; ++i) {
         CassDecimal value;
@@ -189,43 +210,49 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
         value.varint_size = sizeof(varint);
         values.push_back(value);
       }
-      insert_collection_value<CassDecimal>(session.get(), type, CASS_VALUE_TYPE_DECIMAL,  values);
+      insert_collection_value<CassDecimal>(session.get(), type, CASS_VALUE_TYPE_DECIMAL, values);
     }
 
     // C* doesn't support set<Duration>.
-    if (type != CASS_VALUE_TYPE_SET && ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4)) {
+    if (type != CASS_VALUE_TYPE_SET &&
+        ((version.major_version >= 3 && version.minor_version >= 10) ||
+         version.major_version >= 4)) {
       std::vector<CassDuration> values;
       for (int i = 0; i < 3; ++i) {
         CassDuration value(1, 2, 3);
         values.push_back(value);
       }
-      insert_collection_value<CassDuration>(session.get(), type, CASS_VALUE_TYPE_DURATION,  values);
+      insert_collection_value<CassDuration>(session.get(), type, CASS_VALUE_TYPE_DURATION, values);
     }
 
     drop_keyspace(session);
   }
 
-  template<class K, class V>
-  void insert_map_value(CassSession* session, CassValueType primary_type, CassValueType secondary_type, const std::map<K, V>& values) {
-    std::string table_name = str(boost::format("%s_%s_%s") % test_utils::SIMPLE_TABLE
-                                 % test_utils::get_value_type(primary_type)
-                                 % test_utils::get_value_type(secondary_type));
-    std::string type_name = str(boost::format("%s<%s, %s>") % test_utils::get_value_type(CASS_VALUE_TYPE_MAP)
-                                % test_utils::get_value_type(primary_type)
-                                % test_utils::get_value_type(secondary_type));
-
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val %s);")
-                                           % table_name % type_name));
-
-    test_utils::CassCollectionPtr input(cass_collection_new(CASS_COLLECTION_TYPE_MAP, values.size()));
-
-    for (typename std::map<K, V>::const_iterator it = values.begin(),
-        end = values.end(); it != end; ++it) {
+  template <class K, class V>
+  void insert_map_value(CassSession* session, CassValueType primary_type,
+                        CassValueType secondary_type, const std::map<K, V>& values) {
+    std::string table_name =
+        str(boost::format("%s_%s_%s") % test_utils::SIMPLE_TABLE %
+            test_utils::get_value_type(primary_type) % test_utils::get_value_type(secondary_type));
+    std::string type_name =
+        str(boost::format("%s<%s, %s>") % test_utils::get_value_type(CASS_VALUE_TYPE_MAP) %
+            test_utils::get_value_type(primary_type) % test_utils::get_value_type(secondary_type));
+
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, test_val %s);") %
+                     table_name % type_name));
+
+    test_utils::CassCollectionPtr input(
+        cass_collection_new(CASS_COLLECTION_TYPE_MAP, values.size()));
+
+    for (typename std::map<K, V>::const_iterator it = values.begin(), end = values.end(); it != end;
+         ++it) {
       test_utils::Value<K>::append(input.get(), it->first);
       test_utils::Value<V>::append(input.get(), it->second);
     }
 
-    std::string query = str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(0, ?);") % table_name);
+    std::string query =
+        str(boost::format("INSERT INTO %s (tweet_id, test_val) VALUES(0, ?);") % table_name);
     test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 1));
 
     // Determine if bound parameters can be used based on C* version
@@ -240,7 +267,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
     test_utils::wait_and_check_error(result_future.get());
 
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session, str(boost::format("SELECT * FROM %s WHERE tweet_id = 0;") % table_name), &result);
+    test_utils::execute_query(
+        session, str(boost::format("SELECT * FROM %s WHERE tweet_id = 0;") % table_name), &result);
     BOOST_REQUIRE(cass_result_row_count(result.get()) == 1);
     BOOST_REQUIRE(cass_result_column_count(result.get()) > 0);
 
@@ -257,11 +285,13 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       K result_key;
       V result_value;
 
-      BOOST_REQUIRE(test_utils::Value<K>::get(cass_iterator_get_value(iterator.get()), &result_key) == CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<K>::get(cass_iterator_get_value(iterator.get()),
+                                              &result_key) == CASS_OK);
       BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) == primary_type);
 
       BOOST_REQUIRE(cass_iterator_next(iterator.get()) == cass_true);
-      BOOST_REQUIRE(test_utils::Value<V>::get(cass_iterator_get_value(iterator.get()), &result_value) == CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<V>::get(cass_iterator_get_value(iterator.get()),
+                                              &result_value) == CASS_OK);
       BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) == secondary_type);
 
       typename std::map<K, V>::const_iterator it = values.find(result_key);
@@ -275,10 +305,12 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
   void insert_map_all_types() {
     test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-    test_utils::execute_query(session.get(), str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                                 % test_utils::SIMPLE_KEYSPACE % "1"));
+    test_utils::execute_query(session.get(),
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
 
-    test_utils::execute_query(session.get(), str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query(session.get(),
+                              str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
     if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
       {
@@ -286,14 +318,16 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
         values[1] = 2;
         values[3] = 4;
         values[5] = 6;
-        insert_map_value<cass_int8_t, cass_int8_t>(session.get(), CASS_VALUE_TYPE_TINY_INT, CASS_VALUE_TYPE_TINY_INT, values);
+        insert_map_value<cass_int8_t, cass_int8_t>(session.get(), CASS_VALUE_TYPE_TINY_INT,
+                                                   CASS_VALUE_TYPE_TINY_INT, values);
       }
       {
         std::map<cass_int16_t, cass_int16_t> values;
         values[1] = 2;
         values[3] = 4;
         values[5] = 6;
-        insert_map_value<cass_int16_t, cass_int16_t>(session.get(), CASS_VALUE_TYPE_SMALL_INT, CASS_VALUE_TYPE_SMALL_INT, values);
+        insert_map_value<cass_int16_t, cass_int16_t>(session.get(), CASS_VALUE_TYPE_SMALL_INT,
+                                                     CASS_VALUE_TYPE_SMALL_INT, values);
       }
       {
         std::map<CassDate, CassDate> values;
@@ -301,14 +335,16 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
         values[min + 1] = min + 2;
         values[min + 3] = min + 4;
         values[min + 5] = min + 6;
-        insert_map_value<CassDate, CassDate>(session.get(), CASS_VALUE_TYPE_DATE, CASS_VALUE_TYPE_DATE, values);
+        insert_map_value<CassDate, CassDate>(session.get(), CASS_VALUE_TYPE_DATE,
+                                             CASS_VALUE_TYPE_DATE, values);
       }
       {
         std::map<CassTime, CassTime> values;
         values[1] = 2;
         values[3] = 4;
         values[5] = 6;
-        insert_map_value<CassTime, CassTime>(session.get(), CASS_VALUE_TYPE_TIME, CASS_VALUE_TYPE_TIME, values);
+        insert_map_value<CassTime, CassTime>(session.get(), CASS_VALUE_TYPE_TIME,
+                                             CASS_VALUE_TYPE_TIME, values);
       }
     }
 
@@ -317,7 +353,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[1] = 2;
       values[3] = 4;
       values[5] = 6;
-      insert_map_value<cass_int32_t, cass_int32_t>(session.get(), CASS_VALUE_TYPE_INT, CASS_VALUE_TYPE_INT, values);
+      insert_map_value<cass_int32_t, cass_int32_t>(session.get(), CASS_VALUE_TYPE_INT,
+                                                   CASS_VALUE_TYPE_INT, values);
     }
 
     {
@@ -325,7 +362,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[1LL] = 2LL;
       values[3LL] = 4LL;
       values[5LL] = 6LL;
-      insert_map_value<cass_int64_t, cass_int64_t>(session.get(), CASS_VALUE_TYPE_BIGINT, CASS_VALUE_TYPE_BIGINT, values);
+      insert_map_value<cass_int64_t, cass_int64_t>(session.get(), CASS_VALUE_TYPE_BIGINT,
+                                                   CASS_VALUE_TYPE_BIGINT, values);
     }
 
     {
@@ -333,7 +371,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[0.1f] = 0.2f;
       values[0.3f] = 0.4f;
       values[0.5f] = 0.6f;
-      insert_map_value<cass_float_t, cass_float_t>(session.get(), CASS_VALUE_TYPE_FLOAT, CASS_VALUE_TYPE_FLOAT, values);
+      insert_map_value<cass_float_t, cass_float_t>(session.get(), CASS_VALUE_TYPE_FLOAT,
+                                                   CASS_VALUE_TYPE_FLOAT, values);
     }
 
     {
@@ -341,7 +380,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[0.000000000001] = 0.000000000002;
       values[0.000000000003] = 0.000000000004;
       values[0.000000000005] = 0.000000000006;
-      insert_map_value<cass_double_t, cass_double_t>(session.get(), CASS_VALUE_TYPE_DOUBLE, CASS_VALUE_TYPE_DOUBLE, values);
+      insert_map_value<cass_double_t, cass_double_t>(session.get(), CASS_VALUE_TYPE_DOUBLE,
+                                                     CASS_VALUE_TYPE_DOUBLE, values);
     }
 
     {
@@ -349,7 +389,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[CassString("abc")] = CassString("123");
       values[CassString("def")] = CassString("456");
       values[CassString("ghi")] = CassString("789");
-      insert_map_value<CassString, CassString>(session.get(), CASS_VALUE_TYPE_VARCHAR, CASS_VALUE_TYPE_VARCHAR, values);
+      insert_map_value<CassString, CassString>(session.get(), CASS_VALUE_TYPE_VARCHAR,
+                                               CASS_VALUE_TYPE_VARCHAR, values);
     }
 
     {
@@ -357,7 +398,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[test_utils::bytes_from_string("abc")] = test_utils::bytes_from_string("123");
       values[test_utils::bytes_from_string("def")] = test_utils::bytes_from_string("456");
       values[test_utils::bytes_from_string("ghi")] = test_utils::bytes_from_string("789");
-      insert_map_value<CassBytes, CassBytes>(session.get(), CASS_VALUE_TYPE_BLOB, CASS_VALUE_TYPE_BLOB, values);
+      insert_map_value<CassBytes, CassBytes>(session.get(), CASS_VALUE_TYPE_BLOB,
+                                             CASS_VALUE_TYPE_BLOB, values);
     }
 
     {
@@ -365,7 +407,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[test_utils::inet_v4_from_int(16777343)] = test_utils::inet_v4_from_int(16777344);
       values[test_utils::inet_v4_from_int(16777345)] = test_utils::inet_v4_from_int(16777346);
       values[test_utils::inet_v4_from_int(16777347)] = test_utils::inet_v4_from_int(16777348);
-      insert_map_value<CassInet, CassInet>(session.get(), CASS_VALUE_TYPE_INET, CASS_VALUE_TYPE_INET, values);
+      insert_map_value<CassInet, CassInet>(session.get(), CASS_VALUE_TYPE_INET,
+                                           CASS_VALUE_TYPE_INET, values);
     }
 
     {
@@ -373,19 +416,23 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[test_utils::generate_time_uuid(uuid_gen)] = test_utils::generate_random_uuid(uuid_gen);
       values[test_utils::generate_time_uuid(uuid_gen)] = test_utils::generate_random_uuid(uuid_gen);
       values[test_utils::generate_time_uuid(uuid_gen)] = test_utils::generate_random_uuid(uuid_gen);
-      insert_map_value<CassUuid, CassUuid>(session.get(), CASS_VALUE_TYPE_UUID, CASS_VALUE_TYPE_UUID, values);
+      insert_map_value<CassUuid, CassUuid>(session.get(), CASS_VALUE_TYPE_UUID,
+                                           CASS_VALUE_TYPE_UUID, values);
     }
 
     {
-      const cass_uint8_t varint1[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180 };
-      const cass_uint8_t varint2[] = { 112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250 };
+      const cass_uint8_t varint1[] = { 57, 115, 235, 135, 229, 215, 8,   125,
+                                       13, 43,  1,   25,  32,  135, 129, 180 };
+      const cass_uint8_t varint2[] = { 112, 176, 158, 120, 246, 235, 29, 145,
+                                       238, 50,  108, 239, 219, 100, 250 };
       const cass_uint8_t varint3[] = { 84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
 
       std::map<CassDecimal, CassDecimal> values;
       values[CassDecimal(varint1, sizeof(varint1), 0)] = CassDecimal(varint1, sizeof(varint1), 1);
       values[CassDecimal(varint2, sizeof(varint2), 2)] = CassDecimal(varint2, sizeof(varint2), 3);
       values[CassDecimal(varint3, sizeof(varint3), 4)] = CassDecimal(varint3, sizeof(varint3), 5);
-      insert_map_value<CassDecimal, CassDecimal>(session.get(), CASS_VALUE_TYPE_DECIMAL, CASS_VALUE_TYPE_DECIMAL, values);
+      insert_map_value<CassDecimal, CassDecimal>(session.get(), CASS_VALUE_TYPE_DECIMAL,
+                                                 CASS_VALUE_TYPE_DECIMAL, values);
     }
 
     if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
@@ -394,7 +441,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[1] = CassDuration(0, 0, 1);
       values[3] = CassDuration(1, 2, 5);
       values[5] = CassDuration(-1, -2, -3);
-      insert_map_value<cass_int32_t, CassDuration>(session.get(), CASS_VALUE_TYPE_INT, CASS_VALUE_TYPE_DURATION, values);
+      insert_map_value<cass_int32_t, CassDuration>(session.get(), CASS_VALUE_TYPE_INT,
+                                                   CASS_VALUE_TYPE_DURATION, values);
     }
 
     {
@@ -402,7 +450,8 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[CassString("a")] = 1;
       values[CassString("b")] = 2;
       values[CassString("c")] = 3;
-      insert_map_value<CassString, cass_int32_t>(session.get(), CASS_VALUE_TYPE_VARCHAR, CASS_VALUE_TYPE_INT, values);
+      insert_map_value<CassString, cass_int32_t>(session.get(), CASS_VALUE_TYPE_VARCHAR,
+                                                 CASS_VALUE_TYPE_INT, values);
     }
 
     {
@@ -410,34 +459,26 @@ struct CollectionsTests : public test_utils::MultipleNodesTest {
       values[test_utils::generate_time_uuid(uuid_gen)] = CassString("123");
       values[test_utils::generate_time_uuid(uuid_gen)] = CassString("456");
       values[test_utils::generate_time_uuid(uuid_gen)] = CassString("789");
-      insert_map_value<CassUuid, CassString>(session.get(), CASS_VALUE_TYPE_UUID, CASS_VALUE_TYPE_VARCHAR, values);
+      insert_map_value<CassUuid, CassString>(session.get(), CASS_VALUE_TYPE_UUID,
+                                             CASS_VALUE_TYPE_VARCHAR, values);
     }
 
     drop_keyspace(session);
   }
 
   void drop_keyspace(test_utils::CassSessionPtr session) {
-    test_utils::execute_query_with_error(session.get(),
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-        % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session.get(),
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 };
 
 BOOST_FIXTURE_TEST_SUITE(collections, CollectionsTests)
 
-BOOST_AUTO_TEST_CASE(set)
-{
-  insert_collection_all_types(CASS_VALUE_TYPE_SET);
-}
+BOOST_AUTO_TEST_CASE(set) { insert_collection_all_types(CASS_VALUE_TYPE_SET); }
 
-BOOST_AUTO_TEST_CASE(list)
-{
-  insert_collection_all_types(CASS_VALUE_TYPE_LIST);
-}
+BOOST_AUTO_TEST_CASE(list) { insert_collection_all_types(CASS_VALUE_TYPE_LIST); }
 
-BOOST_AUTO_TEST_CASE(map)
-{
-  insert_map_all_types();
-}
+BOOST_AUTO_TEST_CASE(map) { insert_map_all_types(); }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_config.cpp b/test/integration_tests/src/test_config.cpp
index b81a7d26a..2b2b18ae0 100644
--- a/test/integration_tests/src/test_config.cpp
+++ b/test/integration_tests/src/test_config.cpp
@@ -17,63 +17,63 @@
 #include <boost/test/unit_test.hpp>
 
 #include "cassandra.h"
-#include "testing.hpp"
 #include "test_utils.hpp"
+#include "testing.hpp"
+
+using namespace datastax::internal::testing;
 
 struct ConfigTests {
-  ConfigTests() { }
+  ConfigTests() {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(config, ConfigTests)
 
-
-BOOST_AUTO_TEST_CASE(options)
-{
+BOOST_AUTO_TEST_CASE(options) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   {
     unsigned connect_timeout = 9999;
     cass_cluster_set_connect_timeout(cluster.get(), connect_timeout);
-    BOOST_CHECK(cass::get_connect_timeout_from_cluster(cluster.get()) == connect_timeout);
+    BOOST_CHECK(get_connect_timeout_from_cluster(cluster.get()) == connect_timeout);
   }
 
   {
     int port = 7000;
     cass_cluster_set_port(cluster.get(), port);
-    BOOST_CHECK(cass::get_port_from_cluster(cluster.get()) == port);
+    BOOST_CHECK(get_port_from_cluster(cluster.get()) == port);
   }
 }
 
-BOOST_AUTO_TEST_CASE(contact_points)
-{
+BOOST_AUTO_TEST_CASE(contact_points) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   // Simple
   const char* contact_points1 = "127.0.0.1,127.0.0.2,127.0.0.3";
   cass_cluster_set_contact_points(cluster.get(), contact_points1);
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
 
   // Clear
   cass_cluster_set_contact_points(cluster.get(), "");
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).empty());
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).empty());
 
   // Extra commas
   const char* contact_points1_commas = ",,,,127.0.0.1,,,,127.0.0.2,127.0.0.3,,,,";
   cass_cluster_set_contact_points(cluster.get(), contact_points1_commas);
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
 
   // Clear
   cass_cluster_set_contact_points(cluster.get(), "");
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).empty());
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).empty());
 
   // Extra whitespace
-  const char* contact_points1_ws = "   ,\r\n,  ,   ,  127.0.0.1 ,,,  ,\t127.0.0.2,127.0.0.3,  \t\n, ,,   ";
+  const char* contact_points1_ws =
+      "   ,\r\n,  ,   ,  127.0.0.1 ,,,  ,\t127.0.0.2,127.0.0.3,  \t\n, ,,   ";
   cass_cluster_set_contact_points(cluster.get(), contact_points1_ws);
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
 
   // Clear
   cass_cluster_set_contact_points(cluster.get(), "");
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).empty());
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).empty());
 
   // Append
   const char* contact_point1 = "127.0.0.1";
@@ -85,9 +85,7 @@ BOOST_AUTO_TEST_CASE(contact_points)
   const char* contact_point3 = "127.0.0.3";
   cass_cluster_set_contact_points(cluster.get(), contact_point3);
 
-  BOOST_REQUIRE(cass::get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
+  BOOST_REQUIRE(get_contact_points_from_cluster(cluster.get()).compare(contact_points1) == 0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
-
diff --git a/test/integration_tests/src/test_consistency.cpp b/test/integration_tests/src/test_consistency.cpp
index f9b8a79e1..a632b1f2f 100644
--- a/test/integration_tests/src/test_consistency.cpp
+++ b/test/integration_tests/src/test_consistency.cpp
@@ -14,13 +14,13 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "policy_tools.hpp"
+#include "test_utils.hpp"
 
 #include "cassandra.h"
 
-#include <boost/test/unit_test.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 struct ConsistencyTests {
@@ -29,14 +29,13 @@ struct ConsistencyTests {
   std::string ip_prefix;
 
   ConsistencyTests()
-    : ccm(new CCM::Bridge("config.txt"))
-    , ip_prefix(ccm->get_ip_prefix()) {}
+      : ccm(new CCM::Bridge("config.txt"))
+      , ip_prefix(ccm->get_ip_prefix()) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(consistency, ConsistencyTests)
 
-BOOST_AUTO_TEST_CASE(simple_two_nodes)
-{
+BOOST_AUTO_TEST_CASE(simple_two_nodes) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2)) {
@@ -51,27 +50,37 @@ BOOST_AUTO_TEST_CASE(simple_two_nodes)
   policy_tool.create_schema(session.get(), 1); // replication_factor = 1
 
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ONE);	// Should work
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ONE);	// Should work
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result =
+        policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_ONE); // Should work
+    CassError query_result =
+        policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ONE); // Should work
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ANY);  // Should work
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ANY);  // Should fail (ANY is for writing only)
+    CassError init_result =
+        policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_ANY); // Should work
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ANY); // Should fail (ANY is for writing only)
     BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_ERROR_SERVER_INVALID_QUERY);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_LOCAL_QUORUM);  // Should fail (LOCAL_QUORUM is incompatible with SimpleStrategy)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_LOCAL_QUORUM);  // Should fail (see above)
-    BOOST_CHECK_EQUAL(init_result, CASS_OK); // TODO(mpenick): Shouldn't be CASS_OK?
-    BOOST_CHECK_EQUAL(query_result, CASS_OK); // TODO(mpenick): Shouldn't be CASS_OK?
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_LOCAL_QUORUM); // Should fail (LOCAL_QUORUM is
+                                                           // incompatible with SimpleStrategy)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_LOCAL_QUORUM); // Should fail (see above)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);               // TODO(mpenick): Shouldn't be CASS_OK?
+    BOOST_CHECK_EQUAL(query_result, CASS_OK);              // TODO(mpenick): Shouldn't be CASS_OK?
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_EACH_QUORUM);  // Should fail (EACH_QUORUM is incompatible with SimpleStrategy)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_EACH_QUORUM);  // Should fail (see above)
-    BOOST_CHECK_EQUAL(init_result, CASS_OK); // TODO(mpenick): Shouldn't be CASS_OK?
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_EACH_QUORUM); // Should fail (EACH_QUORUM is
+                                                          // incompatible with SimpleStrategy)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_EACH_QUORUM); // Should fail (see above)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);              // TODO(mpenick): Shouldn't be CASS_OK?
     // Handle EACH_QUORUM read support added to C* v3.0.0 [CASSANDRA-9602]
     // https://issues.apache.org/jira/browse/CASSANDRA-9602
     if (test_utils::get_version() >= "3.0.0") {
@@ -81,8 +90,10 @@ BOOST_AUTO_TEST_CASE(simple_two_nodes)
     }
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_THREE);  // Should fail (N=2, RF=1)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_THREE);  // Should fail (N=2, RF=1)
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_THREE); // Should fail (N=2, RF=1)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_THREE); // Should fail (N=2, RF=1)
     BOOST_CHECK_EQUAL(init_result, CASS_ERROR_SERVER_UNAVAILABLE);
     BOOST_CHECK_EQUAL(query_result, CASS_ERROR_SERVER_UNAVAILABLE);
   }
@@ -91,8 +102,7 @@ BOOST_AUTO_TEST_CASE(simple_two_nodes)
   policy_tool.drop_schema(session.get());
 }
 
-BOOST_AUTO_TEST_CASE(one_node_down)
-{
+BOOST_AUTO_TEST_CASE(one_node_down) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(3)) {
@@ -108,36 +118,46 @@ BOOST_AUTO_TEST_CASE(one_node_down)
 
   {
     // Sanity check
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
 
   ccm->force_decommission_node(2);
 
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ONE);	// Should work (N=2, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ONE);	// Should work (N=2, RF=3)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ONE); // Should work (N=2, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ONE); // Should work (N=2, RF=3)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_TWO);	// Should work (N=2, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_TWO);	// Should work (N=2, RF=3)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_TWO); // Should work (N=2, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_TWO); // Should work (N=2, RF=3)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ALL);	// Should fail (N=2, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ALL);	// Should fail (N=2, RF=3)
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should fail (N=2, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should fail (N=2, RF=3)
     BOOST_CHECK_NE(init_result, CASS_OK);
     BOOST_CHECK_NE(query_result, CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_QUORUM);	// Should work (N=2, RF=3, quorum=2)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should work (N=2, RF=3, quorum=2)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=2, RF=3, quorum=2)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=2, RF=3, quorum=2)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
 
@@ -145,8 +165,7 @@ BOOST_AUTO_TEST_CASE(one_node_down)
   ccm->remove_cluster();
 }
 
-BOOST_AUTO_TEST_CASE(two_nodes_down)
-{
+BOOST_AUTO_TEST_CASE(two_nodes_down) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(3)) {
@@ -162,9 +181,11 @@ BOOST_AUTO_TEST_CASE(two_nodes_down)
 
   {
     // Sanity check
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
 
@@ -172,21 +193,27 @@ BOOST_AUTO_TEST_CASE(two_nodes_down)
   ccm->force_decommission_node(3);
 
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_ONE);	// Should work (N=1, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ONE);	// Should work (N=1, RF=3)
-    BOOST_CHECK_EQUAL(init_result,  CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ONE); // Should work (N=1, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ONE); // Should work (N=1, RF=3)
+    BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_TWO);	// Should fail (N=1, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_TWO);	// Should fail (N=1, RF=3)
-    BOOST_CHECK(init_result  != CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_TWO); // Should fail (N=1, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_TWO); // Should fail (N=1, RF=3)
+    BOOST_CHECK(init_result != CASS_OK);
     BOOST_CHECK(query_result != CASS_OK);
   }
   {
-    CassError init_result  = policy_tool.init_return_error(session.get(),  12, CASS_CONSISTENCY_QUORUM);	// Should fail (N=1, RF=3, quorum=2)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should fail (N=1, RF=3, quorum=2)
-    BOOST_CHECK(init_result  != CASS_OK);
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should fail (N=1, RF=3, quorum=2)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should fail (N=1, RF=3, quorum=2)
+    BOOST_CHECK(init_result != CASS_OK);
     BOOST_CHECK(query_result != CASS_OK);
   }
 
@@ -194,8 +221,7 @@ BOOST_AUTO_TEST_CASE(two_nodes_down)
   ccm->remove_cluster();
 }
 
-BOOST_AUTO_TEST_CASE(retry_policy_downgrading)
-{
+BOOST_AUTO_TEST_CASE(retry_policy_downgrading) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
   CassRetryPolicy* downgrading_policy = cass_retry_policy_downgrading_consistency_new();
   cass_cluster_set_retry_policy(cluster.get(), downgrading_policy);
@@ -215,8 +241,10 @@ BOOST_AUTO_TEST_CASE(retry_policy_downgrading)
 
   {
     // Sanity check
-    CassError init_result = policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
-    CassError query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_ALL);	// Should work (N=3, RF=3)
+    CassError init_result = policy_tool.init_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
+    CassError query_result = policy_tool.query_return_error(
+        session.get(), 12, CASS_CONSISTENCY_ALL); // Should work (N=3, RF=3)
     BOOST_CHECK_EQUAL(init_result, CASS_OK);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
@@ -226,12 +254,14 @@ BOOST_AUTO_TEST_CASE(retry_policy_downgrading)
   {
     CassError init_result;
     do {
-      init_result = policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should work (N=2, RF=3)
+      init_result = policy_tool.init_return_error(
+          session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=2, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(init_result, CASS_OK);
     CassError query_result;
     do {
-      query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should work (N=2, RF=3)
+      query_result = policy_tool.query_return_error(
+          session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=2, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
@@ -241,12 +271,14 @@ BOOST_AUTO_TEST_CASE(retry_policy_downgrading)
   {
     CassError init_result;
     do {
-      init_result = policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should work (N=1, RF=3)
+      init_result = policy_tool.init_return_error(
+          session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=1, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(init_result, CASS_OK);
     CassError query_result;
     do {
-      query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_QUORUM);	// Should work (N=1, RF=3)
+      query_result = policy_tool.query_return_error(
+          session.get(), 12, CASS_CONSISTENCY_QUORUM); // Should work (N=1, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
@@ -254,12 +286,14 @@ BOOST_AUTO_TEST_CASE(retry_policy_downgrading)
   {
     CassError init_result;
     do {
-      init_result = policy_tool.init_return_error(session.get(), 12, CASS_CONSISTENCY_TWO);	// Should work (N=1, RF=3)
+      init_result = policy_tool.init_return_error(session.get(), 12,
+                                                  CASS_CONSISTENCY_TWO); // Should work (N=1, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(init_result, CASS_OK);
     CassError query_result;
     do {
-      query_result = policy_tool.query_return_error(session.get(), 12, CASS_CONSISTENCY_TWO);	// Should work (N=1, RF=3)
+      query_result = policy_tool.query_return_error(
+          session.get(), 12, CASS_CONSISTENCY_TWO); // Should work (N=1, RF=3)
     } while (init_result == CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     BOOST_CHECK_EQUAL(query_result, CASS_OK);
   }
diff --git a/test/integration_tests/src/test_control_connection.cpp b/test/integration_tests/src/test_control_connection.cpp
index c59e75c99..2ede30baf 100644
--- a/test/integration_tests/src/test_control_connection.cpp
+++ b/test/integration_tests/src/test_control_connection.cpp
@@ -18,16 +18,18 @@
 
 #include "test_utils.hpp"
 
+#include <boost/chrono.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/test/debug.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <set>
 #include <sstream>
 #include <stdarg.h>
 
+using namespace datastax::internal::testing;
+
 struct ControlConnectionTests {
 public:
   boost::shared_ptr<CCM::Bridge> ccm;
@@ -35,32 +37,35 @@ struct ControlConnectionTests {
   CCM::CassVersion version;
 
   ControlConnectionTests()
-    : ccm(new CCM::Bridge("config.txt"))
-    , ip_prefix(ccm->get_ip_prefix())
-    , version(test_utils::get_version()) {}
+      : ccm(new CCM::Bridge("config.txt"))
+      , ip_prefix(ccm->get_ip_prefix())
+      , version(test_utils::get_version()) {}
 
   std::string get_executing_host(test_utils::CassSessionPtr session) {
     std::stringstream query;
-    query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
+    query << "SELECT * FROM "
+          << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
     test_utils::CassStatementPtr statement(cass_statement_new(query.str().c_str(), 0));
     test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
-    if (cass_future_error_code(future.get()) ==  CASS_OK) {
-      return cass::get_host_from_future(future.get()).c_str();
+    if (cass_future_error_code(future.get()) == CASS_OK) {
+      return get_host_from_future(future.get()).c_str();
     } else {
       CassString message;
       cass_future_error_message(future.get(), &message.data, &message.length);
-      std::cerr << "Failed to query host: " << std::string(message.data, message.length) << std::endl;
+      std::cerr << "Failed to query host: " << std::string(message.data, message.length)
+                << std::endl;
     }
 
     return "";
   }
 
-  void  check_for_live_hosts(test_utils::CassSessionPtr session,
+  void check_for_live_hosts(test_utils::CassSessionPtr session,
                             const std::set<std::string>& should_be_present) {
     std::set<std::string> hosts;
 
     std::stringstream query;
-    query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
+    query << "SELECT * FROM "
+          << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
     for (size_t i = 0; i < should_be_present.size() + 2; ++i) {
       std::string host = get_executing_host(session);
       if (!host.empty()) {
@@ -92,10 +97,9 @@ struct ControlConnectionTests {
 
 BOOST_FIXTURE_TEST_SUITE(control_connection, ControlConnectionTests)
 
-BOOST_AUTO_TEST_CASE(connect_invalid_ip)
-{
+BOOST_AUTO_TEST_CASE(connect_invalid_ip) {
   test_utils::CassLog::reset("Unable to establish a control connection to host "
-    "1.1.1.1 because of the following error: Connection timeout");
+                             "1.1.1.1 because of the following error: Connection timeout");
 
   test_utils::CassClusterPtr cluster(cass_cluster_new());
   cass_cluster_set_contact_points(cluster.get(), "1.1.1.1");
@@ -108,8 +112,7 @@ BOOST_AUTO_TEST_CASE(connect_invalid_ip)
   BOOST_CHECK(test_utils::CassLog::message_count() > 0);
 }
 
-BOOST_AUTO_TEST_CASE(connect_invalid_port)
-{
+BOOST_AUTO_TEST_CASE(connect_invalid_port) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster()) {
@@ -125,8 +128,7 @@ BOOST_AUTO_TEST_CASE(connect_invalid_port)
   BOOST_CHECK_EQUAL(code, CASS_ERROR_LIB_NO_HOSTS_AVAILABLE);
 }
 
-BOOST_AUTO_TEST_CASE(reconnection)
-{
+BOOST_AUTO_TEST_CASE(reconnection) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2)) {
@@ -162,8 +164,7 @@ BOOST_AUTO_TEST_CASE(reconnection)
   ccm->remove_cluster();
 }
 
-BOOST_AUTO_TEST_CASE(topology_change)
-{
+BOOST_AUTO_TEST_CASE(topology_change) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster()) {
@@ -194,8 +195,7 @@ BOOST_AUTO_TEST_CASE(topology_change)
   ccm->remove_cluster();
 }
 
-BOOST_AUTO_TEST_CASE(status_change)
-{
+BOOST_AUTO_TEST_CASE(status_change) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2)) {
@@ -203,7 +203,8 @@ BOOST_AUTO_TEST_CASE(status_change)
   }
 
   // Ensure RR policy
-  cass_cluster_set_load_balance_round_robin(cluster.get());;
+  cass_cluster_set_load_balance_round_robin(cluster.get());
+  ;
 
   test_utils::initialize_contact_points(cluster.get(), ip_prefix, 1);
 
@@ -226,8 +227,7 @@ BOOST_AUTO_TEST_CASE(status_change)
   check_for_live_hosts(session, should_be_present);
 }
 
-BOOST_AUTO_TEST_CASE(node_discovery)
-{
+BOOST_AUTO_TEST_CASE(node_discovery) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(3)) {
@@ -235,7 +235,8 @@ BOOST_AUTO_TEST_CASE(node_discovery)
   }
 
   // Ensure RR policy
-  cass_cluster_set_load_balance_round_robin(cluster.get());;
+  cass_cluster_set_load_balance_round_robin(cluster.get());
+  ;
 
   // Only add a single IP
   test_utils::initialize_contact_points(cluster.get(), ip_prefix, 1);
@@ -243,13 +244,13 @@ BOOST_AUTO_TEST_CASE(node_discovery)
   test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
 
   // Allow the nodes to be discovered
-  boost::this_thread::sleep_for(boost::chrono::seconds(20)); //TODO: Remove sleep and implement a pre-check
+  boost::this_thread::sleep_for(
+      boost::chrono::seconds(20)); // TODO: Remove sleep and implement a pre-check
 
   check_for_live_hosts(session, build_ip_range(ip_prefix, 1, 3));
 }
 
-BOOST_AUTO_TEST_CASE(node_discovery_invalid_ips)
-{
+BOOST_AUTO_TEST_CASE(node_discovery_invalid_ips) {
   test_utils::CassLog::reset("Unable to reach contact point 192.0.2.");
 
   {
@@ -260,7 +261,8 @@ BOOST_AUTO_TEST_CASE(node_discovery_invalid_ips)
     }
 
     // Ensure RR policy
-    cass_cluster_set_load_balance_round_robin(cluster.get());;
+    cass_cluster_set_load_balance_round_robin(cluster.get());
+    ;
 
     // Add invalid IPs first (http://tools.ietf.org/html/rfc5737)
     cass_cluster_set_contact_points(cluster.get(), "192.0.2.0,192.0.2.1,192.0.2.3");
@@ -269,10 +271,12 @@ BOOST_AUTO_TEST_CASE(node_discovery_invalid_ips)
     test_utils::initialize_contact_points(cluster.get(), ip_prefix, 1);
 
     // Make sure the timeout is very high for the initial invalid IPs
-    test_utils::CassSessionPtr session(test_utils::create_session(cluster.get(), NULL, 60 * test_utils::ONE_SECOND_IN_MICROS));
+    test_utils::CassSessionPtr session(
+        test_utils::create_session(cluster.get(), NULL, 60 * test_utils::ONE_SECOND_IN_MICROS));
 
     // Allow the nodes to be discovered
-    boost::this_thread::sleep_for(boost::chrono::seconds(20)); //TODO: Remove sleep and implement a pre-check
+    boost::this_thread::sleep_for(
+        boost::chrono::seconds(20)); // TODO: Remove sleep and implement a pre-check
 
     check_for_live_hosts(session, build_ip_range(ip_prefix, 1, 3));
   }
@@ -280,8 +284,7 @@ BOOST_AUTO_TEST_CASE(node_discovery_invalid_ips)
   BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), 3ul);
 }
 
-BOOST_AUTO_TEST_CASE(node_discovery_no_local_rows)
-{
+BOOST_AUTO_TEST_CASE(node_discovery_no_local_rows) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(3)) {
@@ -289,7 +292,8 @@ BOOST_AUTO_TEST_CASE(node_discovery_no_local_rows)
   }
 
   // Ensure RR policy
-  cass_cluster_set_load_balance_round_robin(cluster.get());;
+  cass_cluster_set_load_balance_round_robin(cluster.get());
+  ;
 
   // Only add a single valid IP
   test_utils::initialize_contact_points(cluster.get(), ip_prefix, 1);
@@ -302,14 +306,15 @@ BOOST_AUTO_TEST_CASE(node_discovery_no_local_rows)
   test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
 
   // Allow the nodes to be discovered
-  boost::this_thread::sleep_for(boost::chrono::seconds(20)); //TODO: Remove sleep and implement a pre-check
+  boost::this_thread::sleep_for(
+      boost::chrono::seconds(20)); // TODO: Remove sleep and implement a pre-check
 
   check_for_live_hosts(session, build_ip_range(ip_prefix, 1, 3));
 }
 
-BOOST_AUTO_TEST_CASE(node_discovery_no_rpc_addresss)
-{
-  test_utils::CassLog::reset("No rpc_address for host " + ip_prefix + "3 in system.peers on " + ip_prefix + "1. Ignoring this entry.");
+BOOST_AUTO_TEST_CASE(node_discovery_no_rpc_addresss) {
+  test_utils::CassLog::reset("No rpc_address for host " + ip_prefix + "3 in system.peers on " +
+                             ip_prefix + "1. Ignoring this entry.");
 
   {
     test_utils::CassClusterPtr cluster(cass_cluster_new());
@@ -319,7 +324,8 @@ BOOST_AUTO_TEST_CASE(node_discovery_no_rpc_addresss)
     }
 
     // Ensure RR policy
-    cass_cluster_set_load_balance_round_robin(cluster.get());;
+    cass_cluster_set_load_balance_round_robin(cluster.get());
+    ;
 
     // Only add a single valid IP
     test_utils::initialize_contact_points(cluster.get(), ip_prefix, 1);
@@ -344,8 +350,7 @@ BOOST_AUTO_TEST_CASE(node_discovery_no_rpc_addresss)
   BOOST_CHECK(test_utils::CassLog::message_count() > 0);
 }
 
-BOOST_AUTO_TEST_CASE(full_outage)
-{
+BOOST_AUTO_TEST_CASE(full_outage) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   const char* query = "SELECT * FROM system.local";
@@ -359,7 +364,8 @@ BOOST_AUTO_TEST_CASE(full_outage)
   test_utils::execute_query(session.get(), query);
 
   ccm->stop_cluster();
-  BOOST_CHECK(test_utils::execute_query_with_error(session.get(), query) == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE);
+  BOOST_CHECK(test_utils::execute_query_with_error(session.get(), query) ==
+              CASS_ERROR_LIB_NO_HOSTS_AVAILABLE);
 
   ccm->start_cluster();
   test_utils::wait_for_node_connection(ip_prefix, 1);
@@ -377,8 +383,7 @@ BOOST_AUTO_TEST_CASE(full_outage)
  * @jira_ticket CPP-210
  * @test_category control_connection
  */
-BOOST_AUTO_TEST_CASE(node_decommission)
-{
+BOOST_AUTO_TEST_CASE(node_decommission) {
   test_utils::CassLog::reset("Adding pool for host " + ip_prefix);
 
   {
@@ -391,7 +396,8 @@ BOOST_AUTO_TEST_CASE(node_decommission)
     test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
 
     // Wait for all hosts to be added to the pool; timeout after 10 seconds
-    boost::chrono::steady_clock::time_point end = boost::chrono::steady_clock::now() + boost::chrono::milliseconds(10000);
+    boost::chrono::steady_clock::time_point end =
+        boost::chrono::steady_clock::now() + boost::chrono::milliseconds(10000);
     while (test_utils::CassLog::message_count() != 2 && boost::chrono::steady_clock::now() < end) {
       boost::this_thread::sleep_for(boost::chrono::seconds(1));
     }
@@ -419,8 +425,7 @@ BOOST_AUTO_TEST_CASE(node_decommission)
  * @jira_ticket CPP-193
  * @test_category control_connection
  */
-BOOST_AUTO_TEST_CASE(randomized_contact_points)
-{
+BOOST_AUTO_TEST_CASE(randomized_contact_points) {
   std::string starting_host = ip_prefix + "1";
   size_t retries = 0;
   test_utils::CassSessionPtr session;
@@ -440,8 +445,10 @@ BOOST_AUTO_TEST_CASE(randomized_contact_points)
       session = test_utils::CassSessionPtr(test_utils::create_session(cluster.get()));
 
       // Wait for all hosts to be added to the pool; timeout after 10 seconds
-      boost::chrono::steady_clock::time_point end = boost::chrono::steady_clock::now() + boost::chrono::milliseconds(10000);
-      while (test_utils::CassLog::message_count() != 4ul && boost::chrono::steady_clock::now() < end) {
+      boost::chrono::steady_clock::time_point end =
+          boost::chrono::steady_clock::now() + boost::chrono::milliseconds(10000);
+      while (test_utils::CassLog::message_count() != 4ul &&
+             boost::chrono::steady_clock::now() < end) {
         boost::this_thread::sleep_for(boost::chrono::seconds(1));
       }
       BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), 4ul);
@@ -481,8 +488,7 @@ BOOST_AUTO_TEST_CASE(randomized_contact_points)
  * @expected_result Driver will not hang and session/control connection will
  *                  terminate; CASS_ERROR_LIB_NO_HOSTS_AVAILABLE
  */
-BOOST_AUTO_TEST_CASE(invalid_dc)
-{
+BOOST_AUTO_TEST_CASE(invalid_dc) {
   // Create the CCM cluster if it does not already exist (2 DCs)
   if (ccm->create_cluster(1, 1)) {
     ccm->start_cluster();
@@ -503,7 +509,8 @@ BOOST_AUTO_TEST_CASE(invalid_dc)
     // Verify the future error message
     CassString message;
     cass_future_error_message(connect_future.get(), &message.data, &message.length);
-    BOOST_CHECK_EQUAL("No hosts available for connection using the current load balancing policy", message.data);
+    BOOST_CHECK_EQUAL("No hosts available for connection using the current load balancing policy",
+                      message.data);
   }
 }
 
@@ -523,8 +530,7 @@ BOOST_AUTO_TEST_CASE(invalid_dc)
  * @expected_result Driver will not hang and session/control connection will
  *                  terminate with error
  */
-BOOST_AUTO_TEST_CASE(terminated_using_multiple_io_threads_with_error)
-{
+BOOST_AUTO_TEST_CASE(terminated_using_multiple_io_threads_with_error) {
   // Create the CCM cluster if it does not already exist
   if (ccm->create_cluster()) {
     ccm->start_cluster();
@@ -549,7 +555,8 @@ BOOST_AUTO_TEST_CASE(terminated_using_multiple_io_threads_with_error)
       test_utils::CassLog::add("Session is disconnected");
 
       // Establish the connection using invalid keyspace
-      test_utils::CassFuturePtr connect_future(cass_session_connect_keyspace(session.get(), cluster.get(), "invalid"));
+      test_utils::CassFuturePtr connect_future(
+          cass_session_connect_keyspace(session.get(), cluster.get(), "invalid"));
       CassError code = cass_future_error_code(connect_future.get());
       BOOST_CHECK_EQUAL(code, CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE);
       BOOST_CHECK_EQUAL(3ul, test_utils::CassLog::message_count());
diff --git a/test/integration_tests/src/test_custom_payload.cpp b/test/integration_tests/src/test_custom_payload.cpp
index 41795bd7b..2e0f44897 100644
--- a/test/integration_tests/src/test_custom_payload.cpp
+++ b/test/integration_tests/src/test_custom_payload.cpp
@@ -17,8 +17,8 @@
 #include "cassandra.h"
 #include "test_utils.hpp"
 
-#include <boost/test/unit_test.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include <map>
 #include <set>
@@ -26,8 +26,7 @@
 
 BOOST_AUTO_TEST_SUITE(custom_payload)
 
-BOOST_AUTO_TEST_CASE(simple)
-{
+BOOST_AUTO_TEST_CASE(simple) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     boost::shared_ptr<CCM::Bridge> ccm(new CCM::Bridge("config.txt"));
@@ -35,7 +34,8 @@ BOOST_AUTO_TEST_CASE(simple)
       // Ensure the cluster is down before updating JVM argument
       ccm->kill_cluster();
     }
-    ccm->start_cluster("-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler");
+    ccm->start_cluster("-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3."
+                       "CustomPayloadMirroringQueryHandler");
 
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 1);
@@ -54,9 +54,9 @@ BOOST_AUTO_TEST_CASE(simple)
     items["key3"] = "value3";
 
     for (PayloadItemMap::const_iterator i = items.begin(); i != items.end(); ++i) {
-      cass_custom_payload_set(custom_payload.get(),
-                              i->first.c_str(),
-                              reinterpret_cast<const cass_byte_t*>(i->second.data()), i->second.size());
+      cass_custom_payload_set(custom_payload.get(), i->first.c_str(),
+                              reinterpret_cast<const cass_byte_t*>(i->second.data()),
+                              i->second.size());
     }
 
     cass_statement_set_custom_payload(statement.get(), custom_payload.get());
@@ -72,9 +72,8 @@ BOOST_AUTO_TEST_CASE(simple)
       size_t name_length;
       const cass_byte_t* value;
       size_t value_size;
-      BOOST_REQUIRE(cass_future_custom_payload_item(future.get(), i,
-                                                    &name, &name_length,
-                                                    &value, &value_size) == CASS_OK);
+      BOOST_REQUIRE(cass_future_custom_payload_item(future.get(), i, &name, &name_length, &value,
+                                                    &value_size) == CASS_OK);
 
       PayloadItemMap::const_iterator it = items.find(std::string(name, name_length));
       BOOST_REQUIRE(it != items.end());
@@ -84,7 +83,8 @@ BOOST_AUTO_TEST_CASE(simple)
       ccm->kill_cluster();
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping custom_payload/simple" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping custom_payload/simple" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_datatypes.cpp b/test/integration_tests/src/test_datatypes.cpp
index b9d409011..d35cc810d 100644
--- a/test/integration_tests/src/test_datatypes.cpp
+++ b/test/integration_tests/src/test_datatypes.cpp
@@ -14,23 +14,26 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
 
 struct DataTypesTests : public test_utils::SingleSessionTest {
-  DataTypesTests() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+  DataTypesTests()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~DataTypesTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   /**
@@ -43,7 +46,8 @@ struct DataTypesTests : public test_utils::SingleSessionTest {
   void insert_value(CassValueType value_type, T value) {
     // Create the table for the test
     std::string table_name = "table_" + test_utils::generate_unique_str(uuid_gen);
-    std::string create_table = "CREATE TABLE " + table_name + "(key text PRIMARY KEY, value " + test_utils::get_value_type(value_type) +")";
+    std::string create_table = "CREATE TABLE " + table_name + "(key text PRIMARY KEY, value " +
+                               test_utils::get_value_type(value_type) + ")";
     test_utils::execute_query(session, create_table.c_str());
 
     // Bind, validate, and insert the value into Cassandra
@@ -56,16 +60,24 @@ struct DataTypesTests : public test_utils::SingleSessionTest {
     }
     BOOST_REQUIRE_EQUAL(cass_statement_bind_string(statement.get(), 0, "simple"), CASS_OK);
     BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind(statement.get(), 1, value), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
     test_utils::CassPreparedPtr prepared(test_utils::prepare(session, insert_query.c_str()));
     statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
-    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type(prepared.get(), 0)), CASS_VALUE_TYPE_VARCHAR);
-    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type_by_name(prepared.get(), "key")), CASS_VALUE_TYPE_VARCHAR);
-    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type(prepared.get(), 1)), value_type);
-    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type_by_name(prepared.get(), "value")), value_type);
+    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type(prepared.get(), 0)),
+                        CASS_VALUE_TYPE_VARCHAR);
+    BOOST_REQUIRE_EQUAL(
+        cass_data_type_type(cass_prepared_parameter_data_type_by_name(prepared.get(), "key")),
+        CASS_VALUE_TYPE_VARCHAR);
+    BOOST_REQUIRE_EQUAL(cass_data_type_type(cass_prepared_parameter_data_type(prepared.get(), 1)),
+                        value_type);
+    BOOST_REQUIRE_EQUAL(
+        cass_data_type_type(cass_prepared_parameter_data_type_by_name(prepared.get(), "value")),
+        value_type);
     BOOST_REQUIRE_EQUAL(cass_statement_bind_string(statement.get(), 0, "prepared"), CASS_OK);
     BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind(statement.get(), 1, value), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
 
     // Ensure the value can be read
     std::string select_query = "SELECT key, value FROM " + table_name;
@@ -85,7 +97,8 @@ struct DataTypesTests : public test_utils::SingleSessionTest {
       BOOST_REQUIRE_EQUAL(cass_data_type_type(key_data_type), CASS_VALUE_TYPE_VARCHAR);
       CassString key_result;
       cass_value_get_string(key_value, &key_result.data, &key_result.length);
-      BOOST_REQUIRE(test_utils::Value<CassString>::equal(CassString("simple"), key_result) || test_utils::Value<CassString>::equal(CassString("prepared"), key_result));
+      BOOST_REQUIRE(test_utils::Value<CassString>::equal(CassString("simple"), key_result) ||
+                    test_utils::Value<CassString>::equal(CassString("prepared"), key_result));
 
       // Verify the value
       const CassValue* value_value = cass_row_get_column(row, 1);
@@ -127,7 +140,8 @@ BOOST_AUTO_TEST_CASE(read_write_primitives) {
   }
 
   {
-    CassBytes value = test_utils::bytes_from_string("012345678900123456789001234567890012345678900123456789001234567890");
+    CassBytes value = test_utils::bytes_from_string(
+        "012345678900123456789001234567890012345678900123456789001234567890");
     insert_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value);
     insert_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value);
   }
@@ -135,9 +149,11 @@ BOOST_AUTO_TEST_CASE(read_write_primitives) {
   insert_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true);
 
   {
-    const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-      112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-      84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+    const cass_uint8_t pi[] = {
+      57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,   25, 32,  135,
+      129, 180, 112, 176, 158, 120, 246, 235, 29,  145, 238, 50, 108, 239,
+      219, 100, 250, 84,  6,   186, 148, 76,  230, 46,  181, 89, 239, 247
+    };
     const cass_int32_t pi_scale = 100;
     CassDecimal value = CassDecimal(pi, sizeof(pi), pi_scale);
     insert_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value);
@@ -150,13 +166,11 @@ BOOST_AUTO_TEST_CASE(read_write_primitives) {
     value = CassDuration(1, 2, 3);
     insert_value<CassDuration>(CASS_VALUE_TYPE_DURATION, value);
 
-    value = CassDuration(std::numeric_limits<int32_t>::max(),
-                         std::numeric_limits<int32_t>::max(),
+    value = CassDuration(std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::max(),
                          std::numeric_limits<int64_t>::max());
     insert_value<CassDuration>(CASS_VALUE_TYPE_DURATION, value);
 
-    value = CassDuration(std::numeric_limits<int32_t>::min(),
-                         std::numeric_limits<int32_t>::min(),
+    value = CassDuration(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::min(),
                          std::numeric_limits<int64_t>::min());
     insert_value<CassDuration>(CASS_VALUE_TYPE_DURATION, value);
   }
@@ -199,15 +213,13 @@ BOOST_AUTO_TEST_CASE(read_write_primitives) {
  * @test_category data_types::duration
  * @expected_result Driver will handle the server error on statement execution
  */
-BOOST_AUTO_TEST_CASE(duration_mixed_values_server_error)
-{
+BOOST_AUTO_TEST_CASE(duration_mixed_values_server_error) {
   CCM::CassVersion version = test_utils::get_version();
-  if ((version.major_version >= 3 && version.minor_version >= 10)
-    || version.major_version >= 4) {
+  if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
     // Create the table for the test
     std::string table_name = "duration_server_error";
-    std::string create_table = "CREATE TABLE " + table_name
-      + "(key text PRIMARY KEY, value duration)";
+    std::string create_table =
+        "CREATE TABLE " + table_name + "(key text PRIMARY KEY, value duration)";
     test_utils::execute_query(session, create_table.c_str());
 
     // Bind, validate, and insert the value into the server
@@ -228,7 +240,7 @@ BOOST_AUTO_TEST_CASE(duration_mixed_values_server_error)
 
   } else {
     std::cout << "Unsupported Test for Cassandra v" << version.to_string()
-      << ": Skipping datatypes/duration_mixed_values_server_error" << std::endl;
+              << ": Skipping datatypes/duration_mixed_values_server_error" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_future.cpp b/test/integration_tests/src/test_future.cpp
index 67be8b5b1..9f07294a3 100644
--- a/test/integration_tests/src/test_future.cpp
+++ b/test/integration_tests/src/test_future.cpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
-#include <boost/thread.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/thread/mutex.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
 #include <boost/thread/condition.hpp>
+#include <boost/thread/mutex.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -30,14 +30,13 @@
 #include <sstream>
 
 struct FuturesTests : public test_utils::MultipleNodesTest {
-  FuturesTests() : test_utils::MultipleNodesTest(1, 0) {
-  }
+  FuturesTests()
+      : test_utils::MultipleNodesTest(1, 0) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(future, FuturesTests)
 
-BOOST_AUTO_TEST_CASE(error)
-{
+BOOST_AUTO_TEST_CASE(error) {
   test_utils::CassSessionPtr session(cass_session_new());
   test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster));
   test_utils::wait_and_check_error(connect_future.get());
@@ -57,15 +56,13 @@ BOOST_AUTO_TEST_CASE(error)
     const char* name;
     const cass_byte_t* value;
     size_t name_length, value_size;
-    BOOST_REQUIRE_EQUAL(cass_future_custom_payload_item(future.get(), 0,
-                                                        &name, &name_length,
-                                                        &value, &value_size),
-                        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
+    BOOST_REQUIRE_EQUAL(
+        cass_future_custom_payload_item(future.get(), 0, &name, &name_length, &value, &value_size),
+        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
   }
 }
 
-BOOST_AUTO_TEST_CASE(result_response)
-{
+BOOST_AUTO_TEST_CASE(result_response) {
   test_utils::CassSessionPtr session(cass_session_new());
   test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster));
   test_utils::wait_and_check_error(connect_future.get());
@@ -86,20 +83,19 @@ BOOST_AUTO_TEST_CASE(result_response)
     const char* name;
     const cass_byte_t* value;
     size_t name_length, value_size;
-    BOOST_REQUIRE_EQUAL(cass_future_custom_payload_item(future.get(), 0,
-                                                        &name, &name_length,
-                                                        &value, &value_size),
-                        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
+    BOOST_REQUIRE_EQUAL(
+        cass_future_custom_payload_item(future.get(), 0, &name, &name_length, &value, &value_size),
+        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
   }
 }
 
-BOOST_AUTO_TEST_CASE(prepare_response)
-{
+BOOST_AUTO_TEST_CASE(prepare_response) {
   test_utils::CassSessionPtr session(cass_session_new());
   test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster));
   test_utils::wait_and_check_error(connect_future.get());
 
-  test_utils::CassFuturePtr future(cass_session_prepare(session.get(), "SELECT * FROM system.local"));
+  test_utils::CassFuturePtr future(
+      cass_session_prepare(session.get(), "SELECT * FROM system.local"));
 
   // Expected
   BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
@@ -117,12 +113,10 @@ BOOST_AUTO_TEST_CASE(prepare_response)
     const char* name;
     const cass_byte_t* value;
     size_t name_length, value_size;
-    BOOST_REQUIRE_EQUAL(cass_future_custom_payload_item(future.get(), 0,
-                                                        &name, &name_length,
-                                                        &value, &value_size),
-                        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
+    BOOST_REQUIRE_EQUAL(
+        cass_future_custom_payload_item(future.get(), 0, &name, &name_length, &value, &value_size),
+        CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS);
   }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
diff --git a/test/integration_tests/src/test_future_callbacks.cpp b/test/integration_tests/src/test_future_callbacks.cpp
index 31c0c857d..41fa5f6ac 100644
--- a/test/integration_tests/src/test_future_callbacks.cpp
+++ b/test/integration_tests/src/test_future_callbacks.cpp
@@ -14,15 +14,15 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
-#include <boost/thread.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/thread/mutex.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
 #include <boost/thread/condition.hpp>
+#include <boost/thread/mutex.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -32,10 +32,10 @@
 namespace {
 
 struct CallbackData {
-  CallbackData(CassSession *session = NULL)
-    : was_called(false)
-    , row_count(0)
-    , cass_session(session) {}
+  CallbackData(CassSession* session = NULL)
+      : was_called(false)
+      , row_count(0)
+      , cass_session(session) {}
 
   void wait() {
     boost::unique_lock<boost::mutex> lock(mutex);
@@ -78,14 +78,13 @@ void check_result_callback(CassFuture* future, void* data) {
 } // namespace
 
 struct FutureCallbacksTests : public test_utils::MultipleNodesTest {
-  FutureCallbacksTests() : test_utils::MultipleNodesTest(1, 0) {
-  }
+  FutureCallbacksTests()
+      : test_utils::MultipleNodesTest(1, 0) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(future_callbacks, FutureCallbacksTests)
 
-BOOST_AUTO_TEST_CASE(connect)
-{
+BOOST_AUTO_TEST_CASE(connect) {
   boost::scoped_ptr<CallbackData> callback_data(new CallbackData());
 
   test_utils::CassSessionPtr session(cass_session_new());
@@ -97,8 +96,7 @@ BOOST_AUTO_TEST_CASE(connect)
   BOOST_CHECK(callback_data->was_called);
 }
 
-BOOST_AUTO_TEST_CASE(close)
-{
+BOOST_AUTO_TEST_CASE(close) {
   boost::scoped_ptr<CallbackData> callback_data(new CallbackData());
 
   test_utils::CassSessionPtr session(cass_session_new());
@@ -114,8 +112,7 @@ BOOST_AUTO_TEST_CASE(close)
   BOOST_CHECK(callback_data->was_called);
 }
 
-BOOST_AUTO_TEST_CASE(result)
-{
+BOOST_AUTO_TEST_CASE(result) {
   boost::scoped_ptr<CallbackData> callback_data(new CallbackData());
 
   test_utils::CassSessionPtr session(cass_session_new());
@@ -126,7 +123,8 @@ BOOST_AUTO_TEST_CASE(result)
   test_utils::CassResultPtr result;
 
   std::stringstream query;
-  query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
+  query << "SELECT * FROM "
+        << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
   test_utils::CassStatementPtr statement(cass_statement_new(query.str().c_str(), 0));
   test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
 
@@ -138,8 +136,7 @@ BOOST_AUTO_TEST_CASE(result)
   BOOST_CHECK(callback_data->row_count > 0);
 }
 
-BOOST_AUTO_TEST_CASE(after_set)
-{
+BOOST_AUTO_TEST_CASE(after_set) {
   boost::scoped_ptr<CallbackData> callback_data(new CallbackData());
 
   test_utils::CassSessionPtr session(cass_session_new());
@@ -155,4 +152,3 @@ BOOST_AUTO_TEST_CASE(after_set)
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
diff --git a/test/integration_tests/src/test_heartbeat.cpp b/test/integration_tests/src/test_heartbeat.cpp
index f6c6061d9..769f63d1c 100644
--- a/test/integration_tests/src/test_heartbeat.cpp
+++ b/test/integration_tests/src/test_heartbeat.cpp
@@ -14,14 +14,15 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include <boost/test/unit_test.hpp>
 
 struct HeartbestTest : public test_utils::MultipleNodesTest {
 public:
-  HeartbestTest() : MultipleNodesTest(2, 0) {}
+  HeartbestTest()
+      : MultipleNodesTest(2, 0) {}
 
   /**
    * Execute a select statement against the system tables for a specified amount
diff --git a/test/integration_tests/src/test_iterators.cpp b/test/integration_tests/src/test_iterators.cpp
index 9b5897e27..8b919005a 100644
--- a/test/integration_tests/src/test_iterators.cpp
+++ b/test/integration_tests/src/test_iterators.cpp
@@ -16,58 +16,61 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 struct IteratorTests : public test_utils::SingleSessionTest {
-  IteratorTests() : SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  IteratorTests()
+      : SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~IteratorTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 };
 
 BOOST_FIXTURE_TEST_SUITE(iterators, IteratorTests)
 
-BOOST_AUTO_TEST_CASE(result_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (part timeuuid, key int, value int, PRIMARY KEY(part, key));")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(result_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format(
+              "CREATE TABLE %s (part timeuuid, key int, value int, PRIMARY KEY(part, key));") %
+          table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string part =  test_utils::string_from_uuid(test_utils::generate_time_uuid(uuid_gen));
+  std::string part = test_utils::string_from_uuid(test_utils::generate_time_uuid(uuid_gen));
 
   int num_rows = 10;
 
   for (cass_int32_t i = 0; i < num_rows; ++i) {
-    std::string insert_query = str(boost::format("INSERT INTO %s (part, key, value) VALUES (%s, %d, %d)")
-                                   % table_name
-                                   % part % i % i);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (part, key, value) VALUES (%s, %d, %d)") % table_name %
+            part % i % i);
     test_utils::execute_query(session, insert_query);
   }
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT key FROM %s WHERE part = %s")
-                                         % table_name
-                                         % part),
-                            &result);
+  test_utils::execute_query(
+      session, str(boost::format("SELECT key FROM %s WHERE part = %s") % table_name % part),
+      &result);
 
   BOOST_REQUIRE(cass_result_row_count(result.get()) == static_cast<size_t>(num_rows));
 
@@ -83,22 +86,21 @@ BOOST_AUTO_TEST_CASE(result_iterator)
   }
 }
 
-BOOST_AUTO_TEST_CASE(row_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, first int, second int, third int);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(row_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query = str(
+      boost::format("CREATE TABLE %s (key int PRIMARY KEY, first int, second int, third int);") %
+      table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, first, second, third) VALUES (0, 1, 2, 3)")
-                                 % table_name);
+  std::string insert_query = str(
+      boost::format("INSERT INTO %s (key, first, second, third) VALUES (0, 1, 2, 3)") % table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
 
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
 
@@ -109,28 +111,27 @@ BOOST_AUTO_TEST_CASE(row_iterator)
   cass_int32_t count = 0;
   while (cass_iterator_next(iterator.get())) {
     cass_int32_t column;
-    BOOST_REQUIRE(cass_value_get_int32(cass_iterator_get_column(iterator.get()), &column) == CASS_OK);
+    BOOST_REQUIRE(cass_value_get_int32(cass_iterator_get_column(iterator.get()), &column) ==
+                  CASS_OK);
     BOOST_REQUIRE(column == count++);
   }
   BOOST_REQUIRE(cass_result_column_count(result.get()) == static_cast<size_t>(count));
 }
 
-BOOST_AUTO_TEST_CASE(collection_list_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value list<int>);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(collection_list_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value list<int>);") % table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES (0, [ 0, 1, 2, 3 ])")
-                                 % table_name);
+  std::string insert_query =
+      str(boost::format("INSERT INTO %s (key, value) VALUES (0, [ 0, 1, 2, 3 ])") % table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
   BOOST_REQUIRE(cass_result_column_count(result.get()) == 2);
 
@@ -147,22 +148,20 @@ BOOST_AUTO_TEST_CASE(collection_list_iterator)
   BOOST_REQUIRE(count == 4);
 }
 
-BOOST_AUTO_TEST_CASE(collection_set_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value set<int>);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(collection_set_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value set<int>);") % table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES (0, { 0, 1, 2, 3 })")
-                                 % table_name);
+  std::string insert_query =
+      str(boost::format("INSERT INTO %s (key, value) VALUES (0, { 0, 1, 2, 3 })") % table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
   BOOST_REQUIRE(cass_result_column_count(result.get()) == 2);
 
@@ -180,22 +179,21 @@ BOOST_AUTO_TEST_CASE(collection_set_iterator)
   BOOST_REQUIRE(count == 4);
 }
 
-BOOST_AUTO_TEST_CASE(collection_map_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value map<text, int>);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(collection_map_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query = str(
+      boost::format("CREATE TABLE %s (key int PRIMARY KEY, value map<text, int>);") % table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES (0, { 'a': 0, 'b': 1, 'c': 2, 'd': 3 })")
-                                 % table_name);
+  std::string insert_query = str(
+      boost::format("INSERT INTO %s (key, value) VALUES (0, { 'a': 0, 'b': 1, 'c': 2, 'd': 3 })") %
+      table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
   BOOST_REQUIRE(cass_result_column_count(result.get()) == 2);
 
@@ -207,8 +205,10 @@ BOOST_AUTO_TEST_CASE(collection_map_iterator)
   cass_int32_t count = 0;
   while (cass_iterator_next(iterator.get())) {
     CassString key;
-    BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) == CASS_VALUE_TYPE_VARCHAR);
-    BOOST_REQUIRE(cass_value_get_string(cass_iterator_get_value(iterator.get()), &key.data, &key.length) == CASS_OK);
+    BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(iterator.get())) ==
+                  CASS_VALUE_TYPE_VARCHAR);
+    BOOST_REQUIRE(cass_value_get_string(cass_iterator_get_value(iterator.get()), &key.data,
+                                        &key.length) == CASS_OK);
     BOOST_REQUIRE(key.length == 1 && key.data[0] == 'a' + count);
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
 
@@ -220,22 +220,21 @@ BOOST_AUTO_TEST_CASE(collection_map_iterator)
   BOOST_REQUIRE(count == 4);
 }
 
-BOOST_AUTO_TEST_CASE(map_iterator)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value map<text, int>);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(map_iterator) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query = str(
+      boost::format("CREATE TABLE %s (key int PRIMARY KEY, value map<text, int>);") % table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES (0, { 'a': 0, 'b': 1, 'c': 2, 'd': 3 })")
-                                 % table_name);
+  std::string insert_query = str(
+      boost::format("INSERT INTO %s (key, value) VALUES (0, { 'a': 0, 'b': 1, 'c': 2, 'd': 3 })") %
+      table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
   BOOST_REQUIRE(cass_result_column_count(result.get()) == 2);
 
@@ -247,31 +246,34 @@ BOOST_AUTO_TEST_CASE(map_iterator)
   cass_int32_t count = 0;
   while (cass_iterator_next(iterator.get())) {
     CassString key;
-    BOOST_REQUIRE(cass_value_type(cass_iterator_get_map_key(iterator.get())) == CASS_VALUE_TYPE_VARCHAR);
-    BOOST_REQUIRE(cass_value_get_string(cass_iterator_get_map_key(iterator.get()), &key.data, &key.length) == CASS_OK);
+    BOOST_REQUIRE(cass_value_type(cass_iterator_get_map_key(iterator.get())) ==
+                  CASS_VALUE_TYPE_VARCHAR);
+    BOOST_REQUIRE(cass_value_get_string(cass_iterator_get_map_key(iterator.get()), &key.data,
+                                        &key.length) == CASS_OK);
     BOOST_REQUIRE(key.length == 1 && key.data[0] == 'a' + count);
 
     cass_int32_t value;
-    BOOST_REQUIRE(cass_value_type(cass_iterator_get_map_value(iterator.get())) == CASS_VALUE_TYPE_INT);
-    BOOST_REQUIRE(cass_value_get_int32(cass_iterator_get_map_value(iterator.get()), &value) == CASS_OK);
+    BOOST_REQUIRE(cass_value_type(cass_iterator_get_map_value(iterator.get())) ==
+                  CASS_VALUE_TYPE_INT);
+    BOOST_REQUIRE(cass_value_get_int32(cass_iterator_get_map_value(iterator.get()), &value) ==
+                  CASS_OK);
     BOOST_REQUIRE(value == count++);
   }
   BOOST_REQUIRE(count == 4);
 }
 
-BOOST_AUTO_TEST_CASE(empty)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (part timeuuid, key int, value int, PRIMARY KEY(part, key));")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(empty) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format(
+              "CREATE TABLE %s (part timeuuid, key int, value int, PRIMARY KEY(part, key));") %
+          table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
 
   BOOST_REQUIRE(cass_result_row_count(result.get()) == 0);
 
@@ -279,22 +281,20 @@ BOOST_AUTO_TEST_CASE(empty)
   BOOST_REQUIRE(cass_iterator_next(iterator.get()) == cass_false);
 }
 
-BOOST_AUTO_TEST_CASE(invalid_value_types)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value list<int>);")
-                                       % table_name);
+BOOST_AUTO_TEST_CASE(invalid_value_types) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format("CREATE TABLE %s (key int PRIMARY KEY, value list<int>);") % table_name);
 
   test_utils::execute_query(session, create_table_query);
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (key, value) VALUES (0, [ 0, 1, 2, 3 ])")
-                                 % table_name);
+  std::string insert_query =
+      str(boost::format("INSERT INTO %s (key, value) VALUES (0, [ 0, 1, 2, 3 ])") % table_name);
   test_utils::execute_query(session, insert_query);
 
   test_utils::CassResultPtr result;
-  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s")
-                                         % table_name),
-                            &result);
+  test_utils::execute_query(session, str(boost::format("SELECT * FROM %s") % table_name), &result);
   BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
   BOOST_REQUIRE(cass_result_column_count(result.get()) == 2);
 
diff --git a/test/integration_tests/src/test_latency_aware_policy.cpp b/test/integration_tests/src/test_latency_aware_policy.cpp
index 098627694..fbe859476 100644
--- a/test/integration_tests/src/test_latency_aware_policy.cpp
+++ b/test/integration_tests/src/test_latency_aware_policy.cpp
@@ -14,27 +14,29 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp> // Sleep functionality
 
 #include <uv.h>
 
 #include "cassandra.h"
-#include "testing.hpp"
 #include "test_utils.hpp"
+#include "testing.hpp"
 
 #define DEFAULT_CASSANDRA_NODE_PORT 9042
 #define WARM_UP_QUERY_COUNT 25
 
+using namespace datastax::internal::testing;
+
 struct LatencyAwarePolicyTest {
 public:
   boost::shared_ptr<CCM::Bridge> ccm_;
 
   LatencyAwarePolicyTest()
-    : ccm_(new CCM::Bridge("config.txt"))
-    , cluster_(cass_cluster_new())
-    , thread_() {
+      : ccm_(new CCM::Bridge("config.txt"))
+      , cluster_(cass_cluster_new())
+      , thread_() {
     uv_mutex_init(&lock_);
     uv_cond_init(&condition_);
 
@@ -44,7 +46,7 @@ struct LatencyAwarePolicyTest {
     }
 
     // Initialize the cluster for latency aware
-    cass_cluster_set_reconnect_wait_time(cluster_.get(), 1);
+    cass_cluster_set_constant_reconnect(cluster_.get(), 1);
     cass_cluster_set_connect_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
     cass_cluster_set_request_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
     test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 3);
@@ -115,13 +117,13 @@ struct LatencyAwarePolicyTest {
    * @param tolerance Acceptable percentage threshold/tolerance
    */
   void check_max_latency(int node, unsigned int expected_latency, double tolerance) {
-      double latency = max_node_latency[node - 1];
-      if (latency < expected_latency) {
-        BOOST_CHECK_CLOSE(latency, expected_latency, tolerance);
-      } else {
-        // Ensure assertions are checked for testing framework
-        BOOST_CHECK(latency >= expected_latency);
-      }
+    double latency = max_node_latency[node - 1];
+    if (latency < expected_latency) {
+      BOOST_CHECK_CLOSE(latency, expected_latency, tolerance);
+    } else {
+      // Ensure assertions are checked for testing framework
+      BOOST_CHECK(latency >= expected_latency);
+    }
   }
 
 private:
@@ -140,9 +142,7 @@ struct LatencyAwarePolicyTest {
    *
    * @param arg Not used
    */
-  static void start_thread(void* arg) {
-    execute_query();
-  }
+  static void start_thread(void* arg) { execute_query(); }
 
   /**
    * Execute a query on the system table
@@ -155,28 +155,29 @@ struct LatencyAwarePolicyTest {
       std::string query = "SELECT * FROM system.local";
       test_utils::CassStatementPtr statement(cass_statement_new_n(query.data(), query.size(), 0));
       test_utils::CassFuturePtr future(cass_session_execute(session_.get(), statement.get()));
-      CassError error_code = test_utils::wait_and_return_error(future.get(),
-                                                               240 * test_utils::ONE_SECOND_IN_MICROS);
+      CassError error_code =
+          test_utils::wait_and_return_error(future.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
 
       // Ignore all timing errors
-      if (error_code != CASS_OK &&
-          error_code != CASS_ERROR_LIB_REQUEST_TIMED_OUT &&
+      if (error_code != CASS_OK && error_code != CASS_ERROR_LIB_REQUEST_TIMED_OUT &&
           error_code != CASS_ERROR_SERVER_READ_TIMEOUT) {
         CassString message;
         cass_future_error_message(future.get(), &message.data, &message.length);
 
         // Indicate error occurred
-        std::cerr << std::string(message.data, message.length) << "' (" << cass_error_desc(error_code) << ")" << std::endl;
+        std::cerr << std::string(message.data, message.length) << "' ("
+                  << cass_error_desc(error_code) << ")" << std::endl;
         is_error_ = true;
         is_running_ = false;
       }
 
       if (!is_error_) {
         // Get the host latency
-        std::string host_ip_address = cass::get_host_from_future(future.get()).c_str();
-        double host_latency = static_cast<double>(cass::get_host_latency_average(session_.get(),
-                                                                                 host_ip_address.c_str(),
-                                                                                 DEFAULT_CASSANDRA_NODE_PORT)) / 1e6;
+        std::string host_ip_address = get_host_from_future(future.get()).c_str();
+        double host_latency =
+            static_cast<double>(get_host_latency_average(session_.get(), host_ip_address.c_str(),
+                                                         DEFAULT_CASSANDRA_NODE_PORT)) /
+            1e6;
 
         // Update the max latency incurred
         std::stringstream node_value;
diff --git a/test/integration_tests/src/test_load_balancing.cpp b/test/integration_tests/src/test_load_balancing.cpp
index 8d3748267..34bd47237 100644
--- a/test/integration_tests/src/test_load_balancing.cpp
+++ b/test/integration_tests/src/test_load_balancing.cpp
@@ -14,16 +14,16 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
-#include "test_utils.hpp"
 #include "policy_tools.hpp"
+#include "test_utils.hpp"
 
 #define MAX_RETRIES 50
 
@@ -33,8 +33,8 @@ struct LoadBalancingTests {
   std::string ip_prefix;
 
   LoadBalancingTests()
-    : ccm(new CCM::Bridge("config.txt"))
-    , ip_prefix(ccm->get_ip_prefix()) {}
+      : ccm(new CCM::Bridge("config.txt"))
+      , ip_prefix(ccm->get_ip_prefix()) {}
 
   /**
    * Wait for the total number of connections established
@@ -42,7 +42,8 @@ struct LoadBalancingTests {
    * @param session Session to get metrics from
    * @param number_of_connections Number of connections to verify
    */
-  void wait_for_total_connections(test_utils::CassSessionPtr session, cass_uint64_t number_of_connections) {
+  void wait_for_total_connections(test_utils::CassSessionPtr session,
+                                  cass_uint64_t number_of_connections) {
     CassMetrics metrics;
     unsigned int count = 0;
     do {
@@ -55,8 +56,7 @@ struct LoadBalancingTests {
 
 BOOST_FIXTURE_TEST_SUITE(load_balancing, LoadBalancingTests)
 
-BOOST_AUTO_TEST_CASE(round_robin)
-{
+BOOST_AUTO_TEST_CASE(round_robin) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(3)) {
@@ -96,8 +96,7 @@ BOOST_AUTO_TEST_CASE(round_robin)
   ccm->start_node(1);
 }
 
-BOOST_AUTO_TEST_CASE(dc_aware)
-{
+BOOST_AUTO_TEST_CASE(dc_aware) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2, 1)) {
@@ -137,8 +136,7 @@ BOOST_AUTO_TEST_CASE(dc_aware)
   ccm->start_node(2);
 }
 
-BOOST_AUTO_TEST_CASE(blacklist)
-{
+BOOST_AUTO_TEST_CASE(blacklist) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2)) {
@@ -188,8 +186,7 @@ BOOST_AUTO_TEST_CASE(blacklist)
   }
 }
 
-BOOST_AUTO_TEST_CASE(blacklist_dc)
-{
+BOOST_AUTO_TEST_CASE(blacklist_dc) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
   if (ccm->create_cluster(2, 2)) {
diff --git a/test/integration_tests/src/test_logging.cpp b/test/integration_tests/src/test_logging.cpp
index a06442005..8d44f5154 100644
--- a/test/integration_tests/src/test_logging.cpp
+++ b/test/integration_tests/src/test_logging.cpp
@@ -16,14 +16,14 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/atomic.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
-#include <boost/atomic.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -32,13 +32,12 @@ struct LoggingTests {
   boost::shared_ptr<CCM::Bridge> ccm;
 
   LoggingTests()
-    : ccm(new CCM::Bridge("config.txt")) {}
+      : ccm(new CCM::Bridge("config.txt")) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(logging, LoggingTests)
 
-BOOST_AUTO_TEST_CASE(logging_callback)
-{
+BOOST_AUTO_TEST_CASE(logging_callback) {
   test_utils::CassLog::reset("Adding pool for host");
 
   if (ccm->create_cluster()) {
@@ -68,8 +67,7 @@ BOOST_AUTO_TEST_CASE(logging_callback)
  * @since 2.4.0
  * @expected_result Logger error reduced to warning
  */
-BOOST_AUTO_TEST_CASE(logging_connection_error_reduced)
-{
+BOOST_AUTO_TEST_CASE(logging_connection_error_reduced) {
   // Ensure the cluster is not running
   if (!ccm->create_cluster()) {
     ccm->stop_cluster();
@@ -112,8 +110,7 @@ BOOST_AUTO_TEST_CASE(logging_connection_error_reduced)
  * @since 2.4.0
  * @expected_result Logger error reduced to warning
  */
-BOOST_AUTO_TEST_CASE(logging_pool_error_reduced)
-{
+BOOST_AUTO_TEST_CASE(logging_pool_error_reduced) {
   test_utils::CassLog::reset("Connection pool was unable to connect to host");
   test_utils::CassLog::set_expected_log_level(CASS_LOG_ERROR);
 
diff --git a/test/integration_tests/src/test_metrics.cpp b/test/integration_tests/src/test_metrics.cpp
index 7de57ed17..374f22831 100644
--- a/test/integration_tests/src/test_metrics.cpp
+++ b/test/integration_tests/src/test_metrics.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp> // Sleep functionality
 
 #include "cassandra.h"
@@ -28,12 +28,10 @@ struct MetricsTest {
   boost::shared_ptr<CCM::Bridge> ccm_;
 
   MetricsTest()
-    : cluster_(cass_cluster_new())
-    , ccm_(new CCM::Bridge("config.txt")) {}
+      : cluster_(cass_cluster_new())
+      , ccm_(new CCM::Bridge("config.txt")) {}
 
-  ~MetricsTest() {
-    close_session();
-  }
+  ~MetricsTest() { close_session(); }
 
   /**
    * Create the session
@@ -55,7 +53,8 @@ struct MetricsTest {
 
       CassString message;
       cass_future_error_message(connect_future.get(), &message.data, &message.length);
-      BOOST_FAIL(std::string(message.data, message.length) << "' (" << cass_error_desc(error_code) << ")");
+      BOOST_FAIL(std::string(message.data, message.length)
+                 << "' (" << cass_error_desc(error_code) << ")");
     }
   }
 
@@ -74,24 +73,22 @@ struct MetricsTest {
    *
    * @param metrics Metrics to assign from the active session
    */
-  void get_metrics(CassMetrics *metrics) {
-    cass_session_get_metrics(session_.get(), metrics);
-  }
+  void get_metrics(CassMetrics* metrics) { cass_session_get_metrics(session_.get(), metrics); }
 
- /**
-  * Get the driver speculative execution metrics
-  *
-  * @param metrics Metrics to assign from the active session
-  */
-  void get_speculative_execution_metrics(CassSpeculativeExecutionMetrics *metrics) {
+  /**
+   * Get the driver speculative execution metrics
+   *
+   * @param metrics Metrics to assign from the active session
+   */
+  void get_speculative_execution_metrics(CassSpeculativeExecutionMetrics* metrics) {
     cass_session_get_speculative_execution_metrics(session_.get(), metrics);
   }
 
   /**
-  * Execute a query on the system table
-  *
-  * @param is_async True if async query; false otherwise
-  */
+   * Execute a query on the system table
+   *
+   * @param is_async True if async query; false otherwise
+   */
   void execute_query(bool is_async = false) {
     std::string query = "SELECT * FROM system.local";
     test_utils::CassStatementPtr statement(cass_statement_new_n(query.data(), query.size(), 0));
@@ -118,10 +115,10 @@ BOOST_FIXTURE_TEST_SUITE(metrics, MetricsTest)
  * @test_category metrics
  */
 BOOST_AUTO_TEST_CASE(connections) {
-  //Create one connections per host
+  // Create one connections per host
   cass_cluster_set_num_threads_io(cluster_.get(), 1);
   cass_cluster_set_core_connections_per_host(cluster_.get(), 1);
-  cass_cluster_set_reconnect_wait_time(cluster_.get(), 10); // Low re-connect for node restart
+  cass_cluster_set_constant_reconnect(cluster_.get(), 10); // Low re-connect for node restart
   test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 3);
   if (ccm_->create_cluster(3)) {
     ccm_->start_cluster();
@@ -203,7 +200,7 @@ BOOST_AUTO_TEST_CASE(timeouts) {
 
     // Ensure the pending request has occurred
     boost::chrono::steady_clock::time_point end =
-    boost::chrono::steady_clock::now() + boost::chrono::seconds(10);
+        boost::chrono::steady_clock::now() + boost::chrono::seconds(10);
     do {
       boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
       get_metrics(&metrics);
@@ -211,7 +208,8 @@ BOOST_AUTO_TEST_CASE(timeouts) {
              metrics.errors.pending_request_timeouts == 0);
     BOOST_CHECK_GT(metrics.errors.pending_request_timeouts, 0);
   } else {
-    std::cout << "Skipping Pending Request Timeout for Cassandra v" << version.to_string() << std::endl;
+    std::cout << "Skipping Pending Request Timeout for Cassandra v" << version.to_string()
+              << std::endl;
   }
 
   /*
@@ -229,12 +227,11 @@ BOOST_AUTO_TEST_CASE(timeouts) {
 
   // Ensure the request timeout has occurred
   boost::chrono::steady_clock::time_point end =
-    boost::chrono::steady_clock::now() + boost::chrono::seconds(10);
+      boost::chrono::steady_clock::now() + boost::chrono::seconds(10);
   do {
     boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
     get_metrics(&metrics);
-  } while (boost::chrono::steady_clock::now() < end &&
-           metrics.errors.request_timeouts == 0);
+  } while (boost::chrono::steady_clock::now() < end && metrics.errors.request_timeouts == 0);
   BOOST_CHECK_GT(metrics.errors.request_timeouts, 0);
 }
 
@@ -252,7 +249,7 @@ BOOST_AUTO_TEST_CASE(timeouts) {
  * @test_category metrics
  */
 BOOST_AUTO_TEST_CASE(request_statistics) {
-  //Create one connections per host
+  // Create one connections per host
   cass_cluster_set_num_threads_io(cluster_.get(), 1);
   cass_cluster_set_core_connections_per_host(cluster_.get(), 1);
   test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 1);
@@ -264,13 +261,12 @@ BOOST_AUTO_TEST_CASE(request_statistics) {
   CassMetrics metrics;
   CassSpeculativeExecutionMetrics spec_metrics;
   boost::chrono::steady_clock::time_point end =
-    boost::chrono::steady_clock::now() + boost::chrono::seconds(70);
+      boost::chrono::steady_clock::now() + boost::chrono::seconds(70);
   do {
     execute_query();
     get_metrics(&metrics);
     get_speculative_execution_metrics(&spec_metrics);
-  } while (boost::chrono::steady_clock::now() < end &&
-    metrics.requests.one_minute_rate == 0.0);
+  } while (boost::chrono::steady_clock::now() < end && metrics.requests.one_minute_rate == 0.0);
 
   BOOST_CHECK_LT(metrics.requests.min, CASS_UINT64_MAX);
   BOOST_CHECK_GT(metrics.requests.max, 0);
diff --git a/test/integration_tests/src/test_named_parameters.cpp b/test/integration_tests/src/test_named_parameters.cpp
index 1aef4f99b..9daa50c46 100644
--- a/test/integration_tests/src/test_named_parameters.cpp
+++ b/test/integration_tests/src/test_named_parameters.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
@@ -32,24 +32,29 @@ struct NamedParametersTests : public test_utils::SingleSessionTest {
    *                    otherwise
    * @param suffix Suffix to apply to table name
    */
-  std::string table_name_builder(CassValueType value_type, bool is_prepared, std::string suffix = "") {
-    std::string table_name = "named_parameters_" + std::string(test_utils::get_value_type(value_type)) + "_";
+  std::string table_name_builder(CassValueType value_type, bool is_prepared,
+                                 std::string suffix = "") {
+    std::string table_name =
+        "named_parameters_" + std::string(test_utils::get_value_type(value_type)) + "_";
     table_name += is_prepared ? "prepared" : "simple";
     table_name += suffix.empty() ? "" : "_" + suffix;
     return table_name;
   }
 
 public:
-  NamedParametersTests() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+  NamedParametersTests()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~NamedParametersTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   /**
@@ -64,20 +69,25 @@ struct NamedParametersTests : public test_utils::SingleSessionTest {
   void insert_primitive_value(CassValueType value_type, T value, bool is_prepared) {
     // Create the table for the test
     std::string table_name = table_name_builder(value_type, is_prepared);
-    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + test_utils::get_value_type(value_type) + ")";
+    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " +
+                               test_utils::get_value_type(value_type) + ")";
     test_utils::execute_query(session, create_table.c_str());
 
     // Bind and insert the named value parameter into Cassandra
     CassUuid key = test_utils::generate_time_uuid(uuid_gen);
-    std::string insert_query = "INSERT INTO " + table_name + "(key, value) VALUES(:named_key, :named_value)";
+    std::string insert_query =
+        "INSERT INTO " + table_name + "(key, value) VALUES(:named_key, :named_value)";
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
     if (is_prepared) {
       test_utils::CassPreparedPtr prepared = test_utils::prepare(session, insert_query.c_str());
       statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
     }
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key), CASS_OK);
-    BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind_by_name(statement.get(), "named_value", value), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
+    BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key),
+                        CASS_OK);
+    BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind_by_name(statement.get(), "named_value", value),
+                        CASS_OK);
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
 
     // Ensure the named parameter value can be read using a named parameter
     std::string select_query = "SELECT value FROM " + table_name + " WHERE key = :named_key";
@@ -86,8 +96,10 @@ struct NamedParametersTests : public test_utils::SingleSessionTest {
       test_utils::CassPreparedPtr prepared = test_utils::prepare(session, select_query.c_str());
       statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
     }
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key), CASS_OK);
-    test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
+    BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key),
+                        CASS_OK);
+    test_utils::CassFuturePtr future =
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
     test_utils::CassResultPtr result(cass_future_get_result(future.get()));
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -101,41 +113,49 @@ struct NamedParametersTests : public test_utils::SingleSessionTest {
   }
 
   /**
-  * Insert and validate a batch
-  *
-  * @param value_type CassValueType to use for value
-  * @param value Value to use
-  * @param total Total number of batches to insert and validate
-  */
+   * Insert and validate a batch
+   *
+   * @param value_type CassValueType to use for value
+   * @param value Value to use
+   * @param total Total number of batches to insert and validate
+   */
   template <class T>
   void insert_primitive_batch_value(CassValueType value_type, T value, unsigned int total) {
     // Create the table for the test
     std::string table_name = table_name_builder(value_type, true, "batch");
-    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + test_utils::get_value_type(value_type) + ")";
+    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " +
+                               test_utils::get_value_type(value_type) + ")";
     test_utils::execute_query(session, create_table.c_str());
 
     // Bind and insert the named value parameter into Cassandra
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
-    std::string insert_query = "INSERT INTO " + table_name + "(key, value) VALUES(:named_key , :named_value)";
+    std::string insert_query =
+        "INSERT INTO " + table_name + "(key, value) VALUES(:named_key , :named_value)";
     test_utils::CassPreparedPtr prepared = test_utils::prepare(session, insert_query.c_str());
     std::vector<CassUuid> uuids;
     for (unsigned int i = 0; i < total; ++i) {
       CassUuid key = test_utils::generate_time_uuid(uuid_gen);
       uuids.push_back(key);
       test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind_by_name(statement.get(), "named_value", value), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", key),
+                          CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<T>::bind_by_name(statement.get(), "named_value", value),
+                          CASS_OK);
       cass_batch_add_statement(batch.get(), statement.get());
     }
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute_batch(session, batch.get())).get());
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute_batch(session, batch.get())).get());
 
     // Ensure the named parameter can be read using a named parameter
     std::string select_query = "SELECT value FROM " + table_name + " WHERE key=:named_key";
     prepared = test_utils::prepare(session, select_query.c_str());
-    for (std::vector<CassUuid>::iterator iterator = uuids.begin(); iterator != uuids.end(); ++iterator) {
+    for (std::vector<CassUuid>::iterator iterator = uuids.begin(); iterator != uuids.end();
+         ++iterator) {
       test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", *iterator), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
+      BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid_by_name(statement.get(), "named_key", *iterator),
+                          CASS_OK);
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -167,9 +187,14 @@ BOOST_AUTO_TEST_CASE(ordered_unordered_read_write) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     NamedParametersTests tester;
-    std::string create_table = "CREATE TABLE ordered_unordered_read_write(key int PRIMARY KEY, value_text text, value_uuid uuid, value_blob blob, value_list_floats list<float>)";
-    std::string insert_query = "INSERT INTO ordered_unordered_read_write(key, value_text, value_uuid, value_blob, value_list_floats) VALUES (:key, :one_text, :two_uuid, :three_blob, :four_list_floats)";
-    std::string select_query = "SELECT value_text, value_uuid, value_blob, value_list_floats FROM ordered_unordered_read_write WHERE key=?";
+    std::string create_table =
+        "CREATE TABLE ordered_unordered_read_write(key int PRIMARY KEY, value_text text, "
+        "value_uuid uuid, value_blob blob, value_list_floats list<float>)";
+    std::string insert_query =
+        "INSERT INTO ordered_unordered_read_write(key, value_text, value_uuid, value_blob, "
+        "value_list_floats) VALUES (:key, :one_text, :two_uuid, :three_blob, :four_list_floats)";
+    std::string select_query = "SELECT value_text, value_uuid, value_blob, value_list_floats FROM "
+                               "ordered_unordered_read_write WHERE key=?";
 
     // Create the table and statement for the test
     test_utils::execute_query(tester.session, create_table.c_str());
@@ -181,37 +206,51 @@ BOOST_AUTO_TEST_CASE(ordered_unordered_read_write) {
       CassString text("Named parameters - In Order");
       CassUuid uuid = test_utils::generate_random_uuid(tester.uuid_gen);
       CassBytes blob = test_utils::bytes_from_string(text.data);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 1), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 1),
+                          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
       test_utils::CassCollectionPtr list(cass_collection_new(CASS_COLLECTION_TYPE_LIST, 1));
       test_utils::Value<cass_float_t>::append(list.get(), 0.01f);
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      BOOST_REQUIRE_EQUAL(
+          cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()),
+          CASS_OK);
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the named query parameters can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 1), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
       BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4);
       const CassRow* row = cass_result_first_row(result.get());
       CassString value_text;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassString>::equal(value_text, text));
       CassUuid value_uuid;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassUuid>::equal(value_uuid, uuid));
       CassBytes value_blob;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassBytes>::equal(value_blob, blob));
-      test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(cass_row_get_column(row, 3)));
+      test_utils::CassIteratorPtr iterator(
+          cass_iterator_from_collection(cass_row_get_column(row, 3)));
       cass_iterator_next(iterator.get());
       cass_float_t value_float;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(cass_iterator_get_value(iterator.get()), &value_float), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(
+                              cass_iterator_get_value(iterator.get()), &value_float),
+                          CASS_OK);
       BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(value_float, 0.01f));
     }
 
@@ -222,37 +261,51 @@ BOOST_AUTO_TEST_CASE(ordered_unordered_read_write) {
       CassString text("Named parameters - Out of Order");
       CassUuid uuid = test_utils::generate_random_uuid(tester.uuid_gen);
       CassBytes blob = test_utils::bytes_from_string(text.data);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
       test_utils::CassCollectionPtr list(cass_collection_new(CASS_COLLECTION_TYPE_LIST, 1));
       test_utils::Value<cass_float_t>::append(list.get(), 0.02f);
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 2), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      BOOST_REQUIRE_EQUAL(
+          cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()),
+          CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 2),
+                          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the named query parameters can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 2), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
       BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4);
       const CassRow* row = cass_result_first_row(result.get());
       CassBytes value_blob;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassBytes>::equal(value_blob, blob));
       CassString value_text;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassString>::equal(value_text, text));
-      test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(cass_row_get_column(row, 3)));
+      test_utils::CassIteratorPtr iterator(
+          cass_iterator_from_collection(cass_row_get_column(row, 3)));
       cass_iterator_next(iterator.get());
       cass_float_t value_float;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(cass_iterator_get_value(iterator.get()), &value_float), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(
+                              cass_iterator_get_value(iterator.get()), &value_float),
+                          CASS_OK);
       BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(value_float, 0.02f));
       CassUuid value_uuid;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassUuid>::equal(value_uuid, uuid));
     }
 
@@ -264,41 +317,56 @@ BOOST_AUTO_TEST_CASE(ordered_unordered_read_write) {
       CassString text("Named parameters - Prepared Statement");
       CassUuid uuid = test_utils::generate_random_uuid(tester.uuid_gen);
       CassBytes blob = test_utils::bytes_from_string(text.data);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::bind_by_name(statement.get(), "three_blob", blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::bind_by_name(statement.get(), "one_text", text), CASS_OK);
       test_utils::CassCollectionPtr list(cass_collection_new(CASS_COLLECTION_TYPE_LIST, 1));
       test_utils::Value<cass_float_t>::append(list.get(), 0.03f);
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 3), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      BOOST_REQUIRE_EQUAL(
+          cass_statement_bind_collection_by_name(statement.get(), "four_list_floats", list.get()),
+          CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 3),
+                          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::bind_by_name(statement.get(), "two_uuid", uuid), CASS_OK);
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the named query parameters can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 3), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
       BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4);
       const CassRow* row = cass_result_first_row(result.get());
       CassBytes value_blob;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassBytes>::get(cass_row_get_column(row, 2), &value_blob), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassBytes>::equal(value_blob, blob));
       CassString value_text;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::get(cass_row_get_column(row, 0), &value_text), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassString>::equal(value_text, text));
-      test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(cass_row_get_column(row, 3)));
+      test_utils::CassIteratorPtr iterator(
+          cass_iterator_from_collection(cass_row_get_column(row, 3)));
       cass_iterator_next(iterator.get());
       cass_float_t value_float;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(cass_iterator_get_value(iterator.get()), &value_float), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(
+                              cass_iterator_get_value(iterator.get()), &value_float),
+                          CASS_OK);
       BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(value_float, 0.03f));
       CassUuid value_uuid;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassUuid>::get(cass_row_get_column(row, 1), &value_uuid), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassUuid>::equal(value_uuid, uuid));
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping named_parameters/ordered_unordered_read_write" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping named_parameters/ordered_unordered_read_write" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -324,7 +392,8 @@ BOOST_AUTO_TEST_CASE(all_primitives) {
       {
         CassString value("Test Value");
         tester.insert_primitive_value<CassString>(CASS_VALUE_TYPE_ASCII, value, is_prepared);
-        tester.insert_primitive_value<CassString>(CASS_VALUE_TYPE_VARCHAR, value, is_prepared); // NOTE: text is alias for varchar
+        tester.insert_primitive_value<CassString>(CASS_VALUE_TYPE_VARCHAR, value,
+                                                  is_prepared); // NOTE: text is alias for varchar
       }
 
       {
@@ -334,7 +403,8 @@ BOOST_AUTO_TEST_CASE(all_primitives) {
       }
 
       {
-        CassBytes value = test_utils::bytes_from_string("012345678900123456789001234567890012345678900123456789001234567890");
+        CassBytes value = test_utils::bytes_from_string(
+            "012345678900123456789001234567890012345678900123456789001234567890");
         tester.insert_primitive_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value, is_prepared);
         tester.insert_primitive_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value, is_prepared);
       }
@@ -342,22 +412,27 @@ BOOST_AUTO_TEST_CASE(all_primitives) {
       tester.insert_primitive_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true, is_prepared);
 
       {
-        const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-          112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-          84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+        const cass_uint8_t pi[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,
+                                    25,  32,  135, 129, 180, 112, 176, 158, 120, 246, 235,
+                                    29,  145, 238, 50,  108, 239, 219, 100, 250, 84,  6,
+                                    186, 148, 76,  230, 46,  181, 89,  239, 247 };
         const cass_int32_t pi_scale = 100;
         CassDecimal value = CassDecimal(pi, sizeof(pi), pi_scale);
         tester.insert_primitive_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value, is_prepared);
       }
 
-      if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-        tester.insert_primitive_value<CassDuration>(CASS_VALUE_TYPE_DURATION, CassDuration(1, 2, 3), is_prepared);
+      if ((version.major_version >= 3 && version.minor_version >= 10) ||
+          version.major_version >= 4) {
+        tester.insert_primitive_value<CassDuration>(CASS_VALUE_TYPE_DURATION, CassDuration(1, 2, 3),
+                                                    is_prepared);
       }
 
-      tester.insert_primitive_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, 3.141592653589793, is_prepared);
+      tester.insert_primitive_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, 3.141592653589793,
+                                                   is_prepared);
       tester.insert_primitive_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, 3.1415926f, is_prepared);
       tester.insert_primitive_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123, is_prepared);
-      if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
+      if ((version.major_version >= 2 && version.minor_version >= 2) ||
+          version.major_version >= 3) {
         tester.insert_primitive_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123, is_prepared);
         tester.insert_primitive_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123, is_prepared);
       }
@@ -378,7 +453,8 @@ BOOST_AUTO_TEST_CASE(all_primitives) {
       }
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping named_parameters/all_primitives" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping named_parameters/all_primitives" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -401,61 +477,82 @@ BOOST_AUTO_TEST_CASE(all_primitives_batched) {
 
     {
       CassString value("Test Value");
-      tester.insert_primitive_batch_value<CassString>(CASS_VALUE_TYPE_ASCII, value, TOTAL_NUMBER_OF_BATCHES);
-      tester.insert_primitive_batch_value<CassString>(CASS_VALUE_TYPE_VARCHAR, value, TOTAL_NUMBER_OF_BATCHES); // NOTE: text is alias for varchar
+      tester.insert_primitive_batch_value<CassString>(CASS_VALUE_TYPE_ASCII, value,
+                                                      TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassString>(
+          CASS_VALUE_TYPE_VARCHAR, value,
+          TOTAL_NUMBER_OF_BATCHES); // NOTE: text is alias for varchar
     }
 
     {
       cass_int64_t value = 1234567890;
-      tester.insert_primitive_batch_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, value, TOTAL_NUMBER_OF_BATCHES);
-      tester.insert_primitive_batch_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, value, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, value,
+                                                        TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, value,
+                                                        TOTAL_NUMBER_OF_BATCHES);
     }
 
     {
-      CassBytes value = test_utils::bytes_from_string("012345678900123456789001234567890012345678900123456789001234567890");
-      tester.insert_primitive_batch_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value, TOTAL_NUMBER_OF_BATCHES);
-      tester.insert_primitive_batch_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value, TOTAL_NUMBER_OF_BATCHES);
+      CassBytes value = test_utils::bytes_from_string(
+          "012345678900123456789001234567890012345678900123456789001234567890");
+      tester.insert_primitive_batch_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value,
+                                                     TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value,
+                                                     TOTAL_NUMBER_OF_BATCHES);
     }
 
-    tester.insert_primitive_batch_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true, TOTAL_NUMBER_OF_BATCHES);
+    tester.insert_primitive_batch_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true,
+                                                     TOTAL_NUMBER_OF_BATCHES);
 
     {
-      const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-        112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-        84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+      const cass_uint8_t pi[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,
+                                  25,  32,  135, 129, 180, 112, 176, 158, 120, 246, 235,
+                                  29,  145, 238, 50,  108, 239, 219, 100, 250, 84,  6,
+                                  186, 148, 76,  230, 46,  181, 89,  239, 247 };
       const cass_int32_t pi_scale = 100;
       CassDecimal value = CassDecimal(pi, sizeof(pi), pi_scale);
-      tester.insert_primitive_batch_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value,
+                                                       TOTAL_NUMBER_OF_BATCHES);
     }
 
     if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-      tester.insert_primitive_batch_value<CassDuration>(CASS_VALUE_TYPE_DURATION, CassDuration(1, 2, 3), TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassDuration>(
+          CASS_VALUE_TYPE_DURATION, CassDuration(1, 2, 3), TOTAL_NUMBER_OF_BATCHES);
     }
 
-    tester.insert_primitive_batch_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, 3.141592653589793, TOTAL_NUMBER_OF_BATCHES);
-    tester.insert_primitive_batch_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, 3.1415926f, TOTAL_NUMBER_OF_BATCHES);
-    tester.insert_primitive_batch_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123, TOTAL_NUMBER_OF_BATCHES);
+    tester.insert_primitive_batch_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, 3.141592653589793,
+                                                       TOTAL_NUMBER_OF_BATCHES);
+    tester.insert_primitive_batch_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, 3.1415926f,
+                                                      TOTAL_NUMBER_OF_BATCHES);
+    tester.insert_primitive_batch_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123,
+                                                      TOTAL_NUMBER_OF_BATCHES);
     if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
-      tester.insert_primitive_batch_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123, TOTAL_NUMBER_OF_BATCHES);
-      tester.insert_primitive_batch_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123,
+                                                        TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123,
+                                                       TOTAL_NUMBER_OF_BATCHES);
     }
 
     {
       CassUuid value = test_utils::generate_random_uuid(tester.uuid_gen);
-      tester.insert_primitive_batch_value<CassUuid>(CASS_VALUE_TYPE_UUID, value, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassUuid>(CASS_VALUE_TYPE_UUID, value,
+                                                    TOTAL_NUMBER_OF_BATCHES);
     }
 
     {
       CassInet value = test_utils::inet_v4_from_int(16777343); // 127.0.0.1
-      tester.insert_primitive_batch_value<CassInet>(CASS_VALUE_TYPE_INET, value, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassInet>(CASS_VALUE_TYPE_INET, value,
+                                                    TOTAL_NUMBER_OF_BATCHES);
     }
 
     {
       CassUuid value = test_utils::generate_time_uuid(tester.uuid_gen);
-      tester.insert_primitive_batch_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, value, TOTAL_NUMBER_OF_BATCHES);
+      tester.insert_primitive_batch_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, value,
+                                                    TOTAL_NUMBER_OF_BATCHES);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping named_parameters/all_primitives" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping named_parameters/all_primitives" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -475,8 +572,10 @@ BOOST_AUTO_TEST_CASE(invalid_name) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     NamedParametersTests tester;
-    std::string create_table = "CREATE TABLE named_parameter_invalid(key int PRIMARY KEY, value text)";
-    std::string insert_query = "INSERT INTO named_parameter_invalid(key, value) VALUES (:key_name, :value_name)";
+    std::string create_table =
+        "CREATE TABLE named_parameter_invalid(key int PRIMARY KEY, value text)";
+    std::string insert_query =
+        "INSERT INTO named_parameter_invalid(key, value) VALUES (:key_name, :value_name)";
 
     // Create the table and statement for the test
     test_utils::execute_query(tester.session, create_table.c_str());
@@ -485,19 +584,32 @@ BOOST_AUTO_TEST_CASE(invalid_name) {
     {
       // Simple
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "invalid_key_name", 0), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(statement.get(), "invalid_value_name", CassString("invalid")), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::wait_and_return_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get()),
-                                                            CASS_ERROR_SERVER_INVALID_QUERY);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "invalid_key_name", 0),
+          CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(
+                              statement.get(), "invalid_value_name", CassString("invalid")),
+                          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::wait_and_return_error(
+              test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()))
+                  .get()),
+          CASS_ERROR_SERVER_INVALID_QUERY);
 
       // Prepared
-      test_utils::CassPreparedPtr prepared = test_utils::prepare(tester.session, insert_query.c_str());
+      test_utils::CassPreparedPtr prepared =
+          test_utils::prepare(tester.session, insert_query.c_str());
       statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "invalid_key_name", 0), CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(statement.get(), "invalid_value_name", CassString("invalid")), CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "invalid_key_name", 0),
+          CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::bind_by_name(
+                              statement.get(), "invalid_value_name", CassString("invalid")),
+                          CASS_ERROR_LIB_NAME_DOES_NOT_EXIST);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping named_parameters/invalid" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping named_parameters/invalid" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_outage.cpp b/test/integration_tests/src/test_outage.cpp
index 60e3d874f..b414cb4da 100644
--- a/test/integration_tests/src/test_outage.cpp
+++ b/test/integration_tests/src/test_outage.cpp
@@ -20,14 +20,14 @@
 #include <signal.h>
 #endif
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/format.hpp>
 #include <boost/asio.hpp>
-#include <boost/thread/future.hpp>
 #include <boost/bind.hpp>
+#include <boost/format.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread/future.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -38,18 +38,12 @@
 bool execute_insert(CassSession* session, const std::string& table_name);
 
 struct OutageTests : public test_utils::MultipleNodesTest {
-  enum NodeState {
-    UP,
-    DOWN,
-    REMOVED,
-    GOSSIP_DISABLED,
-    BINARY_DISABLED
-  };
+  enum NodeState { UP, DOWN, REMOVED, GOSSIP_DISABLED, BINARY_DISABLED };
 
   OutageTests()
-    : test_utils::MultipleNodesTest(NUM_NODES, 0)
-    , is_done(false)
-    , timer(io_service) {
+      : test_utils::MultipleNodesTest(NUM_NODES, 0)
+      , is_done(false)
+      , timer(io_service) {
     test_utils::CassLog::set_output_log_level(CASS_LOG_DISABLED);
     printf("Warning! This test is going to take %d minutes\n", TEST_DURATION_SECS / 60);
     std::fill(nodes_states, nodes_states + NUM_NODES, UP);
@@ -68,24 +62,26 @@ struct OutageTests : public test_utils::MultipleNodesTest {
   bool client_thread(CassSession* session, const std::string table_name) {
     std::string query = str(boost::format("SELECT * FROM %s LIMIT 10000") % table_name);
 
-    for (int i = 0 ; i < 10; ++i)  execute_insert(session, table_name);
+    for (int i = 0; i < 10; ++i)
+      execute_insert(session, table_name);
 
     boost::posix_time::ptime start = boost::posix_time::second_clock::universal_time();
 
     test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
     cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE);
 
-    while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() < TEST_DURATION_SECS) {
+    while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() <
+           TEST_DURATION_SECS) {
       test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
       cass_future_wait(future.get());
 
       CassError code = cass_future_error_code(future.get());
-      if (code != CASS_OK
-         && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT
-         && code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
+      if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT &&
+          code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
         CassString message;
         cass_future_error_message(future.get(), &message.data, &message.length);
-        fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length), message.data);
+        fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length),
+                message.data);
         is_done = true;
         return false;
       }
@@ -104,9 +100,7 @@ struct OutageTests : public test_utils::MultipleNodesTest {
     return true;
   }
 
-  void outage_thread() {
-    io_service.run();
-  }
+  void outage_thread() { io_service.run(); }
 
   void handle_timeout(const boost::system::error_code& error) {
     if (is_done) {
@@ -142,7 +136,7 @@ struct OutageTests : public test_utils::MultipleNodesTest {
           }
         }
       }
-    } else if (NUM_NODES - num_up > 0){
+    } else if (NUM_NODES - num_up > 0) {
       int n = random_int(1, NUM_NODES - num_up);
       for (size_t i = 0; i < NUM_NODES; ++i) {
         if (nodes_states[i] == DOWN || nodes_states[i] == REMOVED) {
@@ -152,13 +146,13 @@ struct OutageTests : public test_utils::MultipleNodesTest {
             break;
           }
         } else if (nodes_states[i] == GOSSIP_DISABLED) {
-           nodes_states[i] = UP;
-           ccm->enable_node_gossip(i);
-           break;
+          nodes_states[i] = UP;
+          ccm->enable_node_gossip(i);
+          break;
         } else if (nodes_states[i] == BINARY_DISABLED) {
-           nodes_states[i] = UP;
-           ccm->enable_node_binary_protocol(i);
-           break;
+          nodes_states[i] = UP;
+          ccm->enable_node_binary_protocol(i);
+          break;
         }
       }
     }
@@ -168,7 +162,9 @@ struct OutageTests : public test_utils::MultipleNodesTest {
   }
 
   bool execute_insert(CassSession* session, const std::string& table_name) {
-    std::string query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
+    std::string query =
+        str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") %
+            table_name);
     test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3));
 
     // Determine if bound parameters can be used based on C* version
@@ -178,7 +174,8 @@ struct OutageTests : public test_utils::MultipleNodesTest {
     }
 
     boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
-    boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
+    boost::chrono::milliseconds event_time(
+        boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
     std::string text_sample(test_utils::string_from_time_point(now));
 
     cass_statement_bind_uuid(statement.get(), 0, test_utils::generate_time_uuid(uuid_gen));
@@ -191,7 +188,8 @@ struct OutageTests : public test_utils::MultipleNodesTest {
     if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
       CassString message;
       cass_future_error_message(future.get(), &message.data, &message.length);
-      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
+      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length),
+              message.data);
       return false;
     }
 
@@ -205,21 +203,23 @@ struct OutageTests : public test_utils::MultipleNodesTest {
   boost::mt19937 rng;
 };
 
-
 BOOST_FIXTURE_TEST_SUITE(outage, OutageTests)
 
-BOOST_AUTO_TEST_CASE(test)
-{
+BOOST_AUTO_TEST_CASE(test) {
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
-  test_utils::execute_query(session.get(), "CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};");
+  test_utils::execute_query(session.get(), "CREATE KEYSPACE test WITH replication = {'class': "
+                                           "'SimpleStrategy', 'replication_factor' : 3};");
   test_utils::execute_query(session.get(), "USE test;");
 
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
 
-  test_utils::execute_query(session.get(), str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
+  test_utils::execute_query(session.get(),
+                            str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
 
   boost::BOOST_THREAD_FUTURE<bool> client_future =
-      boost::async(boost::launch::async, boost::bind(&OutageTests::client_thread, this, session.get(), table_name));
+      boost::async(boost::launch::async,
+                   boost::bind(&OutageTests::client_thread, this, session.get(), table_name));
 
   timer.expires_from_now(boost::posix_time::seconds(2));
   timer.async_wait(boost::bind(&OutageTests::handle_timeout, this, _1));
@@ -233,4 +233,3 @@ BOOST_AUTO_TEST_CASE(test)
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
diff --git a/test/integration_tests/src/test_paging.cpp b/test/integration_tests/src/test_paging.cpp
index c9f9e98f7..51184d279 100644
--- a/test/integration_tests/src/test_paging.cpp
+++ b/test/integration_tests/src/test_paging.cpp
@@ -16,30 +16,33 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 struct PagingTests : public test_utils::SingleSessionTest {
-  PagingTests() : SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  PagingTests()
+      : SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
-    test_utils::execute_query(session, "CREATE TABLE test (part int, key timeuuid, value int, PRIMARY KEY(part, key));");
+    test_utils::execute_query(
+        session, "CREATE TABLE test (part int, key timeuuid, value int, PRIMARY KEY(part, key));");
   }
 
   ~PagingTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   void insert_rows(int num_rows) {
@@ -66,8 +69,7 @@ struct PagingTests : public test_utils::SingleSessionTest {
 
 BOOST_FIXTURE_TEST_SUITE(paging, PagingTests)
 
-BOOST_AUTO_TEST_CASE(paging_simple)
-{
+BOOST_AUTO_TEST_CASE(paging_simple) {
   const int num_rows = 100;
   const int page_size = 5;
 
@@ -76,7 +78,8 @@ BOOST_AUTO_TEST_CASE(paging_simple)
   insert_rows(num_rows);
 
   test_utils::CassResultPtr result;
-  test_utils::CassStatementPtr statement(test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0)));
+  test_utils::CassStatementPtr statement(
+      test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0)));
   cass_statement_set_paging_size(statement.get(), page_size);
 
   cass_int32_t count = 0;
@@ -100,8 +103,7 @@ BOOST_AUTO_TEST_CASE(paging_simple)
   } while (cass_result_has_more_pages(result.get()));
 }
 
-BOOST_AUTO_TEST_CASE(paging_raw)
-{
+BOOST_AUTO_TEST_CASE(paging_raw) {
   const int num_rows = 100;
   const int page_size = 5;
 
@@ -110,7 +112,8 @@ BOOST_AUTO_TEST_CASE(paging_raw)
   insert_rows(num_rows);
 
   test_utils::CassResultPtr result;
-  test_utils::CassStatementPtr statement(test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0)));
+  test_utils::CassStatementPtr statement(
+      test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 0)));
   cass_statement_set_paging_size(statement.get(), page_size);
 
   cass_int32_t count = 0;
@@ -128,18 +131,17 @@ BOOST_AUTO_TEST_CASE(paging_raw)
       BOOST_REQUIRE(value == count++);
     }
 
-
     if (cass_result_has_more_pages(result.get())) {
       const char* paging_state;
       size_t paging_state_size;
-      BOOST_CHECK(cass_result_paging_state_token(result.get(), &paging_state, &paging_state_size) == CASS_OK);
+      BOOST_CHECK(cass_result_paging_state_token(result.get(), &paging_state, &paging_state_size) ==
+                  CASS_OK);
       cass_statement_set_paging_state_token(statement.get(), paging_state, paging_state_size);
     }
   } while (cass_result_has_more_pages(result.get()));
 }
 
-BOOST_AUTO_TEST_CASE(paging_empty)
-{
+BOOST_AUTO_TEST_CASE(paging_empty) {
   const int page_size = 5;
 
   const char* select_query = "SELECT value FROM test";
@@ -153,5 +155,4 @@ BOOST_AUTO_TEST_CASE(paging_empty)
   BOOST_REQUIRE(cass_result_has_more_pages(result.get()) == cass_false);
 }
 
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_pool.cpp b/test/integration_tests/src/test_pool.cpp
index e2630a119..79021b6f4 100644
--- a/test/integration_tests/src/test_pool.cpp
+++ b/test/integration_tests/src/test_pool.cpp
@@ -15,18 +15,18 @@
 */
 
 #include "cassandra.h"
-#include "test_utils.hpp"
 #include "cluster.hpp"
+#include "test_utils.hpp"
 
 #include <uv.h>
 
 #include <boost/scoped_ptr.hpp>
-#include <boost/thread.hpp>
 #include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
 
 struct TestPool : public test_utils::MultipleNodesTest {
   TestPool()
-    : MultipleNodesTest(1, 0) {}
+      : MultipleNodesTest(1, 0) {}
 
   /**
    * Execute a select statement against the system tables for a specified amount
@@ -50,25 +50,23 @@ struct TestPool : public test_utils::MultipleNodesTest {
 
 BOOST_AUTO_TEST_SUITE(pool)
 
-BOOST_AUTO_TEST_CASE(connection_spawn)
-{
+BOOST_AUTO_TEST_CASE(connection_spawn) {
   TestPool tester;
-  const std::string SPAWN_MSG = "Spawning new connection to host " + tester.ccm->get_ip_prefix() + "1";
+  const std::string SPAWN_MSG =
+      "Spawning new connection to host " + tester.ccm->get_ip_prefix() + "1";
   test_utils::CassLog::reset(SPAWN_MSG);
 
   test_utils::MultipleNodesTest inst(1, 0);
   cass_cluster_set_num_threads_io(tester.cluster, 1);
   cass_cluster_set_core_connections_per_host(tester.cluster, 1);
   cass_cluster_set_max_connections_per_host(tester.cluster, 2);
-  cass_cluster_set_max_concurrent_requests_threshold(tester.cluster, 1);// start next connection soon
+  cass_cluster_set_max_concurrent_requests_threshold(tester.cluster,
+                                                     1); // start next connection soon
 
   // only one with no traffic
-  {
-    test_utils::CassSessionPtr session(test_utils::create_session(tester.cluster));
-  }
+  { test_utils::CassSessionPtr session(test_utils::create_session(tester.cluster)); }
   BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), 1u);
 
-
   test_utils::CassLog::reset(SPAWN_MSG);
   // exactly two with traffic
   {
@@ -79,7 +77,8 @@ BOOST_AUTO_TEST_CASE(connection_spawn)
     // run a few to get concurrent requests
     std::vector<test_utils::CassFuturePtr> futures;
     for (size_t i = 0; i < 10; ++i) {
-      futures.push_back(test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
+      futures.push_back(
+          test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
     }
   }
   BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), 2u);
@@ -100,10 +99,11 @@ struct ConnectionInterruptionData {
  *
  * @param data Connection interruption data structure
  */
-static void connection_interruptions(void *data) {
+static void connection_interruptions(void* data) {
   boost::posix_time::ptime start = boost::posix_time::second_clock::universal_time();
   ConnectionInterruptionData* ci_data = static_cast<ConnectionInterruptionData*>(data);
-  while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() < ci_data->duration) {
+  while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() <
+         ci_data->duration) {
     ci_data->ccm->pause_node(ci_data->node);
     boost::this_thread::sleep(boost::posix_time::seconds(ci_data->delay));
     ci_data->ccm->resume_node(ci_data->node);
@@ -122,7 +122,8 @@ static void connection_interruptions(void *data) {
  * @jira_ticket CPP-253 [https://datastax-oss.atlassian.net/browse/CPP-253]
  */
 BOOST_AUTO_TEST_CASE(dont_recycle_pool_on_timeout) {
-  // Limit backpressure test to lower version of C* (difficult to produce in later versions deterministically)
+  // Limit backpressure test to lower version of C* (difficult to produce in later versions
+  // deterministically)
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version <= 2 && version.minor_version < 1) || version.major_version < 2) {
     TestPool tester;
@@ -141,7 +142,8 @@ BOOST_AUTO_TEST_CASE(dont_recycle_pool_on_timeout) {
     cass_cluster_set_load_balance_round_robin(tester.cluster);
 
     // Create session during "connection interruptions"
-    test_utils::CassLog::reset("Host " + ip_prefix + "2 already present attempting to initiate immediate connection");
+    test_utils::CassLog::reset("Host " + ip_prefix +
+                               "2 already present attempting to initiate immediate connection");
     {
       uv_thread_t connection_interruptions_thread;
       ci_data.duration = 5;
@@ -174,10 +176,11 @@ BOOST_AUTO_TEST_CASE(dont_recycle_pool_on_timeout) {
     // Destroy the current cluster (node added)
     tester.ccm->remove_cluster();
   } else {
-    std::cout << "Difficult to Produce Don't Recycle Pool on Timeout for Cassandra v" << version.to_string() << ": Skipping pool/dont_recycle_pool_on_timeout (use C* 1.x - 2.0.x)" << std::endl;
+    std::cout << "Difficult to Produce Don't Recycle Pool on Timeout for Cassandra v"
+              << version.to_string()
+              << ": Skipping pool/dont_recycle_pool_on_timeout (use C* 1.x - 2.0.x)" << std::endl;
     BOOST_REQUIRE(true);
   }
-
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_prepare_on_all.cpp b/test/integration_tests/src/test_prepare_on_all.cpp
index 5be61516a..c08c96f4f 100644
--- a/test/integration_tests/src/test_prepare_on_all.cpp
+++ b/test/integration_tests/src/test_prepare_on_all.cpp
@@ -16,11 +16,11 @@
 
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
@@ -40,12 +40,11 @@ struct PrepareOnAllTests : public test_utils::SingleSessionTest {
    * and clear all prepared statements.
    */
   PrepareOnAllTests()
-    : SingleSessionTest(NUM_LOCAL_NODES, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen)))
-    , prepared_query_(str(boost::format("SELECT * FROM %s.test") % keyspace)) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
+      : SingleSessionTest(NUM_LOCAL_NODES, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen)))
+      , prepared_query_(str(boost::format("SELECT * FROM %s.test") % keyspace)) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace));
     test_utils::execute_query(session, "CREATE TABLE test (k text PRIMARY KEY, v text)");
 
@@ -100,7 +99,8 @@ struct PrepareOnAllTests : public test_utils::SingleSessionTest {
    */
   void prepared_statements_is_empty(int node) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
+    test_utils::execute_query(session_for_node(node).get(),
+                              "SELECT * FROM system.prepared_statements", &result);
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 0u);
   }
 
@@ -113,7 +113,8 @@ struct PrepareOnAllTests : public test_utils::SingleSessionTest {
    */
   bool prepared_statement_is_present(int node, const std::string& query) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
+    test_utils::execute_query(session_for_node(node).get(),
+                              "SELECT * FROM system.prepared_statements", &result);
 
     test_utils::CassIteratorPtr iterator(cass_iterator_from_result(result.get()));
     while (cass_iterator_next(iterator.get())) {
@@ -123,7 +124,8 @@ struct PrepareOnAllTests : public test_utils::SingleSessionTest {
       const CassValue* query_column = cass_row_get_column_by_name(row, "query_string");
       const char* query_string;
       size_t query_string_len;
-      BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len),
+                          CASS_OK);
 
       if (query == std::string(query_string, query_string_len)) {
         return true;
@@ -176,8 +178,8 @@ struct PrepareOnAllTests : public test_utils::SingleSessionTest {
   void wait_for_node(int node) {
     for (int i = 0; i < 10; ++i) {
       test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.peers", 0));
-      test_utils::CassFuturePtr future(cass_session_execute(session_for_node(node).get(),
-                                                            statement.get()));
+      test_utils::CassFuturePtr future(
+          cass_session_execute(session_for_node(node).get(), statement.get()));
       if (cass_future_error_code(future.get()) == CASS_OK) {
         return;
       }
diff --git a/test/integration_tests/src/test_prepare_on_up_or_add_host.cpp b/test/integration_tests/src/test_prepare_on_up_or_add_host.cpp
index 09334bce6..d3723338e 100644
--- a/test/integration_tests/src/test_prepare_on_up_or_add_host.cpp
+++ b/test/integration_tests/src/test_prepare_on_up_or_add_host.cpp
@@ -16,11 +16,11 @@
 
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
@@ -29,6 +29,8 @@
 #include "test_utils.hpp"
 #include "testing.hpp"
 
+using namespace datastax::internal::testing;
+
 /**
  * Test harness for prepare on up or add host functionality.
  */
@@ -39,15 +41,15 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    * and initialize prepared query strings.
    */
   PrepareOnUpOrAddHostTests()
-    : SingleSessionTest(1, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
+      : SingleSessionTest(1, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace));
 
     for (int i = 1; i <= 3; ++i) {
-      test_utils::execute_query(session, str(boost::format("CREATE TABLE test%d (k text PRIMARY KEY, v text)") % i));
+      test_utils::execute_query(
+          session, str(boost::format("CREATE TABLE test%d (k text PRIMARY KEY, v text)") % i));
       prepared_queries_.push_back(str(boost::format("SELECT * FROM %s.test%d") % keyspace % i));
     }
 
@@ -94,7 +96,8 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    */
   void prepared_statements_is_empty(int node) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
+    test_utils::execute_query(session_for_node(node).get(),
+                              "SELECT * FROM system.prepared_statements", &result);
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 0u);
   }
 
@@ -107,7 +110,8 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    */
   bool prepared_statement_is_present(int node, const std::string& query) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
+    test_utils::execute_query(session_for_node(node).get(),
+                              "SELECT * FROM system.prepared_statements", &result);
 
     test_utils::CassIteratorPtr iterator(cass_iterator_from_result(result.get()));
     while (cass_iterator_next(iterator.get())) {
@@ -117,7 +121,8 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
       const CassValue* query_column = cass_row_get_column_by_name(row, "query_string");
       const char* query_string;
       size_t query_string_len;
-      BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len),
+                          CASS_OK);
 
       if (query == std::string(query_string, query_string_len)) {
         return true;
@@ -134,8 +139,7 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    */
   void prepared_statements_are_present(int node) {
     for (std::vector<std::string>::const_iterator it = prepared_queries_.begin();
-         it != prepared_queries_.end();
-         ++it) {
+         it != prepared_queries_.end(); ++it) {
       BOOST_CHECK(prepared_statement_is_present(node, (*it)));
     }
   }
@@ -147,8 +151,7 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    */
   void prepared_statements_are_not_present(int node) {
     for (std::vector<std::string>::const_iterator it = prepared_queries_.begin();
-         it != prepared_queries_.end();
-         ++it) {
+         it != prepared_queries_.end(); ++it) {
       BOOST_CHECK(!prepared_statement_is_present(node, (*it)));
     }
   }
@@ -160,8 +163,7 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
    */
   void prepare_all_queries(test_utils::CassSessionPtr session) {
     for (std::vector<std::string>::const_iterator it = prepared_queries_.begin();
-         it != prepared_queries_.end();
-         ++it) {
+         it != prepared_queries_.end(); ++it) {
       test_utils::CassFuturePtr future(cass_session_prepare(session.get(), it->c_str()));
       BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
     }
@@ -179,18 +181,15 @@ struct PrepareOnUpOrAddHostTests : public test_utils::SingleSessionTest {
 
     for (int i = 0; i < 30; ++i) {
       test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.peers", 0));
-      test_utils::CassFuturePtr future(cass_session_execute(session.get(),
-                                                            statement.get()));
-      std::string host(cass::get_host_from_future(future.get()).c_str());
+      test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
+      std::string host(get_host_from_future(future.get()).c_str());
       if (cass_future_error_code(future.get()) == CASS_OK && host == ip_address.str()) {
         return;
       }
       boost::this_thread::sleep_for(boost::chrono::seconds(1));
     }
     BOOST_REQUIRE_MESSAGE(false,
-                          "Failed to wait for node " <<
-                          ip_address.str() <<
-                          " to become availble");
+                          "Failed to wait for node " << ip_address.str() << " to become availble");
   }
 
   /**
diff --git a/test/integration_tests/src/test_prepared.cpp b/test/integration_tests/src/test_prepared.cpp
index 5efaa5425..31f9f90cb 100644
--- a/test/integration_tests/src/test_prepared.cpp
+++ b/test/integration_tests/src/test_prepared.cpp
@@ -14,18 +14,18 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/container/vector.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/shared_ptr.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/move/move.hpp>
-#include <boost/container/vector.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/version.hpp>
 
 #include "cassandra.h"
@@ -63,23 +63,31 @@ struct PreparedTests : public test_utils::SingleSessionTest {
   std::string values_;
   size_t column_size_;
 
-  PreparedTests() : test_utils::SingleSessionTest(2, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  PreparedTests()
+      : test_utils::SingleSessionTest(2, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
     if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-      test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES_V4_1) % ALL_TYPE_TABLE_NAME));
+      test_utils::execute_query(
+          session,
+          str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES_V4_1) % ALL_TYPE_TABLE_NAME));
       column_size_ = 16;
-    } else if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
-      test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES_V4) % ALL_TYPE_TABLE_NAME));
+    } else if ((version.major_version >= 2 && version.minor_version >= 2) ||
+               version.major_version >= 3) {
+      test_utils::execute_query(
+          session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES_V4) % ALL_TYPE_TABLE_NAME));
       column_size_ = 15;
     } else {
-      test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES) % ALL_TYPE_TABLE_NAME));
+      test_utils::execute_query(
+          session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES) % ALL_TYPE_TABLE_NAME));
       column_size_ = 11;
     }
 
-    columns_ = "id, text_sample, int_sample, bigint_sample, float_sample, double_sample, decimal_sample, "
-      "blob_sample, boolean_sample, timestamp_sample, inet_sample";
+    columns_ =
+        "id, text_sample, int_sample, bigint_sample, float_sample, double_sample, decimal_sample, "
+        "blob_sample, boolean_sample, timestamp_sample, inet_sample";
     values_ = "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?";
     if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
       columns_ += ", tinyint_sample, smallint_sample, date_sample, time_sample";
@@ -93,26 +101,27 @@ struct PreparedTests : public test_utils::SingleSessionTest {
 
   ~PreparedTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
-  void insert_all_types(CassSession* session, const CassPrepared* prepared, const AllTypes& all_types) {
+  void insert_all_types(CassSession* session, const CassPrepared* prepared,
+                        const AllTypes& all_types) {
     test_utils::CassStatementPtr statement(cass_prepared_bind(prepared));
 
     cass_statement_bind_uuid(statement.get(), 0, all_types.id);
-    cass_statement_bind_string_n(statement.get(), 1,
-                                 all_types.text_sample.data, all_types.text_sample.length);
+    cass_statement_bind_string_n(statement.get(), 1, all_types.text_sample.data,
+                                 all_types.text_sample.length);
     cass_statement_bind_int32(statement.get(), 2, all_types.int_sample);
     cass_statement_bind_int64(statement.get(), 3, all_types.bigint_sample);
     cass_statement_bind_float(statement.get(), 4, all_types.float_sample);
     cass_statement_bind_double(statement.get(), 5, all_types.double_sample);
-    cass_statement_bind_decimal(statement.get(), 6,
-                                all_types.decimal_sample.varint, all_types.decimal_sample.varint_size,
+    cass_statement_bind_decimal(statement.get(), 6, all_types.decimal_sample.varint,
+                                all_types.decimal_sample.varint_size,
                                 all_types.decimal_sample.scale);
-    cass_statement_bind_bytes(statement.get(), 7,
-                              all_types.blob_sample.data, all_types.blob_sample.size);
+    cass_statement_bind_bytes(statement.get(), 7, all_types.blob_sample.data,
+                              all_types.blob_sample.size);
     cass_statement_bind_bool(statement.get(), 8, all_types.boolean_sample);
     cass_statement_bind_int64(statement.get(), 9, all_types.timestamp_sample);
     cass_statement_bind_inet(statement.get(), 10, all_types.inet_sample);
@@ -123,9 +132,8 @@ struct PreparedTests : public test_utils::SingleSessionTest {
       cass_statement_bind_int64(statement.get(), 14, all_types.time_sample.time);
     }
     if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-      cass_statement_bind_duration(statement.get(), 15,
-                                   all_types.duration_sample.months, all_types.duration_sample.days,
-                                   all_types.duration_sample.nanos);
+      cass_statement_bind_duration(statement.get(), 15, all_types.duration_sample.months,
+                                   all_types.duration_sample.days, all_types.duration_sample.nanos);
     }
 
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
@@ -135,59 +143,77 @@ struct PreparedTests : public test_utils::SingleSessionTest {
 
   void compare_all_types(const AllTypes& input, const CassRow* row) {
     AllTypes output;
-    BOOST_REQUIRE(cass_value_get_string(cass_row_get_column(row, 1), &output.text_sample.data, &output.text_sample.length) == CASS_OK);
+    BOOST_REQUIRE(cass_value_get_string(cass_row_get_column(row, 1), &output.text_sample.data,
+                                        &output.text_sample.length) == CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal(input.text_sample, output.text_sample));
 
     BOOST_REQUIRE(cass_value_get_int32(cass_row_get_column(row, 2), &output.int_sample) == CASS_OK);
     BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(input.int_sample, output.int_sample));
 
-    BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 3), &output.bigint_sample) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<cass_int64_t>::equal(input.bigint_sample, output.bigint_sample));
+    BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 3), &output.bigint_sample) ==
+                  CASS_OK);
+    BOOST_REQUIRE(
+        test_utils::Value<cass_int64_t>::equal(input.bigint_sample, output.bigint_sample));
 
-    BOOST_REQUIRE(cass_value_get_float(cass_row_get_column(row, 4), &output.float_sample) == CASS_OK);
+    BOOST_REQUIRE(cass_value_get_float(cass_row_get_column(row, 4), &output.float_sample) ==
+                  CASS_OK);
     BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(input.float_sample, output.float_sample));
 
-    BOOST_REQUIRE(cass_value_get_double(cass_row_get_column(row, 5), &output.double_sample) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<cass_double_t>::equal(input.double_sample, output.double_sample));
+    BOOST_REQUIRE(cass_value_get_double(cass_row_get_column(row, 5), &output.double_sample) ==
+                  CASS_OK);
+    BOOST_REQUIRE(
+        test_utils::Value<cass_double_t>::equal(input.double_sample, output.double_sample));
 
-    BOOST_REQUIRE(cass_value_get_decimal(cass_row_get_column(row, 6),
-                                         &output.decimal_sample.varint,
+    BOOST_REQUIRE(cass_value_get_decimal(cass_row_get_column(row, 6), &output.decimal_sample.varint,
                                          &output.decimal_sample.varint_size,
                                          &output.decimal_sample.scale) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<CassDecimal>::equal(input.decimal_sample, output.decimal_sample));
+    BOOST_REQUIRE(
+        test_utils::Value<CassDecimal>::equal(input.decimal_sample, output.decimal_sample));
 
-    BOOST_REQUIRE(cass_value_get_bytes(cass_row_get_column(row, 7), &output.blob_sample.data, &output.blob_sample.size) == CASS_OK);
+    BOOST_REQUIRE(cass_value_get_bytes(cass_row_get_column(row, 7), &output.blob_sample.data,
+                                       &output.blob_sample.size) == CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassBytes>::equal(input.blob_sample, output.blob_sample));
 
-    BOOST_REQUIRE(cass_value_get_bool(cass_row_get_column(row, 8), &output.boolean_sample) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<cass_bool_t>::equal(input.boolean_sample, output.boolean_sample));
+    BOOST_REQUIRE(cass_value_get_bool(cass_row_get_column(row, 8), &output.boolean_sample) ==
+                  CASS_OK);
+    BOOST_REQUIRE(
+        test_utils::Value<cass_bool_t>::equal(input.boolean_sample, output.boolean_sample));
 
-    BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 9), &output.timestamp_sample) == CASS_OK);
-    BOOST_REQUIRE(test_utils::Value<cass_int64_t>::equal(input.timestamp_sample, output.timestamp_sample));
+    BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 9), &output.timestamp_sample) ==
+                  CASS_OK);
+    BOOST_REQUIRE(
+        test_utils::Value<cass_int64_t>::equal(input.timestamp_sample, output.timestamp_sample));
 
-    BOOST_REQUIRE(cass_value_get_inet(cass_row_get_column(row, 10), &output.inet_sample) == CASS_OK);
+    BOOST_REQUIRE(cass_value_get_inet(cass_row_get_column(row, 10), &output.inet_sample) ==
+                  CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassInet>::equal(input.inet_sample, output.inet_sample));
 
     if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
-      BOOST_REQUIRE(cass_value_get_int8(cass_row_get_column(row, 11), &output.tinyint_sample) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<cass_int8_t>::equal(input.tinyint_sample, output.tinyint_sample));
-
-      BOOST_REQUIRE(cass_value_get_int16(cass_row_get_column(row, 12), &output.smallint_sample) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<cass_int16_t>::equal(input.smallint_sample, output.smallint_sample));
-
-      BOOST_REQUIRE(cass_value_get_uint32(cass_row_get_column(row, 13), &output.date_sample.date) == CASS_OK);
+      BOOST_REQUIRE(cass_value_get_int8(cass_row_get_column(row, 11), &output.tinyint_sample) ==
+                    CASS_OK);
+      BOOST_REQUIRE(
+          test_utils::Value<cass_int8_t>::equal(input.tinyint_sample, output.tinyint_sample));
+
+      BOOST_REQUIRE(cass_value_get_int16(cass_row_get_column(row, 12), &output.smallint_sample) ==
+                    CASS_OK);
+      BOOST_REQUIRE(
+          test_utils::Value<cass_int16_t>::equal(input.smallint_sample, output.smallint_sample));
+
+      BOOST_REQUIRE(cass_value_get_uint32(cass_row_get_column(row, 13), &output.date_sample.date) ==
+                    CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassDate>::equal(input.date_sample, output.date_sample));
 
-      BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 14), &output.time_sample.time) == CASS_OK);
+      BOOST_REQUIRE(cass_value_get_int64(cass_row_get_column(row, 14), &output.time_sample.time) ==
+                    CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassTime>::equal(input.time_sample, output.time_sample));
     }
 
     if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-      BOOST_REQUIRE(cass_value_get_duration(cass_row_get_column(row, 15),
-                                           &output.duration_sample.months,
-                                           &output.duration_sample.days,
-                                           &output.duration_sample.nanos) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<CassDuration>::equal(input.duration_sample, output.duration_sample));
+      BOOST_REQUIRE(cass_value_get_duration(
+                        cass_row_get_column(row, 15), &output.duration_sample.months,
+                        &output.duration_sample.days, &output.duration_sample.nanos) == CASS_OK);
+      BOOST_REQUIRE(
+          test_utils::Value<CassDuration>::equal(input.duration_sample, output.duration_sample));
     }
   }
 };
@@ -196,15 +222,12 @@ const char* PreparedTests::ALL_TYPE_TABLE_NAME = "all_types_table_prepared";
 
 BOOST_FIXTURE_TEST_SUITE(prepared, PreparedTests)
 
-BOOST_AUTO_TEST_CASE(bound_all_types_different_values)
-{
-  std::string insert_query = str(boost::format("INSERT INTO %s (%s) VALUES (%s)")
-                                 % ALL_TYPE_TABLE_NAME
-                                 % columns_
-                                 % values_);
+BOOST_AUTO_TEST_CASE(bound_all_types_different_values) {
+  std::string insert_query = str(boost::format("INSERT INTO %s (%s) VALUES (%s)") %
+                                 ALL_TYPE_TABLE_NAME % columns_ % values_);
 
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   insert_query.data(), insert_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, insert_query.data(), insert_query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
@@ -216,7 +239,8 @@ BOOST_AUTO_TEST_CASE(bound_all_types_different_values)
   uint8_t bytes3[] = { 1, 1 };
   uint8_t address1[CASS_INET_V4_LENGTH] = { 192, 168, 0, 100 };
   uint8_t address2[CASS_INET_V4_LENGTH] = { 0, 0, 0, 0 };
-  uint8_t address3[CASS_INET_V6_LENGTH] = { 255, 128, 12, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
+  uint8_t address3[CASS_INET_V6_LENGTH] = { 255, 128, 12,  1,   255, 255, 255, 255,
+                                            255, 255, 255, 255, 255, 255, 255, 255 };
 
   const size_t all_types_count = 3;
   AllTypes all_types[all_types_count];
@@ -224,7 +248,7 @@ BOOST_AUTO_TEST_CASE(bound_all_types_different_values)
   all_types[0].id = test_utils::generate_time_uuid(uuid_gen);
   all_types[0].text_sample = CassString("first");
   all_types[0].int_sample = 10;
-  all_types[0].bigint_sample = CASS_INT64_MAX  - 1L;
+  all_types[0].bigint_sample = CASS_INT64_MAX - 1L;
   all_types[0].float_sample = 1.999f;
   all_types[0].double_sample = 32.002;
   all_types[0].decimal_sample = CassDecimal(varint1, sizeof(varint1), 1);
@@ -288,12 +312,11 @@ BOOST_AUTO_TEST_CASE(bound_all_types_different_values)
     insert_all_types(session, prepared.get(), all_types[i]);
   }
 
-  std::string select_query = str(boost::format("SELECT %s FROM %s WHERE id IN (%s, %s, %s)")
-                                 % columns_
-                                 % ALL_TYPE_TABLE_NAME
-                                 % test_utils::string_from_uuid(all_types[0].id)
-                             % test_utils::string_from_uuid(all_types[1].id)
-      % test_utils::string_from_uuid(all_types[2].id));
+  std::string select_query =
+      str(boost::format("SELECT %s FROM %s WHERE id IN (%s, %s, %s)") % columns_ %
+          ALL_TYPE_TABLE_NAME % test_utils::string_from_uuid(all_types[0].id) %
+          test_utils::string_from_uuid(all_types[1].id) %
+          test_utils::string_from_uuid(all_types[2].id));
 
   test_utils::CassResultPtr result;
   test_utils::execute_query(session, select_query, &result);
@@ -314,15 +337,12 @@ BOOST_AUTO_TEST_CASE(bound_all_types_different_values)
   }
 }
 
-BOOST_AUTO_TEST_CASE(bound_all_types_null_values)
-{
-  std::string insert_query = str(boost::format("INSERT INTO %s (%s) VALUES (%s)")
-                                 % ALL_TYPE_TABLE_NAME
-                                 % columns_
-                                 % values_);
+BOOST_AUTO_TEST_CASE(bound_all_types_null_values) {
+  std::string insert_query = str(boost::format("INSERT INTO %s (%s) VALUES (%s)") %
+                                 ALL_TYPE_TABLE_NAME % columns_ % values_);
 
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   insert_query.data(), insert_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, insert_query.data(), insert_query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
@@ -339,10 +359,8 @@ BOOST_AUTO_TEST_CASE(bound_all_types_null_values)
 
   test_utils::wait_and_check_error(future.get());
 
-  std::string select_query = str(boost::format("SELECT %s FROM %s WHERE id IN (%s)")
-                                 % columns_
-                                 % ALL_TYPE_TABLE_NAME
-                                 % test_utils::string_from_uuid(id));
+  std::string select_query = str(boost::format("SELECT %s FROM %s WHERE id IN (%s)") % columns_ %
+                                 ALL_TYPE_TABLE_NAME % test_utils::string_from_uuid(id));
 
   test_utils::CassResultPtr result;
   test_utils::execute_query(session, select_query, &result);
@@ -358,22 +376,27 @@ BOOST_AUTO_TEST_CASE(bound_all_types_null_values)
   }
 }
 
-BOOST_AUTO_TEST_CASE(select_one)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, numb double, label text);") % table_name);
+BOOST_AUTO_TEST_CASE(select_one) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format("CREATE TABLE %s (tweet_id int PRIMARY KEY, numb double, label text);") %
+          table_name);
 
   test_utils::execute_query(session, create_table_query);
 
   for (int i = 0; i < 10; ++i) {
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, numb, label) VALUES(%d, 0.01,'row%d')") % table_name % i % i);
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, numb, label) VALUES(%d, 0.01,'row%d')") %
+            table_name % i % i);
     test_utils::execute_query(session, insert_query);
   }
 
-  std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
+  std::string select_query =
+      str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % table_name);
 
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   select_query.data(), select_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, select_query.data(), select_query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
@@ -393,7 +416,8 @@ BOOST_AUTO_TEST_CASE(select_one)
   CassString result_label;
   BOOST_REQUIRE(cass_value_get_int32(cass_row_get_column(row, 0), &result_tweet_id) == CASS_OK);
   BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(tweet_id, result_tweet_id));
-  BOOST_REQUIRE(cass_value_get_string(cass_row_get_column(row, 1), &result_label.data, &result_label.length) == CASS_OK);
+  BOOST_REQUIRE(cass_value_get_string(cass_row_get_column(row, 1), &result_label.data,
+                                      &result_label.length) == CASS_OK);
   BOOST_REQUIRE(test_utils::Value<CassString>::equal(CassString("row5"), result_label));
 }
 
@@ -402,8 +426,8 @@ CassPreparedMovable prepare_statement(CassSession* session, std::string query) {
 #else
 test_utils::CassPreparedPtr prepare_statement(CassSession* session, std::string query) {
 #endif
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   query.data(), query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, query.data(), query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
 #if BOOST_VERSION < 105700
   return CassPreparedMovable(cass_future_get_prepared(prepared_future.get()));
@@ -414,21 +438,23 @@ test_utils::CassPreparedPtr prepare_statement(CassSession* session, std::string
 
 void execute_statement(CassSession* session, const CassPrepared* prepared, int value) {
   test_utils::CassStatementPtr statement(cass_prepared_bind(prepared));
-  BOOST_REQUIRE(cass_statement_bind_double(statement.get(), 0, static_cast<double>(value)) == CASS_OK);
+  BOOST_REQUIRE(cass_statement_bind_double(statement.get(), 0, static_cast<double>(value)) ==
+                CASS_OK);
   BOOST_REQUIRE(cass_statement_bind_int32(statement.get(), 1, value) == CASS_OK);
   test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
   test_utils::wait_and_check_error(future.get());
 }
 
-BOOST_AUTO_TEST_CASE(massive_number_of_prepares)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
-  std::string create_table_query = str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, numb1 double, numb2 int);") % table_name);
+BOOST_AUTO_TEST_CASE(massive_number_of_prepares) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+  std::string create_table_query =
+      str(boost::format("CREATE TABLE %s (tweet_id uuid PRIMARY KEY, numb1 double, numb2 int);") %
+          table_name);
   size_t number_of_prepares = 100;
 
   test_utils::execute_query(session, create_table_query);
 
-
 #if BOOST_VERSION < 105700
   CONTAINER<boost::BOOST_THREAD_FUTURE<CassPreparedMovable> > prepare_futures;
 #else
@@ -438,8 +464,11 @@ BOOST_AUTO_TEST_CASE(massive_number_of_prepares)
   std::vector<CassUuid> tweet_ids;
   for (size_t i = 0; i < number_of_prepares; ++i) {
     CassUuid tweet_id = test_utils::generate_time_uuid(uuid_gen);
-    std::string insert_query = str(boost::format("INSERT INTO %s (tweet_id, numb1, numb2) VALUES (%s, ?, ?);") % table_name % test_utils::string_from_uuid(tweet_id));
-    prepare_futures.push_back(boost::async(boost::launch::async, boost::bind(prepare_statement, session, insert_query)));
+    std::string insert_query =
+        str(boost::format("INSERT INTO %s (tweet_id, numb1, numb2) VALUES (%s, ?, ?);") %
+            table_name % test_utils::string_from_uuid(tweet_id));
+    prepare_futures.push_back(
+        boost::async(boost::launch::async, boost::bind(prepare_statement, session, insert_query)));
     tweet_ids.push_back(tweet_id);
   }
 
@@ -455,7 +484,10 @@ BOOST_AUTO_TEST_CASE(massive_number_of_prepares)
 #else
     test_utils::CassPreparedPtr prepared = prepare_futures[i].get();
 #endif
-    execute_futures.push_back(boost::async(boost::launch::async, boost::bind(execute_statement, session, prepared.get(), i)).share());
+    execute_futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(execute_statement, session, prepared.get(), i))
+            .share());
     prepares.push_back(boost::move(prepared));
   }
 
@@ -472,7 +504,8 @@ BOOST_AUTO_TEST_CASE(massive_number_of_prepares)
     const CassRow* row = cass_iterator_get_row(iterator.get());
     CassUuid result_tweet_id;
     cass_value_get_uuid(cass_row_get_column(row, 0), &result_tweet_id);
-    BOOST_REQUIRE(std::find(tweet_ids.begin(), tweet_ids.end(), result_tweet_id) != tweet_ids.end());
+    BOOST_REQUIRE(std::find(tweet_ids.begin(), tweet_ids.end(), result_tweet_id) !=
+                  tweet_ids.end());
   }
 }
 
diff --git a/test/integration_tests/src/test_prepared_batch.cpp b/test/integration_tests/src/test_prepared_batch.cpp
index 645951394..8285a4cfc 100644
--- a/test/integration_tests/src/test_prepared_batch.cpp
+++ b/test/integration_tests/src/test_prepared_batch.cpp
@@ -16,11 +16,11 @@
 
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include "cassandra.h"
@@ -29,16 +29,17 @@
 #include "test_utils.hpp"
 #include "testing.hpp"
 
+using namespace datastax::internal::testing;
+
 /**
  * Test harness for prepared statements in batches.
  */
 struct PreparedBatchTests : public test_utils::SingleSessionTest {
   PreparedBatchTests()
-    : SingleSessionTest(1, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
+      : SingleSessionTest(1, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace));
     test_utils::execute_query(session, "CREATE TABLE test (k text PRIMARY KEY, v text)");
   }
@@ -55,18 +56,15 @@ struct PreparedBatchTests : public test_utils::SingleSessionTest {
 
     for (int i = 0; i < 30; ++i) {
       test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.peers", 0));
-      test_utils::CassFuturePtr future(cass_session_execute(session.get(),
-                                                            statement.get()));
-      std::string host(cass::get_host_from_future(future.get()).c_str());
+      test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
+      std::string host(get_host_from_future(future.get()).c_str());
       if (cass_future_error_code(future.get()) == CASS_OK && host == ip_address.str()) {
         return;
       }
       boost::this_thread::sleep_for(boost::chrono::seconds(1));
     }
     BOOST_REQUIRE_MESSAGE(false,
-                          "Failed to wait for node " <<
-                          ip_address.str() <<
-                          " to become availble");
+                          "Failed to wait for node " << ip_address.str() << " to become availble");
   }
 
   /**
@@ -76,13 +74,11 @@ struct PreparedBatchTests : public test_utils::SingleSessionTest {
    * @param key The key to validate
    * @param expected_value The expected value for the given key
    */
-  void validate_result(test_utils::CassSessionPtr session,
-                       const std::string& key,
+  void validate_result(test_utils::CassSessionPtr session, const std::string& key,
                        const std::string& expected_value) {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session.get(),
-                              str(boost::format("SELECT * FROM test WHERE k = '%s'") % key),
-                              &result);
+    test_utils::execute_query(
+        session.get(), str(boost::format("SELECT * FROM test WHERE k = '%s'") % key), &result);
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
     const CassRow* row = cass_result_first_row(result.get());
     BOOST_REQUIRE(row != NULL);
@@ -118,7 +114,8 @@ BOOST_AUTO_TEST_CASE(reprepare_batch) {
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
   test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace));
 
-  test_utils::CassFuturePtr prepare_future(cass_session_prepare(session.get(), "INSERT INTO test (k, v) VALUES (?, ?)"));
+  test_utils::CassFuturePtr prepare_future(
+      cass_session_prepare(session.get(), "INSERT INTO test (k, v) VALUES (?, ?)"));
   test_utils::wait_and_check_error(prepare_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepare_future.get()));
 
diff --git a/test/integration_tests/src/test_prepared_existing.cpp b/test/integration_tests/src/test_prepared_existing.cpp
index 66d2406ea..0dafe20e6 100644
--- a/test/integration_tests/src/test_prepared_existing.cpp
+++ b/test/integration_tests/src/test_prepared_existing.cpp
@@ -16,26 +16,27 @@
 
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include "cassandra.h"
 #include "execute_request.hpp"
 #include "statement.hpp"
 #include "test_utils.hpp"
 
+using namespace datastax::internal::core;
+
 /**
  * Test harness for prepared from existing functionality.
  */
 struct PreparedFromExistingTests : public test_utils::SingleSessionTest {
   PreparedFromExistingTests()
-    : SingleSessionTest(1, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
+      : SingleSessionTest(1, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace));
     test_utils::execute_query(session, "CREATE TABLE test (k text PRIMARY KEY, v text)");
     test_utils::execute_query(session, "INSERT INTO test (k, v) VALUES ('key1', 'value1')");
@@ -60,7 +61,8 @@ struct PreparedFromExistingTests : public test_utils::SingleSessionTest {
 
     const char* value;
     size_t value_length;
-    BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &value, &value_length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &value, &value_length),
+                        CASS_OK);
     BOOST_CHECK_EQUAL(std::string(value, value_length), "value1");
   }
 
@@ -81,13 +83,16 @@ BOOST_FIXTURE_TEST_SUITE(prepared_existing, PreparedFromExistingTests)
  *
  */
 BOOST_AUTO_TEST_CASE(prepare_from_existing_simple_statement) {
-  test_utils::CassStatementPtr statement(cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
+  test_utils::CassStatementPtr statement(
+      cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
 
   test_utils::CassRetryPolicyPtr retry_policy(cass_retry_policy_downgrading_consistency_new());
 
   // Set unique settings to validate later
-  BOOST_CHECK_EQUAL(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_LOCAL_QUORUM), CASS_OK);
-  BOOST_CHECK_EQUAL(cass_statement_set_serial_consistency(statement.get(), CASS_CONSISTENCY_SERIAL), CASS_OK);
+  BOOST_CHECK_EQUAL(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_LOCAL_QUORUM),
+                    CASS_OK);
+  BOOST_CHECK_EQUAL(cass_statement_set_serial_consistency(statement.get(), CASS_CONSISTENCY_SERIAL),
+                    CASS_OK);
   BOOST_CHECK_EQUAL(cass_statement_set_request_timeout(statement.get(), 99999u), CASS_OK);
   BOOST_CHECK_EQUAL(cass_statement_set_retry_policy(statement.get(), retry_policy.get()), CASS_OK);
 
@@ -101,7 +106,7 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_simple_statement) {
   test_utils::CassStatementPtr bound_statement(cass_prepared_bind(prepared.get()));
   BOOST_REQUIRE(bound_statement);
 
-  cass::ExecuteRequest* execute_request = static_cast<cass::ExecuteRequest*>(bound_statement->from());
+  ExecuteRequest* execute_request = static_cast<ExecuteRequest*>(bound_statement->from());
 
   // Validate that the bound statement inherited the settings from the original statement
   BOOST_CHECK_EQUAL(execute_request->consistency(), CASS_CONSISTENCY_LOCAL_QUORUM);
@@ -109,7 +114,8 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_simple_statement) {
   BOOST_CHECK_EQUAL(execute_request->request_timeout_ms(), 99999u);
   BOOST_CHECK_EQUAL(execute_request->retry_policy().get(), retry_policy.get());
 
-  validate_query_result(test_utils::CassFuturePtr(cass_session_execute(session, bound_statement.get())));
+  validate_query_result(
+      test_utils::CassFuturePtr(cass_session_execute(session, bound_statement.get())));
 }
 
 /**
@@ -122,7 +128,8 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_simple_statement) {
  *
  */
 BOOST_AUTO_TEST_CASE(prepare_from_existing_bound_statement) {
-  test_utils::CassFuturePtr future1(cass_session_prepare(session, "SELECT v FROM test WHERE k = 'key1'"));
+  test_utils::CassFuturePtr future1(
+      cass_session_prepare(session, "SELECT v FROM test WHERE k = 'key1'"));
   BOOST_REQUIRE_EQUAL(cass_future_error_code(future1.get()), CASS_OK);
 
   test_utils::CassPreparedPtr prepared1(cass_future_get_prepared(future1.get()));
@@ -134,13 +141,19 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_bound_statement) {
   test_utils::CassRetryPolicyPtr retry_policy(cass_retry_policy_downgrading_consistency_new());
 
   // Set unique settings to validate later
-  BOOST_CHECK_EQUAL(cass_statement_set_consistency(bound_statement1.get(), CASS_CONSISTENCY_LOCAL_QUORUM), CASS_OK);
-  BOOST_CHECK_EQUAL(cass_statement_set_serial_consistency(bound_statement1.get(), CASS_CONSISTENCY_SERIAL), CASS_OK);
+  BOOST_CHECK_EQUAL(
+      cass_statement_set_consistency(bound_statement1.get(), CASS_CONSISTENCY_LOCAL_QUORUM),
+      CASS_OK);
+  BOOST_CHECK_EQUAL(
+      cass_statement_set_serial_consistency(bound_statement1.get(), CASS_CONSISTENCY_SERIAL),
+      CASS_OK);
   BOOST_CHECK_EQUAL(cass_statement_set_request_timeout(bound_statement1.get(), 99999u), CASS_OK);
-  BOOST_CHECK_EQUAL(cass_statement_set_retry_policy(bound_statement1.get(), retry_policy.get()), CASS_OK);
+  BOOST_CHECK_EQUAL(cass_statement_set_retry_policy(bound_statement1.get(), retry_policy.get()),
+                    CASS_OK);
 
   // Prepare from the existing bound statement
-  test_utils::CassFuturePtr future2(cass_session_prepare_from_existing(session, bound_statement1.get()));
+  test_utils::CassFuturePtr future2(
+      cass_session_prepare_from_existing(session, bound_statement1.get()));
   BOOST_REQUIRE_EQUAL(cass_future_error_code(future2.get()), CASS_OK);
 
   test_utils::CassPreparedPtr prepared2(cass_future_get_prepared(future2.get()));
@@ -149,7 +162,7 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_bound_statement) {
   test_utils::CassStatementPtr bound_statement2(cass_prepared_bind(prepared2.get()));
   BOOST_REQUIRE(bound_statement2);
 
-  cass::ExecuteRequest* execute_request = static_cast<cass::ExecuteRequest*>(bound_statement2->from());
+  ExecuteRequest* execute_request = static_cast<ExecuteRequest*>(bound_statement2->from());
 
   // Validate that the bound statement inherited the settings from the original bound statement
   BOOST_CHECK_EQUAL(execute_request->consistency(), CASS_CONSISTENCY_LOCAL_QUORUM);
@@ -157,7 +170,8 @@ BOOST_AUTO_TEST_CASE(prepare_from_existing_bound_statement) {
   BOOST_CHECK_EQUAL(execute_request->request_timeout_ms(), 99999u);
   BOOST_CHECK_EQUAL(execute_request->retry_policy().get(), retry_policy.get());
 
-  validate_query_result(test_utils::CassFuturePtr(cass_session_execute(session, bound_statement2.get())));
+  validate_query_result(
+      test_utils::CassFuturePtr(cass_session_execute(session, bound_statement2.get())));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_prepared_metadata.cpp b/test/integration_tests/src/test_prepared_metadata.cpp
index a55c66163..78159fd27 100644
--- a/test/integration_tests/src/test_prepared_metadata.cpp
+++ b/test/integration_tests/src/test_prepared_metadata.cpp
@@ -16,10 +16,10 @@
 
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include "cassandra.h"
 #include "execute_request.hpp"
@@ -31,17 +31,15 @@
  */
 struct PreparedMetadataTests : public test_utils::SingleSessionTest {
   PreparedMetadataTests()
-    : SingleSessionTest(1, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
+      : SingleSessionTest(1, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace));
     test_utils::execute_query(session, "CREATE TABLE test (k text PRIMARY KEY, v text)");
     test_utils::execute_query(session, "INSERT INTO test (k, v) VALUES ('key1', 'value1')");
   }
 
-
   /**
    * Check the column count of a bound statement before and after adding a
    * column to a table.
@@ -53,7 +51,8 @@ struct PreparedMetadataTests : public test_utils::SingleSessionTest {
 
     test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace));
 
-    test_utils::CassFuturePtr future(cass_session_prepare(session.get(), "SELECT * FROM test WHERE k = 'key1'"));
+    test_utils::CassFuturePtr future(
+        cass_session_prepare(session.get(), "SELECT * FROM test WHERE k = 'key1'"));
     BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
 
     test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get()));
@@ -64,7 +63,8 @@ struct PreparedMetadataTests : public test_utils::SingleSessionTest {
 
     // Verify that the table has two columns in the metadata
     {
-      test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get()));
+      test_utils::CassFuturePtr result_future(
+          cass_session_execute(session.get(), bound_statement.get()));
       BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK);
 
       test_utils::CassResultPtr result(cass_future_get_result(result_future.get()));
@@ -77,7 +77,8 @@ struct PreparedMetadataTests : public test_utils::SingleSessionTest {
 
     // The column count shouldn't have changed
     {
-      test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get()));
+      test_utils::CassFuturePtr result_future(
+          cass_session_execute(session.get(), bound_statement.get()));
       BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK);
 
       test_utils::CassResultPtr result(cass_future_get_result(result_future.get()));
@@ -103,8 +104,10 @@ BOOST_FIXTURE_TEST_SUITE(prepared_metadata, PreparedMetadataTests)
  *
  */
 BOOST_AUTO_TEST_CASE(alter_doesnt_update_column_count) {
-  cass_cluster_set_use_beta_protocol_version(cluster, cass_false); // Ensure beta protocol is not set
-  BOOST_REQUIRE_EQUAL(cass_cluster_set_protocol_version(cluster, CASS_PROTOCOL_VERSION_V4), CASS_OK);
+  cass_cluster_set_use_beta_protocol_version(cluster,
+                                             cass_false); // Ensure beta protocol is not set
+  BOOST_REQUIRE_EQUAL(cass_cluster_set_protocol_version(cluster, CASS_PROTOCOL_VERSION_V4),
+                      CASS_OK);
 
   // The column count will stay the same even after the alter
   prepared_check_column_count_after_alter(2u);
diff --git a/test/integration_tests/src/test_prepared_outage.cpp b/test/integration_tests/src/test_prepared_outage.cpp
index 25f6e0494..5b2d38a62 100644
--- a/test/integration_tests/src/test_prepared_outage.cpp
+++ b/test/integration_tests/src/test_prepared_outage.cpp
@@ -16,54 +16,57 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/chrono.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 struct PreparedOutageTests : public test_utils::SingleSessionTest {
-  PreparedOutageTests() : SingleSessionTest(3, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "2"));
+  PreparedOutageTests()
+      : SingleSessionTest(3, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "2"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~PreparedOutageTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 };
 
 BOOST_FIXTURE_TEST_SUITE(prepared_outage, PreparedOutageTests)
 
-BOOST_AUTO_TEST_CASE(reprepared_on_new_node)
-{
+BOOST_AUTO_TEST_CASE(reprepared_on_new_node) {
   std::string table_name = "test";
 
-  test_utils::execute_query(session, str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value int);") % table_name));
+  test_utils::execute_query(
+      session,
+      str(boost::format("CREATE TABLE %s (key text PRIMARY KEY, value int);") % table_name));
 
   std::string insert_query = "INSERT INTO %s (key, value) VALUES ('%s', %d);";
   test_utils::execute_query(session, str(boost::format(insert_query) % table_name % "123" % 17));
   test_utils::execute_query(session, str(boost::format(insert_query) % table_name % "456" % 18));
 
-
   std::string select_query = str(boost::format("SELECT * FROM %s WHERE key = ?;") % table_name);
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   select_query.data(), select_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, select_query.data(), select_query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
   {
     test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
-    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) == CASS_OK);
+    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) ==
+                  CASS_OK);
     BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 0, "123") == CASS_OK);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
@@ -103,7 +106,8 @@ BOOST_AUTO_TEST_CASE(reprepared_on_new_node)
 
   for (int i = 0; i < 10; ++i) {
     test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
-    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) == CASS_OK);
+    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) ==
+                  CASS_OK);
     BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 0, "789") == CASS_OK);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
@@ -121,14 +125,16 @@ BOOST_AUTO_TEST_CASE(reprepared_on_new_node)
   ccm->disable_node_gossip(2);
   ccm->disable_node_gossip(1);
 
-  //Ensure the binary protocol is disabled before executing the inserts
+  // Ensure the binary protocol is disabled before executing the inserts
   boost::this_thread::sleep_for(boost::chrono::seconds(5));
-  test_utils::execute_query(session, str(boost::format(insert_query) % table_name % "123456789" % 20));
+  test_utils::execute_query(session,
+                            str(boost::format(insert_query) % table_name % "123456789" % 20));
   ccm->enable_node_gossip(2);
 
   for (int i = 0; i < 10; ++i) {
     test_utils::CassStatementPtr statement(cass_prepared_bind(prepared.get()));
-    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) == CASS_OK);
+    BOOST_REQUIRE(cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM) ==
+                  CASS_OK);
     BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 0, "123456789") == CASS_OK);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
diff --git a/test/integration_tests/src/test_schema_agreement.cpp b/test/integration_tests/src/test_schema_agreement.cpp
index 991d1b7ed..cd5c4bc49 100644
--- a/test/integration_tests/src/test_schema_agreement.cpp
+++ b/test/integration_tests/src/test_schema_agreement.cpp
@@ -28,15 +28,13 @@
 
 struct ClusterInit {
   ClusterInit()
-    : inst(3, 0)
-    , session(NULL)
-    , schema_alter_session(NULL) {
+      : inst(3, 0)
+      , session(NULL)
+      , schema_alter_session(NULL) {
     new_session();
   }
 
-  ~ClusterInit() {
-    close_session();
-  }
+  ~ClusterInit() { close_session(); }
 
   void new_session() {
     close_session();
@@ -52,7 +50,8 @@ struct ClusterInit {
     whitelist_hosts << ip_prefix << "1";
     cass_cluster_set_whitelist_filtering(inst.cluster, whitelist_hosts.str().c_str());
     schema_alter_session = cass_session_new();
-    test_utils::CassFuturePtr connect_future(cass_session_connect(schema_alter_session, inst.cluster));
+    test_utils::CassFuturePtr connect_future(
+        cass_session_connect(schema_alter_session, inst.cluster));
     test_utils::wait_and_check_error(connect_future.get());
   }
 
@@ -76,17 +75,18 @@ struct ClusterInit {
 BOOST_FIXTURE_TEST_SUITE(schema_agreement, ClusterInit)
 
 // only doing a keyspace for now since there is no difference for types or tables
-BOOST_AUTO_TEST_CASE(keyspace_add_drop)
-{
+BOOST_AUTO_TEST_CASE(keyspace_add_drop) {
   test_utils::CassLog::reset("Found schema agreement in");
 
-  // "USE" in fast succession would normally fail on the next node if the previous query did not wait
+  // "USE" in fast succession would normally fail on the next node if the previous query did not
+  // wait
   const std::string use_simple = str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE);
-  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                         % test_utils::SIMPLE_KEYSPACE % 2));
+  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                         test_utils::SIMPLE_KEYSPACE % 2));
   test_utils::execute_query(session, use_simple);
   test_utils::execute_query(session, "USE system");
-  test_utils::execute_query(session, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
+  test_utils::execute_query(session,
+                            str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
   test_utils::CassResultPtr result;
   CassError rc = test_utils::execute_query_with_error(session, use_simple, &result);
   BOOST_CHECK_EQUAL(rc, CASS_ERROR_SERVER_INVALID_QUERY);
@@ -112,11 +112,12 @@ BOOST_AUTO_TEST_CASE(agreement_node_down) {
 
   test_utils::CassLog::reset("Found schema agreement in");
   const std::string use_simple = str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE);
-  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                         % test_utils::SIMPLE_KEYSPACE % 2));
+  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                         test_utils::SIMPLE_KEYSPACE % 2));
   test_utils::execute_query(session, use_simple);
   test_utils::execute_query(session, "USE system");
-  test_utils::execute_query(session, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
+  test_utils::execute_query(session,
+                            str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
   test_utils::CassResultPtr result;
   CassError rc = test_utils::execute_query_with_error(session, use_simple, &result);
   BOOST_CHECK_EQUAL(rc, CASS_ERROR_SERVER_INVALID_QUERY);
@@ -130,20 +131,24 @@ BOOST_AUTO_TEST_CASE(agreement_node_down) {
 }
 
 #define MAX_SCHEMA_AGREEMENT_WAIT_MS 10000
-static void alter_schema_version(void *arg) {
+static void alter_schema_version(void* arg) {
   ClusterInit* cluster_init = static_cast<ClusterInit*>(arg);
   std::string ip_prefix = cluster_init->inst.ccm->get_ip_prefix();
   boost::chrono::steady_clock::time_point end =
-    boost::chrono::steady_clock::now() + boost::chrono::milliseconds(MAX_SCHEMA_AGREEMENT_WAIT_MS + 2000);
+      boost::chrono::steady_clock::now() +
+      boost::chrono::milliseconds(MAX_SCHEMA_AGREEMENT_WAIT_MS + 2000);
   size_t i = 0;
 
   do {
     std::stringstream ss;
     // Update node 2 and 3's schema version in node 1's peers table.
-    ss << "UPDATE system.peers SET schema_version=? WHERE peer='" << ip_prefix << ((i++ % 2) + 2) << "'";
+    ss << "UPDATE system.peers SET schema_version=? WHERE peer='" << ip_prefix << ((i++ % 2) + 2)
+       << "'";
     test_utils::CassStatementPtr schema_stmt(cass_statement_new(ss.str().c_str(), 1));
-    cass_statement_bind_uuid(schema_stmt.get(), 0, test_utils::generate_random_uuid(cluster_init->inst.uuid_gen));
-    test_utils::CassFuturePtr future(cass_session_execute(cluster_init->schema_alter_session, schema_stmt.get()));
+    cass_statement_bind_uuid(schema_stmt.get(), 0,
+                             test_utils::generate_random_uuid(cluster_init->inst.uuid_gen));
+    test_utils::CassFuturePtr future(
+        cass_session_execute(cluster_init->schema_alter_session, schema_stmt.get()));
     cass_future_wait(future.get());
     BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
 
@@ -160,8 +165,11 @@ BOOST_AUTO_TEST_CASE(no_agreement_timeout) {
   uv_thread_t thread;
   uv_thread_create(&thread, alter_schema_version, this);
 
-  test_utils::CassStatementPtr create_stmt(cass_statement_new(str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                                               % test_utils::SIMPLE_KEYSPACE % 2).c_str(), 0));
+  test_utils::CassStatementPtr create_stmt(
+      cass_statement_new(str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                             test_utils::SIMPLE_KEYSPACE % 2)
+                             .c_str(),
+                         0));
   test_utils::CassFuturePtr create_future(cass_session_execute(session, create_stmt.get()));
 
   cass_future_wait(create_future.get());
@@ -171,9 +179,8 @@ BOOST_AUTO_TEST_CASE(no_agreement_timeout) {
   uv_thread_join(&thread);
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session,
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % test_utils::SIMPLE_KEYSPACE));
+  test_utils::execute_query_with_error(
+      session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
 
   close_session();
 }
diff --git a/test/integration_tests/src/test_schema_metadata.cpp b/test/integration_tests/src/test_schema_metadata.cpp
index 281591c4c..f95ebbab6 100644
--- a/test/integration_tests/src/test_schema_metadata.cpp
+++ b/test/integration_tests/src/test_schema_metadata.cpp
@@ -15,13 +15,13 @@
 */
 
 #include "cassandra.h"
-#include "testing.hpp"
-#include "test_utils.hpp"
 #include "metadata.hpp"
+#include "test_utils.hpp"
+#include "testing.hpp"
 
-#include <boost/test/unit_test.hpp>
 #include <boost/format.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
 #include <algorithm>
@@ -31,7 +31,7 @@
 
 #define SIMPLE_STRATEGY_KEYSPACE_NAME "simple"
 #define NETWORK_TOPOLOGY_KEYSPACE_NAME "network"
-#define SIMPLE_STRATEGY_CLASS_NAME  "org.apache.cassandra.locator.SimpleStrategy"
+#define SIMPLE_STRATEGY_CLASS_NAME "org.apache.cassandra.locator.SimpleStrategy"
 #define NETWORK_TOPOLOGY_STRATEGY_CLASS_NAME "org.apache.cassandra.locator.NetworkTopologyStrategy"
 #define LOCAL_STRATEGY_CLASS_NAME "org.apache.cassandra.locator.LocalStrategy"
 #define COMMENT "A TESTABLE COMMENT HERE"
@@ -41,18 +41,19 @@
 #define USER_DEFINED_AGGREGATE_NAME "user_defined_aggregate"
 #define USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME "uda_udf_final"
 
-#define RETRIEVE_METADATA(meta, func, type) do { \
-  int attempts = 0; \
-  while (!meta && attempts < 10) { \
-    meta = func; \
-    if (!meta) { \
-      std::cout << type << " metadata is not valid; initiating schema refresh" << std::endl; \
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(1000)); \
-      refresh_schema_meta(); \
-    } \
-    ++attempts; \
-  } \
-} while(0)
+#define RETRIEVE_METADATA(meta, func, type)                                                    \
+  do {                                                                                         \
+    int attempts = 0;                                                                          \
+    while (!meta && attempts < 10) {                                                           \
+      meta = func;                                                                             \
+      if (!meta) {                                                                             \
+        std::cout << type << " metadata is not valid; initiating schema refresh" << std::endl; \
+        boost::this_thread::sleep_for(boost::chrono::milliseconds(1000));                      \
+        refresh_schema_meta();                                                                 \
+      }                                                                                        \
+      ++attempts;                                                                              \
+    }                                                                                          \
+  } while (0)
 
 namespace std {
 
@@ -60,8 +61,7 @@ std::ostream& operator<<(std::ostream& os, const CassString& str) {
   return os << std::string(str.data, str.length);
 }
 
-std::ostream& operator<<(std::ostream& os, const std::pair<std::string, std::string>& p)
-{
+std::ostream& operator<<(std::ostream& os, const std::pair<std::string, std::string>& p) {
   return os << "(\"" << p.first << "\", \"" << p.second << "\")";
 }
 
@@ -78,8 +78,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
   const CassSchemaMeta* schema_meta_;
 
   TestSchemaMetadata()
-    : SingleSessionTest(1, 0, false)
-    , schema_meta_(NULL) {
+      : SingleSessionTest(1, 0, false)
+      , schema_meta_(NULL) {
     cass_cluster_set_token_aware_routing(cluster, cass_false);
     create_session();
   }
@@ -94,10 +94,12 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     test_utils::CassResultPtr result;
 
     for (int i = 0; i < 10; ++i) {
-      const char* system_schema_ks = version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces";
+      const char* system_schema_ks =
+          version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces";
       test_utils::execute_query(session,
-                                str(boost::format(
-                                      "SELECT * FROM  %s WHERE keyspace_name = '%s'") % system_schema_ks % ks), &result);
+                                str(boost::format("SELECT * FROM  %s WHERE keyspace_name = '%s'") %
+                                    system_schema_ks % ks),
+                                &result);
       if (cass_result_row_count(result.get()) > 0) {
         return;
       }
@@ -111,14 +113,15 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
       const CassSchemaMeta* old = schema_meta_;
       schema_meta_ = cass_session_get_schema_meta(session);
 
-      for (size_t i = 0;
-           i < 10 && cass_schema_meta_snapshot_version(schema_meta_) == cass_schema_meta_snapshot_version(old);
+      for (size_t i = 0; i < 10 && cass_schema_meta_snapshot_version(schema_meta_) ==
+                                       cass_schema_meta_snapshot_version(old);
            ++i) {
         boost::this_thread::sleep_for(boost::chrono::milliseconds(1000));
         cass_schema_meta_free(schema_meta_);
         schema_meta_ = cass_session_get_schema_meta(session);
       }
-      if (cass_schema_meta_snapshot_version(schema_meta_) == cass_schema_meta_snapshot_version(old)) {
+      if (cass_schema_meta_snapshot_version(schema_meta_) ==
+          cass_schema_meta_snapshot_version(old)) {
         std::cout << "Schema metadata was not refreshed or was not changed" << std::endl;
       }
       cass_schema_meta_free(old);
@@ -127,38 +130,51 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     }
   }
 
-  void create_simple_strategy_keyspace(unsigned int replication_factor = 1, bool durable_writes = true) {
-    test_utils::execute_query_with_error(session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % SIMPLE_STRATEGY_KEYSPACE_NAME));
-    test_utils::execute_query(session, str(boost::format("CREATE KEYSPACE %s WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor' : %s } AND durable_writes = %s")
-                                           % SIMPLE_STRATEGY_KEYSPACE_NAME % replication_factor % (durable_writes ? "true" : "false")));
+  void create_simple_strategy_keyspace(unsigned int replication_factor = 1,
+                                       bool durable_writes = true) {
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % SIMPLE_STRATEGY_KEYSPACE_NAME));
+    test_utils::execute_query(
+        session,
+        str(boost::format("CREATE KEYSPACE %s WITH replication = { 'class' : 'SimpleStrategy', "
+                          "'replication_factor' : %s } AND durable_writes = %s") %
+            SIMPLE_STRATEGY_KEYSPACE_NAME % replication_factor %
+            (durable_writes ? "true" : "false")));
     refresh_schema_meta();
   }
 
-  void create_network_topology_strategy_keyspace(unsigned int replicationFactorDataCenterOne = 3, unsigned int replicationFactorDataCenterTwo = 2, bool isDurableWrites = true) {
-    test_utils::execute_query_with_error(session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % NETWORK_TOPOLOGY_KEYSPACE_NAME));
-    test_utils::execute_query(session, str(boost::format("CREATE KEYSPACE %s WITH replication = { 'class' : 'NetworkTopologyStrategy',  'dc1' : %d, 'dc2' : %d } AND durable_writes = %s")
-                                           % NETWORK_TOPOLOGY_KEYSPACE_NAME % replicationFactorDataCenterOne % replicationFactorDataCenterTwo
-                                           % (isDurableWrites ? "true" : "false")));
+  void create_network_topology_strategy_keyspace(unsigned int replicationFactorDataCenterOne = 3,
+                                                 unsigned int replicationFactorDataCenterTwo = 2,
+                                                 bool isDurableWrites = true) {
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % NETWORK_TOPOLOGY_KEYSPACE_NAME));
+    test_utils::execute_query(
+        session,
+        str(boost::format(
+                "CREATE KEYSPACE %s WITH replication = { 'class' : 'NetworkTopologyStrategy',  "
+                "'dc1' : %d, 'dc2' : %d } AND durable_writes = %s") %
+            NETWORK_TOPOLOGY_KEYSPACE_NAME % replicationFactorDataCenterOne %
+            replicationFactorDataCenterTwo % (isDurableWrites ? "true" : "false")));
 
     refresh_schema_meta();
   }
 
   const CassKeyspaceMeta* schema_get_keyspace(const std::string& ks_name) {
     const CassKeyspaceMeta* ks_meta = NULL;
-    RETRIEVE_METADATA(ks_meta,
-                      cass_schema_meta_keyspace_by_name(schema_meta_, ks_name.c_str()),
+    RETRIEVE_METADATA(ks_meta, cass_schema_meta_keyspace_by_name(schema_meta_, ks_name.c_str()),
                       "Keyspace");
     BOOST_REQUIRE(ks_meta);
     return ks_meta;
   }
 
-  const CassTableMeta* schema_get_table(const std::string& ks_name,
-                                     const std::string& table_name) {
+  const CassTableMeta* schema_get_table(const std::string& ks_name, const std::string& table_name) {
     const CassTableMeta* table_meta = NULL;
-    RETRIEVE_METADATA(table_meta,
-                      cass_keyspace_meta_table_by_name(schema_get_keyspace(ks_name),
-                                                       table_name.c_str()),
-                      "Table");
+    RETRIEVE_METADATA(
+        table_meta,
+        cass_keyspace_meta_table_by_name(schema_get_keyspace(ks_name), table_name.c_str()),
+        "Table");
     BOOST_REQUIRE(table_meta);
     return table_meta;
   }
@@ -174,64 +190,62 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     return view_meta;
   }
 
-  const CassColumnMeta* schema_get_column(const std::string& ks_name,
-                                      const std::string& table_name,
-                                      const std::string& col_name) {
+  const CassColumnMeta* schema_get_column(const std::string& ks_name, const std::string& table_name,
+                                          const std::string& col_name) {
     const CassColumnMeta* col_meta = NULL;
-    RETRIEVE_METADATA(col_meta,
-                      cass_table_meta_column_by_name(schema_get_table(ks_name, table_name),
-                                                     col_name.c_str()),
-                      "Column");
+    RETRIEVE_METADATA(
+        col_meta,
+        cass_table_meta_column_by_name(schema_get_table(ks_name, table_name), col_name.c_str()),
+        "Column");
     BOOST_REQUIRE(col_meta);
     return col_meta;
   }
 
   const CassFunctionMeta* schema_get_function(const std::string& ks_name,
-                              const std::string& func_name,
-                              const std::vector<std::string>& func_types) {
+                                              const std::string& func_name,
+                                              const std::vector<std::string>& func_types) {
 
     const CassFunctionMeta* func_meta = NULL;
-    RETRIEVE_METADATA(func_meta,
-                      cass_keyspace_meta_function_by_name(schema_get_keyspace(ks_name),
-                                                          func_name.c_str(),
-                                                          test_utils::implode(func_types, ',').c_str()),
-                      "Function");
+    RETRIEVE_METADATA(
+        func_meta,
+        cass_keyspace_meta_function_by_name(schema_get_keyspace(ks_name), func_name.c_str(),
+                                            test_utils::implode(func_types, ',').c_str()),
+        "Function");
     BOOST_REQUIRE(func_meta);
     return func_meta;
   }
 
   const CassAggregateMeta* schema_get_aggregate(const std::string& ks_name,
-                                const std::string& agg_name,
-                                const std::vector<std::string>& agg_types) {
+                                                const std::string& agg_name,
+                                                const std::vector<std::string>& agg_types) {
     const CassAggregateMeta* agg_meta = NULL;
-    RETRIEVE_METADATA(agg_meta,
-                      cass_keyspace_meta_aggregate_by_name(schema_get_keyspace(ks_name),
-                                                           agg_name.c_str(),
-                                                           test_utils::implode(agg_types, ',').c_str()),
-                      "Aggregate");
+    RETRIEVE_METADATA(
+        agg_meta,
+        cass_keyspace_meta_aggregate_by_name(schema_get_keyspace(ks_name), agg_name.c_str(),
+                                             test_utils::implode(agg_types, ',').c_str()),
+        "Aggregate");
     BOOST_REQUIRE(agg_meta);
     return agg_meta;
   }
 
-  void verify_function_dropped(const std::string& ks_name,
-                               const std::string& func_name,
+  void verify_function_dropped(const std::string& ks_name, const std::string& func_name,
                                const std::vector<std::string>& func_types) {
-    const CassFunctionMeta* func_meta = cass_keyspace_meta_function_by_name(schema_get_keyspace(ks_name),
-                                                                            func_name.c_str(),
-                                                                            test_utils::implode(func_types, ',').c_str());
+    const CassFunctionMeta* func_meta =
+        cass_keyspace_meta_function_by_name(schema_get_keyspace(ks_name), func_name.c_str(),
+                                            test_utils::implode(func_types, ',').c_str());
     BOOST_CHECK(func_meta == NULL);
   }
 
-  void verify_aggregate_dropped(const std::string& ks_name,
-                                const std::string& agg_name,
+  void verify_aggregate_dropped(const std::string& ks_name, const std::string& agg_name,
                                 const std::vector<std::string>& agg_types) {
-    const CassAggregateMeta* agg_meta = cass_keyspace_meta_aggregate_by_name(schema_get_keyspace(ks_name),
-                                                                             agg_name.c_str(),
-                                                                             test_utils::implode(agg_types, ',').c_str());
+    const CassAggregateMeta* agg_meta =
+        cass_keyspace_meta_aggregate_by_name(schema_get_keyspace(ks_name), agg_name.c_str(),
+                                             test_utils::implode(agg_types, ',').c_str());
     BOOST_CHECK(agg_meta == NULL);
   }
 
-  void verify_fields(const test_utils::CassIteratorPtr& itr, const std::set<std::string>& expected_fields) {
+  void verify_fields(const test_utils::CassIteratorPtr& itr,
+                     const std::set<std::string>& expected_fields) {
     // all fields present, nothing extra
     std::set<std::string> observed;
     while (cass_iterator_next(itr.get())) {
@@ -239,15 +253,15 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
       cass_iterator_get_meta_field_name(itr.get(), &name.data, &name.length);
       observed.insert(std::string(name.data, name.length));
     }
-    BOOST_REQUIRE_EQUAL_COLLECTIONS(observed.begin(), observed.end(),
-                                    expected_fields.begin(), expected_fields.end());
+    BOOST_REQUIRE_EQUAL_COLLECTIONS(observed.begin(), observed.end(), expected_fields.begin(),
+                                    expected_fields.end());
   }
 
-
   void verify_value(const CassValue* value, const std::string& expected) {
     BOOST_REQUIRE(value);
     CassValueType type = cass_value_type(value);
-    BOOST_REQUIRE(type == CASS_VALUE_TYPE_ASCII || type == CASS_VALUE_TYPE_TEXT || type == CASS_VALUE_TYPE_VARCHAR);
+    BOOST_REQUIRE(type == CASS_VALUE_TYPE_ASCII || type == CASS_VALUE_TYPE_TEXT ||
+                  type == CASS_VALUE_TYPE_VARCHAR);
     CassString v;
     cass_value_get_string(value, &v.data, &v.length);
     BOOST_CHECK_EQUAL(v.length, expected.size());
@@ -262,7 +276,7 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK_EQUAL(v, expected);
   }
 
-  template<typename value_type>
+  template <typename value_type>
   void verify_value(const CassValue* value, std::map<std::string, value_type> expected) {
     BOOST_REQUIRE(value);
     BOOST_REQUIRE_EQUAL(cass_value_type(value), CASS_VALUE_TYPE_MAP);
@@ -271,15 +285,16 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     while (cass_iterator_next(itr.get())) {
       CassString key;
       cass_value_get_string(cass_iterator_get_map_key(itr.get()), &key.data, &key.length);
-      typename std::map<std::string, value_type>::const_iterator i = expected.find(std::string(key.data, key.length));
+      typename std::map<std::string, value_type>::const_iterator i =
+          expected.find(std::string(key.data, key.length));
       BOOST_REQUIRE(i != expected.end());
       verify_value(cass_iterator_get_map_value(itr.get()), i->second);
     }
   }
 
-  void verify_index(const CassIndexMeta* index_meta,
-                    const std::string& index_name, CassIndexType index_type,
-                    const std::string& index_target, const std::map<std::string, std::string>& index_options) {
+  void verify_index(const CassIndexMeta* index_meta, const std::string& index_name,
+                    CassIndexType index_type, const std::string& index_target,
+                    const std::map<std::string, std::string>& index_options) {
     BOOST_REQUIRE(index_meta != NULL);
 
     CassString name;
@@ -316,7 +331,6 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
                                   index_options.begin(), index_options.end());
   }
 
-
   const std::set<std::string>& column_fields() {
     static std::set<std::string> fields;
     if (fields.empty()) {
@@ -347,7 +361,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     return fields;
   }
 
-  void verify_fields_by_name(const CassKeyspaceMeta* keyspace_meta, const std::set<std::string>& fields) {
+  void verify_fields_by_name(const CassKeyspaceMeta* keyspace_meta,
+                             const std::set<std::string>& fields) {
     for (std::set<std::string>::iterator i = fields.begin(); i != fields.end(); ++i) {
       BOOST_CHECK(cass_keyspace_meta_field_by_name(keyspace_meta, i->c_str()) != NULL);
     }
@@ -359,7 +374,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     }
   }
 
-  void verify_fields_by_name(const CassColumnMeta* column_meta, const std::set<std::string>& fields) {
+  void verify_fields_by_name(const CassColumnMeta* column_meta,
+                             const std::set<std::string>& fields) {
     for (std::set<std::string>::iterator i = fields.begin(); i != fields.end(); ++i) {
       BOOST_CHECK(cass_column_meta_field_by_name(column_meta, i->c_str()) != NULL);
     }
@@ -371,10 +387,10 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
       const CassColumnMeta* col_meta = cass_iterator_get_column_meta(itr.get());
       CassColumnType col_type = cass_column_meta_type(col_meta);
       // C* 1.2.0 columns won't have fields for partition and clustering key columns
-      if (version >= "2.0.0" ||
-          (col_type != CASS_COLUMN_TYPE_CLUSTERING_KEY &&
-           col_type != CASS_COLUMN_TYPE_PARTITION_KEY)) {
-        verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_column_meta(col_meta)), column_fields());
+      if (version >= "2.0.0" || (col_type != CASS_COLUMN_TYPE_CLUSTERING_KEY &&
+                                 col_type != CASS_COLUMN_TYPE_PARTITION_KEY)) {
+        verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_column_meta(col_meta)),
+                      column_fields());
         verify_fields_by_name(col_meta, column_fields());
       }
       // no entries at this level
@@ -464,18 +480,24 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
   void verify_table(const std::string& ks_name, const std::string& table_name,
                     const std::string& comment, const std::string& non_key_column) {
-    const CassTableMeta* table_meta = schema_get_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME);
+    const CassTableMeta* table_meta =
+        schema_get_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME);
 
-    verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_table_meta(table_meta)), table_fields());
+    verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_table_meta(table_meta)),
+                  table_fields());
     verify_fields_by_name(table_meta, table_fields());
-    verify_value(cass_table_meta_field_by_name(table_meta, "keyspace_name"), SIMPLE_STRATEGY_KEYSPACE_NAME);
-    verify_value(cass_table_meta_field_by_name(table_meta, version >= "3.0.0" ? "table_name" : "columnfamily_name"), ALL_DATA_TYPES_TABLE_NAME);
-
-    // not going for every field, just making sure one of each type (fixed, list, map) is correctly added
+    verify_value(cass_table_meta_field_by_name(table_meta, "keyspace_name"),
+                 SIMPLE_STRATEGY_KEYSPACE_NAME);
+    verify_value(cass_table_meta_field_by_name(
+                     table_meta, version >= "3.0.0" ? "table_name" : "columnfamily_name"),
+                 ALL_DATA_TYPES_TABLE_NAME);
+
+    // not going for every field, just making sure one of each type (fixed, list, map) is correctly
+    // added
     verify_value(cass_table_meta_field_by_name(table_meta, "comment"), COMMENT);
 
-
-    const CassValue* value = cass_table_meta_field_by_name(table_meta, version >= "3.0.0" ? "compression" : "compression_parameters");
+    const CassValue* value = cass_table_meta_field_by_name(
+        table_meta, version >= "3.0.0" ? "compression" : "compression_parameters");
     BOOST_REQUIRE(value);
     BOOST_REQUIRE_EQUAL(cass_value_type(value), CASS_VALUE_TYPE_MAP);
     BOOST_REQUIRE_GE(cass_value_item_count(value), 1ul);
@@ -514,35 +536,37 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_REQUIRE(cass_table_meta_column_by_name(table_meta, non_key_column.c_str()));
 
     // goes away
-    if (version >= "2.0.0") {// dropping a column not supported in 1.2
-      test_utils::execute_query(session, "ALTER TABLE "+table_name+" DROP "+non_key_column);
+    if (version >= "2.0.0") { // dropping a column not supported in 1.2
+      test_utils::execute_query(session, "ALTER TABLE " + table_name + " DROP " + non_key_column);
       refresh_schema_meta();
       table_meta = schema_get_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME);
       BOOST_CHECK(!cass_table_meta_column_by_name(table_meta, non_key_column.c_str()));
     }
 
     // new column
-    test_utils::execute_query(session, "ALTER TABLE "+table_name+" ADD jkldsfafdjsklafajklsljkfds text");
+    test_utils::execute_query(session,
+                              "ALTER TABLE " + table_name + " ADD jkldsfafdjsklafajklsljkfds text");
     refresh_schema_meta();
     table_meta = schema_get_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME);
     BOOST_CHECK(cass_table_meta_column_by_name(table_meta, "jkldsfafdjsklafajklsljkfds"));
 
     // drop table
-    test_utils::execute_query(session, "DROP TABLE "+table_name);
+    test_utils::execute_query(session, "DROP TABLE " + table_name);
     refresh_schema_meta();
-    const CassKeyspaceMeta* ks_meta = cass_schema_meta_keyspace_by_name(schema_meta_, SIMPLE_STRATEGY_KEYSPACE_NAME);
+    const CassKeyspaceMeta* ks_meta =
+        cass_schema_meta_keyspace_by_name(schema_meta_, SIMPLE_STRATEGY_KEYSPACE_NAME);
     table_meta = cass_keyspace_meta_table_by_name(ks_meta, ALL_DATA_TYPES_TABLE_NAME);
     BOOST_CHECK(!table_meta);
   }
 
-  void verify_materialized_view_count(const std::string& keyspace_name,
-                                      size_t count) {
+  void verify_materialized_view_count(const std::string& keyspace_name, size_t count) {
     size_t actual_count = 0;
     size_t attempts = 0;
     // Allow for extra attempts in the event the schema needs to be refreshed
     while (actual_count != count && attempts < 10) {
       const CassKeyspaceMeta* keyspace_meta = schema_get_keyspace("materialized_views");
-      test_utils::CassIteratorPtr iterator(cass_iterator_materialized_views_from_keyspace_meta(keyspace_meta));
+      test_utils::CassIteratorPtr iterator(
+          cass_iterator_materialized_views_from_keyspace_meta(keyspace_meta));
       while (cass_iterator_next(iterator.get())) {
         actual_count++;
       }
@@ -556,8 +580,7 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK_EQUAL(actual_count, count);
   }
 
-  void verify_materialized_view(const CassMaterializedViewMeta* view,
-                                const std::string& view_name,
+  void verify_materialized_view(const CassMaterializedViewMeta* view, const std::string& view_name,
                                 const std::string& view_base_table_name,
                                 const std::string& view_columns,
                                 const std::string& view_partition_key,
@@ -575,11 +598,11 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
     std::vector<std::string> columns;
     test_utils::explode(view_columns, columns);
-    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_column_count(view),  columns.size());
+    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_column_count(view), columns.size());
 
     test_utils::CassIteratorPtr iterator(cass_iterator_columns_from_materialized_view_meta(view));
-    for (std::vector<std::string>::const_iterator i = columns.begin(),
-         end = columns.end(); i != end; ++i) {
+    for (std::vector<std::string>::const_iterator i = columns.begin(), end = columns.end();
+         i != end; ++i) {
       BOOST_REQUIRE(cass_iterator_next(iterator.get()));
       const CassColumnMeta* column = cass_iterator_get_column_meta(iterator.get());
 
@@ -601,7 +624,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
     std::vector<std::string> partition_key;
     test_utils::explode(view_partition_key, partition_key);
-    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_partition_key_count(view), partition_key.size());
+    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_partition_key_count(view),
+                        partition_key.size());
     for (size_t i = 0; i < partition_key.size(); ++i) {
       const CassColumnMeta* column = cass_materialized_view_meta_partition_key(view, i);
 
@@ -613,7 +637,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
     std::vector<std::string> clustering_key;
     test_utils::explode(view_clustering_key, clustering_key);
-    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view), clustering_key.size());
+    BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view),
+                        clustering_key.size());
     for (size_t i = 0; i < clustering_key.size(); ++i) {
       const CassColumnMeta* column = cass_materialized_view_meta_clustering_key(view, i);
 
@@ -639,15 +664,16 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     return fields;
   }
 
-  void verify_keyspace(const std::string& name,
-                       bool durable_writes,
+  void verify_keyspace(const std::string& name, bool durable_writes,
                        const std::string& strategy_class,
                        const std::map<std::string, std::string>& strategy_options) {
     const CassKeyspaceMeta* ks_meta = schema_get_keyspace(name);
-    verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_keyspace_meta(ks_meta)), keyspace_fields());
+    verify_fields(test_utils::CassIteratorPtr(cass_iterator_fields_from_keyspace_meta(ks_meta)),
+                  keyspace_fields());
     verify_fields_by_name(ks_meta, keyspace_fields());
     verify_value(cass_keyspace_meta_field_by_name(ks_meta, "keyspace_name"), name);
-    //verify_value(cass_keyspace_meta_field_by_name(ks_meta, "durable_writes"), (cass_bool_t)durable_writes);
+    // verify_value(cass_keyspace_meta_field_by_name(ks_meta, "durable_writes"),
+    // (cass_bool_t)durable_writes);
     if (version >= "3.0.0") {
       std::map<std::string, std::string> replication(strategy_options);
       replication["class"] = strategy_class;
@@ -659,7 +685,6 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK(!cass_keyspace_meta_table_by_name(ks_meta, "some bogus entry"));
   }
 
-
   void verify_system_tables() {
     // make sure system tables present, and nothing extra
     refresh_schema_meta();
@@ -672,7 +697,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
     test_utils::CassIteratorPtr itr(cass_iterator_keyspaces_from_schema_meta(schema_meta_));
     size_t keyspace_count = 0;
-    while (cass_iterator_next(itr.get())) ++keyspace_count;
+    while (cass_iterator_next(itr.get()))
+      ++keyspace_count;
     size_t number_of_default_keyspaces = 2;
     if (ccm->is_dse() && ccm->get_dse_version() >= "5.0.0") {
       number_of_default_keyspaces = 9;
@@ -690,17 +716,18 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
 
     std::map<std::string, std::string> strategy_options;
     strategy_options.insert(std::make_pair("replication_factor", "1"));
-    verify_keyspace(SIMPLE_STRATEGY_KEYSPACE_NAME, true, SIMPLE_STRATEGY_CLASS_NAME, strategy_options);
+    verify_keyspace(SIMPLE_STRATEGY_KEYSPACE_NAME, true, SIMPLE_STRATEGY_CLASS_NAME,
+                    strategy_options);
 
     // alter keyspace
-    test_utils::execute_query(session,
-                              "ALTER KEYSPACE "
-                              SIMPLE_STRATEGY_KEYSPACE_NAME
-                              " WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '2' } AND durable_writes = false");
+    test_utils::execute_query(session, "ALTER KEYSPACE " SIMPLE_STRATEGY_KEYSPACE_NAME
+                                       " WITH replication = { 'class' : 'SimpleStrategy', "
+                                       "'replication_factor': '2' } AND durable_writes = false");
     refresh_schema_meta();
 
     strategy_options["replication_factor"] = "2";
-    verify_keyspace(SIMPLE_STRATEGY_KEYSPACE_NAME, false, SIMPLE_STRATEGY_CLASS_NAME, strategy_options);
+    verify_keyspace(SIMPLE_STRATEGY_KEYSPACE_NAME, false, SIMPLE_STRATEGY_CLASS_NAME,
+                    strategy_options);
 
     // keyspace goes away
     test_utils::execute_query(session, "DROP KEYSPACE " SIMPLE_STRATEGY_KEYSPACE_NAME);
@@ -712,7 +739,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     strategy_options.clear();
     strategy_options.insert(std::make_pair("dc1", "3"));
     strategy_options.insert(std::make_pair("dc2", "2"));
-    verify_keyspace(NETWORK_TOPOLOGY_KEYSPACE_NAME, true, NETWORK_TOPOLOGY_STRATEGY_CLASS_NAME, strategy_options);
+    verify_keyspace(NETWORK_TOPOLOGY_KEYSPACE_NAME, true, NETWORK_TOPOLOGY_STRATEGY_CLASS_NAME,
+                    strategy_options);
     test_utils::execute_query(session, "DROP KEYSPACE " NETWORK_TOPOLOGY_KEYSPACE_NAME);
   }
 
@@ -720,24 +748,30 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     create_simple_strategy_keyspace();
 
     test_utils::execute_query(session, "USE " SIMPLE_STRATEGY_KEYSPACE_NAME);
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES) % ALL_DATA_TYPES_TABLE_NAME));
+    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_ALL_TYPES) %
+                                           ALL_DATA_TYPES_TABLE_NAME));
     refresh_schema_meta();
-    test_utils::execute_query(session, "ALTER TABLE " ALL_DATA_TYPES_TABLE_NAME " WITH comment='" COMMENT "'");
+    test_utils::execute_query(session, "ALTER TABLE " ALL_DATA_TYPES_TABLE_NAME
+                                       " WITH comment='" COMMENT "'");
     refresh_schema_meta();
 
-    verify_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME, COMMENT, "boolean_sample");
+    verify_table(SIMPLE_STRATEGY_KEYSPACE_NAME, ALL_DATA_TYPES_TABLE_NAME, COMMENT,
+                 "boolean_sample");
   }
 
-  std::vector<std::string> get_user_data_type_field_names(const std::string& ks_name, const std::string& udt_name) {
+  std::vector<std::string> get_user_data_type_field_names(const std::string& ks_name,
+                                                          const std::string& udt_name) {
     std::vector<std::string> result;
 
-    const CassKeyspaceMeta* ks_meta = cass_schema_meta_keyspace_by_name(schema_meta_, ks_name.c_str());
+    const CassKeyspaceMeta* ks_meta =
+        cass_schema_meta_keyspace_by_name(schema_meta_, ks_name.c_str());
     if (ks_meta) {
-      const CassDataType* data_type = cass_keyspace_meta_user_type_by_name(ks_meta, udt_name.c_str());
+      const CassDataType* data_type =
+          cass_keyspace_meta_user_type_by_name(ks_meta, udt_name.c_str());
       if (data_type) {
         size_t count = cass_data_type_sub_type_count(data_type);
         for (size_t i = 0; i < count; ++i) {
-          const char *name;
+          const char* name;
           size_t name_length;
           if (cass_data_type_sub_type_name(data_type, i, &name, &name_length) == CASS_OK) {
             result.push_back(std::string(name, name_length));
@@ -749,15 +783,15 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     return result;
   }
 
-  void verify_user_type(const std::string& ks_name,
-    const std::string& udt_name,
-    const std::vector<std::string>& udt_datatypes) {
-    std::vector<std::string> udt_field_names = get_user_data_type_field_names(ks_name.c_str(), udt_name.c_str());
-    BOOST_REQUIRE_EQUAL_COLLECTIONS(udt_datatypes.begin(), udt_datatypes.end(), udt_field_names.begin(), udt_field_names.end());
+  void verify_user_type(const std::string& ks_name, const std::string& udt_name,
+                        const std::vector<std::string>& udt_datatypes) {
+    std::vector<std::string> udt_field_names =
+        get_user_data_type_field_names(ks_name.c_str(), udt_name.c_str());
+    BOOST_REQUIRE_EQUAL_COLLECTIONS(udt_datatypes.begin(), udt_datatypes.end(),
+                                    udt_field_names.begin(), udt_field_names.end());
   }
 
-  void verify_partition_key(const CassTableMeta* table_meta,
-                            size_t index,
+  void verify_partition_key(const CassTableMeta* table_meta, size_t index,
                             const std::string& column_name) {
     CassString actual_name;
     const CassColumnMeta* column_meta = cass_table_meta_partition_key(table_meta, index);
@@ -767,8 +801,7 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK_EQUAL(cass_column_meta_type(column_meta), CASS_COLUMN_TYPE_PARTITION_KEY);
   }
 
-  void verify_clustering_key(const CassTableMeta* table_meta,
-                             size_t index,
+  void verify_clustering_key(const CassTableMeta* table_meta, size_t index,
                              const std::string& column_name) {
     CassString actual_name;
     const CassColumnMeta* column_meta = cass_table_meta_clustering_key(table_meta, index);
@@ -778,10 +811,8 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK_EQUAL(cass_column_meta_type(column_meta), CASS_COLUMN_TYPE_CLUSTERING_KEY);
   }
 
-  void verify_column_order(const CassTableMeta* table_meta,
-                           size_t partition_key_size,
-                           size_t clustering_key_size,
-                           size_t column_count) {
+  void verify_column_order(const CassTableMeta* table_meta, size_t partition_key_size,
+                           size_t clustering_key_size, size_t column_count) {
     size_t actual_column_count = cass_table_meta_column_count(table_meta);
     BOOST_REQUIRE(partition_key_size + clustering_key_size <= actual_column_count);
 
@@ -793,8 +824,7 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     }
     for (; index < clustering_key_size; ++index) {
       const CassColumnMeta* column_meta = NULL;
-      RETRIEVE_METADATA(column_meta, cass_table_meta_column(table_meta, index),
-                        "Column");
+      RETRIEVE_METADATA(column_meta, cass_table_meta_column(table_meta, index), "Column");
       BOOST_REQUIRE(column_meta);
       BOOST_CHECK_EQUAL(cass_column_meta_type(column_meta), CASS_COLUMN_TYPE_CLUSTERING_KEY);
     }
@@ -802,35 +832,41 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     BOOST_CHECK_EQUAL(actual_column_count, column_count);
   }
 
-  void verify_user_function(const std::string& ks_name,
-    const std::string& udf_name,
-    const std::vector<std::string>& udf_argument,
-    const std::vector<std::string>& udf_value_types,
-    const std::string& udf_body,
-    const std::string& udf_language,
-    const cass_bool_t is_called_on_null,
-    const CassValueType return_value_type) {
+  void verify_user_function(const std::string& ks_name, const std::string& udf_name,
+                            const std::vector<std::string>& udf_argument,
+                            const std::vector<std::string>& udf_value_types,
+                            const std::string& udf_body, const std::string& udf_language,
+                            const cass_bool_t is_called_on_null,
+                            const CassValueType return_value_type) {
     BOOST_REQUIRE_EQUAL(udf_argument.size(), udf_value_types.size());
     const CassFunctionMeta* func_meta = schema_get_function(ks_name, udf_name, udf_value_types);
     CassString func_meta_string_value;
 
     // Function name
-    cass_function_meta_name(func_meta, &func_meta_string_value.data, &func_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_name.c_str()), func_meta_string_value));
+    cass_function_meta_name(func_meta, &func_meta_string_value.data,
+                            &func_meta_string_value.length);
+    BOOST_CHECK(
+        test_utils::Value<CassString>::equal(CassString(udf_name.c_str()), func_meta_string_value));
 
     // Full Function name (includes datatypes of arguments)
     std::stringstream udf_full_name;
     udf_full_name << udf_name << "(" << test_utils::implode(udf_value_types, ',') << ")";
-    cass_function_meta_full_name(func_meta, &func_meta_string_value.data, &func_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_full_name.str().c_str()), func_meta_string_value));
+    cass_function_meta_full_name(func_meta, &func_meta_string_value.data,
+                                 &func_meta_string_value.length);
+    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_full_name.str().c_str()),
+                                                     func_meta_string_value));
 
     // Function body
-    cass_function_meta_body(func_meta, &func_meta_string_value.data, &func_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_body.c_str()), func_meta_string_value));
+    cass_function_meta_body(func_meta, &func_meta_string_value.data,
+                            &func_meta_string_value.length);
+    BOOST_CHECK(
+        test_utils::Value<CassString>::equal(CassString(udf_body.c_str()), func_meta_string_value));
 
     // Function language
-    cass_function_meta_language(func_meta, &func_meta_string_value.data, &func_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_language.c_str()), func_meta_string_value));
+    cass_function_meta_language(func_meta, &func_meta_string_value.data,
+                                &func_meta_string_value.length);
+    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_language.c_str()),
+                                                     func_meta_string_value));
 
     // Is function called on null input
     BOOST_CHECK_EQUAL(is_called_on_null, cass_function_meta_called_on_null_input(func_meta));
@@ -841,15 +877,23 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     // Function arguments (by index)
     for (size_t i = 0; i < udf_argument.size(); ++i) {
       const CassDataType* datatype;
-      cass_function_meta_argument(func_meta, i, &func_meta_string_value.data, &func_meta_string_value.length, &datatype);
-      BOOST_CHECK_EQUAL(udf_value_types[i].compare(std::string(test_utils::get_value_type(cass_data_type_type(datatype)))), 0);
+      cass_function_meta_argument(func_meta, i, &func_meta_string_value.data,
+                                  &func_meta_string_value.length, &datatype);
+      BOOST_CHECK_EQUAL(udf_value_types[i].compare(
+                            std::string(test_utils::get_value_type(cass_data_type_type(datatype)))),
+                        0);
     }
 
     // Function arguments (by name)
     std::vector<std::string>::const_iterator value_iterator = udf_value_types.begin();
-    for (std::vector<std::string>::const_iterator iterator = udf_argument.begin(); iterator != udf_argument.end(); ++iterator) {
-      const CassDataType* datatype = cass_function_meta_argument_type_by_name(func_meta, (*iterator).c_str());
-      BOOST_CHECK_EQUAL((*value_iterator).compare(std::string(test_utils::get_value_type(cass_data_type_type(datatype)))), 0);
+    for (std::vector<std::string>::const_iterator iterator = udf_argument.begin();
+         iterator != udf_argument.end(); ++iterator) {
+      const CassDataType* datatype =
+          cass_function_meta_argument_type_by_name(func_meta, (*iterator).c_str());
+      BOOST_CHECK_EQUAL(
+          (*value_iterator)
+              .compare(std::string(test_utils::get_value_type(cass_data_type_type(datatype)))),
+          0);
       ++value_iterator;
     }
 
@@ -859,24 +903,26 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
   }
 
   template <class T>
-  void verify_user_aggregate(const std::string& ks_name,
-    const std::string& udf_name, std::string udf_final_name,
-    const std::string& uda_name, const std::vector<std::string>& uda_value_types,
-    const CassValueType return_value_type,
-    const CassValueType state_value_type,
-    T init_cond_value) {
+  void verify_user_aggregate(const std::string& ks_name, const std::string& udf_name,
+                             std::string udf_final_name, const std::string& uda_name,
+                             const std::vector<std::string>& uda_value_types,
+                             const CassValueType return_value_type,
+                             const CassValueType state_value_type, T init_cond_value) {
     const CassAggregateMeta* agg_meta = schema_get_aggregate(ks_name, uda_name, uda_value_types);
     CassString agg_meta_string_value;
 
     // Aggregate name
     cass_aggregate_meta_name(agg_meta, &agg_meta_string_value.data, &agg_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(uda_name.c_str()), agg_meta_string_value));
+    BOOST_CHECK(
+        test_utils::Value<CassString>::equal(CassString(uda_name.c_str()), agg_meta_string_value));
 
     // Full Aggregate name (includes datatypes of arguments)
     std::stringstream uda_full_name;
     uda_full_name << uda_name << "(" << test_utils::implode(uda_value_types, ',') << ")";
-    cass_aggregate_meta_full_name(agg_meta, &agg_meta_string_value.data, &agg_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(uda_full_name.str().c_str()), agg_meta_string_value));
+    cass_aggregate_meta_full_name(agg_meta, &agg_meta_string_value.data,
+                                  &agg_meta_string_value.length);
+    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(uda_full_name.str().c_str()),
+                                                     agg_meta_string_value));
 
     // Aggregate argument count
     BOOST_CHECK_EQUAL(uda_value_types.size(), cass_aggregate_meta_argument_count(agg_meta));
@@ -884,7 +930,9 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     // Aggregate argument (indexes only)
     for (size_t i = 0; i < uda_value_types.size(); ++i) {
       const CassDataType* datatype = cass_aggregate_meta_argument_type(agg_meta, i);
-      BOOST_CHECK_EQUAL(uda_value_types[i].compare(std::string(test_utils::get_value_type(cass_data_type_type(datatype)))), 0);
+      BOOST_CHECK_EQUAL(uda_value_types[i].compare(
+                            std::string(test_utils::get_value_type(cass_data_type_type(datatype)))),
+                        0);
     }
 
     // Aggregate return type
@@ -898,12 +946,14 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     // Aggregate state function
     const CassFunctionMeta* func_meta = cass_aggregate_meta_state_func(agg_meta);
     cass_function_meta_name(func_meta, &agg_meta_string_value.data, &agg_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_name.c_str()), agg_meta_string_value));
+    BOOST_CHECK(
+        test_utils::Value<CassString>::equal(CassString(udf_name.c_str()), agg_meta_string_value));
 
     // Aggregate final function
     func_meta = cass_aggregate_meta_final_func(agg_meta);
     cass_function_meta_name(func_meta, &agg_meta_string_value.data, &agg_meta_string_value.length);
-    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_final_name.c_str()), agg_meta_string_value));
+    BOOST_CHECK(test_utils::Value<CassString>::equal(CassString(udf_final_name.c_str()),
+                                                     agg_meta_string_value));
 
     const CassValue* agg_init_cond = cass_aggregate_meta_init_cond(agg_meta);
     BOOST_REQUIRE(agg_init_cond);
@@ -914,8 +964,10 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
       std::string s(ss.str());
       CassString agg_init_cond_value;
       BOOST_CHECK(cass_value_type(agg_init_cond) == CASS_VALUE_TYPE_VARCHAR);
-      BOOST_CHECK(test_utils::Value<CassString>::get(agg_init_cond, &agg_init_cond_value) == CASS_OK);
-      BOOST_REQUIRE(test_utils::Value<CassString>::equal(CassString(s.data(), s.length()), agg_init_cond_value));
+      BOOST_CHECK(test_utils::Value<CassString>::get(agg_init_cond, &agg_init_cond_value) ==
+                  CASS_OK);
+      BOOST_REQUIRE(test_utils::Value<CassString>::equal(CassString(s.data(), s.length()),
+                                                         agg_init_cond_value));
     } else {
       T agg_init_cond_value;
       BOOST_CHECK(cass_value_type(agg_init_cond) == return_value_type);
@@ -930,13 +982,15 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     std::vector<std::string> udt_datatypes;
 
     // New UDT
-    test_utils::execute_query(session, str(boost::format("CREATE TYPE %s(integer_value int)") % USER_DATA_TYPE_NAME));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE TYPE %s(integer_value int)") % USER_DATA_TYPE_NAME));
     udt_datatypes.push_back("integer_value");
     refresh_schema_meta();
     verify_user_type(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DATA_TYPE_NAME, udt_datatypes);
 
     // Altered UDT
-    test_utils::execute_query(session, str(boost::format("ALTER TYPE %s ADD text_value text") % USER_DATA_TYPE_NAME));
+    test_utils::execute_query(
+        session, str(boost::format("ALTER TYPE %s ADD text_value text") % USER_DATA_TYPE_NAME));
     udt_datatypes.push_back("text_value");
     refresh_schema_meta();
     verify_user_type(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DATA_TYPE_NAME, udt_datatypes);
@@ -949,10 +1003,11 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
   }
 
   void create_simple_strategy_functions() {
-    test_utils::execute_query(session,
-      str(boost::format("CREATE OR REPLACE FUNCTION %s.%s(rhs int, lhs int) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE javascript AS 'lhs + rhs';")
-      % SIMPLE_STRATEGY_KEYSPACE_NAME
-      % USER_DEFINED_FUNCTION_NAME));
+    test_utils::execute_query(
+        session,
+        str(boost::format("CREATE OR REPLACE FUNCTION %s.%s(rhs int, lhs int) RETURNS NULL ON NULL "
+                          "INPUT RETURNS int LANGUAGE javascript AS 'lhs + rhs';") %
+            SIMPLE_STRATEGY_KEYSPACE_NAME % USER_DEFINED_FUNCTION_NAME));
   }
 
   void verify_user_defined_function() {
@@ -967,32 +1022,31 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     udf_value_types.push_back(test_utils::get_value_type(CASS_VALUE_TYPE_INT));
     udf_value_types.push_back(test_utils::get_value_type(CASS_VALUE_TYPE_INT));
     refresh_schema_meta();
-    verify_user_function(SIMPLE_STRATEGY_KEYSPACE_NAME,
-      USER_DEFINED_FUNCTION_NAME, udf_arguments, udf_value_types,
-      test_utils::implode(udf_arguments, '+', " ", " "),
-      "javascript", cass_false, CASS_VALUE_TYPE_INT);
+    verify_user_function(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_FUNCTION_NAME, udf_arguments,
+                         udf_value_types, test_utils::implode(udf_arguments, '+', " ", " "),
+                         "javascript", cass_false, CASS_VALUE_TYPE_INT);
 
     // Drop UDF
-    test_utils::execute_query(session, str(boost::format("DROP FUNCTION %s.%s")
-      % SIMPLE_STRATEGY_KEYSPACE_NAME
-      % USER_DEFINED_FUNCTION_NAME));
+    test_utils::execute_query(session,
+                              str(boost::format("DROP FUNCTION %s.%s") %
+                                  SIMPLE_STRATEGY_KEYSPACE_NAME % USER_DEFINED_FUNCTION_NAME));
     refresh_schema_meta();
-    verify_function_dropped(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_FUNCTION_NAME, udf_value_types);
+    verify_function_dropped(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_FUNCTION_NAME,
+                            udf_value_types);
   }
 
   void create_simple_strategy_aggregate() {
     create_simple_strategy_functions();
-    test_utils::execute_query(session,
-      str(boost::format("CREATE OR REPLACE FUNCTION %s.%s(val int) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE javascript AS 'val * val';")
-      % SIMPLE_STRATEGY_KEYSPACE_NAME
-      % USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE OR REPLACE FUNCTION %s.%s(val int) RETURNS NULL ON NULL "
+                                   "INPUT RETURNS int LANGUAGE javascript AS 'val * val';") %
+                     SIMPLE_STRATEGY_KEYSPACE_NAME % USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME));
 
-    test_utils::execute_query(session,
-      str(boost::format("CREATE OR REPLACE AGGREGATE %s.%s(int) SFUNC %s STYPE int FINALFUNC %s INITCOND 0")
-      % SIMPLE_STRATEGY_KEYSPACE_NAME
-      % USER_DEFINED_AGGREGATE_NAME
-      % USER_DEFINED_FUNCTION_NAME
-      % USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME));
+    test_utils::execute_query(
+        session, str(boost::format("CREATE OR REPLACE AGGREGATE %s.%s(int) SFUNC %s STYPE int "
+                                   "FINALFUNC %s INITCOND 0") %
+                     SIMPLE_STRATEGY_KEYSPACE_NAME % USER_DEFINED_AGGREGATE_NAME %
+                     USER_DEFINED_FUNCTION_NAME % USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME));
   }
 
   void verify_user_defined_aggregate() {
@@ -1003,18 +1057,18 @@ struct TestSchemaMetadata : public test_utils::SingleSessionTest {
     std::vector<std::string> uda_value_types;
     uda_value_types.push_back(test_utils::get_value_type(CASS_VALUE_TYPE_INT));
     refresh_schema_meta();
-    verify_user_aggregate<cass_int32_t>(SIMPLE_STRATEGY_KEYSPACE_NAME,
-      USER_DEFINED_FUNCTION_NAME, USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME,
-      USER_DEFINED_AGGREGATE_NAME, uda_value_types,
-      CASS_VALUE_TYPE_INT, CASS_VALUE_TYPE_INT,
-      0);
+    verify_user_aggregate<cass_int32_t>(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_FUNCTION_NAME,
+                                        USER_DEFINED_AGGREGATE_FINAL_FUNCTION_NAME,
+                                        USER_DEFINED_AGGREGATE_NAME, uda_value_types,
+                                        CASS_VALUE_TYPE_INT, CASS_VALUE_TYPE_INT, 0);
 
     // Drop UDA
-    test_utils::execute_query(session, str(boost::format("DROP AGGREGATE %s.%s")
-      % SIMPLE_STRATEGY_KEYSPACE_NAME
-      % USER_DEFINED_AGGREGATE_NAME));
+    test_utils::execute_query(session,
+                              str(boost::format("DROP AGGREGATE %s.%s") %
+                                  SIMPLE_STRATEGY_KEYSPACE_NAME % USER_DEFINED_AGGREGATE_NAME));
     refresh_schema_meta();
-    verify_aggregate_dropped(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_AGGREGATE_NAME, uda_value_types);
+    verify_aggregate_dropped(SIMPLE_STRATEGY_KEYSPACE_NAME, USER_DEFINED_AGGREGATE_NAME,
+                             uda_value_types);
   }
 };
 
@@ -1024,7 +1078,7 @@ BOOST_FIXTURE_TEST_SUITE(schema_metadata, TestSchemaMetadata)
 // It might be good to get away from boost suite fixtures and do a static global.
 // (not going down that route ahead of test runner refactor)
 BOOST_AUTO_TEST_CASE(simple) {
-  verify_system_tables();// must be run first -- looking for "no other tables"
+  verify_system_tables(); // must be run first -- looking for "no other tables"
   verify_user_keyspace();
   verify_user_table();
   if (version >= "2.1.0") {
@@ -1054,7 +1108,8 @@ BOOST_AUTO_TEST_CASE(keys) {
   refresh_schema_meta();
 
   {
-    test_utils::execute_query(session, "CREATE TABLE keys.single_partition_key (key text, value text, PRIMARY KEY(key))");
+    test_utils::execute_query(
+        session, "CREATE TABLE keys.single_partition_key (key text, value text, PRIMARY KEY(key))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("keys", "single_partition_key");
@@ -1066,8 +1121,9 @@ BOOST_AUTO_TEST_CASE(keys) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE keys.composite_partition_key (key1 text, key2 text, value text, "
-                                       "PRIMARY KEY((key1, key2)))");
+    test_utils::execute_query(
+        session, "CREATE TABLE keys.composite_partition_key (key1 text, key2 text, value text, "
+                 "PRIMARY KEY((key1, key2)))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("keys", "composite_partition_key");
@@ -1080,8 +1136,9 @@ BOOST_AUTO_TEST_CASE(keys) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE keys.composite_key (key1 text, key2 text, value text, "
-                                       "PRIMARY KEY(key1, key2))");
+    test_utils::execute_query(session,
+                              "CREATE TABLE keys.composite_key (key1 text, key2 text, value text, "
+                              "PRIMARY KEY(key1, key2))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("keys", "composite_key");
@@ -1096,8 +1153,10 @@ BOOST_AUTO_TEST_CASE(keys) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE keys.composite_clustering_key (key1 text, key2 text, key3 text, value text, "
-                                       "PRIMARY KEY(key1, key2, key3))");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE keys.composite_clustering_key (key1 text, key2 text, key3 text, value text, "
+        "PRIMARY KEY(key1, key2, key3))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("keys", "composite_clustering_key");
@@ -1113,11 +1172,13 @@ BOOST_AUTO_TEST_CASE(keys) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE keys.composite_partition_and_clustering_key (key1 text, key2 text, key3 text, key4 text, value text, "
+    test_utils::execute_query(session, "CREATE TABLE keys.composite_partition_and_clustering_key "
+                                       "(key1 text, key2 text, key3 text, key4 text, value text, "
                                        "PRIMARY KEY((key1, key2), key3, key4))");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("keys", "composite_partition_and_clustering_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("keys", "composite_partition_and_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_partition_key_count(table_meta), 2);
     verify_partition_key(table_meta, 0, "key1");
@@ -1143,14 +1204,14 @@ BOOST_AUTO_TEST_CASE(keys) {
  */
 BOOST_AUTO_TEST_CASE(dense_table) {
   test_utils::execute_query(session, "CREATE KEYSPACE dense WITH replication = "
-    "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
+                                     "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
   refresh_schema_meta();
 
-  test_utils::execute_query(session,
-                            "CREATE TABLE dense.my_table (key text, value text, PRIMARY KEY(key, value)) WITH COMPACT STORAGE");
+  test_utils::execute_query(session, "CREATE TABLE dense.my_table (key text, value text, PRIMARY "
+                                     "KEY(key, value)) WITH COMPACT STORAGE");
   refresh_schema_meta();
 
-  const CassTableMeta *table_meta = schema_get_table("dense", "my_table");
+  const CassTableMeta* table_meta = schema_get_table("dense", "my_table");
 
   BOOST_REQUIRE_EQUAL(cass_table_meta_partition_key_count(table_meta), 1);
   verify_partition_key(table_meta, 0, "key");
@@ -1192,7 +1253,6 @@ BOOST_AUTO_TEST_CASE(disable) {
 
   close_session();
 
-
   // Disable schema and reconnect
   cass_cluster_set_use_schema(cluster, cass_false);
   create_session();
@@ -1213,8 +1273,10 @@ BOOST_AUTO_TEST_CASE(disable) {
   }
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "ks1"));
-  test_utils::execute_query_with_error(session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "ks2"));
+  test_utils::execute_query_with_error(
+      session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "ks1"));
+  test_utils::execute_query_with_error(
+      session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "ks2"));
 }
 
 /**
@@ -1251,91 +1313,118 @@ BOOST_AUTO_TEST_CASE(clustering_order) {
   refresh_schema_meta();
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.single_partition_key (key text, value text, PRIMARY KEY(key))");
+    test_utils::execute_query(session, "CREATE TABLE clustering_order.single_partition_key (key "
+                                       "text, value text, PRIMARY KEY(key))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("clustering_order", "single_partition_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 0);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_NONE);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_NONE);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.composite_key (key1 int, key2 text, value text, "
-                                       "PRIMARY KEY(key1, key2))");
+    test_utils::execute_query(
+        session, "CREATE TABLE clustering_order.composite_key (key1 int, key2 text, value text, "
+                 "PRIMARY KEY(key1, key2))");
     refresh_schema_meta();
 
     const CassTableMeta* table_meta = schema_get_table("clustering_order", "composite_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 1);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.composite_clustering_key (key1 text, key2 text, key3 text, value text, "
+    test_utils::execute_query(session, "CREATE TABLE clustering_order.composite_clustering_key "
+                                       "(key1 text, key2 text, key3 text, value text, "
                                        "PRIMARY KEY(key1, key2, key3))");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("clustering_order", "composite_clustering_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("clustering_order", "composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 2);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_ASC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.reversed_composite_key (key1 text, key2 text, value text, "
-                                       "PRIMARY KEY(key1, key2)) "
-                                       "WITH CLUSTERING ORDER BY (key2 DESC)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE clustering_order.reversed_composite_key (key1 text, key2 text, value text, "
+        "PRIMARY KEY(key1, key2)) "
+        "WITH CLUSTERING ORDER BY (key2 DESC)");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("clustering_order", "reversed_composite_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("clustering_order", "reversed_composite_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 1);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.reversed_composite_clustering_key (key1 text, key2 text, key3 text, value text, "
-                                       "PRIMARY KEY(key1, key2, key3))"
-                                       "WITH CLUSTERING ORDER BY (key2 DESC, key3 DESC)");
+    test_utils::execute_query(session,
+                              "CREATE TABLE clustering_order.reversed_composite_clustering_key "
+                              "(key1 text, key2 text, key3 text, value text, "
+                              "PRIMARY KEY(key1, key2, key3))"
+                              "WITH CLUSTERING ORDER BY (key2 DESC, key3 DESC)");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("clustering_order", "reversed_composite_clustering_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("clustering_order", "reversed_composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 2);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_DESC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1), CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1),
+                      CASS_CLUSTERING_ORDER_DESC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.mixed_composite_clustering_key ("
-                                       "key1 text, key2 text, key3 text, key4 text, value text, "
-                                       "PRIMARY KEY(key1, key2, key3, key4))"
-                                       "WITH CLUSTERING ORDER BY (key2 DESC, key3 ASC, key4 DESC)");
+    test_utils::execute_query(session,
+                              "CREATE TABLE clustering_order.mixed_composite_clustering_key ("
+                              "key1 text, key2 text, key3 text, key4 text, value text, "
+                              "PRIMARY KEY(key1, key2, key3, key4))"
+                              "WITH CLUSTERING ORDER BY (key2 DESC, key3 ASC, key4 DESC)");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("clustering_order", "mixed_composite_clustering_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("clustering_order", "mixed_composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 3);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_DESC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1), CASS_CLUSTERING_ORDER_ASC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 2), CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1),
+                      CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 2),
+                      CASS_CLUSTERING_ORDER_DESC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE clustering_order.mixed_order_composite_clustering_key ("
-                                       "key1 text, key2 text, key3 text, key4 text, value text, "
-                                       "PRIMARY KEY(key1, key4, key3, key2))"
-                                       "WITH CLUSTERING ORDER BY (key4 DESC, key3 ASC, key2 ASC)");
+    test_utils::execute_query(session,
+                              "CREATE TABLE clustering_order.mixed_order_composite_clustering_key ("
+                              "key1 text, key2 text, key3 text, key4 text, value text, "
+                              "PRIMARY KEY(key1, key4, key3, key2))"
+                              "WITH CLUSTERING ORDER BY (key4 DESC, key3 ASC, key2 ASC)");
     refresh_schema_meta();
 
-    const CassTableMeta* table_meta = schema_get_table("clustering_order", "mixed_order_composite_clustering_key");
+    const CassTableMeta* table_meta =
+        schema_get_table("clustering_order", "mixed_order_composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_table_meta_clustering_key_count(table_meta), 3);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0), CASS_CLUSTERING_ORDER_DESC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1), CASS_CLUSTERING_ORDER_ASC);
-    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 2), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 1),
+                      CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_table_meta_clustering_key_order(table_meta, 2),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 }
 
@@ -1357,7 +1446,9 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   refresh_schema_meta();
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.regular_map (key text PRIMARY KEY, value map<text, text>)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE frozen_types.regular_map (key text PRIMARY KEY, value map<text, text>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "regular_map", "value");
@@ -1367,7 +1458,8 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_map (key text PRIMARY KEY, value frozen<map<text, text>>)");
+    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_map (key text PRIMARY "
+                                       "KEY, value frozen<map<text, text>>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_map", "value");
@@ -1377,7 +1469,8 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.regular_set (key text PRIMARY KEY, value set<text>)");
+    test_utils::execute_query(
+        session, "CREATE TABLE frozen_types.regular_set (key text PRIMARY KEY, value set<text>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "regular_set", "value");
@@ -1387,7 +1480,9 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_set (key text PRIMARY KEY, value frozen<set<text>>)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE frozen_types.frozen_set (key text PRIMARY KEY, value frozen<set<text>>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_set", "value");
@@ -1397,7 +1492,8 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.regular_list (key text PRIMARY KEY, value list<text>)");
+    test_utils::execute_query(
+        session, "CREATE TABLE frozen_types.regular_list (key text PRIMARY KEY, value list<text>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "regular_list", "value");
@@ -1407,7 +1503,9 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_list (key text PRIMARY KEY, value frozen<list<text>>)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE frozen_types.frozen_list (key text PRIMARY KEY, value frozen<list<text>>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_list", "value");
@@ -1417,7 +1515,9 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.regular_tuple (key text PRIMARY KEY, value tuple<text, int>)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE frozen_types.regular_tuple (key text PRIMARY KEY, value tuple<text, int>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "regular_tuple", "value");
@@ -1428,7 +1528,8 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_tuple (key text PRIMARY KEY, value frozen<tuple<text, int>>)");
+    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_tuple (key text PRIMARY "
+                                       "KEY, value frozen<tuple<text, int>>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_tuple", "value");
@@ -1440,8 +1541,11 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   // Note: Non-frozen UDTs are not supported as of C* 3.0
 
   {
-    test_utils::execute_query(session, "CREATE TYPE frozen_types.type1 (field1 text, field2 frozen<set<text>>)");
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_udt (key text PRIMARY KEY, value frozen<type1>)");
+    test_utils::execute_query(
+        session, "CREATE TYPE frozen_types.type1 (field1 text, field2 frozen<set<text>>)");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE frozen_types.frozen_udt (key text PRIMARY KEY, value frozen<type1>)");
     refresh_schema_meta();
 
     const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_udt", "value");
@@ -1457,15 +1561,18 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
     const CassDataType* value_data_type = cass_data_type_sub_data_type(data_type, 1);
     BOOST_CHECK_EQUAL(cass_data_type_type(value_data_type), CASS_VALUE_TYPE_SET);
     // Note: C* < 3.0.0 doesn't keep the frozen<> information for types inside UDTs
-    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(value_data_type), version < "3.0.0" ? cass_false : cass_true);
+    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(value_data_type),
+                      version < "3.0.0" ? cass_false : cass_true);
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_nested_map (key text PRIMARY KEY, "
-                                       "value map<frozen<set<text>>, frozen<list<text>>>)");
+    test_utils::execute_query(session,
+                              "CREATE TABLE frozen_types.frozen_nested_map (key text PRIMARY KEY, "
+                              "value map<frozen<set<text>>, frozen<list<text>>>)");
     refresh_schema_meta();
 
-    const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_nested_map", "value");
+    const CassColumnMeta* column_meta =
+        schema_get_column("frozen_types", "frozen_nested_map", "value");
     const CassDataType* data_type = cass_column_meta_data_type(column_meta);
 
     BOOST_CHECK_EQUAL(cass_data_type_type(data_type), CASS_VALUE_TYPE_MAP);
@@ -1482,11 +1589,13 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
   }
 
   {
-    test_utils::execute_query(session, "CREATE TABLE frozen_types.frozen_nested_tuple (key text PRIMARY KEY, "
-                                       "value tuple<int, text, frozen<set<text>>, frozen<list<text>>>)");
+    test_utils::execute_query(
+        session, "CREATE TABLE frozen_types.frozen_nested_tuple (key text PRIMARY KEY, "
+                 "value tuple<int, text, frozen<set<text>>, frozen<list<text>>>)");
     refresh_schema_meta();
 
-    const CassColumnMeta* column_meta = schema_get_column("frozen_types", "frozen_nested_tuple", "value");
+    const CassColumnMeta* column_meta =
+        schema_get_column("frozen_types", "frozen_nested_tuple", "value");
     const CassDataType* data_type = cass_column_meta_data_type(column_meta);
 
     BOOST_CHECK_EQUAL(cass_data_type_type(data_type), CASS_VALUE_TYPE_TUPLE);
@@ -1494,7 +1603,7 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
     BOOST_CHECK_EQUAL(cass_data_type_is_frozen(data_type), cass_true);
 
     const CassDataType* key_data_type;
-    const CassDataType* value_data_type ;
+    const CassDataType* value_data_type;
 
     key_data_type = cass_data_type_sub_data_type(data_type, 0);
     BOOST_CHECK_EQUAL(cass_data_type_type(key_data_type), CASS_VALUE_TYPE_INT);
@@ -1507,12 +1616,14 @@ BOOST_AUTO_TEST_CASE(frozen_types) {
     key_data_type = cass_data_type_sub_data_type(data_type, 2);
     BOOST_CHECK_EQUAL(cass_data_type_type(key_data_type), CASS_VALUE_TYPE_SET);
     // Note: C* < 3.0.0 doesn't keep the frozen<> information for types inside tuple<>
-    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(key_data_type), version < "3.0.0" ? cass_false : cass_true);
+    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(key_data_type),
+                      version < "3.0.0" ? cass_false : cass_true);
 
     value_data_type = cass_data_type_sub_data_type(data_type, 3);
     BOOST_CHECK_EQUAL(cass_data_type_type(value_data_type), CASS_VALUE_TYPE_LIST);
     // Note: C* < 3.0.0 doesn't keep the frozen<> information for types inside tuple<>
-    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(value_data_type), version < "3.0.0" ? cass_false : cass_true);
+    BOOST_CHECK_EQUAL(cass_data_type_is_frozen(value_data_type),
+                      version < "3.0.0" ? cass_false : cass_true);
   }
 }
 
@@ -1533,16 +1644,18 @@ BOOST_AUTO_TEST_CASE(lookup) {
   if (version < "2.2.0") return;
 
   test_utils::execute_query(session, "CREATE KEYSPACE lookup WITH replication = "
-    "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
+                                     "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
   refresh_schema_meta();
 
   // See https://docs.datastax.com/en/cql/3.3/cql/cql_using/useCreateUDF.html
   // and https://docs.datastax.com/en/cql/3.3/cql/cql_using/useCreateUDA.html
   {
     // Frozen added to arguments and return types in C* 3.0.0 by default for collections
-    test_utils::execute_query(session, "CREATE OR REPLACE FUNCTION lookup.avg_state(state tuple<int, bigint>, val int) "
-      "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
-      "LANGUAGE java AS 'if (val !=null) { state.setInt(0, state.getInt(0) + 1); state.setLong(1, state.getLong(1) + val.intValue()); } return state;'");
+    test_utils::execute_query(
+        session, "CREATE OR REPLACE FUNCTION lookup.avg_state(state tuple<int, bigint>, val int) "
+                 "CALLED ON NULL INPUT RETURNS tuple<int, bigint> "
+                 "LANGUAGE java AS 'if (val !=null) { state.setInt(0, state.getInt(0) + 1); "
+                 "state.setLong(1, state.getLong(1) + val.intValue()); } return state;'");
     refresh_schema_meta();
 
     // Create the function arguments for the avg_state function
@@ -1555,43 +1668,47 @@ BOOST_AUTO_TEST_CASE(lookup) {
 
     // Ensure the function can be looked up and validate arguments and return
     const CassFunctionMeta* func_meta = cass_keyspace_meta_function_by_name(
-      schema_get_keyspace("lookup"),
-      "avg_state",
-      func_args.c_str());
+        schema_get_keyspace("lookup"), "avg_state", func_args.c_str());
     BOOST_REQUIRE(func_meta);
     const CassDataType* datatype = cass_function_meta_argument_type_by_name(func_meta, "state");
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_TUPLE, cass_data_type_type(datatype));
     BOOST_CHECK(cass_data_type_is_frozen(datatype));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
     datatype = cass_function_meta_argument_type_by_name(func_meta, "val");
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(datatype));
     datatype = cass_function_meta_return_type(func_meta);
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_TUPLE, cass_data_type_type(datatype));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
-
-    test_utils::execute_query(session, "CREATE OR REPLACE FUNCTION lookup.avg_final(state tuple<int, bigint>) "
-      "CALLED ON NULL INPUT RETURNS double "
-      "LANGUAGE java AS 'double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r /= state.getInt(0); return Double.valueOf(r);'");
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
+
+    test_utils::execute_query(
+        session, "CREATE OR REPLACE FUNCTION lookup.avg_final(state tuple<int, bigint>) "
+                 "CALLED ON NULL INPUT RETURNS double "
+                 "LANGUAGE java AS 'double r = 0; if (state.getInt(0) == 0) return null; r = "
+                 "state.getLong(1); r /= state.getInt(0); return Double.valueOf(r);'");
     test_utils::execute_query(session, "CREATE AGGREGATE IF NOT EXISTS lookup.average (int) "
-      "SFUNC avg_state STYPE tuple<int, bigint> "
-      "FINALFUNC avg_final INITCOND (0, 0);");
+                                       "SFUNC avg_state STYPE tuple<int, bigint> "
+                                       "FINALFUNC avg_final INITCOND (0, 0);");
     refresh_schema_meta();
 
     // Ensure the aggregate can be looked up and validated
-    const CassAggregateMeta* agg_meta = cass_keyspace_meta_aggregate_by_name(
-      schema_get_keyspace("lookup"),
-      "average",
-      "int");
+    const CassAggregateMeta* agg_meta =
+        cass_keyspace_meta_aggregate_by_name(schema_get_keyspace("lookup"), "average", "int");
     BOOST_REQUIRE(agg_meta);
     datatype = cass_aggregate_meta_argument_type(agg_meta, 0);
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(datatype));
     datatype = cass_aggregate_meta_state_type(agg_meta);
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_TUPLE, cass_data_type_type(datatype));
     BOOST_CHECK(cass_data_type_is_frozen(datatype));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
     datatype = cass_aggregate_meta_return_type(agg_meta);
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_DOUBLE, cass_data_type_type(datatype));
     func_meta = cass_aggregate_meta_final_func(agg_meta);
@@ -1599,8 +1716,10 @@ BOOST_AUTO_TEST_CASE(lookup) {
     datatype = cass_function_meta_argument_type_by_name(func_meta, "state");
     BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_TUPLE, cass_data_type_type(datatype));
     BOOST_CHECK(cass_data_type_is_frozen(datatype));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
-    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT, cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_INT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 0)));
+    BOOST_CHECK_EQUAL(CASS_VALUE_TYPE_BIGINT,
+                      cass_data_type_type(cass_data_type_sub_data_type(datatype, 1)));
   }
 }
 
@@ -1619,7 +1738,8 @@ BOOST_AUTO_TEST_CASE(indexes) {
     test_utils::execute_query(session, "CREATE KEYSPACE indexes WITH replication = "
                                        "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
 
-    test_utils::execute_query(session, "CREATE TABLE indexes.table1 (key1 text, value1 int, value2 map<text, text>,  PRIMARY KEY(key1))");
+    test_utils::execute_query(session, "CREATE TABLE indexes.table1 (key1 text, value1 int, value2 "
+                                       "map<text, text>,  PRIMARY KEY(key1))");
 
     refresh_schema_meta();
     const CassTableMeta* table_meta = schema_get_table("indexes", "table1");
@@ -1641,10 +1761,10 @@ BOOST_AUTO_TEST_CASE(indexes) {
     if (version >= "3.0.0") {
       index_options["target"] = "value1";
     }
-    verify_index(cass_table_meta_index_by_name(table_meta, "index1"),
-                 "index1", CASS_INDEX_TYPE_COMPOSITES, "value1", index_options);
-    verify_index(cass_table_meta_index(table_meta, 0),
-                 "index1", CASS_INDEX_TYPE_COMPOSITES, "value1", index_options);
+    verify_index(cass_table_meta_index_by_name(table_meta, "index1"), "index1",
+                 CASS_INDEX_TYPE_COMPOSITES, "value1", index_options);
+    verify_index(cass_table_meta_index(table_meta, 0), "index1", CASS_INDEX_TYPE_COMPOSITES,
+                 "value1", index_options);
   }
 
   // Index on map keys (C* >= 2.1)
@@ -1663,10 +1783,10 @@ BOOST_AUTO_TEST_CASE(indexes) {
       } else {
         index_options["index_keys"] = "";
       }
-      verify_index(cass_table_meta_index_by_name(table_meta, "index2"),
-        "index2", CASS_INDEX_TYPE_COMPOSITES, "keys(value2)", index_options);
-      verify_index(cass_table_meta_index(table_meta, 1),
-        "index2", CASS_INDEX_TYPE_COMPOSITES, "keys(value2)", index_options);
+      verify_index(cass_table_meta_index_by_name(table_meta, "index2"), "index2",
+                   CASS_INDEX_TYPE_COMPOSITES, "keys(value2)", index_options);
+      verify_index(cass_table_meta_index(table_meta, 1), "index2", CASS_INDEX_TYPE_COMPOSITES,
+                   "keys(value2)", index_options);
     }
   }
 
@@ -1703,8 +1823,11 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
     test_utils::execute_query(session, "CREATE KEYSPACE materialized_views WITH replication = "
                                        "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
 
-    test_utils::execute_query(session, "CREATE TABLE materialized_views.table1 (key1 text, value1 int, PRIMARY KEY(key1))");
-    test_utils::execute_query(session, "CREATE TABLE materialized_views.table2 (key1 text, key2 int, value1 int, PRIMARY KEY(key1, key2))");
+    test_utils::execute_query(
+        session,
+        "CREATE TABLE materialized_views.table1 (key1 text, value1 int, PRIMARY KEY(key1))");
+    test_utils::execute_query(session, "CREATE TABLE materialized_views.table2 (key1 text, key2 "
+                                       "int, value1 int, PRIMARY KEY(key1, key2))");
 
     refresh_schema_meta();
 
@@ -1718,9 +1841,10 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
 
   // Simple materialized view
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_views.view1 AS "
-                                       "SELECT key1 FROM materialized_views.table1 WHERE value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key1)");
+    test_utils::execute_query(session,
+                              "CREATE MATERIALIZED VIEW materialized_views.view1 AS "
+                              "SELECT key1 FROM materialized_views.table1 WHERE value1 IS NOT NULL "
+                              "PRIMARY KEY(value1, key1)");
     refresh_schema_meta();
 
     verify_materialized_view_count("materialized_views", 1);
@@ -1729,15 +1853,16 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
     BOOST_CHECK(cass_table_meta_materialized_view_count(table_meta) == 1);
 
     verify_materialized_view(cass_table_meta_materialized_view_by_name(table_meta, "view1"),
-                             "view1", "table1",
-                             "value1,key1", "value1", "key1");
+                             "view1", "table1", "value1,key1", "value1", "key1");
   }
 
   // Materialized view with composite partition key
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_views.view2 AS "
-                                       "SELECT key1 FROM materialized_views.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
-                                       "PRIMARY KEY((value1, key2), key1)");
+    test_utils::execute_query(
+        session,
+        "CREATE MATERIALIZED VIEW materialized_views.view2 AS "
+        "SELECT key1 FROM materialized_views.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
+        "PRIMARY KEY((value1, key2), key1)");
 
     refresh_schema_meta();
 
@@ -1747,16 +1872,17 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
     BOOST_CHECK(cass_table_meta_materialized_view_count(table_meta) == 1);
 
     verify_materialized_view(cass_table_meta_materialized_view_by_name(table_meta, "view2"),
-                             "view2", "table2",
-                             "value1,key2,key1", "value1,key2", "key1");
+                             "view2", "table2", "value1,key2,key1", "value1,key2", "key1");
   }
 
   // Materialized view with composite clustering key
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_views.view3 AS "
-                                       "SELECT key1 FROM materialized_views.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key2, key1) "
-                                       "WITH CLUSTERING ORDER BY (key2 DESC)");
+    test_utils::execute_query(
+        session,
+        "CREATE MATERIALIZED VIEW materialized_views.view3 AS "
+        "SELECT key1 FROM materialized_views.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
+        "PRIMARY KEY(value1, key2, key1) "
+        "WITH CLUSTERING ORDER BY (key2 DESC)");
 
     refresh_schema_meta();
 
@@ -1766,29 +1892,30 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
     BOOST_CHECK(cass_table_meta_materialized_view_count(table_meta) == 2);
 
     verify_materialized_view(cass_table_meta_materialized_view_by_name(table_meta, "view3"),
-                             "view3", "table2",
-                             "value1,key2,key1", "value1", "key2,key1");
+                             "view3", "table2", "value1,key2,key1", "value1", "key2,key1");
   }
 
   // Iterator
   {
     const CassTableMeta* table_meta = schema_get_table("materialized_views", "table2");
 
-    test_utils::CassIteratorPtr iterator(cass_iterator_materialized_views_from_table_meta(table_meta));
+    test_utils::CassIteratorPtr iterator(
+        cass_iterator_materialized_views_from_table_meta(table_meta));
 
     while (cass_iterator_next(iterator.get())) {
-      const CassMaterializedViewMeta* view_meta = cass_iterator_get_materialized_view_meta(iterator.get());
+      const CassMaterializedViewMeta* view_meta =
+          cass_iterator_get_materialized_view_meta(iterator.get());
       BOOST_REQUIRE(view_meta != NULL);
 
       CassString name;
       cass_materialized_view_meta_name(view_meta, &name.data, &name.length);
 
       if (name == CassString("view2")) {
-        verify_materialized_view(view_meta, "view2", "table2",
-                                 "value1,key2,key1", "value1,key2", "key1");
+        verify_materialized_view(view_meta, "view2", "table2", "value1,key2,key1", "value1,key2",
+                                 "key1");
       } else if (name == CassString("view3")) {
-        verify_materialized_view(view_meta, "view3", "table2",
-                                 "value1,key2,key1", "value1", "key2,key1");
+        verify_materialized_view(view_meta, "view3", "table2", "value1,key2,key1", "value1",
+                                 "key2,key1");
       } else {
         BOOST_CHECK(false);
       }
@@ -1804,7 +1931,8 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
 
     refresh_schema_meta();
     verify_materialized_view_count("materialized_views", 2);
-    BOOST_REQUIRE(cass_keyspace_meta_materialized_view_by_name(schema_get_keyspace("materialized_views"), "view2") == NULL);
+    BOOST_REQUIRE(cass_keyspace_meta_materialized_view_by_name(
+                      schema_get_keyspace("materialized_views"), "view2") == NULL);
 
     const CassTableMeta* new_table_meta = schema_get_table("materialized_views", "table2");
     schema_get_view("materialized_views", "view1"); // Ensures view not NULL
@@ -1816,7 +1944,8 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
 
     refresh_schema_meta();
     verify_materialized_view_count("materialized_views", 1);
-    BOOST_REQUIRE(cass_keyspace_meta_materialized_view_by_name(schema_get_keyspace("materialized_views"), "view1") == NULL);
+    BOOST_REQUIRE(cass_keyspace_meta_materialized_view_by_name(
+                      schema_get_keyspace("materialized_views"), "view1") == NULL);
 
     new_table_meta = schema_get_table("materialized_views", "table1");
     BOOST_CHECK(cass_table_meta_materialized_view_count(new_table_meta) == 0);
@@ -1827,7 +1956,7 @@ BOOST_AUTO_TEST_CASE(materialized_views) {
   {
     const CassMaterializedViewMeta* view = schema_get_view("materialized_views", "view3");
     test_utils::execute_query(session, "ALTER MATERIALIZED VIEW materialized_views.view3 "
-                              "WITH comment = 'my view rocks'");
+                                       "WITH comment = 'my view rocks'");
     refresh_schema_meta();
     verify_materialized_view_count("materialized_views", 1);
     const CassMaterializedViewMeta* new_view = schema_get_view("materialized_views", "view3");
@@ -1854,79 +1983,109 @@ BOOST_AUTO_TEST_CASE(materialized_view_clustering_order) {
   if (version < "3.0.0") return;
 
   {
-    test_utils::execute_query(session, "CREATE KEYSPACE materialized_view_clustering_order WITH replication = "
-                                       "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
+    test_utils::execute_query(
+        session, "CREATE KEYSPACE materialized_view_clustering_order WITH replication = "
+                 "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
 
-    test_utils::execute_query(session, "CREATE TABLE materialized_view_clustering_order.table1 (key1 text, value1 text, PRIMARY KEY(key1))");
-    test_utils::execute_query(session, "CREATE TABLE materialized_view_clustering_order.table2 (key1 text, key2 text, value1 text, PRIMARY KEY(key1, key2))");
+    test_utils::execute_query(session, "CREATE TABLE materialized_view_clustering_order.table1 "
+                                       "(key1 text, value1 text, PRIMARY KEY(key1))");
+    test_utils::execute_query(session,
+                              "CREATE TABLE materialized_view_clustering_order.table2 (key1 text, "
+                              "key2 text, value1 text, PRIMARY KEY(key1, key2))");
 
     refresh_schema_meta();
   }
 
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_view_clustering_order.composite_key AS "
-                                       "SELECT key1 FROM materialized_view_clustering_order.table1 WHERE value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key1)");
+    test_utils::execute_query(
+        session,
+        "CREATE MATERIALIZED VIEW materialized_view_clustering_order.composite_key AS "
+        "SELECT key1 FROM materialized_view_clustering_order.table1 WHERE value1 IS NOT NULL "
+        "PRIMARY KEY(value1, key1)");
     refresh_schema_meta();
 
-    const CassMaterializedViewMeta* view_meta = schema_get_view("materialized_view_clustering_order", "composite_key");
+    const CassMaterializedViewMeta* view_meta =
+        schema_get_view("materialized_view_clustering_order", "composite_key");
 
     BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view_meta), 1);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_view_clustering_order.reversed_composite_key AS "
-                                       "SELECT key1 FROM materialized_view_clustering_order.table1 WHERE value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key1)"
-                                       "WITH CLUSTERING ORDER BY (key1 DESC)");
+    test_utils::execute_query(
+        session,
+        "CREATE MATERIALIZED VIEW materialized_view_clustering_order.reversed_composite_key AS "
+        "SELECT key1 FROM materialized_view_clustering_order.table1 WHERE value1 IS NOT NULL "
+        "PRIMARY KEY(value1, key1)"
+        "WITH CLUSTERING ORDER BY (key1 DESC)");
     refresh_schema_meta();
 
-    const CassMaterializedViewMeta* view_meta = schema_get_view("materialized_view_clustering_order", "reversed_composite_key");
+    const CassMaterializedViewMeta* view_meta =
+        schema_get_view("materialized_view_clustering_order", "reversed_composite_key");
 
     BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view_meta), 1);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0), CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_view_clustering_order.composite_clustering_key AS "
-                                       "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key2, key1)");
+    test_utils::execute_query(
+        session,
+        "CREATE MATERIALIZED VIEW materialized_view_clustering_order.composite_clustering_key AS "
+        "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT NULL AND "
+        "value1 IS NOT NULL "
+        "PRIMARY KEY(value1, key2, key1)");
     refresh_schema_meta();
 
-    const CassMaterializedViewMeta* view_meta = schema_get_view("materialized_view_clustering_order", "composite_clustering_key");
+    const CassMaterializedViewMeta* view_meta =
+        schema_get_view("materialized_view_clustering_order", "composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view_meta), 2);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0), CASS_CLUSTERING_ORDER_ASC);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0),
+                      CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_view_clustering_order.reversed_composite_clustering_key AS "
-                                       "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key2, key1) "
-                                       "WITH CLUSTERING ORDER BY (key2 DESC, key1 DESC)");
+    test_utils::execute_query(
+        session, "CREATE MATERIALIZED VIEW "
+                 "materialized_view_clustering_order.reversed_composite_clustering_key AS "
+                 "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT "
+                 "NULL AND value1 IS NOT NULL "
+                 "PRIMARY KEY(value1, key2, key1) "
+                 "WITH CLUSTERING ORDER BY (key2 DESC, key1 DESC)");
     refresh_schema_meta();
 
-    const CassMaterializedViewMeta* view_meta = schema_get_view("materialized_view_clustering_order", "reversed_composite_clustering_key");
+    const CassMaterializedViewMeta* view_meta =
+        schema_get_view("materialized_view_clustering_order", "reversed_composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view_meta), 2);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0), CASS_CLUSTERING_ORDER_DESC);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1), CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1),
+                      CASS_CLUSTERING_ORDER_DESC);
   }
 
   {
-    test_utils::execute_query(session, "CREATE MATERIALIZED VIEW materialized_view_clustering_order.mixed_composite_clustering_key AS "
-                                       "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT NULL AND value1 IS NOT NULL "
-                                       "PRIMARY KEY(value1, key2, key1) "
-                                       "WITH CLUSTERING ORDER BY (key2 DESC, key1 ASC)");
+    test_utils::execute_query(
+        session, "CREATE MATERIALIZED VIEW "
+                 "materialized_view_clustering_order.mixed_composite_clustering_key AS "
+                 "SELECT key1 FROM materialized_view_clustering_order.table2 WHERE key2 IS NOT "
+                 "NULL AND value1 IS NOT NULL "
+                 "PRIMARY KEY(value1, key2, key1) "
+                 "WITH CLUSTERING ORDER BY (key2 DESC, key1 ASC)");
     refresh_schema_meta();
 
-    const CassMaterializedViewMeta* view_meta = schema_get_view("materialized_view_clustering_order", "mixed_composite_clustering_key");
+    const CassMaterializedViewMeta* view_meta =
+        schema_get_view("materialized_view_clustering_order", "mixed_composite_clustering_key");
 
     BOOST_REQUIRE_EQUAL(cass_materialized_view_meta_clustering_key_count(view_meta), 2);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0), CASS_CLUSTERING_ORDER_DESC);
-    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1), CASS_CLUSTERING_ORDER_ASC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 0),
+                      CASS_CLUSTERING_ORDER_DESC);
+    BOOST_CHECK_EQUAL(cass_materialized_view_meta_clustering_key_order(view_meta, 1),
+                      CASS_CLUSTERING_ORDER_ASC);
   }
 }
 
@@ -1946,14 +2105,16 @@ BOOST_AUTO_TEST_CASE(duplicate_table_name) {
   test_utils::execute_query(session, "CREATE KEYSPACE test14 WITH replication = "
                                      "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
 
-  test_utils::execute_query(session, "CREATE TABLE test14.table1 (key1 TEXT PRIMARY KEY, value1 INT)" );
+  test_utils::execute_query(session,
+                            "CREATE TABLE test14.table1 (key1 TEXT PRIMARY KEY, value1 INT)");
 
   test_utils::execute_query(session, "CREATE INDEX index1 ON test14.table1 (value1)");
 
   test_utils::execute_query(session, "CREATE KEYSPACE test15 WITH replication = "
                                      "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
 
-  test_utils::execute_query(session, "CREATE TABLE test15.table1 (key1 TEXT PRIMARY KEY, value1 INT)" );
+  test_utils::execute_query(session,
+                            "CREATE TABLE test15.table1 (key1 TEXT PRIMARY KEY, value1 INT)");
 
   test_utils::execute_query(session, "CREATE INDEX index1 ON test15.table1 (value1)");
 
@@ -1989,7 +2150,8 @@ BOOST_AUTO_TEST_CASE(duplicate_table_name) {
 BOOST_AUTO_TEST_CASE(integer_type_varint_mapping) {
   test_utils::execute_query(session, "CREATE KEYSPACE varint_type WITH replication = "
                                      "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
-  test_utils::execute_query(session, "CREATE TABLE varint_type.table1 (key1 TEXT PRIMARY KEY, value1 VARINT)" );
+  test_utils::execute_query(
+      session, "CREATE TABLE varint_type.table1 (key1 TEXT PRIMARY KEY, value1 VARINT)");
   refresh_schema_meta();
 
   {
@@ -2012,12 +2174,15 @@ BOOST_AUTO_TEST_CASE(single_quote_custom_type) {
 
   test_utils::execute_query(session, "CREATE KEYSPACE single_quote_custom_type WITH replication = "
                                      "{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
-  test_utils::execute_query(session, "CREATE TABLE single_quote_custom_type.table1 (key1 TEXT PRIMARY KEY, value1 'org.apache.cassandra.db.marshal.LexicalUUIDType')");
+  test_utils::execute_query(session,
+                            "CREATE TABLE single_quote_custom_type.table1 (key1 TEXT PRIMARY KEY, "
+                            "value1 'org.apache.cassandra.db.marshal.LexicalUUIDType')");
 
   refresh_schema_meta();
 
   {
-    const CassColumnMeta* col_meta = schema_get_column("single_quote_custom_type", "table1", "value1");
+    const CassColumnMeta* col_meta =
+        schema_get_column("single_quote_custom_type", "table1", "value1");
     const CassDataType* data_type = cass_column_meta_data_type(col_meta);
     BOOST_REQUIRE(data_type != NULL);
     const CassValueType value_type = cass_data_type_type(data_type);
diff --git a/test/integration_tests/src/test_serial_consistency.cpp b/test/integration_tests/src/test_serial_consistency.cpp
index d3f18392e..aa96104e2 100644
--- a/test/integration_tests/src/test_serial_consistency.cpp
+++ b/test/integration_tests/src/test_serial_consistency.cpp
@@ -14,33 +14,36 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "policy_tools.hpp"
+#include "test_utils.hpp"
 
 #include "cassandra.h"
 
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/test/unit_test.hpp>
+#include <boost/format.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/format.hpp>
 
 struct SerialConsistencyTests : public test_utils::SingleSessionTest {
-  SerialConsistencyTests() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+  SerialConsistencyTests()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
     test_utils::execute_query(session, "CREATE TABLE test (key text PRIMARY KEY, value int);");
   }
 
   ~SerialConsistencyTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
-  test_utils::CassFuturePtr insert_row(const std::string& key, int value, CassConsistency serial_consistency) {
+  test_utils::CassFuturePtr insert_row(const std::string& key, int value,
+                                       CassConsistency serial_consistency) {
     std::string insert_query = "INSERT INTO test (key, value) VALUES (?, ?) IF NOT EXISTS";
 
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
@@ -54,8 +57,7 @@ struct SerialConsistencyTests : public test_utils::SingleSessionTest {
 
 BOOST_AUTO_TEST_SUITE(serial_consistency)
 
-BOOST_AUTO_TEST_CASE(simple)
-{
+BOOST_AUTO_TEST_CASE(simple) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     SerialConsistencyTests tester;
@@ -70,26 +72,31 @@ BOOST_AUTO_TEST_CASE(simple)
       BOOST_REQUIRE_EQUAL(applied, i == 0 ? cass_true : cass_false);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping serial_consistency/simple" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping serial_consistency/simple" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
-BOOST_AUTO_TEST_CASE(invalid)
-{
+BOOST_AUTO_TEST_CASE(invalid) {
   CCM::CassVersion version = test_utils::get_version();
   if (version.major_version != 1) {
     SerialConsistencyTests tester;
-    test_utils::CassFuturePtr future = tester.insert_row("abc", 99, CASS_CONSISTENCY_ONE); // Invalid
+    test_utils::CassFuturePtr future =
+        tester.insert_row("abc", 99, CASS_CONSISTENCY_ONE); // Invalid
 
     CassError code = cass_future_error_code(future.get());
     BOOST_REQUIRE_EQUAL(code, CASS_ERROR_SERVER_INVALID_QUERY);
 
     CassString message;
     cass_future_error_message(future.get(), &message.data, &message.length);
-    BOOST_REQUIRE(strncmp(message.data, "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL", message.length) == 0);
+    BOOST_REQUIRE(
+        strncmp(message.data,
+                "Invalid consistency for conditional update. Must be one of SERIAL or LOCAL_SERIAL",
+                message.length) == 0);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping serial_consistency/invalid" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping serial_consistency/invalid" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_server_failures.cpp b/test/integration_tests/src/test_server_failures.cpp
index 8431df1cb..9b02fe734 100644
--- a/test/integration_tests/src/test_server_failures.cpp
+++ b/test/integration_tests/src/test_server_failures.cpp
@@ -14,24 +14,27 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
 
 struct ServerFailuresTest : public test_utils::SingleSessionTest {
 public:
-  ServerFailuresTest() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+  ServerFailuresTest()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~ServerFailuresTest() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 };
 
@@ -49,14 +52,19 @@ BOOST_AUTO_TEST_SUITE(server_failures)
  * @test_category queries:basic
  * @cassandra_version 2.2.x
  */
- BOOST_AUTO_TEST_CASE(function_failure) {
+BOOST_AUTO_TEST_CASE(function_failure) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     ServerFailuresTest tester;
-    std::string create_table = "CREATE TABLE server_function_failures (id int PRIMARY KEY, value double)";
+    std::string create_table =
+        "CREATE TABLE server_function_failures (id int PRIMARY KEY, value double)";
     std::string insert_query = "INSERT INTO server_function_failures(id, value) VALUES (?, ?)";
-    std::string failing_function = "CREATE FUNCTION " + test_utils::SIMPLE_KEYSPACE + ".function_failure(value double) RETURNS NULL ON NULL INPUT RETURNS double LANGUAGE java AS 'throw new RuntimeException(\"failure\");'";
-    std::string select_query = "SELECT function_failure(value) FROM server_function_failures WHERE id = ?";
+    std::string failing_function =
+        "CREATE FUNCTION " + test_utils::SIMPLE_KEYSPACE +
+        ".function_failure(value double) RETURNS NULL ON NULL INPUT RETURNS double LANGUAGE java "
+        "AS 'throw new RuntimeException(\"failure\");'";
+    std::string select_query =
+        "SELECT function_failure(value) FROM server_function_failures WHERE id = ?";
 
     // Create the table and associated failing function
     test_utils::execute_query(tester.session, create_table.c_str());
@@ -64,17 +72,22 @@ BOOST_AUTO_TEST_SUITE(server_failures)
 
     // Bind and insert values into Cassandra
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
-    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "id", 1), CASS_OK);
-    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_double_t>::bind_by_name(statement.get(), "value", 3.14), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "id", 1),
+                        CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        test_utils::Value<cass_double_t>::bind_by_name(statement.get(), "value", 3.14), CASS_OK);
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
     // Execute the failing function
     statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
     BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind(statement.get(), 0, 1), CASS_OK);
-    CassError error_code = test_utils::wait_and_return_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+    CassError error_code = test_utils::wait_and_return_error(
+        test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
     BOOST_REQUIRE_EQUAL(error_code, CASS_ERROR_SERVER_FUNCTION_FAILURE);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping server_failures/function_failure" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping server_failures/function_failure" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -95,18 +108,24 @@ BOOST_AUTO_TEST_CASE(already_exists) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     ServerFailuresTest tester;
-    std::string create_table = "CREATE TABLE already_exists_table (id int PRIMARY KEY, value double)";
-    std::string create_keyspace = str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1");
+    std::string create_table =
+        "CREATE TABLE already_exists_table (id int PRIMARY KEY, value double)";
+    std::string create_keyspace = str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                      test_utils::SIMPLE_KEYSPACE % "1");
 
     // Create the table
-    BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, create_table.c_str()), CASS_OK);
+    BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, create_table.c_str()),
+                        CASS_OK);
 
     // Ensure Cassandra returns Already_exists for table and keyspace
-    BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, create_table.c_str()), CASS_ERROR_SERVER_ALREADY_EXISTS);
-    BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, create_keyspace.c_str()), CASS_ERROR_SERVER_ALREADY_EXISTS);
-  }
-  else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping server_failures/already_exists" << std::endl;
+    BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, create_table.c_str()),
+                        CASS_ERROR_SERVER_ALREADY_EXISTS);
+    BOOST_REQUIRE_EQUAL(
+        test_utils::execute_query_with_error(tester.session, create_keyspace.c_str()),
+        CASS_ERROR_SERVER_ALREADY_EXISTS);
+  } else {
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping server_failures/already_exists" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_sessions.cpp b/test/integration_tests/src/test_sessions.cpp
index 690e7f2bc..aaecc50f3 100644
--- a/test/integration_tests/src/test_sessions.cpp
+++ b/test/integration_tests/src/test_sessions.cpp
@@ -16,15 +16,15 @@
 
 #include <algorithm>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
+#include <boost/atomic.hpp>
+#include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
-#include <boost/thread.hpp>
-#include <boost/chrono.hpp>
-#include <boost/atomic.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
 
 #include <uv.h>
 
@@ -33,10 +33,13 @@
 
 #define SESSION_STRESS_OPENED_LOG_MESSAGE "Session is connected"
 #define SESSION_STRESS_CLOSED_LOG_MESSAGE "Session is disconnected"
-#define SESSION_STRESS_NUMBER_OF_SESSIONS 16 //NOTE: Keep low due to CPP-194
-#define SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS 8 //NOTE: Total threads will be (SESSION_STRESS_NUMBER_OF_SESSIONS / 4) * SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS
+#define SESSION_STRESS_NUMBER_OF_SESSIONS 16 // NOTE: Keep low due to CPP-194
+#define SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS \
+  8 // NOTE: Total threads will be (SESSION_STRESS_NUMBER_OF_SESSIONS / 4) *
+    // SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS
 #define SESSION_STRESS_CHAOS_NUMBER_OF_ITERATIONS 256
-#define SESSION_STRESS_NUMBER_OF_ITERATIONS 4 //NOTE: This effects sleep timer as well for async log messages
+#define SESSION_STRESS_NUMBER_OF_ITERATIONS \
+  4 // NOTE: This effects sleep timer as well for async log messages
 #define SESSION_STRESS_NUMBER_OF_ALLOWED_NO_HOST_AVAILABLE_OCCURRENCES 2
 
 struct SessionTests {
@@ -44,13 +47,12 @@ struct SessionTests {
   boost::shared_ptr<CCM::Bridge> ccm;
 
   SessionTests()
-    : ccm(new CCM::Bridge("config.txt")) {}
+      : ccm(new CCM::Bridge("config.txt")) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(sessions, SessionTests)
 
-BOOST_AUTO_TEST_CASE(connect_invalid_name)
-{
+BOOST_AUTO_TEST_CASE(connect_invalid_name) {
   test_utils::CassLog::reset("Unable to resolve address for node.domain-does-not-exist.dne");
 
   CassError code;
@@ -69,8 +71,7 @@ BOOST_AUTO_TEST_CASE(connect_invalid_name)
   BOOST_CHECK_EQUAL(code, CASS_ERROR_LIB_NO_HOSTS_AVAILABLE);
 }
 
-BOOST_AUTO_TEST_CASE(connect_invalid_keyspace)
-{
+BOOST_AUTO_TEST_CASE(connect_invalid_keyspace) {
   test_utils::CassLog::reset("Received error response 'Keyspace 'invalid' does not exist");
 
   {
@@ -83,7 +84,8 @@ BOOST_AUTO_TEST_CASE(connect_invalid_keyspace)
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 1);
 
     test_utils::CassSessionPtr session(cass_session_new());
-    test_utils::CassFuturePtr connect_future(cass_session_connect_keyspace(session.get(), cluster.get(), "invalid"));
+    test_utils::CassFuturePtr connect_future(
+        cass_session_connect_keyspace(session.get(), cluster.get(), "invalid"));
     CassError code = cass_future_error_code(connect_future.get());
     BOOST_CHECK_EQUAL(code, CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE);
   }
@@ -91,8 +93,7 @@ BOOST_AUTO_TEST_CASE(connect_invalid_keyspace)
   BOOST_CHECK(test_utils::CassLog::message_count() > 0);
 }
 
-BOOST_AUTO_TEST_CASE(close_timeout_error)
-{
+BOOST_AUTO_TEST_CASE(close_timeout_error) {
   test_utils::CassLog::reset("Timed out during startup"); // JIRA CPP-127
 
   {
@@ -128,8 +129,7 @@ BOOST_AUTO_TEST_CASE(close_timeout_error)
  * @since 1.0.0-rc1
  * @test_category sessions
  */
-BOOST_AUTO_TEST_CASE(connect_when_already_connected)
-{
+BOOST_AUTO_TEST_CASE(connect_when_already_connected) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
   if (ccm->create_cluster()) {
     ccm->start_cluster();
@@ -153,8 +153,7 @@ BOOST_AUTO_TEST_CASE(connect_when_already_connected)
  * @since 1.0.0-rc1
  * @test_category sessions
  */
-BOOST_AUTO_TEST_CASE(close_when_already_closed)
-{
+BOOST_AUTO_TEST_CASE(close_when_already_closed) {
   test_utils::CassClusterPtr cluster(cass_cluster_new());
   if (ccm->create_cluster()) {
     ccm->start_cluster();
@@ -181,8 +180,7 @@ BOOST_AUTO_TEST_CASE(close_when_already_closed)
  * @since 1.0.0-rc1
  * @test_category sessions
  */
-BOOST_AUTO_TEST_CASE(close_when_not_connected)
-{
+BOOST_AUTO_TEST_CASE(close_when_not_connected) {
   test_utils::CassSessionPtr session(cass_session_new());
   test_utils::CassFuturePtr close_future(cass_session_close(session.get()));
   CassError code = test_utils::wait_and_return_error(close_future.get());
@@ -202,61 +200,64 @@ BOOST_AUTO_TEST_CASE(close_when_not_connected)
 BOOST_AUTO_TEST_CASE(add_nodes_connect) {
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
   {
-    //Create a single node cluster with three nodes initialized as contact points
-    std::cout << "Create single node cluster with all three nodes initialized as contact points" << std::endl;
+    // Create a single node cluster with three nodes initialized as contact points
+    std::cout << "Create single node cluster with all three nodes initialized as contact points"
+              << std::endl;
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster()) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 3);
 
-    //Add two nodes
+    // Add two nodes
     ccm->bootstrap_node();
     ccm->bootstrap_node();
 
-    //Create session
+    // Create session
     test_utils::create_session(cluster.get());
     ccm->remove_cluster();
   }
   BOOST_CHECK(test_utils::CassLog::message_count() == 1);
 
-
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
   {
-    //Create a single node cluster with two nodes initialized as contact points
-    std::cout << "Create single node cluster with two of the three nodes initialized as contact points" << std::endl;
+    // Create a single node cluster with two nodes initialized as contact points
+    std::cout
+        << "Create single node cluster with two of the three nodes initialized as contact points"
+        << std::endl;
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster()) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 2);
 
-    //Add two nodes
+    // Add two nodes
     ccm->bootstrap_node();
     ccm->bootstrap_node();
 
-    //Create session
+    // Create session
     test_utils::create_session(cluster.get());
     ccm->remove_cluster();
   }
   BOOST_CHECK(test_utils::CassLog::message_count() == 1);
 
-
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
   {
-    //Create a single node cluster with one node initialized as contact points
-    std::cout << "Create single node cluster with one of the three nodes initialized as contact points" << std::endl;
+    // Create a single node cluster with one node initialized as contact points
+    std::cout
+        << "Create single node cluster with one of the three nodes initialized as contact points"
+        << std::endl;
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster()) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 1);
 
-    //Add two nodes
+    // Add two nodes
     ccm->bootstrap_node();
     ccm->bootstrap_node();
 
-    //Create session
+    // Create session
     test_utils::create_session(cluster.get());
     ccm->remove_cluster();
   }
@@ -264,18 +265,19 @@ BOOST_AUTO_TEST_CASE(add_nodes_connect) {
 
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
   {
-    //Create a two node cluster with three nodes initialized as contact points
-    std::cout << "Create two node cluster with all three of the nodes initialized as contact points" << std::endl;
+    // Create a two node cluster with three nodes initialized as contact points
+    std::cout << "Create two node cluster with all three of the nodes initialized as contact points"
+              << std::endl;
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster(2)) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 3);
 
-    //Add one nodes
+    // Add one nodes
     ccm->bootstrap_node();
 
-    //Create session
+    // Create session
     test_utils::create_session(cluster.get());
     ccm->remove_cluster();
   }
@@ -283,18 +285,19 @@ BOOST_AUTO_TEST_CASE(add_nodes_connect) {
 
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
   {
-    //Create a two node cluster with two nodes initialized as contact points
-    std::cout << "Create two node cluster with two of the three nodes initialized as contact points" << std::endl;
+    // Create a two node cluster with two nodes initialized as contact points
+    std::cout << "Create two node cluster with two of the three nodes initialized as contact points"
+              << std::endl;
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster(2)) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 2);
 
-    //Add one nodes
+    // Add one nodes
     ccm->bootstrap_node();
 
-    //Create session
+    // Create session
     test_utils::create_session(cluster.get());
     ccm->remove_cluster();
   }
@@ -321,13 +324,11 @@ struct SessionContainer {
   const CassCluster* cluster;
 
   SessionContainer(const CassCluster* cluster)
-    : cluster(cluster) {
+      : cluster(cluster) {
     BOOST_REQUIRE(uv_rwlock_init(&sessions_lock) == 0);
   }
 
-  ~SessionContainer() {
-    uv_rwlock_destroy(&sessions_lock);
-  }
+  ~SessionContainer() { uv_rwlock_destroy(&sessions_lock); }
 
   /**
    * Add a session to the container
@@ -354,10 +355,10 @@ struct SessionContainer {
 };
 
 /**
-* Open a session and add it to the list of sessions opened
-*
-* @param arg Session container to add session
-*/
+ * Open a session and add it to the list of sessions opened
+ *
+ * @param arg Session container to add session
+ */
 static void open_session(void* arg) {
   SessionContainer* sessions = static_cast<SessionContainer*>(arg);
   test_utils::CassSessionPtr session(cass_session_new());
@@ -374,8 +375,9 @@ static void open_session(void* arg) {
  * @param num_of_sessions Number of sessions to create concurrently
  * @param is_concurrently True if concurrent; false otherwise
  */
-void open_sessions(SessionContainer* sessions, unsigned int num_of_sessions, bool is_concurrently = true) {
-  //Create session threads
+void open_sessions(SessionContainer* sessions, unsigned int num_of_sessions,
+                   bool is_concurrently = true) {
+  // Create session threads
   std::vector<uv_thread_t> threads(num_of_sessions);
   for (unsigned int n = 0; n < num_of_sessions; ++n) {
     if (is_concurrently) {
@@ -385,14 +387,14 @@ void open_sessions(SessionContainer* sessions, unsigned int num_of_sessions, boo
     }
   }
 
-  //Ensure all threads have completed
+  // Ensure all threads have completed
   if (is_concurrently) {
     for (unsigned int n = 0; n < num_of_sessions; ++n) {
       uv_thread_join(&threads[n]);
     }
   }
 
-  //TODO: Remove sleep and create a timed wait for log messages (no boost)
+  // TODO: Remove sleep and create a timed wait for log messages (no boost)
   for (unsigned int n = 0; n < (SESSION_STRESS_NUMBER_OF_ITERATIONS * 20); ++n) {
     if (static_cast<unsigned int>(test_utils::CassLog::message_count()) != num_of_sessions) {
       boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
@@ -419,18 +421,20 @@ static void close_session(void* session) {
  * @param num_of_sessions Number of sessions to close concurrently
  * @param is_concurrently True if concurrent; false otherwise
  */
-void close_sessions(SessionContainer* sessions, unsigned int num_of_sessions, bool is_concurrently = true) {
-  //Close session threads (LIFO)
+void close_sessions(SessionContainer* sessions, unsigned int num_of_sessions,
+                    bool is_concurrently = true) {
+  // Close session threads (LIFO)
   std::vector<uv_thread_t> threads(num_of_sessions);
   for (unsigned int n = 0; n < num_of_sessions; ++n) {
     if (is_concurrently) {
-      uv_thread_create(&threads[n], close_session, sessions->sessions[sessions->count() - n - 1].get());
+      uv_thread_create(&threads[n], close_session,
+                       sessions->sessions[sessions->count() - n - 1].get());
     } else {
       close_session(sessions->sessions[sessions->count() - n - 1].get());
     }
   }
 
-  //Ensure all threads have completed
+  // Ensure all threads have completed
   if (is_concurrently) {
     for (unsigned int n = 0; n < num_of_sessions; ++n) {
       uv_thread_join(&threads[n]);
@@ -439,7 +443,7 @@ void close_sessions(SessionContainer* sessions, unsigned int num_of_sessions, bo
 
   sessions->sessions.clear();
 
-  //TODO: Remove sleep and create a timed wait for log messages (no boost)
+  // TODO: Remove sleep and create a timed wait for log messages (no boost)
   for (unsigned int n = 0; n < (SESSION_STRESS_NUMBER_OF_ITERATIONS * 20); ++n) {
     if (static_cast<unsigned int>(test_utils::CassLog::message_count()) != num_of_sessions) {
       boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
@@ -451,8 +455,8 @@ void close_sessions(SessionContainer* sessions, unsigned int num_of_sessions, bo
 
 struct QuerySession {
   QuerySession(CassSession* session = NULL)
-    : session(session)
-    , error_code(CASS_OK) {}
+      : session(session)
+      , error_code(CASS_OK) {}
   CassSession* session;
   CassError error_code;
 };
@@ -464,11 +468,9 @@ struct QuerySession {
  */
 static void query_session(void* arg) {
   QuerySession* query = static_cast<QuerySession*>(arg);
-  query->error_code = test_utils::execute_query_with_error(query->session,
-                                                           test_utils::SELECT_VERSION,
-                                                           NULL,
-                                                           CASS_CONSISTENCY_ONE,
-                                                           20 * test_utils::ONE_SECOND_IN_MICROS);
+  query->error_code = test_utils::execute_query_with_error(
+      query->session, test_utils::SELECT_VERSION, NULL, CASS_CONSISTENCY_ONE,
+      20 * test_utils::ONE_SECOND_IN_MICROS);
 }
 
 /**
@@ -477,13 +479,14 @@ static void query_session(void* arg) {
  * @param sessions Session container for closing sessions
  */
 void query_sessions(const SessionContainer& sessions) {
-  //Query session in multiple threads
+  // Query session in multiple threads
   unsigned int thread_count = sessions.count() * SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS;
 
   std::vector<uv_thread_t> threads(thread_count);
   std::vector<QuerySession> queries;
 
-  for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS; ++iterations) {
+  for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_SHARED_SESSION_THREADS;
+       ++iterations) {
     for (unsigned int n = 0; n < sessions.count(); ++n) {
       int thread_index = (sessions.count() * iterations) + n;
       QuerySession query = QuerySession(sessions.sessions[n].get());
@@ -492,27 +495,30 @@ void query_sessions(const SessionContainer& sessions) {
     }
   }
 
-  //Ensure all threads have completed
+  // Ensure all threads have completed
   for (unsigned int n = 0; n < thread_count; ++n) {
     uv_thread_join(&threads[n]);
   }
 
   int no_host_count = 0;
   for (unsigned int n = 0; n < thread_count; ++n) {
-    //Timeouts are OK (especially on the minor chaos test)
+    // Timeouts are OK (especially on the minor chaos test)
     CassError error_code = queries[n].error_code;
     if (error_code != CASS_OK && error_code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) {
       if (error_code == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE) {
         ++no_host_count;
       } else {
-        BOOST_FAIL("Error occurred during query '" << std::string(cass_error_desc(error_code)) << "' [" << error_code << "]");
+        BOOST_FAIL("Error occurred during query '" << std::string(cass_error_desc(error_code))
+                                                   << "' [" << error_code << "]");
       }
     }
   }
 
   // Ensure that some hosts were available (chaos)
   if (no_host_count > SESSION_STRESS_NUMBER_OF_ALLOWED_NO_HOST_AVAILABLE_OCCURRENCES) {
-    BOOST_FAIL("Unacceptable Limit of CASS_ERROR_LIB_NO_HOSTS_AVAILABLE Occurred: " << no_host_count << " > " << SESSION_STRESS_NUMBER_OF_ALLOWED_NO_HOST_AVAILABLE_OCCURRENCES);
+    BOOST_FAIL("Unacceptable Limit of CASS_ERROR_LIB_NO_HOSTS_AVAILABLE Occurred: "
+               << no_host_count << " > "
+               << SESSION_STRESS_NUMBER_OF_ALLOWED_NO_HOST_AVAILABLE_OCCURRENCES);
   }
 }
 
@@ -521,7 +527,7 @@ void query_sessions(const SessionContainer& sessions) {
  *
  * @param ccm CCM bridge pointer
  */
-static void minor_chaos(void *ccm) {
+static void minor_chaos(void* ccm) {
   CCM::Bridge* ccm_ptr = static_cast<CCM::Bridge*>(ccm);
   ccm_ptr->kill_node(1);
   ccm_ptr->force_decommission_node(2);
@@ -539,15 +545,15 @@ static void minor_chaos(void *ccm) {
  *   <li>Open and close multiple session SESSION_STRESS_NUMBER_OF_ITERATIONS times</li>
  *   <ol>
  *     <li>Open SESSION_STRESS_NUMBER_OF_SESSIONS {@code Session} concurrently</li>
- *     <li>Verify that SESSION_STRESS_NUMBER_OF_SESSIONS sessions are reported as open by the {@code Session}</li>
- *     <li>Close SESSION_STRESS_NUMBER_OF_SESSIONS {@code Session} concurrently</li>
- *     <li>Verify that SESSION_STRESS_NUMBER_OF_SESSIONS sessions are reported as close by the {@code Session}</li>
+ *     <li>Verify that SESSION_STRESS_NUMBER_OF_SESSIONS sessions are reported as open by the {@code
+ * Session}</li> <li>Close SESSION_STRESS_NUMBER_OF_SESSIONS {@code Session} concurrently</li>
+ *     <li>Verify that SESSION_STRESS_NUMBER_OF_SESSIONS sessions are reported as close by the
+ * {@code Session}</li>
  *   </ol>
- *   <li>Open multiple sessions [SESSION_STRESS_NUMBER_OF_SESSIONS / 4] and perform query operations sharing sessions on multiple threads</li>
- *   <li>Open multiple sessions [SESSION_STRESS_NUMBER_OF_SESSIONS / 4] and perform query operations sharing sessions on multiple threads with minor chaos</li>
- *   <ol>
- *     <li>Kill one node</li>
- *     <li>Disable gossip on another node</li>
+ *   <li>Open multiple sessions [SESSION_STRESS_NUMBER_OF_SESSIONS / 4] and perform query operations
+ * sharing sessions on multiple threads</li> <li>Open multiple sessions
+ * [SESSION_STRESS_NUMBER_OF_SESSIONS / 4] and perform query operations sharing sessions on multiple
+ * threads with minor chaos</li> <ol> <li>Kill one node</li> <li>Disable gossip on another node</li>
  *     <li>Restart killed node</li>
  *     <li>Decommission third node</li>
  *   </ol>
@@ -557,24 +563,24 @@ static void minor_chaos(void *ccm) {
  * @test_category sessions:stress
  * @jira_ticket CPP-157 [https://datastax-oss.atlassian.net/browse/CPP-157]
  */
-BOOST_AUTO_TEST_CASE(stress)
-{
-  //Initialize the logger with the opened log message
+BOOST_AUTO_TEST_CASE(stress) {
+  // Initialize the logger with the opened log message
   test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
 
   {
-    //Create a single node cluster
-    test_utils::CassLog::set_output_log_level(CASS_LOG_DISABLED); //Quiet the logger output
+    // Create a single node cluster
+    test_utils::CassLog::set_output_log_level(CASS_LOG_DISABLED); // Quiet the logger output
     test_utils::CassClusterPtr cluster(cass_cluster_new());
     if (ccm->create_cluster()) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 1);
 
-    //Open and close sessions sequentially
+    // Open and close sessions sequentially
     SessionContainer sessions(cluster.get());
     std::cout << "Sequential" << std::endl;
-    for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_ITERATIONS; ++iterations) {
+    for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_ITERATIONS;
+         ++iterations) {
       open_sessions(&sessions, SESSION_STRESS_NUMBER_OF_SESSIONS, false);
       BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), SESSION_STRESS_NUMBER_OF_SESSIONS);
       BOOST_CHECK_EQUAL(sessions.count(), SESSION_STRESS_NUMBER_OF_SESSIONS);
@@ -585,9 +591,10 @@ BOOST_AUTO_TEST_CASE(stress)
       BOOST_CHECK_EQUAL(sessions.count(), 0);
     }
 
-    //Open and close sessions concurrently in sequence
+    // Open and close sessions concurrently in sequence
     std::cout << "Concurrently in Sequence" << std::endl;
-    for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_ITERATIONS; ++iterations) {
+    for (unsigned int iterations = 0; iterations < SESSION_STRESS_NUMBER_OF_ITERATIONS;
+         ++iterations) {
       test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
       open_sessions(&sessions, SESSION_STRESS_NUMBER_OF_SESSIONS);
       BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), SESSION_STRESS_NUMBER_OF_SESSIONS);
@@ -599,7 +606,7 @@ BOOST_AUTO_TEST_CASE(stress)
       BOOST_CHECK_EQUAL(sessions.count(), 0);
     }
 
-    //Perform query operations between threads using sessions (1/4 sessions)
+    // Perform query operations between threads using sessions (1/4 sessions)
     std::cout << "Query sessions across multiple threads" << std::endl;
     unsigned int quarter_sessions = SESSION_STRESS_NUMBER_OF_SESSIONS / 4;
     for (unsigned int n = 0; n < quarter_sessions; ++n) {
@@ -608,7 +615,7 @@ BOOST_AUTO_TEST_CASE(stress)
       BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), quarter_sessions);
       BOOST_CHECK_EQUAL(sessions.count(), quarter_sessions);
 
-      //Query sessions over multiple threads
+      // Query sessions over multiple threads
       query_sessions(sessions);
 
       test_utils::CassLog::reset(SESSION_STRESS_CLOSED_LOG_MESSAGE);
@@ -617,32 +624,34 @@ BOOST_AUTO_TEST_CASE(stress)
       BOOST_CHECK_EQUAL(sessions.count(), 0);
     }
 
-    //Perform query operations between threads using sessions; with chaos
+    // Perform query operations between threads using sessions; with chaos
     if (ccm->create_cluster(3)) {
       ccm->start_cluster();
     }
     test_utils::initialize_contact_points(cluster.get(), ccm->get_ip_prefix(), 3);
 
-    //Create sessions
+    // Create sessions
     test_utils::CassLog::reset(SESSION_STRESS_OPENED_LOG_MESSAGE);
     cass_cluster_set_num_threads_io(cluster.get(), 2);
     open_sessions(&sessions, (SESSION_STRESS_NUMBER_OF_SESSIONS / 4), false);
-    BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), (SESSION_STRESS_NUMBER_OF_SESSIONS / 4));
+    BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(),
+                      (SESSION_STRESS_NUMBER_OF_SESSIONS / 4));
     BOOST_CHECK_EQUAL(sessions.count(), (SESSION_STRESS_NUMBER_OF_SESSIONS / 4));
 
-    //Query sessions over multiple threads
+    // Query sessions over multiple threads
     uv_thread_t chaos_thread;
     uv_thread_create(&chaos_thread, minor_chaos, ccm.get());
-    //Do many of these so minor chaos can complete
+    // Do many of these so minor chaos can complete
     for (unsigned int queries = 0; queries < SESSION_STRESS_CHAOS_NUMBER_OF_ITERATIONS; ++queries) {
       query_sessions(sessions);
     }
     uv_thread_join(&chaos_thread);
 
-    //Close sessions
+    // Close sessions
     test_utils::CassLog::reset(SESSION_STRESS_CLOSED_LOG_MESSAGE);
     close_sessions(&sessions, (SESSION_STRESS_NUMBER_OF_SESSIONS / 4), false);
-    BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(), (SESSION_STRESS_NUMBER_OF_SESSIONS / 4));
+    BOOST_CHECK_EQUAL(test_utils::CassLog::message_count(),
+                      (SESSION_STRESS_NUMBER_OF_SESSIONS / 4));
     BOOST_CHECK_EQUAL(sessions.count(), 0);
     ccm->remove_cluster();
   }
diff --git a/test/integration_tests/src/test_set_keyspace.cpp b/test/integration_tests/src/test_set_keyspace.cpp
index a6cbc1fe1..3f95a3550 100644
--- a/test/integration_tests/src/test_set_keyspace.cpp
+++ b/test/integration_tests/src/test_set_keyspace.cpp
@@ -18,10 +18,10 @@
 #include <map>
 #include <string>
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include "cassandra.h"
 #include "constants.hpp"
@@ -36,15 +36,13 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
    * keyspace is be use for the queries instead of the session keyspace
    */
   SetKeyspaceTests()
-    : SingleSessionTest(1, 0)
-    , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen)))
-    , keyspace2(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen)))  {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace
-                                           % "1"));
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % keyspace2
-                                           % "1"));
+      : SingleSessionTest(1, 0)
+      , keyspace(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen)))
+      , keyspace2(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace % "1"));
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace2 % "1"));
     create_table();
     cass_cluster_set_use_beta_protocol_version(cluster, cass_true);
   }
@@ -53,18 +51,19 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
    * Create table schema.
    */
   void create_table() {
-    test_utils::execute_query(session, str(boost::format("CREATE TABLE %s.test (k text PRIMARY KEY, v text)")
-                                           % keyspace2));
-    test_utils::execute_query(session, str(boost::format("INSERT INTO %s.test (k, v) VALUES ('key1', 'value1')")
-                                           % keyspace2));
+    test_utils::execute_query(
+        session,
+        str(boost::format("CREATE TABLE %s.test (k text PRIMARY KEY, v text)") % keyspace2));
+    test_utils::execute_query(
+        session,
+        str(boost::format("INSERT INTO %s.test (k, v) VALUES ('key1', 'value1')") % keyspace2));
   }
 
   /**
    * Drop table schema.
    */
   void drop_table() {
-    test_utils::execute_query(session, str(boost::format("DROP TABLE %s.test")
-                                           % keyspace2));
+    test_utils::execute_query(session, str(boost::format("DROP TABLE %s.test") % keyspace2));
   }
 
   /**
@@ -80,11 +79,13 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
       test_utils::execute_query(session.get(), str(boost::format("USE %s") % session_keyspace));
     }
 
-    test_utils::CassStatementPtr statement(cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
+    test_utils::CassStatementPtr statement(
+        cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
 
     cass_statement_set_keyspace(statement.get(), keyspace2.c_str());
 
-    validate_query_result(test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
+    validate_query_result(
+        test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
   }
 
   /**
@@ -100,9 +101,11 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
       test_utils::execute_query(session.get(), str(boost::format("USE %s") % session_keyspace));
     }
 
-    test_utils::CassStatementPtr statement(prepare(session, "SELECT v FROM test WHERE k = 'key1'", keyspace2));
+    test_utils::CassStatementPtr statement(
+        prepare(session, "SELECT v FROM test WHERE k = 'key1'", keyspace2));
 
-    validate_query_result(test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
+    validate_query_result(
+        test_utils::CassFuturePtr(cass_session_execute(session.get(), statement.get())));
   }
 
   /**
@@ -115,8 +118,10 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
   void batch_query_with_keyspace(const std::string& session_keyspace) {
     test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-    test_utils::CassStatementPtr statement1(cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
-    test_utils::CassStatementPtr statement2(cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
+    test_utils::CassStatementPtr statement1(
+        cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
+    test_utils::CassStatementPtr statement2(
+        cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
 
     test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
 
@@ -139,8 +144,7 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
    * @param keyspace  The keyspace used to prepare the query (optional)
    * @return A bound statement for the prepared query
    */
-  test_utils::CassStatementPtr prepare(test_utils::CassSessionPtr session,
-                                       const std::string& query,
+  test_utils::CassStatementPtr prepare(test_utils::CassSessionPtr session, const std::string& query,
                                        const std::string& keyspace = std::string()) {
     test_utils::CassStatementPtr existing_statement(cass_statement_new(query.c_str(), 0));
 
@@ -148,7 +152,8 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
       cass_statement_set_keyspace(existing_statement.get(), keyspace.c_str());
     }
 
-    test_utils::CassFuturePtr future(cass_session_prepare_from_existing(session.get(), existing_statement.get()));
+    test_utils::CassFuturePtr future(
+        cass_session_prepare_from_existing(session.get(), existing_statement.get()));
     BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
 
     test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get()));
@@ -179,7 +184,8 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
 
     const char* value;
     size_t value_length;
-    BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &value, &value_length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &value, &value_length),
+                        CASS_OK);
     BOOST_CHECK_EQUAL(std::string(value, value_length), "value1");
   }
 
@@ -188,7 +194,8 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
    */
   void validate_batch_results() {
     test_utils::CassResultPtr result;
-    test_utils::execute_query(session, str(boost::format("SELECT k, v FROM %s.test") % keyspace2), &result);
+    test_utils::execute_query(session, str(boost::format("SELECT k, v FROM %s.test") % keyspace2),
+                              &result);
     BOOST_REQUIRE(result);
 
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 3u);
@@ -207,11 +214,13 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
 
       const char* key;
       size_t key_length;
-      BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &key, &key_length), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 0), &key, &key_length),
+                          CASS_OK);
 
       const char* value;
       size_t value_length;
-      BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 1), &value, &value_length), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_value_get_string(cass_row_get_column(row, 1), &value, &value_length),
+                          CASS_OK);
 
       actual[std::string(key, key_length)] = std::string(value, value_length);
     }
@@ -228,7 +237,6 @@ struct SetKeyspaceTests : public test_utils::SingleSessionTest {
    * Statement keyspace
    */
   std::string keyspace2;
-
 };
 
 BOOST_FIXTURE_TEST_SUITE(set_keyspace, SetKeyspaceTests)
@@ -246,7 +254,8 @@ BOOST_AUTO_TEST_CASE(query_not_supported_by_older_protocol) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement(cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
+  test_utils::CassStatementPtr statement(
+      cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
 
   // Attempt to set the keyspace with an older protocol
   cass_statement_set_keyspace(statement.get(), keyspace2.c_str());
@@ -308,12 +317,14 @@ BOOST_AUTO_TEST_CASE(prepared_not_supported_by_older_protocol) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement(cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
+  test_utils::CassStatementPtr statement(
+      cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
 
   // Attempt to set the keyspace with an older protocol
   cass_statement_set_keyspace(statement.get(), keyspace2.c_str());
 
-  test_utils::CassFuturePtr future(cass_session_prepare_from_existing(session.get(), statement.get()));
+  test_utils::CassFuturePtr future(
+      cass_session_prepare_from_existing(session.get(), statement.get()));
   BOOST_CHECK_EQUAL(cass_future_error_code(future.get()), CASS_ERROR_SERVER_INVALID_QUERY);
 }
 
@@ -330,19 +341,22 @@ BOOST_AUTO_TEST_CASE(prepared_should_reprepare_with_the_same_keyspace) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement(cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
+  test_utils::CassStatementPtr statement(
+      cass_statement_new("SELECT v FROM test WHERE k = 'key1'", 0));
 
   // Attempt to set the keyspace with an older protocol
   cass_statement_set_keyspace(statement.get(), keyspace2.c_str());
 
-  test_utils::CassFuturePtr future(cass_session_prepare_from_existing(session.get(), statement.get()));
+  test_utils::CassFuturePtr future(
+      cass_session_prepare_from_existing(session.get(), statement.get()));
   BOOST_CHECK_EQUAL(cass_future_error_code(future.get()), CASS_OK);
 
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get()));
   BOOST_CHECK(prepared);
 
   // Force the statement to be reprepared
-  test_utils::execute_query(session.get(), "TRUNCATE system.prepared_statements"); // Required for 3.10+ (CASSANDRA-8831)
+  test_utils::execute_query(
+      session.get(), "TRUNCATE system.prepared_statements"); // Required for 3.10+ (CASSANDRA-8831)
   drop_table();
   create_table();
 
@@ -350,7 +364,8 @@ BOOST_AUTO_TEST_CASE(prepared_should_reprepare_with_the_same_keyspace) {
   test_utils::CassStatementPtr bound_statement(cass_prepared_bind(prepared.get()));
   BOOST_CHECK(bound_statement);
 
-  validate_query_result(test_utils::CassFuturePtr(cass_session_execute(session.get(), bound_statement.get())));
+  validate_query_result(
+      test_utils::CassFuturePtr(cass_session_execute(session.get(), bound_statement.get())));
 }
 
 /**
@@ -405,8 +420,10 @@ BOOST_AUTO_TEST_CASE(batch_with_keyspace_from_simple_statement) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement1(cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
-  test_utils::CassStatementPtr statement2(cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
+  test_utils::CassStatementPtr statement1(
+      cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
+  test_utils::CassStatementPtr statement2(
+      cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
 
   // The batch should get the keyspace from the second statement
   cass_statement_set_keyspace(statement2.get(), keyspace2.c_str());
@@ -435,10 +452,12 @@ BOOST_AUTO_TEST_CASE(batch_with_keyspace_from_prepared) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement1(cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
+  test_utils::CassStatementPtr statement1(
+      cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
 
   // The batch should get the keyspace from the second statement
-  test_utils::CassStatementPtr statement2(prepare(session, "INSERT INTO test (k, v) VALUES ('key3', 'value3')", keyspace2));
+  test_utils::CassStatementPtr statement2(
+      prepare(session, "INSERT INTO test (k, v) VALUES ('key3', 'value3')", keyspace2));
 
   test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
 
@@ -464,8 +483,10 @@ BOOST_AUTO_TEST_CASE(batch_not_supported_by_older_protocol) {
 
   test_utils::CassSessionPtr session(test_utils::create_session(cluster));
 
-  test_utils::CassStatementPtr statement1(cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
-  test_utils::CassStatementPtr statement2(cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
+  test_utils::CassStatementPtr statement1(
+      cass_statement_new("INSERT INTO test (k, v) VALUES ('key2', 'value2')", 0));
+  test_utils::CassStatementPtr statement2(
+      cass_statement_new("INSERT INTO test (k, v) VALUES ('key3', 'value3')", 0));
 
   test_utils::CassBatchPtr batch(cass_batch_new(CASS_BATCH_TYPE_LOGGED));
 
diff --git a/test/integration_tests/src/test_speculative_execution_policy.cpp b/test/integration_tests/src/test_speculative_execution_policy.cpp
index 909caa845..d357af14d 100644
--- a/test/integration_tests/src/test_speculative_execution_policy.cpp
+++ b/test/integration_tests/src/test_speculative_execution_policy.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include "request_handler.hpp"
 #include "statement.hpp"
@@ -29,15 +29,18 @@
 #define SPEC_EX_TABLE_FORMAT "CREATE TABLE %s.%s (key int PRIMARY KEY, value int)"
 #define SPEC_EX_INSERT_FORMAT "INSERT INTO %s.%s (key, value) VALUES (%d, %d)"
 #define SPEC_EX_SELECT_FORMAT "SELECT timeout(value) FROM %s.%s WHERE key=%d"
-#define SPEC_EX_TIMEOUT_UDF_FORMAT "CREATE OR REPLACE FUNCTION %s.timeout(arg int) " \
+#define SPEC_EX_TIMEOUT_UDF_FORMAT                        \
+  "CREATE OR REPLACE FUNCTION %s.timeout(arg int) "       \
   "RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java " \
-  "AS $$ long start = System.currentTimeMillis(); " \
-    "while(System.currentTimeMillis() - start < arg) {" \
-      ";;" \
-    "}" \
-  "return arg;" \
+  "AS $$ long start = System.currentTimeMillis(); "       \
+  "while(System.currentTimeMillis() - start < arg) {"     \
+  ";;"                                                    \
+  "}"                                                     \
+  "return arg;"                                           \
   "$$;"
 
+using namespace datastax::internal::core;
+
 /**
  * Speculative Execution Policy Integration Test Class
  *
@@ -47,17 +50,15 @@
  */
 struct TestSpeculativeExecutionPolicy : public test_utils::SingleSessionTest {
   TestSpeculativeExecutionPolicy()
-    : SingleSessionTest(3, 0, false)
-    , keyspace_("speculative_execution_policy")
-    , test_name_(boost::unit_test::framework::current_test_case().p_name) {
-  }
+      : SingleSessionTest(3, 0, false)
+      , keyspace_("speculative_execution_policy")
+      , test_name_(boost::unit_test::framework::current_test_case().p_name) {}
 
   ~TestSpeculativeExecutionPolicy() {
     // Drop the keyspace in between each test execution
     if (session) {
-      test_utils::execute_query(session, str(boost::format(
-        test_utils::DROP_KEYSPACE_IF_EXISTS_FORMAT)
-        % keyspace_));
+      test_utils::execute_query(
+          session, str(boost::format(test_utils::DROP_KEYSPACE_IF_EXISTS_FORMAT) % keyspace_));
     }
   }
 
@@ -69,20 +70,13 @@ struct TestSpeculativeExecutionPolicy : public test_utils::SingleSessionTest {
   void initialize() {
     cass_cluster_set_use_beta_protocol_version(cluster, cass_false);
     create_session();
-    test_utils::execute_query(session, str(boost::format(
-      test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-        % keyspace_
-        % "3"));
-    test_utils::execute_query(session, str(boost::format(SPEC_EX_TABLE_FORMAT)
-      % keyspace_
-      % test_name_));
-    test_utils::execute_query(session, str(boost::format(SPEC_EX_INSERT_FORMAT)
-      % keyspace_
-      % test_name_
-      % 0
-      % 1000));
-    test_utils::execute_query(session, str(boost::format(SPEC_EX_TIMEOUT_UDF_FORMAT)
-      % keyspace_));
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace_ % "3"));
+    test_utils::execute_query(session,
+                              str(boost::format(SPEC_EX_TABLE_FORMAT) % keyspace_ % test_name_));
+    test_utils::execute_query(
+        session, str(boost::format(SPEC_EX_INSERT_FORMAT) % keyspace_ % test_name_ % 0 % 1000));
+    test_utils::execute_query(session, str(boost::format(SPEC_EX_TIMEOUT_UDF_FORMAT) % keyspace_));
   }
 
   /**
@@ -97,18 +91,14 @@ struct TestSpeculativeExecutionPolicy : public test_utils::SingleSessionTest {
    *                            (DEFAULT: CASS_OK)
    * @return The future used during executing the query
    */
-  test_utils::CassFuturePtr query(bool is_idempotent,
-    cass_uint64_t timeout_ms = 30000, CassError expected_error_code = CASS_OK) {
+  test_utils::CassFuturePtr query(bool is_idempotent, cass_uint64_t timeout_ms = 30000,
+                                  CassError expected_error_code = CASS_OK) {
     // Create and execute the statement that will utilize the timeout UDF
-    std::string query = str(boost::format(SPEC_EX_SELECT_FORMAT)
-      % keyspace_
-      % test_name_
-      % 0);
+    std::string query = str(boost::format(SPEC_EX_SELECT_FORMAT) % keyspace_ % test_name_ % 0);
     test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
-    cass_statement_set_is_idempotent(statement.get(),
-      (is_idempotent ? cass_true : cass_false));
+    cass_statement_set_is_idempotent(statement.get(), (is_idempotent ? cass_true : cass_false));
     cass_statement_set_request_timeout(statement.get(), timeout_ms);
-    cass::Statement* native_statement = static_cast<cass::Statement*>(statement.get());
+    Statement* native_statement = static_cast<Statement*>(statement.get());
     native_statement->set_record_attempted_addresses(true);
     test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
     if (expected_error_code == CASS_OK) {
@@ -130,12 +120,12 @@ struct TestSpeculativeExecutionPolicy : public test_utils::SingleSessionTest {
   std::vector<std::string> attempted_hosts(test_utils::CassFuturePtr future) {
     // Gather and return the attempted hosts from the response
     std::vector<std::string> attempted_hosts;
-    cass::Future* native_future = static_cast<cass::Future*>(future.get());
-    if (native_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      cass::ResponseFuture* native_response_future = static_cast<cass::ResponseFuture*>(native_future);
-      cass::AddressVec attempted_addresses = native_response_future->attempted_addresses();
-      for (cass::AddressVec::iterator iterator = attempted_addresses.begin();
-        iterator != attempted_addresses.end(); ++iterator) {
+    Future* native_future = static_cast<Future*>(future.get());
+    if (native_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      ResponseFuture* native_response_future = static_cast<ResponseFuture*>(native_future);
+      AddressVec attempted_addresses = native_response_future->attempted_addresses();
+      for (AddressVec::iterator iterator = attempted_addresses.begin();
+           iterator != attempted_addresses.end(); ++iterator) {
         attempted_hosts.push_back(iterator->to_string().c_str());
       }
       std::sort(attempted_hosts.begin(), attempted_hosts.end());
@@ -151,9 +141,9 @@ struct TestSpeculativeExecutionPolicy : public test_utils::SingleSessionTest {
    */
   std::string executed_host(test_utils::CassFuturePtr future) {
     std::string host;
-    cass::Future* native_future = static_cast<cass::Future*>(future.get());
-    if (native_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      cass::ResponseFuture* native_response_future = static_cast<cass::ResponseFuture*>(native_future);
+    Future* native_future = static_cast<Future*>(future.get());
+    if (native_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      ResponseFuture* native_response_future = static_cast<ResponseFuture*>(native_future);
       host = native_response_future->address().to_string().c_str();
     }
     return host;
@@ -187,13 +177,12 @@ BOOST_AUTO_TEST_CASE(execute_on_all_nodes) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
     TestSpeculativeExecutionPolicy tester;
-    cass_cluster_set_constant_speculative_execution_policy(tester.cluster,
-      100, 20);
+    cass_cluster_set_constant_speculative_execution_policy(tester.cluster, 100, 20);
     tester.initialize();
 
     // Execute a query and ensure all hosts are attempted
@@ -206,8 +195,8 @@ BOOST_AUTO_TEST_CASE(execute_on_all_nodes) {
       BOOST_REQUIRE_EQUAL(expected_host.str(), attempted_hosts.at(n));
     }
     std::string executed_host = tester.executed_host(future);
-    std::vector<std::string>::iterator iterator = std::find(
-      attempted_hosts.begin(), attempted_hosts.end(), executed_host);
+    std::vector<std::string>::iterator iterator =
+        std::find(attempted_hosts.begin(), attempted_hosts.end(), executed_host);
     BOOST_REQUIRE(iterator != attempted_hosts.end());
 
     // Ok, this is lame. We have the response from our request, but there
@@ -259,13 +248,12 @@ BOOST_AUTO_TEST_CASE(execute_one_node_idempotent) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
     TestSpeculativeExecutionPolicy tester;
-    cass_cluster_set_constant_speculative_execution_policy(tester.cluster,
-      5000, 20);
+    cass_cluster_set_constant_speculative_execution_policy(tester.cluster, 5000, 20);
     tester.initialize();
 
     // Execute a query and ensure one host is attempted (non-idempotent)
@@ -302,13 +290,12 @@ BOOST_AUTO_TEST_CASE(execute_one_node_non_idempotent) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
     TestSpeculativeExecutionPolicy tester;
-    cass_cluster_set_constant_speculative_execution_policy(tester.cluster,
-      100, 20);
+    cass_cluster_set_constant_speculative_execution_policy(tester.cluster, 100, 20);
     tester.initialize();
 
     // Execute a query and ensure one host is attempted (non-idempotent)
@@ -343,13 +330,12 @@ BOOST_AUTO_TEST_CASE(attempt_two_nodes) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
     TestSpeculativeExecutionPolicy tester;
-    cass_cluster_set_constant_speculative_execution_policy(tester.cluster,
-      100, 1);
+    cass_cluster_set_constant_speculative_execution_policy(tester.cluster, 100, 1);
     tester.initialize();
 
     // Execute a query and ensure two hosts are attempted
@@ -357,8 +343,8 @@ BOOST_AUTO_TEST_CASE(attempt_two_nodes) {
     std::vector<std::string> attempted_hosts = tester.attempted_hosts(future);
     BOOST_REQUIRE_EQUAL(2, attempted_hosts.size());
     std::string executed_host = tester.executed_host(future);
-    std::vector<std::string>::iterator iterator = std::find(
-      attempted_hosts.begin(), attempted_hosts.end(), executed_host);
+    std::vector<std::string>::iterator iterator =
+        std::find(attempted_hosts.begin(), attempted_hosts.end(), executed_host);
     BOOST_REQUIRE(iterator != attempted_hosts.end());
 
     // Ok, this is lame. We have the response from our request, but there
@@ -393,7 +379,7 @@ BOOST_AUTO_TEST_CASE(without_speculative_execution_policy) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
@@ -431,18 +417,16 @@ BOOST_AUTO_TEST_CASE(execute_on_all_nodes_with_timeout) {
   CCM::CassVersion version = test_utils::get_version();
   if (version < "2.2.0") {
     std::cout << "Speculative Execution Test Requires UDF Functionality: Cassandra v"
-      << version.to_string() << " does not support UDFs" << std::endl;
+              << version.to_string() << " does not support UDFs" << std::endl;
     BOOST_REQUIRE(true);
   } else {
     // Create the session and initialize the server
     TestSpeculativeExecutionPolicy tester;
-    cass_cluster_set_constant_speculative_execution_policy(tester.cluster,
-      100, 20);
+    cass_cluster_set_constant_speculative_execution_policy(tester.cluster, 100, 20);
     tester.initialize();
 
     // Execute a query and ensure all nodes are tested and timeout occurs
-    test_utils::CassFuturePtr future = tester.query(true, 300,
-      CASS_ERROR_LIB_REQUEST_TIMED_OUT);
+    test_utils::CassFuturePtr future = tester.query(true, 300, CASS_ERROR_LIB_REQUEST_TIMED_OUT);
     std::vector<std::string> attempted_hosts = tester.attempted_hosts(future);
     BOOST_REQUIRE_EQUAL(3, attempted_hosts.size());
 
diff --git a/test/integration_tests/src/test_ssl.cpp b/test/integration_tests/src/test_ssl.cpp
index 5385fdbb3..1722ed2c0 100644
--- a/test/integration_tests/src/test_ssl.cpp
+++ b/test/integration_tests/src/test_ssl.cpp
@@ -15,16 +15,16 @@
 */
 
 #ifdef _WIN32
-#   ifndef CASS_STATIC
-#      include <openssl/applink.c>
-#   endif
+#ifndef CASS_STATIC
+#include <openssl/applink.c>
+#endif
 #endif
 
 #include <boost/chrono.hpp>
+#include <boost/format.hpp>
 #include <boost/test/debug.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/format.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -103,21 +103,22 @@ struct TestSSL {
       , connect_future_(NULL)
       , session_(NULL)
       , ssl_(NULL) {
-    //Load the PEM certificates and private keys
+    // Load the PEM certificates and private keys
     cassandra_certificate_ = test_utils::load_ssl_certificate(CASSANDRA_PEM_CERTIFICATE_FILENAME);
     driver_certificate_ = test_utils::load_ssl_certificate(DRIVER_PEM_CERTIFICATE_FILENAME);
     driver_private_key_ = test_utils::load_ssl_certificate(DRIVER_PEM_PRIVATE_KEY_FILENAME);
-    invalid_cassandra_certificate_ = test_utils::load_ssl_certificate(INVALID_CASSANDRA_PEM_CERTIFICATE_FILENAME);
-    invalid_driver_certificate_ = test_utils::load_ssl_certificate(INVALID_DRIVER_PEM_CERTIFICATE_FILENAME);
-    invalid_driver_private_key_ = test_utils::load_ssl_certificate(INVALID_DRIVER_PEM_PRIVATE_KEY_FILENAME);
+    invalid_cassandra_certificate_ =
+        test_utils::load_ssl_certificate(INVALID_CASSANDRA_PEM_CERTIFICATE_FILENAME);
+    invalid_driver_certificate_ =
+        test_utils::load_ssl_certificate(INVALID_DRIVER_PEM_CERTIFICATE_FILENAME);
+    invalid_driver_private_key_ =
+        test_utils::load_ssl_certificate(INVALID_DRIVER_PEM_PRIVATE_KEY_FILENAME);
   }
 
   /**
    * Destructor
    */
-  ~TestSSL() {
-    cleanup();
-  }
+  ~TestSSL() { cleanup(); }
 
   /**
    * Create the Cassandra cluster, initialize the cpp-driver cluster, and create
@@ -132,12 +133,13 @@ struct TestSSL {
    *                   (default: false)
    * @param nodes Number of nodes for the cluster (default: 1)
    */
-  void ssl_setup(bool is_ssl = true, bool is_client_authentication = false, bool is_failure = false, unsigned int nodes = 1) {
-    //Create a n-node cluster
+  void ssl_setup(bool is_ssl = true, bool is_client_authentication = false, bool is_failure = false,
+                 unsigned int nodes = 1) {
+    // Create a n-node cluster
     ccm_->create_cluster(nodes, 0, false, is_ssl, is_client_authentication);
     ccm_->start_cluster();
 
-    //Initialize the cpp-driver
+    // Initialize the cpp-driver
     cluster_ = cass_cluster_new();
     test_utils::initialize_contact_points(cluster_, ccm_->get_ip_prefix(), nodes);
     cass_cluster_set_connect_timeout(cluster_, 10000);
@@ -147,22 +149,21 @@ struct TestSSL {
     cass_cluster_set_max_connections_per_host(cluster_, 4);
     cass_cluster_set_ssl(cluster_, ssl_);
 
-    //Establish the connection (if ssl)
+    // Establish the connection (if ssl)
     session_ = cass_session_new();
     connect_future_ = cass_session_connect(session_, cluster_);
     if (!is_failure) {
       test_utils::wait_and_check_error(connect_future_);
     } else {
-      BOOST_REQUIRE(cass_future_wait_timed(connect_future_, 2000000)); //Ensure the wait is long enough for slow machines
+      BOOST_REQUIRE(cass_future_wait_timed(
+          connect_future_, 2000000)); // Ensure the wait is long enough for slow machines
     }
   }
 
   /**
    * Alias to driver connection cleanup
    */
-  void ssl_teardown() {
-    cleanup();
-  }
+  void ssl_teardown() { cleanup(); }
 
   /**
    * Cleanup the driver connection
@@ -219,20 +220,27 @@ struct TestSSL {
    * Test established connection with a normal load query
    */
   void test_normal_load() {
-    //Create and use the simple keyspace
-    test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+    // Create and use the simple keyspace
+    test_utils::execute_query(session_,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
-    //Create a table to fill with numbers and characters
-    test_utils::execute_query(session_, "CREATE TABLE normal_load (key int PRIMARY KEY, a int, b float, c text)");
+    // Create a table to fill with numbers and characters
+    test_utils::execute_query(
+        session_, "CREATE TABLE normal_load (key int PRIMARY KEY, a int, b float, c text)");
 
-    //Perform queries and validate inserted data
+    // Perform queries and validate inserted data
     for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) {
       std::string text = test_utils::generate_random_string(16);
-      test_utils::execute_query(session_, str(boost::format("INSERT INTO normal_load (key, a, b, c) VALUES (%d, %d, %f, '%s')") % n % (n * 100) % (n * .001f) % text));
+      test_utils::execute_query(
+          session_,
+          str(boost::format("INSERT INTO normal_load (key, a, b, c) VALUES (%d, %d, %f, '%s')") %
+              n % (n * 100) % (n * .001f) % text));
 
       test_utils::CassResultPtr result;
-      test_utils::execute_query(session_, str(boost::format("SELECT * FROM normal_load WHERE key = %d") % n), &result);
+      test_utils::execute_query(
+          session_, str(boost::format("SELECT * FROM normal_load WHERE key = %d") % n), &result);
       BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u);
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u);
 
@@ -263,31 +271,39 @@ struct TestSSL {
       BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text.c_str())));
     }
 
-    //Drop the table and keyspace
+    // Drop the table and keyspace
     test_utils::execute_query(session_, "DROP TABLE normal_load");
-    test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s")  % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query(session_,
+                              str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   /**
    * Test established connection with a high load query
    */
   void test_high_load() {
-    //Create and use the simple keyspace
-    test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+    // Create and use the simple keyspace
+    test_utils::execute_query(session_,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
 
-    //Create a table to fill with large text fields
-    test_utils::execute_query(session_, "CREATE TABLE high_load (key int PRIMARY KEY, a text, b text, c text)");
+    // Create a table to fill with large text fields
+    test_utils::execute_query(
+        session_, "CREATE TABLE high_load (key int PRIMARY KEY, a text, b text, c text)");
 
-    //Perform queries and validate inserted data
+    // Perform queries and validate inserted data
     for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) {
       std::string text_a = test_utils::generate_random_string(10240);
       std::string text_b = test_utils::generate_random_string(20480);
       std::string text_c = test_utils::generate_random_string(40960);
-      test_utils::execute_query(session_, str(boost::format("INSERT INTO high_load (key, a, b, c) VALUES (%d, '%s', '%s', '%s')") % n % text_a % text_b % text_c));
+      test_utils::execute_query(
+          session_,
+          str(boost::format("INSERT INTO high_load (key, a, b, c) VALUES (%d, '%s', '%s', '%s')") %
+              n % text_a % text_b % text_c));
 
       test_utils::CassResultPtr result;
-      test_utils::execute_query(session_, str(boost::format("SELECT * FROM high_load WHERE key = %d") % n), &result);
+      test_utils::execute_query(
+          session_, str(boost::format("SELECT * FROM high_load WHERE key = %d") % n), &result);
       BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u);
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u);
 
@@ -318,9 +334,10 @@ struct TestSSL {
       BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text_c.c_str())));
     }
 
-    //Drop the table and keyspace
+    // Drop the table and keyspace
     test_utils::execute_query(session_, "DROP TABLE high_load");
-    test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s")  % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query(session_,
+                              str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 };
 
@@ -336,7 +353,9 @@ BOOST_AUTO_TEST_CASE(connect) {
 
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(), cassandra_certificate_.size()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(),
+                                                  cassandra_certificate_.size()),
+                      CASS_OK);
   ssl_setup();
   test_normal_load();
   test_high_load();
@@ -344,7 +363,9 @@ BOOST_AUTO_TEST_CASE(connect) {
 
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_IDENTITY);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(), cassandra_certificate_.size()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(),
+                                                  cassandra_certificate_.size()),
+                      CASS_OK);
   ssl_setup();
   test_normal_load();
   test_high_load();
@@ -354,7 +375,9 @@ BOOST_AUTO_TEST_CASE(connect) {
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
   BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, cassandra_certificate_.c_str()), CASS_OK);
   BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, driver_certificate_.c_str()), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD), CASS_OK);
+  BOOST_REQUIRE_EQUAL(
+      cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD),
+      CASS_OK);
   ssl_setup(true, true);
   test_normal_load();
   test_high_load();
@@ -362,20 +385,26 @@ BOOST_AUTO_TEST_CASE(connect) {
 }
 
 BOOST_AUTO_TEST_CASE(connect_failures) {
-  //Load invalid certificates
+  // Load invalid certificates
   create_ssl_context();
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, "Invalid Client Certificate"), CASS_ERROR_SSL_INVALID_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, "Invalid Trusted Certificate"), CASS_ERROR_SSL_INVALID_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, "Invalid Private Key", "invalid"), CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), "invalid"), CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, "Invalid Client Certificate"),
+                      CASS_ERROR_SSL_INVALID_CERT);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, "Invalid Trusted Certificate"),
+                      CASS_ERROR_SSL_INVALID_CERT);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, "Invalid Private Key", "invalid"),
+                      CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), "invalid"),
+                      CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
 
   // Null certificate arg
   BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, NULL), CASS_ERROR_SSL_INVALID_CERT);
   BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, NULL), CASS_ERROR_SSL_INVALID_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, NULL, "invalid"), CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), NULL), CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, NULL, "invalid"),
+                      CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), NULL),
+                      CASS_ERROR_SSL_INVALID_PRIVATE_KEY);
 
-  //Connect with SSL where the Cassandra server has SSL disabled
+  // Connect with SSL where the Cassandra server has SSL disabled
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_NONE);
   ssl_setup(false, false, true);
@@ -394,33 +423,42 @@ BOOST_AUTO_TEST_CASE(connect_failures) {
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
   BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, cassandra_certificate_.c_str()), CASS_OK);
   BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, driver_certificate_.c_str()), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD), CASS_OK);
+  BOOST_REQUIRE_EQUAL(
+      cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD),
+      CASS_OK);
   ssl_setup(false, false, true);
   ssl_teardown();
 
-  //Connect with SSL with invalid peer and client certificates
+  // Connect with SSL with invalid peer and client certificates
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()),
+                      CASS_OK);
   ssl_setup(true, false, true);
   ssl_teardown();
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_IDENTITY);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()),
+                      CASS_OK);
   ssl_setup(true, false, true);
   ssl_teardown();
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, invalid_cassandra_certificate_.c_str()),
+                      CASS_OK);
   BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, driver_certificate_.c_str()), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD), CASS_OK);
+  BOOST_REQUIRE_EQUAL(
+      cass_ssl_set_private_key(ssl_, driver_private_key_.c_str(), DRIVER_PEM_PRIVATE_KEY_PASSWORD),
+      CASS_OK);
   ssl_setup(true, true, true);
   ssl_teardown();
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
   BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert(ssl_, cassandra_certificate_.c_str()), CASS_OK);
   BOOST_REQUIRE_EQUAL(cass_ssl_set_cert(ssl_, invalid_driver_certificate_.c_str()), CASS_OK);
-  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, invalid_driver_private_key_.c_str(), INVALID_DRIVER_PEM_PRIVATE_KEY_PASSWORD), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_set_private_key(ssl_, invalid_driver_private_key_.c_str(),
+                                               INVALID_DRIVER_PEM_PRIVATE_KEY_PASSWORD),
+                      CASS_OK);
   ssl_setup(true, true, true);
   ssl_teardown();
 }
@@ -441,7 +479,9 @@ BOOST_AUTO_TEST_CASE(connect_failures) {
 BOOST_AUTO_TEST_CASE(reconnect_after_cluster_crash_and_restart) {
   create_ssl_context();
   cass_ssl_set_verify_flags(ssl_, CASS_SSL_VERIFY_PEER_CERT);
-  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(), cassandra_certificate_.size()), CASS_OK);
+  BOOST_REQUIRE_EQUAL(cass_ssl_add_trusted_cert_n(ssl_, cassandra_certificate_.data(),
+                                                  cassandra_certificate_.size()),
+                      CASS_OK);
   ssl_setup();
   crash_and_restart_cluster();
   ssl_teardown();
@@ -449,4 +489,3 @@ BOOST_AUTO_TEST_CASE(reconnect_after_cluster_crash_and_restart) {
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
diff --git a/test/integration_tests/src/test_stress.cpp b/test/integration_tests/src/test_stress.cpp
index a63e40bc5..4dd742f72 100644
--- a/test/integration_tests/src/test_stress.cpp
+++ b/test/integration_tests/src/test_stress.cpp
@@ -20,15 +20,15 @@
 #include <signal.h>
 #endif
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/format.hpp>
 #include <boost/asio/io_service.hpp>
-#include <boost/thread/future.hpp>
 #include <boost/bind.hpp>
 #include <boost/chrono.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread/future.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
@@ -36,33 +36,36 @@
 struct StressTests : public test_utils::MultipleNodesTest {
   CassSession* session;
 
-  StressTests() : MultipleNodesTest(3, 0) {
+  StressTests()
+      : MultipleNodesTest(3, 0) {
     session = cass_session_new();
     test_utils::CassFuturePtr session_future(cass_session_connect(session, cluster));
     test_utils::wait_and_check_error(session_future.get());
 
-    test_utils::execute_query(session, "CREATE KEYSPACE tester WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};");
+    test_utils::execute_query(session, "CREATE KEYSPACE tester WITH replication = {'class': "
+                                       "'SimpleStrategy', 'replication_factor' : 3};");
     test_utils::execute_query(session, "USE tester;");
   }
 
   ~StressTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % "tester"));
+    test_utils::execute_query_with_error(
+        session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "tester"));
 
     cass_session_free(session);
   }
 
-  bool create_and_execute_insert(const std::string &query, CassConsistency consistency) {
+  bool create_and_execute_insert(const std::string& query, CassConsistency consistency) {
     CassUuid time_uuid = test_utils::generate_random_uuid(uuid_gen);
     std::string time_uuid_string = test_utils::Value<CassUuid>::to_string(time_uuid);
     boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
-    boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
+    boost::chrono::milliseconds event_time(
+        boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
     std::string text_sample("'" + test_utils::string_from_time_point(now) + "'");
 
     std::string simple_query = test_utils::replaceAll(query, "?", "%s");
-    simple_query = str(boost::format(simple_query) % time_uuid_string % event_time.count() % text_sample);
+    simple_query =
+        str(boost::format(simple_query) % time_uuid_string % event_time.count() % text_sample);
     test_utils::CassStatementPtr statement(cass_statement_new(simple_query.c_str(), 0));
     cass_statement_set_consistency(statement.get(), consistency);
 
@@ -71,7 +74,8 @@ struct StressTests : public test_utils::MultipleNodesTest {
 
   bool bind_and_execute_insert(CassStatement* statement) {
     boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
-    boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
+    boost::chrono::milliseconds event_time(
+        boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
     std::string text_sample(test_utils::string_from_time_point(now));
 
     cass_statement_bind_uuid(statement, 0, test_utils::generate_time_uuid(uuid_gen));
@@ -88,7 +92,8 @@ struct StressTests : public test_utils::MultipleNodesTest {
     if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
       CassString message;
       cass_future_error_message(future.get(), &message.data, &message.length);
-      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
+      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length),
+              message.data);
       return false;
     }
 
@@ -113,7 +118,8 @@ struct StressTests : public test_utils::MultipleNodesTest {
     return is_successful;
   }
 
-  bool insert_prepared_task(const CassPrepared* prepared, CassConsistency consistency, int rows_per_id) {
+  bool insert_prepared_task(const CassPrepared* prepared, CassConsistency consistency,
+                            int rows_per_id) {
     bool is_successful = true;
     for (int i = 0; i < rows_per_id; ++i) {
       test_utils::CassStatementPtr statement(cass_prepared_bind(prepared));
@@ -135,12 +141,12 @@ struct StressTests : public test_utils::MultipleNodesTest {
       cass_future_wait(future.get());
 
       CassError code = cass_future_error_code(future.get());
-      if (code != CASS_OK
-         && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT
-         && code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
+      if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT &&
+          code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
         CassString message;
         cass_future_error_message(future.get(), &message.data, &message.length);
-        fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length), message.data);
+        fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length),
+                message.data);
         is_successful = false;
       }
 
@@ -163,23 +169,23 @@ struct StressTests : public test_utils::MultipleNodesTest {
   }
 };
 
-bool is_failed(boost::shared_future<bool> future) {
-  return future.get() == false;
-}
+bool is_failed(boost::shared_future<bool> future) { return future.get() == false; }
 
 BOOST_FIXTURE_TEST_SUITE(stress, StressTests)
 
-BOOST_AUTO_TEST_CASE(parallel_insert_and_select)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(parallel_insert_and_select) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
 
-  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
+  test_utils::execute_query(session,
+                            str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
+  std::string insert_query = str(
+      boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
   std::string select_query = str(boost::format("SELECT * FROM %s LIMIT 10000") % table_name);
 
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   insert_query.data(), insert_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, insert_query.data(), insert_query.size()));
 
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
@@ -193,38 +199,75 @@ BOOST_AUTO_TEST_CASE(parallel_insert_and_select)
   std::vector<boost::shared_future<bool> > futures;
 
   for (int i = 0; i < 10; ++i) {
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
   }
 
   boost::wait_for_all(futures.begin(), futures.end());
-  BOOST_REQUIRE(std::find_if (futures.begin(), futures.end(), is_failed) == futures.end());
+  BOOST_REQUIRE(std::find_if(futures.begin(), futures.end(), is_failed) == futures.end());
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "tester"));
+  test_utils::execute_query_with_error(
+      session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % "tester"));
 }
 
-BOOST_AUTO_TEST_CASE(parallel_insert_and_select_with_nodes_failing)
-{
-  std::string table_name = str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
+BOOST_AUTO_TEST_CASE(parallel_insert_and_select_with_nodes_failing) {
+  std::string table_name =
+      str(boost::format("table_%s") % test_utils::generate_unique_str(uuid_gen));
 
-  test_utils::execute_query(session, str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
+  test_utils::execute_query(session,
+                            str(boost::format(test_utils::CREATE_TABLE_TIME_SERIES) % table_name));
 
-  std::string insert_query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
+  std::string insert_query = str(
+      boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
   std::string select_query = str(boost::format("SELECT * FROM %s LIMIT 10000") % table_name);
 
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session,
-                                                                   insert_query.data(), insert_query.size()));
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session, insert_query.data(), insert_query.size()));
 
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
@@ -238,24 +281,60 @@ BOOST_AUTO_TEST_CASE(parallel_insert_and_select_with_nodes_failing)
   std::vector<boost::shared_future<bool> > futures;
 
   for (int i = 0; i < 10; ++i) {
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_task, this, insert_query, CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::insert_prepared_task, this, prepared.get(), CASS_CONSISTENCY_QUORUM, rows_per_id)).share());
-    futures.push_back(boost::async(boost::launch::async, boost::bind(&StressTests::select_task, this, select_query, CASS_CONSISTENCY_QUORUM, num_iterations)).share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::insert_task, this, insert_query,
+                                               CASS_CONSISTENCY_QUORUM, rows_per_id))
+                          .share());
+
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(
+        boost::async(boost::launch::async,
+                     boost::bind(&StressTests::insert_prepared_task, this, prepared.get(),
+                                 CASS_CONSISTENCY_QUORUM, rows_per_id))
+            .share());
+    futures.push_back(boost::async(boost::launch::async,
+                                   boost::bind(&StressTests::select_task, this, select_query,
+                                               CASS_CONSISTENCY_QUORUM, num_iterations))
+                          .share());
   }
 
-  futures.insert(futures.begin() + 8, boost::async(boost::launch::async, boost::bind(&StressTests::kill_task, this)).share());
+  futures.insert(
+      futures.begin() + 8,
+      boost::async(boost::launch::async, boost::bind(&StressTests::kill_task, this)).share());
 
   boost::wait_for_all(futures.begin(), futures.end());
-  BOOST_REQUIRE(std::find_if (futures.begin(), futures.end(), is_failed) == futures.end());
+  BOOST_REQUIRE(std::find_if(futures.begin(), futures.end(), is_failed) == futures.end());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integration_tests/src/test_timestamps.cpp b/test/integration_tests/src/test_timestamps.cpp
index fec157f1e..fb097f0b6 100644
--- a/test/integration_tests/src/test_timestamps.cpp
+++ b/test/integration_tests/src/test_timestamps.cpp
@@ -17,31 +17,35 @@
 #include "test_utils.hpp"
 
 #include "cassandra.h"
-#include "timestamp_generator.hpp"
 #include "get_time.hpp"
+#include "timestamp_generator.hpp"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 struct TimestampsTest : public test_utils::SingleSessionTest {
   typedef test_utils::CassBatchPtr CassBatchPtr;
   typedef test_utils::CassFuturePtr CassFuturePtr;
   typedef test_utils::CassStatementPtr CassStatementPtr;
 
   TimestampsTest()
-    : SingleSessionTest(1, 0, false) { }
+      : SingleSessionTest(1, 0, false) {}
 
   ~TimestampsTest() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   void create_session() {
     test_utils::SingleSessionTest::create_session();
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT)
-                                           % test_utils::SIMPLE_KEYSPACE % "1"));
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
@@ -53,7 +57,8 @@ struct TimestampsTest : public test_utils::SingleSessionTest {
   cass_int64_t get_timestamp(const std::string table_name, const std::string& key) {
     cass_int64_t timestamp;
     test_utils::CassResultPtr result;
-    std::string query = str(boost::format("SELECT writetime(value) FROM %s WHERE key = '%s'") % table_name % key);
+    std::string query =
+        str(boost::format("SELECT writetime(value) FROM %s WHERE key = '%s'") % table_name % key);
     test_utils::execute_query(session, query, &result);
     BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
     BOOST_REQUIRE(cass_result_column_count(result.get()) > 0);
@@ -64,11 +69,11 @@ struct TimestampsTest : public test_utils::SingleSessionTest {
   }
 };
 
-class TestTimestampGenerator : public cass::TimestampGenerator {
+class TestTimestampGenerator : public TimestampGenerator {
 public:
   TestTimestampGenerator(int64_t timestamp)
-    : TimestampGenerator(SERVER_SIDE) // Doesn't matter for this test
-    , timestamp_(timestamp) { }
+      : TimestampGenerator(SERVER_SIDE) // Doesn't matter for this test
+      , timestamp_(timestamp) {}
 
   virtual int64_t next() { return timestamp_; }
 
@@ -76,16 +81,16 @@ class TestTimestampGenerator : public cass::TimestampGenerator {
   int64_t timestamp_;
 };
 
-class TestMonotonicTimestampGenerator : public cass::MonotonicTimestampGenerator {
+class TestMonotonicTimestampGenerator : public MonotonicTimestampGenerator {
 public:
   std::vector<int64_t> timestamps_;
 
   TestMonotonicTimestampGenerator(int64_t warning_threshold_us = 1000000,
                                   int64_t warning_interval_ms = 1000)
-    : MonotonicTimestampGenerator(warning_threshold_us, warning_interval_ms) { }
+      : MonotonicTimestampGenerator(warning_threshold_us, warning_interval_ms) {}
 
   virtual int64_t next() {
-    int64_t timestamp = cass::MonotonicTimestampGenerator::next();
+    int64_t timestamp = MonotonicTimestampGenerator::next();
     timestamps_.push_back(timestamp);
     return timestamp;
   }
@@ -112,8 +117,7 @@ BOOST_AUTO_TEST_SUITE(timestamps)
  * @test_category queries:timestamp
  * @cassandra_version 2.1.x
  */
-BOOST_AUTO_TEST_CASE(statement_and_batch)
-{
+BOOST_AUTO_TEST_CASE(statement_and_batch) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     TimestampsTest tester;
@@ -164,7 +168,8 @@ BOOST_AUTO_TEST_CASE(statement_and_batch)
       BOOST_CHECK_EQUAL(tester.get_timestamp(table_name, key2), 1234);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping timestamps/statement_and_batch" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping timestamps/statement_and_batch" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -180,12 +185,11 @@ BOOST_AUTO_TEST_CASE(statement_and_batch)
  * @test_category queries:timestamp
  * @cassandra_version 2.1.x
  */
-BOOST_AUTO_TEST_CASE(generator)
-{
+BOOST_AUTO_TEST_CASE(generator) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     TimestampsTest tester;
-    cass::SharedRefPtr<TestTimestampGenerator> gen(new TestTimestampGenerator(1234));
+    SharedRefPtr<TestTimestampGenerator> gen(new TestTimestampGenerator(1234));
 
     cass_cluster_set_timestamp_gen(tester.cluster, CassTimestampGen::to(gen.get()));
     tester.create_session();
@@ -197,7 +201,8 @@ BOOST_AUTO_TEST_CASE(generator)
     // Statement
     {
       std::string table_name("table_" + test_utils::generate_unique_str(tester.uuid_gen));
-      std::string create_table = "CREATE TABLE " + table_name + "(key text PRIMARY KEY, value text)";
+      std::string create_table =
+          "CREATE TABLE " + table_name + "(key text PRIMARY KEY, value text)";
       test_utils::execute_query(tester.session, create_table.c_str());
 
       std::string key(test_utils::generate_unique_str(tester.uuid_gen));
@@ -234,7 +239,8 @@ BOOST_AUTO_TEST_CASE(generator)
       BOOST_CHECK_EQUAL(tester.get_timestamp(table_name, key2), 1234);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping timestamps/generator" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping timestamps/generator" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -250,8 +256,7 @@ BOOST_AUTO_TEST_CASE(generator)
  * @test_category queries:timestamp
  * @cassandra_version 2.1.x
  */
-BOOST_AUTO_TEST_CASE(server_side)
-{
+BOOST_AUTO_TEST_CASE(server_side) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     TimestampsTest tester;
@@ -269,13 +274,14 @@ BOOST_AUTO_TEST_CASE(server_side)
     cass_statement_bind_string(statement.get(), 0, key.c_str());
     cass_statement_bind_string(statement.get(), 1, key.c_str());
 
-    uint64_t timestamp = cass::get_time_since_epoch_ms();
+    uint64_t timestamp = get_time_since_epoch_ms();
     test_utils::CassFuturePtr future(cass_session_execute(tester.session, statement.get()));
     BOOST_REQUIRE(cass_future_error_code(future.get()) == CASS_OK);
 
     BOOST_CHECK_GE(tester.get_timestamp(table_name, key), static_cast<int64_t>(timestamp));
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping timestamps/server_side" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping timestamps/server_side" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -291,10 +297,10 @@ BOOST_AUTO_TEST_CASE(server_side)
  * @test_category queries:timestamp
  * @expected_result Timestamp generated matches timestamp on server
  */
-BOOST_AUTO_TEST_CASE(monotonic_generator)
-{
+BOOST_AUTO_TEST_CASE(monotonic_generator) {
   TimestampsTest tester;
-  cass::SharedRefPtr<TestMonotonicTimestampGenerator> gen(new TestMonotonicTimestampGenerator()); // mimics cass_timestamp_gen_monotonic_new())
+  SharedRefPtr<TestMonotonicTimestampGenerator> gen(
+      new TestMonotonicTimestampGenerator()); // mimics cass_timestamp_gen_monotonic_new())
   cass_cluster_set_timestamp_gen(tester.cluster, CassTimestampGen::to(gen.get()));
   tester.create_session();
 
@@ -328,10 +334,10 @@ BOOST_AUTO_TEST_CASE(monotonic_generator)
  * @expected_result Timestamp generated matches timestamp on server and warning
  *                  thresholds are generated by the driver
  */
-BOOST_AUTO_TEST_CASE(monotonic_generator_warnings)
-{
+BOOST_AUTO_TEST_CASE(monotonic_generator_warnings) {
   TimestampsTest tester;
-  cass::SharedRefPtr<TestMonotonicTimestampGenerator> gen(new TestMonotonicTimestampGenerator(1, 1000)); // mimics cass_timestamp_gen_monotonic_new_with_settings())
+  SharedRefPtr<TestMonotonicTimestampGenerator> gen(new TestMonotonicTimestampGenerator(
+      1, 1000)); // mimics cass_timestamp_gen_monotonic_new_with_settings())
   cass_cluster_set_timestamp_gen(tester.cluster, CassTimestampGen::to(gen.get()));
   tester.create_session();
 
@@ -360,13 +366,13 @@ BOOST_AUTO_TEST_CASE(monotonic_generator_warnings)
       test_utils::CassFuturePtr future(cass_session_execute(tester.session, statement.get()));
       futures.insert(std::pair<std::string, test_utils::CassFuturePtr>(key, future));
     } while (test_utils::CassLog::message_count() > 0 &&
-      (static_cast<double>(uv_hrtime() - start_time) / 1e9) < 120);
+             (static_cast<double>(uv_hrtime() - start_time) / 1e9) < 120);
 
     // Ensure the timestamps are valid
     for (std::map<std::string, test_utils::CassFuturePtr>::iterator it = futures.begin();
-      it != futures.end(); ++it) {
-        BOOST_REQUIRE_EQUAL(CASS_OK, cass_future_error_code(it->second.get()));
-        BOOST_REQUIRE(gen->contains_timestamp(tester.get_timestamp(table_name, it->first)));
+         it != futures.end(); ++it) {
+      BOOST_REQUIRE_EQUAL(CASS_OK, cass_future_error_code(it->second.get()));
+      BOOST_REQUIRE(gen->contains_timestamp(tester.get_timestamp(table_name, it->first)));
     }
 
     // Ensure the skew threshold was achieved
diff --git a/test/integration_tests/src/test_token_aware_policy.cpp b/test/integration_tests/src/test_token_aware_policy.cpp
index 268f867c9..343ae10b4 100644
--- a/test/integration_tests/src/test_token_aware_policy.cpp
+++ b/test/integration_tests/src/test_token_aware_policy.cpp
@@ -21,31 +21,33 @@
 #endif
 
 #include "cassandra.h"
-#include "testing.hpp"
 #include "test_utils.hpp"
+#include "testing.hpp"
 
-#include <boost/test/unit_test.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/format.hpp>
 #include <boost/asio/io_service.hpp>
-#include <boost/thread/future.hpp>
 #include <boost/bind.hpp>
 #include <boost/chrono.hpp>
 #include <boost/cstdint.hpp>
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread/future.hpp>
 
 #include <map>
 #include <set>
 #include <string>
 
+using namespace datastax::internal::testing;
+
 BOOST_AUTO_TEST_SUITE(token_aware_policy)
 
 struct TestTokenMap {
   struct Host {
     Host() {}
     Host(const std::string& ip, const std::string& dc)
-      : ip(ip), dc(dc) {}
+        : ip(ip)
+        , dc(dc) {}
     std::string ip;
     std::string dc;
   };
@@ -65,7 +67,7 @@ struct TestTokenMap {
 
     for (int i = 0; i < num_nodes; ++i) {
       test_utils::CassStatementPtr statement(
-            cass_statement_new("SELECT tokens, data_center FROM system.local", 0));
+          cass_statement_new("SELECT tokens, data_center FROM system.local", 0));
       test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
@@ -77,7 +79,7 @@ struct TestTokenMap {
       cass_value_get_string(data_center, &str.data, &str.length);
       std::string dc(str.data, str.length);
 
-      std::string ip = cass::get_host_from_future(future.get()).c_str();
+      std::string ip = get_host_from_future(future.get()).c_str();
       test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(token_set));
       while (cass_iterator_next(iterator.get())) {
         cass_value_get_string(cass_iterator_get_value(iterator.get()), &str.data, &str.length);
@@ -87,10 +89,11 @@ struct TestTokenMap {
     }
   }
 
-  ReplicaSet get_expected_replicas(size_t rf, const std::string& value, const std::string& local_dc = "") {
+  ReplicaSet get_expected_replicas(size_t rf, const std::string& value,
+                                   const std::string& local_dc = "") {
     ReplicaSet replicas;
-    TokenHostMap::iterator i = tokens.upper_bound(cass::create_murmur3_hash_from_string(value.c_str()));
-    while  (replicas.size() < rf) {
+    TokenHostMap::iterator i = tokens.upper_bound(create_murmur3_hash_from_string(value.c_str()));
+    while (replicas.size() < rf) {
       if (local_dc.empty() || local_dc == i->second.dc) {
         replicas.insert(i->second.ip);
       }
@@ -103,25 +106,20 @@ struct TestTokenMap {
   }
 };
 
-std::string get_replica(test_utils::CassSessionPtr session,
-                        const std::string& keyspace,
+std::string get_replica(test_utils::CassSessionPtr session, const std::string& keyspace,
                         const std::string& value) {
   // The query doesn't matter
-  test_utils::CassStatementPtr statement(
-        cass_statement_new("SELECT * FROM system.local", 1));
+  test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.local", 1));
   cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE);
   cass_statement_bind_string_n(statement.get(), 0, value.data(), value.size());
   cass_statement_add_key_index(statement.get(), 0);
   cass_statement_set_keyspace(statement.get(), keyspace.c_str());
-  test_utils::CassFuturePtr future(
-        cass_session_execute(session.get(), statement.get()));
-  return cass::get_host_from_future(future.get()).c_str();
+  test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
+  return get_host_from_future(future.get()).c_str();
 }
 
-TestTokenMap::ReplicaSet get_replicas(size_t rf,
-                                      test_utils::CassSessionPtr session,
-                                      const std::string& keyspace,
-                                      const std::string& value) {
+TestTokenMap::ReplicaSet get_replicas(size_t rf, test_utils::CassSessionPtr session,
+                                      const std::string& keyspace, const std::string& value) {
   TestTokenMap::ReplicaSet replicas;
   for (size_t i = 0; i < rf * rf; ++i) {
     replicas.insert(get_replica(session, keyspace, "abc"));
@@ -130,8 +128,7 @@ TestTokenMap::ReplicaSet get_replicas(size_t rf,
   return replicas;
 }
 
-BOOST_AUTO_TEST_CASE(simple)
-{
+BOOST_AUTO_TEST_CASE(simple) {
   const size_t rf = 2;
   const std::string value = "abc";
 
@@ -153,13 +150,14 @@ BOOST_AUTO_TEST_CASE(simple)
 
   std::string keyspace = "ks";
 
-  test_utils::execute_query(session.get(),
-                            str(boost::format("CREATE KEYSPACE %s "
-                                              "WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': %d }") %
-                                keyspace % rf));
+  test_utils::execute_query(
+      session.get(),
+      str(boost::format(
+              "CREATE KEYSPACE %s "
+              "WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': %d }") %
+          keyspace % rf));
 
-  for (size_t i = 0; i < rf; ++i)
-  {
+  for (size_t i = 0; i < rf; ++i) {
     TestTokenMap token_map;
     token_map.build(ip_prefix, rf);
 
@@ -174,21 +172,18 @@ BOOST_AUTO_TEST_CASE(simple)
   }
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session.get(),
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % keyspace));
+  test_utils::execute_query_with_error(
+      session.get(), str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % keyspace));
 }
 
 bool intersects(const TestTokenMap::ReplicaSet& set1, const TestTokenMap::ReplicaSet& set2) {
   TestTokenMap::ReplicaSet intersection;
-  std::set_intersection(set1.begin(), set1.end(),
-                        set2.begin(), set2.end(),
+  std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(),
                         std::inserter(intersection, intersection.begin()));
   return intersection.size() > 0;
 }
 
-BOOST_AUTO_TEST_CASE(network_topology)
-{
+BOOST_AUTO_TEST_CASE(network_topology) {
   const size_t rf = 2;
   const std::string value = "abc";
 
@@ -210,10 +205,12 @@ BOOST_AUTO_TEST_CASE(network_topology)
 
   std::string keyspace = "ks";
 
-  test_utils::execute_query(session.get(),
-                            str(boost::format("CREATE KEYSPACE %s "
-                                              "WITH replication = { 'class': 'NetworkTopologyStrategy', 'dc1': %d , 'dc2': %d }") %
-                                keyspace % rf % rf));
+  test_utils::execute_query(
+      session.get(),
+      str(boost::format(
+              "CREATE KEYSPACE %s "
+              "WITH replication = { 'class': 'NetworkTopologyStrategy', 'dc1': %d , 'dc2': %d }") %
+          keyspace % rf % rf));
 
   TestTokenMap token_map;
   token_map.build(ip_prefix, 2 * rf);
@@ -240,9 +237,8 @@ BOOST_AUTO_TEST_CASE(network_topology)
   BOOST_CHECK(replicas.size() > 0 && !intersects(replicas, local_replicas));
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session.get(),
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % keyspace));
+  test_utils::execute_query_with_error(
+      session.get(), str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % keyspace));
 }
 
 /**
@@ -254,8 +250,7 @@ BOOST_AUTO_TEST_CASE(network_topology)
  * @jira_ticket CPP-266
  * @test_category load_balancing:token_aware
  */
-BOOST_AUTO_TEST_CASE(shuffle_replicas)
-{
+BOOST_AUTO_TEST_CASE(shuffle_replicas) {
   const size_t rf = 2;
   const size_t max_iterations = rf * rf;
   const std::string value = "abc";
@@ -278,10 +273,12 @@ BOOST_AUTO_TEST_CASE(shuffle_replicas)
 
   std::string keyspace = "ks";
 
-  test_utils::execute_query(session.get(),
-                            str(boost::format("CREATE KEYSPACE %s "
-                                              "WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': %d }") %
-                                keyspace % rf));
+  test_utils::execute_query(
+      session.get(),
+      str(boost::format(
+              "CREATE KEYSPACE %s "
+              "WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': %d }") %
+          keyspace % rf));
   std::string replica_previous;
 
   // With shuffle enabled (default) the replica order should eventually change
@@ -309,9 +306,8 @@ BOOST_AUTO_TEST_CASE(shuffle_replicas)
   }
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session.get(),
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % keyspace));
+  test_utils::execute_query_with_error(
+      session.get(), str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % keyspace));
 }
 
 /**
@@ -325,8 +321,7 @@ BOOST_AUTO_TEST_CASE(shuffle_replicas)
  * @test_category load_balancing:token_aware
  * @test_subcategory collections
  */
-BOOST_AUTO_TEST_CASE(single_entry_routing_key)
-{
+BOOST_AUTO_TEST_CASE(single_entry_routing_key) {
   const size_t rf = 2;
   test_utils::CassClusterPtr cluster(cass_cluster_new());
 
@@ -344,17 +339,21 @@ BOOST_AUTO_TEST_CASE(single_entry_routing_key)
   test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
 
   std::string keyspace = "ks";
-  test_utils::execute_query(session.get(),
-                            str(boost::format("CREATE KEYSPACE %s "
-                                              "WITH replication = { 'class': 'NetworkTopologyStrategy', 'dc1': %d , 'dc2': %d }") %
-                                keyspace % rf % rf));
+  test_utils::execute_query(
+      session.get(),
+      str(boost::format(
+              "CREATE KEYSPACE %s "
+              "WITH replication = { 'class': 'NetworkTopologyStrategy', 'dc1': %d , 'dc2': %d }") %
+          keyspace % rf % rf));
   test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace));
-  test_utils::execute_query(session.get(), "CREATE TABLE invalid_routing_key (routing_key text PRIMARY KEY,"
-                                            "cass_collection map<text,text>);");
+  test_utils::execute_query(session.get(),
+                            "CREATE TABLE invalid_routing_key (routing_key text PRIMARY KEY,"
+                            "cass_collection map<text,text>);");
 
-  std::string insert_query = "UPDATE invalid_routing_key SET cass_collection = ? WHERE routing_key = ?";
-  test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session.get(),
-                                                                   insert_query.data(), insert_query.size()));
+  std::string insert_query =
+      "UPDATE invalid_routing_key SET cass_collection = ? WHERE routing_key = ?";
+  test_utils::CassFuturePtr prepared_future(
+      cass_session_prepare_n(session.get(), insert_query.data(), insert_query.size()));
   test_utils::wait_and_check_error(prepared_future.get());
   test_utils::CassPreparedPtr prepared(cass_future_get_prepared(prepared_future.get()));
 
@@ -369,9 +368,8 @@ BOOST_AUTO_TEST_CASE(single_entry_routing_key)
   test_utils::wait_and_check_error(future.get());
 
   // Drop the keyspace (ignore any and all errors)
-  test_utils::execute_query_with_error(session.get(),
-    str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-    % keyspace));
+  test_utils::execute_query_with_error(
+      session.get(), str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % keyspace));
 }
 
 /**
@@ -387,8 +385,7 @@ BOOST_AUTO_TEST_CASE(single_entry_routing_key)
  * @test_category load_balancing:token_aware
  * @test_category control_connection
  */
-BOOST_AUTO_TEST_CASE(no_timeout_control_connection)
-{
+BOOST_AUTO_TEST_CASE(no_timeout_control_connection) {
   int num_of_keyspaces = 50;
   int num_of_tables = 10;
   std::string keyspace_prefix = "tap_";
@@ -430,10 +427,13 @@ BOOST_AUTO_TEST_CASE(no_timeout_control_connection)
     // Create the keyspace (handling errors to avoid test failure))
     CassError error_code;
     do {
-      error_code = test_utils::execute_query_with_error(session.get(),
-        str(boost::format("CREATE KEYSPACE " + keyspace_prefix + "%d "
-        "WITH replication = { 'class': 'NetworkTopologyStrategy', "
-        + nts_dcs + " }") % i));
+      error_code = test_utils::execute_query_with_error(
+          session.get(),
+          str(boost::format("CREATE KEYSPACE " + keyspace_prefix +
+                            "%d "
+                            "WITH replication = { 'class': 'NetworkTopologyStrategy', " +
+                            nts_dcs + " }") %
+              i));
     } while (error_code != CASS_OK && error_code != CASS_ERROR_SERVER_ALREADY_EXISTS);
 
     // Perform table creation and random selects (iff keyspace is valid))
@@ -441,13 +441,12 @@ BOOST_AUTO_TEST_CASE(no_timeout_control_connection)
       // Create the table (handling errors to avoid test failures)
       for (int j = 0; j < num_of_tables; ++j) {
         std::stringstream full_table_name;
-        full_table_name << keyspace_prefix << i << "."
-          << table_prefix << j;
+        full_table_name << keyspace_prefix << i << "." << table_prefix << j;
         CassError error_code = CASS_ERROR_SERVER_READ_TIMEOUT;
         do {
-          error_code = test_utils::execute_query_with_error(session.get(),
-          str(boost::format(test_utils::CREATE_TABLE_SIMPLE) %
-            full_table_name.str()));
+          error_code = test_utils::execute_query_with_error(
+              session.get(),
+              str(boost::format(test_utils::CREATE_TABLE_SIMPLE) % full_table_name.str()));
         } while (error_code != CASS_OK && error_code != CASS_ERROR_SERVER_ALREADY_EXISTS);
 
         // Randomly perform select statements on the newly created table
diff --git a/test/integration_tests/src/test_tuples.cpp b/test/integration_tests/src/test_tuples.cpp
index c6feea40a..260770211 100644
--- a/test/integration_tests/src/test_tuples.cpp
+++ b/test/integration_tests/src/test_tuples.cpp
@@ -14,13 +14,14 @@
   limitations under the License.
 */
 
-#include "test_utils.hpp"
 #include "cassandra.h"
+#include "test_utils.hpp"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
 
-#define NESTED_COLLECTION_SIZE_LIMITER 50 // Limit nested collections size (as to not exceed high water mark)
+#define NESTED_COLLECTION_SIZE_LIMITER \
+  50 // Limit nested collections size (as to not exceed high water mark)
 
 struct TupleTests : public test_utils::SingleSessionTest {
 private:
@@ -33,11 +34,13 @@ struct TupleTests : public test_utils::SingleSessionTest {
    *                        NOTE: This value must map to a CassCollectionType to
    *                        be considered for tuple.
    */
-  std::string table_name_builder(CassValueType tuple_type, unsigned int size, CassValueType collection_type) {
+  std::string table_name_builder(CassValueType tuple_type, unsigned int size,
+                                 CassValueType collection_type) {
     // Build the table prefix
     std::string cql_value_type = test_utils::get_value_type(tuple_type);
     std::string table_prefix = cql_value_type;
-    if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP || collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
+    if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP ||
+        collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
       std::string collection_cql_value_type = test_utils::get_value_type(collection_type);
       table_prefix = cql_value_type + "_" + collection_cql_value_type;
     }
@@ -58,12 +61,14 @@ struct TupleTests : public test_utils::SingleSessionTest {
    *                        be considered for tuple.
    * @param is_frozen True if frozen; false otherwise (default: true)
    */
-  std::string tuple_cql_builder(CassValueType tuple_type, unsigned int size, CassValueType collection_type, bool is_frozen = true) {
+  std::string tuple_cql_builder(CassValueType tuple_type, unsigned int size,
+                                CassValueType collection_type, bool is_frozen = true) {
     std::string cql_value_type = test_utils::get_value_type(tuple_type);
     std::string tuple_value_types = cql_value_type;
 
     // Determine if this is a nested collection
-    if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP || collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
+    if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP ||
+        collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
       // Build the nested collection
       std::string collection_cql_value_type = test_utils::get_value_type(collection_type);
       tuple_value_types = collection_cql_value_type + "<";
@@ -103,16 +108,19 @@ struct TupleTests : public test_utils::SingleSessionTest {
    */
   static const CassValueType nested_collection_types_[];
 
-  TupleTests() : test_utils::SingleSessionTest(1, 0) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
+  TupleTests()
+      : test_utils::SingleSessionTest(1, 0) {
+    test_utils::execute_query(session,
+                              str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) %
+                                  test_utils::SIMPLE_KEYSPACE % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
   }
 
   ~TupleTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % test_utils::SIMPLE_KEYSPACE));
+    test_utils::execute_query_with_error(
+        session,
+        str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % test_utils::SIMPLE_KEYSPACE));
   }
 
   /**
@@ -127,23 +135,29 @@ struct TupleTests : public test_utils::SingleSessionTest {
    *                        CassCollectionType to be considered for tuple.
    */
   template <class T>
-  void insert_varying_sized_value(CassValueType tuple_type, T tuple_values, unsigned int size = 1, CassValueType collection_type = CASS_VALUE_TYPE_UNKNOWN) {
+  void insert_varying_sized_value(CassValueType tuple_type, T tuple_values, unsigned int size = 1,
+                                  CassValueType collection_type = CASS_VALUE_TYPE_UNKNOWN) {
     // Create the table for the test
     std::string table_name = table_name_builder(tuple_type, size, collection_type);
     std::string tuple_cql = tuple_cql_builder(tuple_type, size, collection_type);
-    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + tuple_cql + ")";
+    std::string create_table =
+        "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + tuple_cql + ")";
     test_utils::execute_query(session, create_table.c_str());
 
     // Insert the values into the tuple collection
     test_utils::CassTuplePtr tuple(cass_tuple_new(size));
     for (unsigned int i = 0; i < size; ++i) {
       // Handle collection subtypes
-      if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP || collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
-        test_utils::CassCollectionPtr collection(cass_collection_new(static_cast<CassCollectionType>(collection_type), size));
+      if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP ||
+          collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
+        test_utils::CassCollectionPtr collection(
+            cass_collection_new(static_cast<CassCollectionType>(collection_type), size));
         for (unsigned int j = 0; j < size; ++j) {
-          BOOST_REQUIRE_EQUAL(test_utils::Value<T>::append(collection.get(), tuple_values), CASS_OK);
+          BOOST_REQUIRE_EQUAL(test_utils::Value<T>::append(collection.get(), tuple_values),
+                              CASS_OK);
           if (collection_type == CASS_VALUE_TYPE_MAP) {
-            BOOST_REQUIRE_EQUAL(test_utils::Value<T>::append(collection.get(), tuple_values), CASS_OK);
+            BOOST_REQUIRE_EQUAL(test_utils::Value<T>::append(collection.get(), tuple_values),
+                                CASS_OK);
           }
         }
         BOOST_REQUIRE_EQUAL(cass_tuple_set_collection(tuple.get(), i, collection.get()), CASS_OK);
@@ -159,13 +173,15 @@ struct TupleTests : public test_utils::SingleSessionTest {
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
     BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
     BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
 
     // Ensure the tuple collection can be read
     std::string select_query = "SELECT value FROM " + table_name + " WHERE key=?";
     statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
     BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-    test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
+    test_utils::CassFuturePtr future =
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
     test_utils::CassResultPtr result(cass_future_get_result(future.get()));
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -186,27 +202,38 @@ struct TupleTests : public test_utils::SingleSessionTest {
       if (cass_value_is_collection(abstract_collection_value)) {
         BOOST_REQUIRE_EQUAL(cass_value_type(abstract_collection_value), collection_type);
         BOOST_REQUIRE_EQUAL(cass_value_primary_sub_type(abstract_collection_value), tuple_type);
-        BOOST_REQUIRE_EQUAL(cass_value_secondary_sub_type(abstract_collection_value), collection_type == CASS_VALUE_TYPE_MAP ? tuple_type : CASS_VALUE_TYPE_UNKNOWN);
+        BOOST_REQUIRE_EQUAL(cass_value_secondary_sub_type(abstract_collection_value),
+                            collection_type == CASS_VALUE_TYPE_MAP ? tuple_type
+                                                                   : CASS_VALUE_TYPE_UNKNOWN);
         BOOST_REQUIRE_EQUAL(cass_value_item_count(abstract_collection_value), size);
 
-        test_utils::CassIteratorPtr subtype_iterator(cass_iterator_from_collection(abstract_collection_value));
+        test_utils::CassIteratorPtr subtype_iterator(
+            cass_iterator_from_collection(abstract_collection_value));
         int subtype_count = 0;
         while (cass_iterator_next(subtype_iterator.get())) {
           ++subtype_count;
           T collection_value;
-          BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(subtype_iterator.get())) == tuple_type);
-          BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()), &collection_value), CASS_OK);
+          BOOST_REQUIRE(cass_value_type(cass_iterator_get_value(subtype_iterator.get())) ==
+                        tuple_type);
+          BOOST_REQUIRE_EQUAL(
+              test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()),
+                                        &collection_value),
+              CASS_OK);
           BOOST_REQUIRE(test_utils::Value<T>::equal(collection_value, tuple_values));
           if (collection_type == CASS_VALUE_TYPE_MAP) {
             BOOST_REQUIRE(cass_iterator_next(subtype_iterator.get()) == cass_true);
-            BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()), &collection_value), CASS_OK);
+            BOOST_REQUIRE_EQUAL(
+                test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()),
+                                          &collection_value),
+                CASS_OK);
             BOOST_REQUIRE(test_utils::Value<T>::equal(collection_value, tuple_values));
           }
         }
         BOOST_REQUIRE_EQUAL(subtype_count, size);
       } else {
         T tuple_value;
-        BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(abstract_collection_value, &tuple_value), CASS_OK);
+        BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(abstract_collection_value, &tuple_value),
+                            CASS_OK);
         BOOST_REQUIRE(test_utils::Value<T>::equal(tuple_value, tuple_values));
       }
     }
@@ -214,29 +241,33 @@ struct TupleTests : public test_utils::SingleSessionTest {
   }
 
   /**
-  * Insert and validate a tuple of varying size
-  *
-  * @param tuple_type CassValueType to use for value
-  * @param size Size of the tuple (default: 1)
-  * @param collection_type Value type to use when overriding primary subtype
-  *                        (default: CASS_VALUE_TYPE_UNKNOWN; indicates not
-  *                        overridden). NOTE: This value must map to a
-  *                        CassCollectionType to be considered for tuple.
-  */
+   * Insert and validate a tuple of varying size
+   *
+   * @param tuple_type CassValueType to use for value
+   * @param size Size of the tuple (default: 1)
+   * @param collection_type Value type to use when overriding primary subtype
+   *                        (default: CASS_VALUE_TYPE_UNKNOWN; indicates not
+   *                        overridden). NOTE: This value must map to a
+   *                        CassCollectionType to be considered for tuple.
+   */
   template <class T>
-  void insert_varying_sized_null_value(CassValueType tuple_type, unsigned int size = 1, CassValueType collection_type = CASS_VALUE_TYPE_UNKNOWN) {
+  void insert_varying_sized_null_value(CassValueType tuple_type, unsigned int size = 1,
+                                       CassValueType collection_type = CASS_VALUE_TYPE_UNKNOWN) {
     // Create the table for the test
     std::string table_name = table_name_builder(tuple_type, size, collection_type) + "_null";
     std::string tuple_cql = tuple_cql_builder(tuple_type, size, collection_type);
-    std::string create_table = "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + tuple_cql + ")";
+    std::string create_table =
+        "CREATE TABLE " + table_name + "(key timeuuid PRIMARY KEY, value " + tuple_cql + ")";
     test_utils::execute_query(session, create_table.c_str());
 
     // Create empty (null) tuple collection
     test_utils::CassTuplePtr tuple(cass_tuple_new(size));
     for (unsigned int i = 0; i < size; ++i) {
       // Handle collection subtypes
-      if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP || collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
-        test_utils::CassCollectionPtr collection(cass_collection_new(static_cast<CassCollectionType>(collection_type), size));
+      if (collection_type == CASS_VALUE_TYPE_LIST || collection_type == CASS_VALUE_TYPE_MAP ||
+          collection_type == CASS_VALUE_TYPE_SET || collection_type == CASS_VALUE_TYPE_TUPLE) {
+        test_utils::CassCollectionPtr collection(
+            cass_collection_new(static_cast<CassCollectionType>(collection_type), size));
         BOOST_REQUIRE_EQUAL(cass_tuple_set_collection(tuple.get(), i, collection.get()), CASS_OK);
       }
     }
@@ -247,13 +278,15 @@ struct TupleTests : public test_utils::SingleSessionTest {
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
     BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
     BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get())).get());
 
     // Ensure the tuple collection can be read
     std::string select_query = "SELECT value FROM " + table_name + " WHERE key=?";
     statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
     BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-    test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
+    test_utils::CassFuturePtr future =
+        test_utils::CassFuturePtr(cass_session_execute(session, statement.get()));
     test_utils::wait_and_check_error(future.get());
     test_utils::CassResultPtr result(cass_future_get_result(future.get()));
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -274,28 +307,38 @@ struct TupleTests : public test_utils::SingleSessionTest {
       if (cass_value_is_collection(abstract_collection_value)) {
         BOOST_REQUIRE_EQUAL(cass_value_type(abstract_collection_value), collection_type);
         BOOST_REQUIRE_EQUAL(cass_value_primary_sub_type(abstract_collection_value), tuple_type);
-        BOOST_REQUIRE_EQUAL(cass_value_secondary_sub_type(abstract_collection_value), collection_type == CASS_VALUE_TYPE_MAP ? tuple_type : CASS_VALUE_TYPE_UNKNOWN);
+        BOOST_REQUIRE_EQUAL(cass_value_secondary_sub_type(abstract_collection_value),
+                            collection_type == CASS_VALUE_TYPE_MAP ? tuple_type
+                                                                   : CASS_VALUE_TYPE_UNKNOWN);
         BOOST_REQUIRE_EQUAL(cass_value_item_count(abstract_collection_value), size);
 
-        test_utils::CassIteratorPtr subtype_iterator(cass_iterator_from_collection(abstract_collection_value));
+        test_utils::CassIteratorPtr subtype_iterator(
+            cass_iterator_from_collection(abstract_collection_value));
         int subtype_count = 0;
         while (cass_iterator_next(subtype_iterator.get())) {
           ++subtype_count;
           BOOST_REQUIRE(cass_value_is_null(cass_iterator_get_value(subtype_iterator.get())));
           T collection_value;
-          BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()), &collection_value), CASS_ERROR_LIB_NULL_VALUE);
+          BOOST_REQUIRE_EQUAL(
+              test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()),
+                                        &collection_value),
+              CASS_ERROR_LIB_NULL_VALUE);
           if (collection_type == CASS_VALUE_TYPE_MAP) {
             BOOST_REQUIRE(cass_iterator_next(subtype_iterator.get()) == cass_true);
             BOOST_REQUIRE(cass_value_is_null(cass_iterator_get_value(subtype_iterator.get())));
             T collection_value;
-            BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()), &collection_value), CASS_ERROR_LIB_NULL_VALUE);
+            BOOST_REQUIRE_EQUAL(
+                test_utils::Value<T>::get(cass_iterator_get_value(subtype_iterator.get()),
+                                          &collection_value),
+                CASS_ERROR_LIB_NULL_VALUE);
           }
         }
         BOOST_REQUIRE_EQUAL(subtype_count, size);
       } else {
         BOOST_REQUIRE(cass_value_is_null(abstract_collection_value));
         T collection_value;
-        BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(abstract_collection_value, &collection_value), CASS_ERROR_LIB_NULL_VALUE);
+        BOOST_REQUIRE_EQUAL(test_utils::Value<T>::get(abstract_collection_value, &collection_value),
+                            CASS_ERROR_LIB_NULL_VALUE);
       }
     }
     BOOST_REQUIRE_EQUAL(count, size);
@@ -303,8 +346,9 @@ struct TupleTests : public test_utils::SingleSessionTest {
 };
 
 const unsigned int TupleTests::sizes_[] = { 1, 2, 3, 5, 37, 73, 74, 877 };
-//TODO: Determine why nested collections are not working properly (values are inserted as seen via cqlsh)
-//const CassValueType TupleTests::nested_collection_types_[] = { CASS_VALUE_TYPE_UNKNOWN, CASS_VALUE_TYPE_LIST, CASS_VALUE_TYPE_MAP, CASS_VALUE_TYPE_SET, CASS_VALUE_TYPE_TUPLE };
+// TODO: Determine why nested collections are not working properly (values are inserted as seen via
+// cqlsh) const CassValueType TupleTests::nested_collection_types_[] = { CASS_VALUE_TYPE_UNKNOWN,
+// CASS_VALUE_TYPE_LIST, CASS_VALUE_TYPE_MAP, CASS_VALUE_TYPE_SET, CASS_VALUE_TYPE_TUPLE };
 const CassValueType TupleTests::nested_collection_types_[] = { CASS_VALUE_TYPE_UNKNOWN };
 
 BOOST_AUTO_TEST_SUITE(tuples)
@@ -323,7 +367,8 @@ BOOST_AUTO_TEST_CASE(read_write) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     TupleTests tester;
-    std::string create_table = "CREATE TABLE tuple_read_write(key int PRIMARY KEY, value frozen<tuple<int, text, float>>)";
+    std::string create_table =
+        "CREATE TABLE tuple_read_write(key int PRIMARY KEY, value frozen<tuple<int, text, float>>)";
     std::string insert_query = "INSERT INTO tuple_read_write(key, value) VALUES (?, ?)";
     std::string select_query = "SELECT value FROM tuple_read_write WHERE key=?";
 
@@ -340,28 +385,33 @@ BOOST_AUTO_TEST_CASE(read_write) {
         std::string random_string = test_utils::generate_random_string();
         CassString tuple_string = CassString(random_string.c_str());
         test_utils::Value<CassString>::tuple_set(tuple.get(), 1, tuple_string);
-        test_utils::Value<cass_float_t>::tuple_set(tuple.get(), 2, static_cast<cass_float_t>(size * 100.0f));
+        test_utils::Value<cass_float_t>::tuple_set(tuple.get(), 2,
+                                                   static_cast<cass_float_t>(size * 100.0f));
 
         // Bind and insert the tuple collection into Cassandra
         test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
         // Alternate bound parameters (simple) and prepared statement use
         if (size % 2 == 0) {
-          test_utils::CassPreparedPtr prepared = test_utils::prepare(tester.session, insert_query.c_str());
+          test_utils::CassPreparedPtr prepared =
+              test_utils::prepare(tester.session, insert_query.c_str());
           statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
         }
         BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, size), CASS_OK);
         BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-        test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+        test_utils::wait_and_check_error(
+            test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
         // Ensure the tuple collection can be read
         statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
         // Alternate bound parameters (simple) and prepared statement use
         if (size % 2 == 0) {
-          test_utils::CassPreparedPtr prepared = test_utils::prepare(tester.session, select_query.c_str());
+          test_utils::CassPreparedPtr prepared =
+              test_utils::prepare(tester.session, select_query.c_str());
           statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
         }
         BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, size), CASS_OK);
-        test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+        test_utils::CassFuturePtr future =
+            test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
         test_utils::wait_and_check_error(future.get());
         test_utils::CassResultPtr result(cass_future_get_result(future.get()));
         BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -374,16 +424,23 @@ BOOST_AUTO_TEST_CASE(read_write) {
         test_utils::CassIteratorPtr iterator(cass_iterator_from_tuple(value));
         cass_iterator_next(iterator.get());
         cass_int32_t value_integer;
-        BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::get(cass_iterator_get_value(iterator.get()), &value_integer), CASS_OK);
+        BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::get(
+                                cass_iterator_get_value(iterator.get()), &value_integer),
+                            CASS_OK);
         BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(value_integer, size * 10));
         cass_iterator_next(iterator.get());
         CassString value_string;
-        BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(cass_iterator_get_value(iterator.get()), &value_string), CASS_OK);
+        BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(
+                                cass_iterator_get_value(iterator.get()), &value_string),
+                            CASS_OK);
         BOOST_REQUIRE(test_utils::Value<CassString>::equal(value_string, tuple_string));
         cass_iterator_next(iterator.get());
         cass_float_t value_float;
-        BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(cass_iterator_get_value(iterator.get()), &value_float), CASS_OK);
-        BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(value_float, static_cast<cass_float_t>(size * 100.0f)));
+        BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(
+                                cass_iterator_get_value(iterator.get()), &value_float),
+                            CASS_OK);
+        BOOST_REQUIRE(test_utils::Value<cass_float_t>::equal(
+            value_float, static_cast<cass_float_t>(size * 100.0f)));
       }
     }
 
@@ -397,12 +454,14 @@ BOOST_AUTO_TEST_CASE(read_write) {
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 1), CASS_OK);
       BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the tuple collection can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 1), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -415,19 +474,26 @@ BOOST_AUTO_TEST_CASE(read_write) {
       test_utils::CassIteratorPtr iterator(cass_iterator_from_tuple(value));
       cass_iterator_next(iterator.get());
       cass_int32_t value_integer;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::get(cass_iterator_get_value(iterator.get()), &value_integer), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::get(
+                              cass_iterator_get_value(iterator.get()), &value_integer),
+                          CASS_OK);
       BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(value_integer, 123));
       cass_iterator_next(iterator.get());
       CassString value_string;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(cass_iterator_get_value(iterator.get()), &value_string), CASS_OK);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::get(
+                              cass_iterator_get_value(iterator.get()), &value_string),
+                          CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassString>::equal(value_string, "foo"));
       cass_iterator_next(iterator.get());
       BOOST_REQUIRE(cass_value_is_null(cass_iterator_get_value(iterator.get())));
       cass_float_t value_float;
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(cass_iterator_get_value(iterator.get()), &value_float), CASS_ERROR_LIB_NULL_VALUE);
+      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_float_t>::get(
+                              cass_iterator_get_value(iterator.get()), &value_float),
+                          CASS_ERROR_LIB_NULL_VALUE);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping tuples/read_write" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping tuples/read_write" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -451,89 +517,115 @@ BOOST_AUTO_TEST_CASE(varying_size) {
     // Create some varying size tuple tests (primitives)
     for (unsigned int i = 0; i < (sizeof(tester.sizes_) / sizeof(int)); ++i) {
       unsigned int size = tester.sizes_[i];
-      for (unsigned int j = 0; j < (sizeof(tester.nested_collection_types_) / sizeof(CassValueType)); ++j) {
+      for (unsigned int j = 0;
+           j < (sizeof(tester.nested_collection_types_) / sizeof(CassValueType)); ++j) {
         CassValueType nested_collection_type = tester.nested_collection_types_[j];
-        if (nested_collection_type == CASS_VALUE_TYPE_UNKNOWN || size <= NESTED_COLLECTION_SIZE_LIMITER) {
+        if (nested_collection_type == CASS_VALUE_TYPE_UNKNOWN ||
+            size <= NESTED_COLLECTION_SIZE_LIMITER) {
           {
             CassString value("Test Value");
-            tester.insert_varying_sized_value<CassString>(CASS_VALUE_TYPE_ASCII, value, size, nested_collection_type);
-            tester.insert_varying_sized_value<CassString>(CASS_VALUE_TYPE_VARCHAR, value, size, nested_collection_type); // NOTE: text is alias for varchar
+            tester.insert_varying_sized_value<CassString>(CASS_VALUE_TYPE_ASCII, value, size,
+                                                          nested_collection_type);
+            tester.insert_varying_sized_value<CassString>(
+                CASS_VALUE_TYPE_VARCHAR, value, size,
+                nested_collection_type); // NOTE: text is alias for varchar
           }
 
           {
             cass_int64_t value = 1234567890;
-            tester.insert_varying_sized_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, value, size, nested_collection_type);
-            tester.insert_varying_sized_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, value, size,
+                                                            nested_collection_type);
+            tester.insert_varying_sized_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, value, size,
+                                                            nested_collection_type);
           }
 
           {
-            CassBytes value = test_utils::bytes_from_string("012345678900123456789001234567890012345678900123456789001234567890");
-            tester.insert_varying_sized_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value, size, nested_collection_type);
-            tester.insert_varying_sized_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value, size, nested_collection_type);
+            CassBytes value = test_utils::bytes_from_string(
+                "012345678900123456789001234567890012345678900123456789001234567890");
+            tester.insert_varying_sized_value<CassBytes>(CASS_VALUE_TYPE_BLOB, value, size,
+                                                         nested_collection_type);
+            tester.insert_varying_sized_value<CassBytes>(CASS_VALUE_TYPE_VARINT, value, size,
+                                                         nested_collection_type);
           }
 
-          tester.insert_varying_sized_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true, size, nested_collection_type);
+          tester.insert_varying_sized_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, cass_true, size,
+                                                         nested_collection_type);
 
           {
-            const cass_uint8_t pi[] = { 57, 115, 235, 135, 229, 215, 8, 125, 13, 43, 1, 25, 32, 135, 129, 180,
-              112, 176, 158, 120, 246, 235, 29, 145, 238, 50, 108, 239, 219, 100, 250,
-              84, 6, 186, 148, 76, 230, 46, 181, 89, 239, 247 };
+            const cass_uint8_t pi[] = { 57,  115, 235, 135, 229, 215, 8,   125, 13,  43,  1,
+                                        25,  32,  135, 129, 180, 112, 176, 158, 120, 246, 235,
+                                        29,  145, 238, 50,  108, 239, 219, 100, 250, 84,  6,
+                                        186, 148, 76,  230, 46,  181, 89,  239, 247 };
             const cass_int32_t pi_scale = 100;
             CassDecimal value = CassDecimal(pi, sizeof(pi), pi_scale);
-            tester.insert_varying_sized_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, value, size,
+                                                           nested_collection_type);
           }
 
-          if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
+          if ((version.major_version >= 3 && version.minor_version >= 10) ||
+              version.major_version >= 4) {
             CassDuration value = CassDuration(1, 2, 3);
-            tester.insert_varying_sized_value<CassDuration>(CASS_VALUE_TYPE_DURATION, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<CassDuration>(CASS_VALUE_TYPE_DURATION, value, size,
+                                                            nested_collection_type);
           }
 
-          tester.insert_varying_sized_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, 3.141592653589793, size, nested_collection_type);
-          tester.insert_varying_sized_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, 3.1415926f, size, nested_collection_type);
-          tester.insert_varying_sized_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123, size, nested_collection_type);
-          if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
-            tester.insert_varying_sized_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123, size, nested_collection_type);
-            tester.insert_varying_sized_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123, size, nested_collection_type);
-            tester.insert_varying_sized_value<CassDate>(CASS_VALUE_TYPE_DATE,
-                                                                    test_utils::Value<CassDate>::min_value() + 1u,
-                                                                    size, nested_collection_type);
-            tester.insert_varying_sized_value<CassTime>(CASS_VALUE_TYPE_TIME, 123, size, nested_collection_type);
+          tester.insert_varying_sized_value<cass_double_t>(
+              CASS_VALUE_TYPE_DOUBLE, 3.141592653589793, size, nested_collection_type);
+          tester.insert_varying_sized_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, 3.1415926f, size,
+                                                          nested_collection_type);
+          tester.insert_varying_sized_value<cass_int32_t>(CASS_VALUE_TYPE_INT, 123, size,
+                                                          nested_collection_type);
+          if ((version.major_version >= 2 && version.minor_version >= 2) ||
+              version.major_version >= 3) {
+            tester.insert_varying_sized_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, 123, size,
+                                                            nested_collection_type);
+            tester.insert_varying_sized_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, 123, size,
+                                                           nested_collection_type);
+            tester.insert_varying_sized_value<CassDate>(
+                CASS_VALUE_TYPE_DATE, test_utils::Value<CassDate>::min_value() + 1u, size,
+                nested_collection_type);
+            tester.insert_varying_sized_value<CassTime>(CASS_VALUE_TYPE_TIME, 123, size,
+                                                        nested_collection_type);
           }
 
           {
             CassUuid value = test_utils::generate_random_uuid(tester.uuid_gen);
-            tester.insert_varying_sized_value<CassUuid>(CASS_VALUE_TYPE_UUID, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<CassUuid>(CASS_VALUE_TYPE_UUID, value, size,
+                                                        nested_collection_type);
           }
 
           {
             CassInet value = test_utils::inet_v4_from_int(16777343); // 127.0.0.1
-            tester.insert_varying_sized_value<CassInet>(CASS_VALUE_TYPE_INET, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<CassInet>(CASS_VALUE_TYPE_INET, value, size,
+                                                        nested_collection_type);
           }
 
           {
             CassUuid value = test_utils::generate_time_uuid(tester.uuid_gen);
-            tester.insert_varying_sized_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, value, size, nested_collection_type);
+            tester.insert_varying_sized_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, value, size,
+                                                        nested_collection_type);
           }
         }
       }
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping tuples/varying_size" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping tuples/varying_size" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
 /**
-* Null Tuples
-*
-* This test ensures tuples can be read/written using Cassandra v2.1+ of varying
-* sizes with null values.
-*
-* @since 2.1.0-beta
-* @jira_ticket CPP-262
-* @test_category data_types:tuples
-* @cassandra_version 2.1.x
-*/
+ * Null Tuples
+ *
+ * This test ensures tuples can be read/written using Cassandra v2.1+ of varying
+ * sizes with null values.
+ *
+ * @since 2.1.0-beta
+ * @jira_ticket CPP-262
+ * @test_category data_types:tuples
+ * @cassandra_version 2.1.x
+ */
 BOOST_AUTO_TEST_CASE(null) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
@@ -542,54 +634,79 @@ BOOST_AUTO_TEST_CASE(null) {
     // Create some varying size null tuple tests
     for (unsigned int i = 0; i < (sizeof(tester.sizes_) / sizeof(int)); ++i) {
       unsigned int size = tester.sizes_[i];
-      for (unsigned int j = 0; j < (sizeof(tester.nested_collection_types_) / sizeof(CassValueType)); ++j) {
+      for (unsigned int j = 0;
+           j < (sizeof(tester.nested_collection_types_) / sizeof(CassValueType)); ++j) {
         CassValueType nested_collection_type = tester.nested_collection_types_[j];
-        tester.insert_varying_sized_null_value<CassString>(CASS_VALUE_TYPE_ASCII, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassString>(CASS_VALUE_TYPE_VARCHAR, size, nested_collection_type); // NOTE: text is alias for varchar
-        tester.insert_varying_sized_null_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassBytes>(CASS_VALUE_TYPE_BLOB, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassBytes>(CASS_VALUE_TYPE_VARINT, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<cass_int32_t>(CASS_VALUE_TYPE_INT, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassUuid>(CASS_VALUE_TYPE_UUID, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassInet>(CASS_VALUE_TYPE_INET, size, nested_collection_type);
-        tester.insert_varying_sized_null_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, size, nested_collection_type);
-        if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
-          tester.insert_varying_sized_null_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, size, nested_collection_type);
-          tester.insert_varying_sized_null_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, size, nested_collection_type);
-          tester.insert_varying_sized_null_value<CassDate>(CASS_VALUE_TYPE_DATE, size, nested_collection_type);
-          tester.insert_varying_sized_null_value<CassTime>(CASS_VALUE_TYPE_TIME, size, nested_collection_type);
+        tester.insert_varying_sized_null_value<CassString>(CASS_VALUE_TYPE_ASCII, size,
+                                                           nested_collection_type);
+        tester.insert_varying_sized_null_value<CassString>(
+            CASS_VALUE_TYPE_VARCHAR, size,
+            nested_collection_type); // NOTE: text is alias for varchar
+        tester.insert_varying_sized_null_value<cass_int64_t>(CASS_VALUE_TYPE_BIGINT, size,
+                                                             nested_collection_type);
+        tester.insert_varying_sized_null_value<cass_int64_t>(CASS_VALUE_TYPE_TIMESTAMP, size,
+                                                             nested_collection_type);
+        tester.insert_varying_sized_null_value<CassBytes>(CASS_VALUE_TYPE_BLOB, size,
+                                                          nested_collection_type);
+        tester.insert_varying_sized_null_value<CassBytes>(CASS_VALUE_TYPE_VARINT, size,
+                                                          nested_collection_type);
+        tester.insert_varying_sized_null_value<cass_bool_t>(CASS_VALUE_TYPE_BOOLEAN, size,
+                                                            nested_collection_type);
+        tester.insert_varying_sized_null_value<CassDecimal>(CASS_VALUE_TYPE_DECIMAL, size,
+                                                            nested_collection_type);
+        tester.insert_varying_sized_null_value<cass_double_t>(CASS_VALUE_TYPE_DOUBLE, size,
+                                                              nested_collection_type);
+        tester.insert_varying_sized_null_value<cass_float_t>(CASS_VALUE_TYPE_FLOAT, size,
+                                                             nested_collection_type);
+        tester.insert_varying_sized_null_value<cass_int32_t>(CASS_VALUE_TYPE_INT, size,
+                                                             nested_collection_type);
+        tester.insert_varying_sized_null_value<CassUuid>(CASS_VALUE_TYPE_UUID, size,
+                                                         nested_collection_type);
+        tester.insert_varying_sized_null_value<CassInet>(CASS_VALUE_TYPE_INET, size,
+                                                         nested_collection_type);
+        tester.insert_varying_sized_null_value<CassUuid>(CASS_VALUE_TYPE_TIMEUUID, size,
+                                                         nested_collection_type);
+        if ((version.major_version >= 2 && version.minor_version >= 2) ||
+            version.major_version >= 3) {
+          tester.insert_varying_sized_null_value<cass_int8_t>(CASS_VALUE_TYPE_TINY_INT, size,
+                                                              nested_collection_type);
+          tester.insert_varying_sized_null_value<cass_int16_t>(CASS_VALUE_TYPE_SMALL_INT, size,
+                                                               nested_collection_type);
+          tester.insert_varying_sized_null_value<CassDate>(CASS_VALUE_TYPE_DATE, size,
+                                                           nested_collection_type);
+          tester.insert_varying_sized_null_value<CassTime>(CASS_VALUE_TYPE_TIME, size,
+                                                           nested_collection_type);
         }
-        if ((version.major_version >= 3 && version.minor_version >= 10) || version.major_version >= 4) {
-          tester.insert_varying_sized_null_value<CassDuration>(CASS_VALUE_TYPE_DURATION, size, nested_collection_type);
+        if ((version.major_version >= 3 && version.minor_version >= 10) ||
+            version.major_version >= 4) {
+          tester.insert_varying_sized_null_value<CassDuration>(CASS_VALUE_TYPE_DURATION, size,
+                                                               nested_collection_type);
         }
       }
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping tuples/null" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping tuples/null" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
 /**
-* Invalid Tuple
-*
-* This test ensures invalid tuples cannot be written to Cassandra
-*
-* @since 2.1.0-beta
-* @jira_ticket CPP-262
-* @test_category data_types:tuples
-* @cassandra_version 2.1.x
-*/
+ * Invalid Tuple
+ *
+ * This test ensures invalid tuples cannot be written to Cassandra
+ *
+ * @since 2.1.0-beta
+ * @jira_ticket CPP-262
+ * @test_category data_types:tuples
+ * @cassandra_version 2.1.x
+ */
 BOOST_AUTO_TEST_CASE(invalid) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     TupleTests tester;
-    std::string create_table = "CREATE TABLE tuple_invalid(key int PRIMARY KEY, value frozen<tuple<int, text, float>>)";
+    std::string create_table =
+        "CREATE TABLE tuple_invalid(key int PRIMARY KEY, value frozen<tuple<int, text, float>>)";
     std::string insert_query = "INSERT INTO tuple_invalid(key, value) VALUES (?, ?)";
     std::string select_query = "SELECT value FROM tuple_invalid WHERE key=?";
 
@@ -609,8 +726,11 @@ BOOST_AUTO_TEST_CASE(invalid) {
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 1), CASS_OK);
       BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::wait_and_return_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get()),
-                          CASS_ERROR_SERVER_INVALID_QUERY);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::wait_and_return_error(
+              test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()))
+                  .get()),
+          CASS_ERROR_SERVER_INVALID_QUERY);
     }
 
     // Invalid type in tuple
@@ -624,11 +744,15 @@ BOOST_AUTO_TEST_CASE(invalid) {
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_int32(statement.get(), 0, 1), CASS_OK);
       BOOST_REQUIRE_EQUAL(cass_statement_bind_tuple(statement.get(), 1, tuple.get()), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::wait_and_return_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get()),
-                          CASS_ERROR_SERVER_INVALID_QUERY);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::wait_and_return_error(
+              test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()))
+                  .get()),
+          CASS_ERROR_SERVER_INVALID_QUERY);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping tuples/invalid" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping tuples/invalid" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_udts.cpp b/test/integration_tests/src/test_udts.cpp
index 86d85dfca..51035c7f2 100644
--- a/test/integration_tests/src/test_udts.cpp
+++ b/test/integration_tests/src/test_udts.cpp
@@ -14,9 +14,9 @@
   limitations under the License.
 */
 
+#include "cassandra.h"
 #include "test_utils.hpp"
 #include "testing.hpp"
-#include "cassandra.h"
 
 #include <boost/format.hpp>
 #include <boost/test/unit_test.hpp>
@@ -29,7 +29,8 @@ typedef std::map<CassString, CassString> PhoneMap;
 typedef std::pair<CassString, CassString> PhonePair;
 
 #define PHONE_UDT_CQL "CREATE TYPE phone (alias text, number text)"
-#define ADDRESS_UDT_CQL "CREATE TYPE address (street text, \"ZIP\" int, phone_numbers set<frozen<phone>>)"
+#define ADDRESS_UDT_CQL \
+  "CREATE TYPE address (street text, \"ZIP\" int, phone_numbers set<frozen<phone>>)"
 
 struct UDTTests : public test_utils::SingleSessionTest {
 private:
@@ -61,7 +62,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
     const CassDataType* datatype = NULL;
     while (udt_field_names.empty() && ++count <= 10) {
       update_schema();
-      const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta_.get(), keyspace_.c_str());
+      const CassKeyspaceMeta* keyspace_meta =
+          cass_schema_meta_keyspace_by_name(schema_meta_.get(), keyspace_.c_str());
       BOOST_REQUIRE(keyspace_meta != NULL);
       datatype = cass_keyspace_meta_user_type_by_name(keyspace_meta, udt_name.c_str());
       if (datatype == NULL) {
@@ -73,18 +75,18 @@ struct UDTTests : public test_utils::SingleSessionTest {
 
 public:
   UDTTests()
-    : test_utils::SingleSessionTest(1, 0)
-    , schema_meta_(NULL)
-    , keyspace_(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
-    test_utils::execute_query(session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace_ % "1"));
+      : test_utils::SingleSessionTest(1, 0)
+      , schema_meta_(NULL)
+      , keyspace_(str(boost::format("ks_%s") % test_utils::generate_unique_str(uuid_gen))) {
+    test_utils::execute_query(
+        session, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % keyspace_ % "1"));
     test_utils::execute_query(session, str(boost::format("USE %s") % keyspace_));
   }
 
   ~UDTTests() {
     // Drop the keyspace (ignore any and all errors)
-    test_utils::execute_query_with_error(session,
-      str(boost::format(test_utils::DROP_KEYSPACE_FORMAT)
-      % keyspace_));
+    test_utils::execute_query_with_error(
+        session, str(boost::format(test_utils::DROP_KEYSPACE_FORMAT) % keyspace_));
   }
 
   /**
@@ -103,11 +105,13 @@ struct UDTTests : public test_utils::SingleSessionTest {
    * @param udt_name UDT name to create from schema
    * @return UDT
    */
-  test_utils::CassUserTypePtr new_udt(const std::string &udt_name) {
+  test_utils::CassUserTypePtr new_udt(const std::string& udt_name) {
     verify_user_type(udt_name);
-    const CassKeyspaceMeta* keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta_.get(), keyspace_.c_str());
+    const CassKeyspaceMeta* keyspace_meta =
+        cass_schema_meta_keyspace_by_name(schema_meta_.get(), keyspace_.c_str());
     BOOST_REQUIRE(keyspace_meta != NULL);
-    const CassDataType* datatype = cass_keyspace_meta_user_type_by_name(keyspace_meta, udt_name.c_str());
+    const CassDataType* datatype =
+        cass_keyspace_meta_user_type_by_name(keyspace_meta, udt_name.c_str());
     BOOST_REQUIRE(datatype != NULL);
     return test_utils::CassUserTypePtr(cass_user_type_new_from_data_type(datatype));
   }
@@ -117,18 +121,14 @@ struct UDTTests : public test_utils::SingleSessionTest {
    *
    * @return Phone UDT
    */
-  test_utils::CassUserTypePtr new_phone_udt() {
-    return new_udt("phone");
-  }
+  test_utils::CassUserTypePtr new_phone_udt() { return new_udt("phone"); }
 
   /**
-  * Create a new address UDT
-  *
-  * @return Address UDT
-  */
-  test_utils::CassUserTypePtr new_address_udt() {
-    return new_udt("address");
-  }
+   * Create a new address UDT
+   *
+   * @return Address UDT
+   */
+  test_utils::CassUserTypePtr new_address_udt() { return new_udt("address"); }
 
   /**
    * Verify the phone UDT field names
@@ -144,13 +144,17 @@ struct UDTTests : public test_utils::SingleSessionTest {
     // Verify alias field name
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
     CassString alias_field_name;
-    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &alias_field_name.data, &alias_field_name.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(
+                            iterator.get(), &alias_field_name.data, &alias_field_name.length),
+                        CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal("alias", alias_field_name));
 
     // Verify number field name
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
     CassString number_field_name;
-    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &number_field_name.data, &number_field_name.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(
+                            iterator.get(), &number_field_name.data, &number_field_name.length),
+                        CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal("number", number_field_name));
   }
 
@@ -161,7 +165,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
    * @param expected_alias Expected alias to verify against result
    * @param expected_number Expected number to verify against result
    */
-  void verify_phone_udt(const CassValue* value, CassString expected_alias, CassString expected_number) {
+  void verify_phone_udt(const CassValue* value, CassString expected_alias,
+                        CassString expected_number) {
     // Verify field names for phone UDT and create the iterator for validation
     verify_phone_udt_field_names(value);
     test_utils::CassIteratorPtr iterator(cass_iterator_fields_from_user_type(value));
@@ -171,7 +176,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
     const CassValue* alias_value = cass_iterator_get_user_type_field_value(iterator.get());
     BOOST_REQUIRE_EQUAL(cass_value_type(alias_value), CASS_VALUE_TYPE_VARCHAR);
     CassString alias_result;
-    BOOST_REQUIRE_EQUAL(cass_value_get_string(alias_value, &alias_result.data, &alias_result.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        cass_value_get_string(alias_value, &alias_result.data, &alias_result.length), CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal(alias_result, expected_alias));
 
     // Verify number result
@@ -179,7 +185,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
     const CassValue* number_value = cass_iterator_get_user_type_field_value(iterator.get());
     BOOST_REQUIRE_EQUAL(cass_value_type(number_value), CASS_VALUE_TYPE_VARCHAR);
     CassString number_result;
-    BOOST_REQUIRE_EQUAL(cass_value_get_string(number_value, &number_result.data, &number_result.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        cass_value_get_string(number_value, &number_result.data, &number_result.length), CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal(number_result, expected_number));
   }
 
@@ -197,19 +204,26 @@ struct UDTTests : public test_utils::SingleSessionTest {
     // Verify street field name
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
     CassString street_field_name;
-    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &street_field_name.data, &street_field_name.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(
+                            iterator.get(), &street_field_name.data, &street_field_name.length),
+                        CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal("street", street_field_name));
 
     // Verify zip field name
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
     CassString zip_field_name;
-    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &zip_field_name.data, &zip_field_name.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &zip_field_name.data,
+                                                               &zip_field_name.length),
+                        CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal("ZIP", zip_field_name));
 
     // Verify phone numbers field name
     BOOST_REQUIRE(cass_iterator_next(iterator.get()));
     CassString phone_numbers_field_name;
-    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &phone_numbers_field_name.data, &phone_numbers_field_name.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(),
+                                                               &phone_numbers_field_name.data,
+                                                               &phone_numbers_field_name.length),
+                        CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal("phone_numbers", phone_numbers_field_name));
   }
 
@@ -221,7 +235,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
    * @param expected_zip Expected zip code to verify against result
    * @param expected_phone_numbers Expected numbers to verify against result
    */
-  void verify_address_udt(const CassValue* value, CassString expected_street, cass_int32_t expected_zip, PhoneMap expected_phone_numbers) {
+  void verify_address_udt(const CassValue* value, CassString expected_street,
+                          cass_int32_t expected_zip, PhoneMap expected_phone_numbers) {
     // Verify field names for address UDT and create the iterator for validation
     verify_address_udt_field_names(value);
     test_utils::CassIteratorPtr iterator(cass_iterator_fields_from_user_type(value));
@@ -231,7 +246,8 @@ struct UDTTests : public test_utils::SingleSessionTest {
     const CassValue* street_value = cass_iterator_get_user_type_field_value(iterator.get());
     BOOST_REQUIRE_EQUAL(cass_value_type(street_value), CASS_VALUE_TYPE_VARCHAR);
     CassString street_result;
-    BOOST_REQUIRE_EQUAL(cass_value_get_string(street_value, &street_result.data, &street_result.length), CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        cass_value_get_string(street_value, &street_result.data, &street_result.length), CASS_OK);
     BOOST_REQUIRE(test_utils::Value<CassString>::equal(street_result, expected_street));
 
     // Verify zip result
@@ -247,11 +263,14 @@ struct UDTTests : public test_utils::SingleSessionTest {
     const CassValue* phone_numbers_value = cass_iterator_get_user_type_field_value(iterator.get());
     BOOST_REQUIRE_EQUAL(cass_value_type(phone_numbers_value), CASS_VALUE_TYPE_SET);
     BOOST_REQUIRE_EQUAL(cass_value_item_count(phone_numbers_value), expected_phone_numbers.size());
-    test_utils::CassIteratorPtr phone_numbers_iterator(cass_iterator_from_collection(phone_numbers_value));
+    test_utils::CassIteratorPtr phone_numbers_iterator(
+        cass_iterator_from_collection(phone_numbers_value));
     unsigned int count = 0;
     PhoneMap::iterator phone_iterator = expected_phone_numbers.begin();
-    while (cass_iterator_next(phone_numbers_iterator.get()) && phone_iterator != expected_phone_numbers.end()) {
-      verify_phone_udt(cass_iterator_get_value(phone_numbers_iterator.get()), phone_iterator->first, phone_iterator->second);
+    while (cass_iterator_next(phone_numbers_iterator.get()) &&
+           phone_iterator != expected_phone_numbers.end()) {
+      verify_phone_udt(cass_iterator_get_value(phone_numbers_iterator.get()), phone_iterator->first,
+                       phone_iterator->second);
       ++phone_iterator;
       ++count;
     }
@@ -291,39 +310,56 @@ BOOST_AUTO_TEST_CASE(read_write) {
       CassString home_phone_number("555-911-1212");
       phone_numbers.insert(PhonePair(home_phone_alias, home_phone_number));
       test_utils::CassUserTypePtr home_phone(tester.new_phone_udt());
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(home_phone.get(), 0, home_phone_alias), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(home_phone.get(), 1, home_phone_number), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(home_phone.get(), 0, home_phone_alias),
+          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(home_phone.get(), 1, home_phone_number),
+          CASS_OK);
       CassString work_phone_alias("Work");
       CassString work_phone_number("650-389-6000");
       phone_numbers.insert(PhonePair(work_phone_alias, work_phone_number));
       test_utils::CassUserTypePtr work_phone(tester.new_phone_udt());
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(work_phone.get(), 0, work_phone_alias), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(work_phone.get(), 1, work_phone_number), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(work_phone.get(), 0, work_phone_alias),
+          CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(work_phone.get(), 1, work_phone_number),
+          CASS_OK);
 
       // Create a collection for the phone numbers
-      test_utils::CassCollectionPtr phone_numbers_set(cass_collection_new(CASS_COLLECTION_TYPE_SET, 2));
-      BOOST_REQUIRE_EQUAL(cass_collection_append_user_type(phone_numbers_set.get(), home_phone.get()), CASS_OK);
-      BOOST_REQUIRE_EQUAL(cass_collection_append_user_type(phone_numbers_set.get(), work_phone.get()), CASS_OK);
+      test_utils::CassCollectionPtr phone_numbers_set(
+          cass_collection_new(CASS_COLLECTION_TYPE_SET, 2));
+      BOOST_REQUIRE_EQUAL(
+          cass_collection_append_user_type(phone_numbers_set.get(), home_phone.get()), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          cass_collection_append_user_type(phone_numbers_set.get(), work_phone.get()), CASS_OK);
 
       // Address number UDT (nested UDT)
       CassString street_address("3975 Freedom Circle");
       cass_int32_t zip_code = 95054;
       test_utils::CassUserTypePtr address(tester.new_address_udt());
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(address.get(), 0, street_address), CASS_OK);
-      BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::user_type_set(address.get(), 1, zip_code), CASS_OK);
-      BOOST_REQUIRE_EQUAL(cass_user_type_set_collection(address.get(), 2, phone_numbers_set.get()), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(address.get(), 0, street_address), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<cass_int32_t>::user_type_set(address.get(), 1, zip_code), CASS_OK);
+      BOOST_REQUIRE_EQUAL(cass_user_type_set_collection(address.get(), 2, phone_numbers_set.get()),
+                          CASS_OK);
 
       // Bind and insert the UDT into Cassandra
       CassUuid key = test_utils::generate_time_uuid(tester.uuid_gen);
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_user_type(statement.get(), 1, address.get()), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      BOOST_REQUIRE_EQUAL(cass_statement_bind_user_type(statement.get(), 1, address.get()),
+                          CASS_OK);
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the UDT can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -338,19 +374,23 @@ BOOST_AUTO_TEST_CASE(read_write) {
       // Street only address UDT (no nested UDT)
       CassString street_address("1 Furzeground Way");
       test_utils::CassUserTypePtr address(tester.new_address_udt());
-      BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set(address.get(), 0, street_address), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::Value<CassString>::user_type_set(address.get(), 0, street_address), CASS_OK);
 
       // Bind and insert the UDT into Cassandra
       CassUuid key = test_utils::generate_time_uuid(tester.uuid_gen);
       test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-      BOOST_REQUIRE_EQUAL(cass_statement_bind_user_type(statement.get(), 1, address.get()), CASS_OK);
-      test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+      BOOST_REQUIRE_EQUAL(cass_statement_bind_user_type(statement.get(), 1, address.get()),
+                          CASS_OK);
+      test_utils::wait_and_check_error(
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
       // Ensure the UDT can be read
       statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
       BOOST_REQUIRE_EQUAL(cass_statement_bind_uuid(statement.get(), 0, key), CASS_OK);
-      test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+      test_utils::CassFuturePtr future =
+          test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
       test_utils::wait_and_check_error(future.get());
       test_utils::CassResultPtr result(cass_future_get_result(future.get()));
       BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -365,7 +405,8 @@ BOOST_AUTO_TEST_CASE(read_write) {
       const CassValue* street_value = cass_iterator_get_user_type_field_value(iterator.get());
       BOOST_REQUIRE_EQUAL(cass_value_type(street_value), CASS_VALUE_TYPE_VARCHAR);
       CassString street_result;
-      BOOST_REQUIRE_EQUAL(cass_value_get_string(street_value, &street_result.data, &street_result.length), CASS_OK);
+      BOOST_REQUIRE_EQUAL(
+          cass_value_get_string(street_value, &street_result.data, &street_result.length), CASS_OK);
       BOOST_REQUIRE(test_utils::Value<CassString>::equal(street_result, street_address));
       // Verify zip result is NULL
       BOOST_REQUIRE(cass_iterator_next(iterator.get()));
@@ -375,7 +416,8 @@ BOOST_AUTO_TEST_CASE(read_write) {
       BOOST_REQUIRE(cass_value_is_null(cass_iterator_get_user_type_field_value(iterator.get())));
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping udts/read_write" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping udts/read_write" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
@@ -394,18 +436,24 @@ BOOST_AUTO_TEST_CASE(invalid) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     UDTTests tester;
-    std::string invalid_udt_missing_frozen_keyword = "CREATE TYPE invalid_udt (id uuid, address address)";
+    std::string invalid_udt_missing_frozen_keyword =
+        "CREATE TYPE invalid_udt (id uuid, address address)";
     std::string invalid_parent_udt = "CREATE TYPE invalid_udt (address frozen<address>)";
-    std::string create_table = "CREATE TABLE invalid_udt_user (id uuid PRIMARY KEY, invalid frozen<invalid_udt>)";
+    std::string create_table =
+        "CREATE TABLE invalid_udt_user (id uuid PRIMARY KEY, invalid frozen<invalid_udt>)";
     std::string insert_query = "INSERT INTO invalid_udt_user(id, invalid) VALUES (?, ?)";
 
     {
       if (version.major_version < 3) {
         // Ensure UDT cannot be created when missing frozen keyword
-        BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, invalid_udt_missing_frozen_keyword.c_str()), CASS_ERROR_SERVER_INVALID_QUERY);
+        BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(
+                                tester.session, invalid_udt_missing_frozen_keyword.c_str()),
+                            CASS_ERROR_SERVER_INVALID_QUERY);
       }
       // Ensure UDT cannot be created when referencing non-existent UDT
-      BOOST_REQUIRE_EQUAL(test_utils::execute_query_with_error(tester.session, invalid_parent_udt.c_str()), CASS_ERROR_SERVER_INVALID_QUERY);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::execute_query_with_error(tester.session, invalid_parent_udt.c_str()),
+          CASS_ERROR_SERVER_INVALID_QUERY);
     }
 
     // Create the UDTs and table for the test
@@ -417,7 +465,8 @@ BOOST_AUTO_TEST_CASE(invalid) {
     {
       test_utils::CassUserTypePtr phone(tester.new_phone_udt());
       test_utils::CassUserTypePtr invalid_udt(tester.new_udt("invalid_udt"));
-      BOOST_REQUIRE_EQUAL(cass_user_type_set_user_type(invalid_udt.get(), 0, phone.get()), CASS_ERROR_LIB_INVALID_VALUE_TYPE);
+      BOOST_REQUIRE_EQUAL(cass_user_type_set_user_type(invalid_udt.get(), 0, phone.get()),
+                          CASS_ERROR_LIB_INVALID_VALUE_TYPE);
     }
 
     // Invalid UDT bound to statement
@@ -431,33 +480,38 @@ BOOST_AUTO_TEST_CASE(invalid) {
       if (version >= "3.11.0") {
         expected_error = CASS_ERROR_SERVER_SERVER_ERROR;
       }
-      BOOST_REQUIRE_EQUAL(test_utils::wait_and_return_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get()),
-                          expected_error);
+      BOOST_REQUIRE_EQUAL(
+          test_utils::wait_and_return_error(
+              test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()))
+                  .get()),
+          expected_error);
     }
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping udts/invalid" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping udts/invalid" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
 /**
-* Ensure varchar/text datatypes are correctly handled with nested UDTs
-*
-* This test ensures the text datatypes are handled correctly using Cassandra
-* v2.1+ with nested UDTs
-*
-* @since 2.2.0-beta
-* @jira_ticket CPP-287
-* @test_category data_types:udt
-* @cassandra_version 2.1.x
-*/
+ * Ensure varchar/text datatypes are correctly handled with nested UDTs
+ *
+ * This test ensures the text datatypes are handled correctly using Cassandra
+ * v2.1+ with nested UDTs
+ *
+ * @since 2.2.0-beta
+ * @jira_ticket CPP-287
+ * @test_category data_types:udt
+ * @cassandra_version 2.1.x
+ */
 BOOST_AUTO_TEST_CASE(text_types) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 1) || version.major_version >= 3) {
     UDTTests tester;
     std::string nested_type = "CREATE TYPE nested_type (value_1 int, value_2 int)";
     std::string parent_type = "CREATE TYPE parent_type (name text, values frozen<nested_type>)";
-    std::string create_table = "CREATE TABLE key_value_pair (key int PRIMARY KEY, value frozen<parent_type>)";
+    std::string create_table =
+        "CREATE TABLE key_value_pair (key int PRIMARY KEY, value frozen<parent_type>)";
     std::string insert_query = "INSERT INTO key_value_pair(key, value) VALUES (?, ?)";
     std::string select_query = "SELECT value FROM key_value_pair WHERE key=?";
 
@@ -469,23 +523,35 @@ BOOST_AUTO_TEST_CASE(text_types) {
     test_utils::execute_query(tester.session, create_table.c_str());
 
     // Fill in the nested UDT values
-    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::user_type_set_by_name(nested_udt.get(), "value_1", 100), CASS_OK);
-    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::user_type_set_by_name(nested_udt.get(), "value_2", 200), CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        test_utils::Value<cass_int32_t>::user_type_set_by_name(nested_udt.get(), "value_1", 100),
+        CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        test_utils::Value<cass_int32_t>::user_type_set_by_name(nested_udt.get(), "value_2", 200),
+        CASS_OK);
 
     // Fill in the parent UDT values
-    BOOST_REQUIRE_EQUAL(test_utils::Value<CassString>::user_type_set_by_name(parent_udt.get(), "name", "DataStax"), CASS_OK);
-    BOOST_REQUIRE_EQUAL(cass_user_type_set_user_type_by_name(parent_udt.get(), "values", nested_udt.get()), CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        test_utils::Value<CassString>::user_type_set_by_name(parent_udt.get(), "name", "DataStax"),
+        CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        cass_user_type_set_user_type_by_name(parent_udt.get(), "values", nested_udt.get()),
+        CASS_OK);
 
     // Bind and insert the nested UDT into Cassandra
     test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 2));
-    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 1), CASS_OK);
-    BOOST_REQUIRE_EQUAL(cass_statement_bind_user_type_by_name(statement.get(), "value", parent_udt.get()), CASS_OK);
-    test_utils::wait_and_check_error(test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
+    BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind_by_name(statement.get(), "key", 1),
+                        CASS_OK);
+    BOOST_REQUIRE_EQUAL(
+        cass_statement_bind_user_type_by_name(statement.get(), "value", parent_udt.get()), CASS_OK);
+    test_utils::wait_and_check_error(
+        test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get())).get());
 
     // Ensure the UDT can be read
     statement = test_utils::CassStatementPtr(cass_statement_new(select_query.c_str(), 1));
     BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::bind(statement.get(), 0, 1), CASS_OK);
-    test_utils::CassFuturePtr future = test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
+    test_utils::CassFuturePtr future =
+        test_utils::CassFuturePtr(cass_session_execute(tester.session, statement.get()));
     test_utils::wait_and_check_error(future.get());
     test_utils::CassResultPtr result(cass_future_get_result(future.get()));
     BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1);
@@ -523,7 +589,8 @@ BOOST_AUTO_TEST_CASE(text_types) {
     BOOST_REQUIRE_EQUAL(test_utils::Value<cass_int32_t>::get(value_value, &value_result), CASS_OK);
     BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(value_result, 200));
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping udts/text_types" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping udts/text_types" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
diff --git a/test/integration_tests/src/test_utils.cpp b/test/integration_tests/src/test_utils.cpp
index 724046be9..79245b6b6 100644
--- a/test/integration_tests/src/test_utils.cpp
+++ b/test/integration_tests/src/test_utils.cpp
@@ -19,17 +19,17 @@
 #include "cassandra.h"
 #include "testing.hpp"
 
-#include <boost/test/test_tools.hpp>
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/test_tools.hpp>
 #include <boost/thread.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/format.hpp>
 
 #include <assert.h>
+#include <cstdlib>
 #include <fstream>
 #include <istream>
 #include <vector>
-#include <cstdlib>
 
 namespace test_utils {
 //-----------------------------------------------------------------------------------
@@ -37,83 +37,76 @@ const cass_duration_t ONE_SECOND_IN_MILLISECONDS = 1000;
 const cass_duration_t ONE_MILLISECOND_IN_MICROS = 1000;
 const cass_duration_t ONE_SECOND_IN_MICROS = 1000 * ONE_MILLISECOND_IN_MICROS;
 
-const char* CREATE_TABLE_ALL_TYPES =
-    "CREATE TABLE %s ("
-    "id uuid PRIMARY KEY,"
-    "text_sample text,"
-    "int_sample int,"
-    "bigint_sample bigint,"
-    "float_sample float,"
-    "double_sample double,"
-    "decimal_sample decimal,"
-    "blob_sample blob,"
-    "boolean_sample boolean,"
-    "timestamp_sample timestamp,"
-    "inet_sample inet);";
-
-const char* CREATE_TABLE_ALL_TYPES_V4 =
-    "CREATE TABLE %s ("
-    "id uuid PRIMARY KEY,"
-    "text_sample text,"
-    "int_sample int,"
-    "bigint_sample bigint,"
-    "float_sample float,"
-    "double_sample double,"
-    "decimal_sample decimal,"
-    "blob_sample blob,"
-    "boolean_sample boolean,"
-    "timestamp_sample timestamp,"
-    "inet_sample inet,"
-    "tinyint_sample tinyint,"
-    "smallint_sample smallint,"
-    "date_sample date,"
-    "time_sample time);";
-
-const char* CREATE_TABLE_ALL_TYPES_V4_1 =
-    "CREATE TABLE %s ("
-    "id uuid PRIMARY KEY,"
-    "text_sample text,"
-    "int_sample int,"
-    "bigint_sample bigint,"
-    "float_sample float,"
-    "double_sample double,"
-    "decimal_sample decimal,"
-    "blob_sample blob,"
-    "boolean_sample boolean,"
-    "timestamp_sample timestamp,"
-    "inet_sample inet,"
-    "tinyint_sample tinyint,"
-    "smallint_sample smallint,"
-    "date_sample date,"
-    "time_sample time,"
-    "duration_sample duration);";
-
-const char* CREATE_TABLE_TIME_SERIES =
-    "CREATE TABLE %s ("
-    "id uuid,"
-    "event_time timestamp,"
-    "text_sample text,"
-    "int_sample int,"
-    "bigint_sample bigint,"
-    "float_sample float,"
-    "double_sample double,"
-    "decimal_sample decimal,"
-    "blob_sample blob,"
-    "boolean_sample boolean,"
-    "timestamp_sample timestamp,"
-    "inet_sample inet,"
-    "PRIMARY KEY(id, event_time));";
-
-const char* CREATE_TABLE_SIMPLE =
-    "CREATE TABLE %s ("
-    "id int PRIMARY KEY,"
-    "test_val text);";
+const char* CREATE_TABLE_ALL_TYPES = "CREATE TABLE %s ("
+                                     "id uuid PRIMARY KEY,"
+                                     "text_sample text,"
+                                     "int_sample int,"
+                                     "bigint_sample bigint,"
+                                     "float_sample float,"
+                                     "double_sample double,"
+                                     "decimal_sample decimal,"
+                                     "blob_sample blob,"
+                                     "boolean_sample boolean,"
+                                     "timestamp_sample timestamp,"
+                                     "inet_sample inet);";
+
+const char* CREATE_TABLE_ALL_TYPES_V4 = "CREATE TABLE %s ("
+                                        "id uuid PRIMARY KEY,"
+                                        "text_sample text,"
+                                        "int_sample int,"
+                                        "bigint_sample bigint,"
+                                        "float_sample float,"
+                                        "double_sample double,"
+                                        "decimal_sample decimal,"
+                                        "blob_sample blob,"
+                                        "boolean_sample boolean,"
+                                        "timestamp_sample timestamp,"
+                                        "inet_sample inet,"
+                                        "tinyint_sample tinyint,"
+                                        "smallint_sample smallint,"
+                                        "date_sample date,"
+                                        "time_sample time);";
+
+const char* CREATE_TABLE_ALL_TYPES_V4_1 = "CREATE TABLE %s ("
+                                          "id uuid PRIMARY KEY,"
+                                          "text_sample text,"
+                                          "int_sample int,"
+                                          "bigint_sample bigint,"
+                                          "float_sample float,"
+                                          "double_sample double,"
+                                          "decimal_sample decimal,"
+                                          "blob_sample blob,"
+                                          "boolean_sample boolean,"
+                                          "timestamp_sample timestamp,"
+                                          "inet_sample inet,"
+                                          "tinyint_sample tinyint,"
+                                          "smallint_sample smallint,"
+                                          "date_sample date,"
+                                          "time_sample time,"
+                                          "duration_sample duration);";
+
+const char* CREATE_TABLE_TIME_SERIES = "CREATE TABLE %s ("
+                                       "id uuid,"
+                                       "event_time timestamp,"
+                                       "text_sample text,"
+                                       "int_sample int,"
+                                       "bigint_sample bigint,"
+                                       "float_sample float,"
+                                       "double_sample double,"
+                                       "decimal_sample decimal,"
+                                       "blob_sample blob,"
+                                       "boolean_sample boolean,"
+                                       "timestamp_sample timestamp,"
+                                       "inet_sample inet,"
+                                       "PRIMARY KEY(id, event_time));";
+
+const char* CREATE_TABLE_SIMPLE = "CREATE TABLE %s ("
+                                  "id int PRIMARY KEY,"
+                                  "test_val text);";
 
 CassLog::LogData CassLog::log_data_;
 
-size_t CassLog::message_count() {
-  return log_data_.message_count;
-}
+size_t CassLog::message_count() { return log_data_.message_count; }
 
 void CassLog::callback(const CassLogMessage* message, void* data) {
   LogData* log_data = reinterpret_cast<LogData*>(data);
@@ -122,13 +115,13 @@ void CassLog::callback(const CassLogMessage* message, void* data) {
     fprintf(stderr, "CassLog: %u.%03u [%s] (%s:%d:%s): %s\n",
             static_cast<unsigned int>(message->time_ms / 1000),
             static_cast<unsigned int>(message->time_ms % 1000),
-            cass_log_level_string(message->severity),
-            message->file, message->line, message->function,
-            message->message);
+            cass_log_level_string(message->severity), message->file, message->line,
+            message->function, message->message);
   }
   boost::lock_guard<LogData> l(*log_data);
   if (log_data->messages.empty()) return;
-  for (std::vector<std::string>::const_iterator iterator = log_data->messages.begin(); iterator != log_data->messages.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = log_data->messages.begin();
+       iterator != log_data->messages.end(); ++iterator) {
     if (str.find(*iterator) != std::string::npos) {
       if (log_data_.expected_log_level_ == CASS_LOG_DISABLED ||
           message->severity == log_data_.expected_log_level_) {
@@ -140,52 +133,79 @@ void CassLog::callback(const CassLogMessage* message, void* data) {
 
 const char* get_value_type(CassValueType type) {
   switch (type) {
-    case CASS_VALUE_TYPE_CUSTOM: return "custom";
-    case CASS_VALUE_TYPE_ASCII: return "ascii";
-    case CASS_VALUE_TYPE_BIGINT: return "bigint";
-    case CASS_VALUE_TYPE_BLOB: return "blob";
-    case CASS_VALUE_TYPE_BOOLEAN: return "boolean";
-    case CASS_VALUE_TYPE_COUNTER: return "counter";
-    case CASS_VALUE_TYPE_DECIMAL: return "decimal";
-    case CASS_VALUE_TYPE_DURATION: return "duration";
-    case CASS_VALUE_TYPE_DOUBLE: return "double";
-    case CASS_VALUE_TYPE_FLOAT: return "float";
-    case CASS_VALUE_TYPE_INT: return "int";
-    case CASS_VALUE_TYPE_TEXT: return "text";
-    case CASS_VALUE_TYPE_TIMESTAMP: return "timestamp";
-    case CASS_VALUE_TYPE_UUID: return "uuid";
-    case CASS_VALUE_TYPE_VARCHAR: return "varchar";
-    case CASS_VALUE_TYPE_VARINT: return "varint";
-    case CASS_VALUE_TYPE_TIMEUUID: return "timeuuid";
-    case CASS_VALUE_TYPE_INET: return "inet";
-    case CASS_VALUE_TYPE_LIST: return "list";
-    case CASS_VALUE_TYPE_MAP: return "map";
-    case CASS_VALUE_TYPE_SET: return "set";
-    case CASS_VALUE_TYPE_TUPLE: return "tuple";
-    case CASS_VALUE_TYPE_SMALL_INT: return "smallint";
-    case CASS_VALUE_TYPE_TINY_INT: return "tinyint";
-    case CASS_VALUE_TYPE_DATE: return "date";
-    case CASS_VALUE_TYPE_TIME: return "time";
+    case CASS_VALUE_TYPE_CUSTOM:
+      return "custom";
+    case CASS_VALUE_TYPE_ASCII:
+      return "ascii";
+    case CASS_VALUE_TYPE_BIGINT:
+      return "bigint";
+    case CASS_VALUE_TYPE_BLOB:
+      return "blob";
+    case CASS_VALUE_TYPE_BOOLEAN:
+      return "boolean";
+    case CASS_VALUE_TYPE_COUNTER:
+      return "counter";
+    case CASS_VALUE_TYPE_DECIMAL:
+      return "decimal";
+    case CASS_VALUE_TYPE_DURATION:
+      return "duration";
+    case CASS_VALUE_TYPE_DOUBLE:
+      return "double";
+    case CASS_VALUE_TYPE_FLOAT:
+      return "float";
+    case CASS_VALUE_TYPE_INT:
+      return "int";
+    case CASS_VALUE_TYPE_TEXT:
+      return "text";
+    case CASS_VALUE_TYPE_TIMESTAMP:
+      return "timestamp";
+    case CASS_VALUE_TYPE_UUID:
+      return "uuid";
+    case CASS_VALUE_TYPE_VARCHAR:
+      return "varchar";
+    case CASS_VALUE_TYPE_VARINT:
+      return "varint";
+    case CASS_VALUE_TYPE_TIMEUUID:
+      return "timeuuid";
+    case CASS_VALUE_TYPE_INET:
+      return "inet";
+    case CASS_VALUE_TYPE_LIST:
+      return "list";
+    case CASS_VALUE_TYPE_MAP:
+      return "map";
+    case CASS_VALUE_TYPE_SET:
+      return "set";
+    case CASS_VALUE_TYPE_TUPLE:
+      return "tuple";
+    case CASS_VALUE_TYPE_SMALL_INT:
+      return "smallint";
+    case CASS_VALUE_TYPE_TINY_INT:
+      return "tinyint";
+    case CASS_VALUE_TYPE_DATE:
+      return "date";
+    case CASS_VALUE_TYPE_TIME:
+      return "time";
     default:
       assert(false && "Invalid value type");
       return "";
   }
 }
 
-std::string to_hex(const char *byte_array) {
-    std::stringstream value;
-    value << std::hex << std::setfill('0');
-    for (unsigned int n = 0; n < strlen(byte_array); ++n) {
-      value << std::setw(2) << static_cast<unsigned>(byte_array[n]);
-    }
+std::string to_hex(const char* byte_array) {
+  std::stringstream value;
+  value << std::hex << std::setfill('0');
+  for (unsigned int n = 0; n < strlen(byte_array); ++n) {
+    value << std::setw(2) << static_cast<unsigned>(byte_array[n]);
+  }
 
-    if (value.str().size() == 0) {
-      value << "00";
-    }
-    return value.str();
+  if (value.str().size() == 0) {
+    value << "00";
+  }
+  return value.str();
 }
 
-std::string replaceAll(const std::string& current, const std::string& search, const std::string& replace) {
+std::string replaceAll(const std::string& current, const std::string& search,
+                       const std::string& replace) {
   // Go through each found occurrence and replace the value (in place)
   std::string updated = current;
   size_t found_position = 0;
@@ -198,36 +218,47 @@ std::string replaceAll(const std::string& current, const std::string& search, co
 }
 
 //-----------------------------------------------------------------------------------
-const std::string CREATE_KEYSPACE_SIMPLE_FORMAT = "CREATE KEYSPACE %s WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor' : %s }";
-const std::string CREATE_KEYSPACE_NETWORK_FORMAT = "CREATE KEYSPACE %s WITH replication = { 'class' : 'NetworkTopologyStrategy',  'dc1' : %d, 'dc2' : %d }";
-const std::string CREATE_KEYSPACE_GENERIC_FORMAT = "CREATE KEYSPACE {0} WITH replication = { 'class' : '{1}', {2} }";
+const std::string CREATE_KEYSPACE_SIMPLE_FORMAT = "CREATE KEYSPACE %s WITH replication = { 'class' "
+                                                  ": 'SimpleStrategy', 'replication_factor' : %s }";
+const std::string CREATE_KEYSPACE_NETWORK_FORMAT =
+    "CREATE KEYSPACE %s WITH replication = { 'class' : 'NetworkTopologyStrategy',  'dc1' : %d, "
+    "'dc2' : %d }";
+const std::string CREATE_KEYSPACE_GENERIC_FORMAT =
+    "CREATE KEYSPACE {0} WITH replication = { 'class' : '{1}', {2} }";
 const std::string DROP_KEYSPACE_FORMAT = "DROP KEYSPACE %s";
 const std::string DROP_KEYSPACE_IF_EXISTS_FORMAT = "DROP KEYSPACE IF EXISTS %s";
 const std::string SIMPLE_KEYSPACE = "ks";
 const std::string NUMERIC_KEYSPACE_FORMAT = "ks%d";
 const std::string SIMPLE_TABLE = "test";
-const std::string CREATE_TABLE_SIMPLE_FORMAT = "CREATE TABLE {0} (k text PRIMARY KEY, t text, i int, f float)";
+const std::string CREATE_TABLE_SIMPLE_FORMAT =
+    "CREATE TABLE {0} (k text PRIMARY KEY, t text, i int, f float)";
 const std::string INSERT_FORMAT = "INSERT INTO {0} (k, t, i, f) VALUES ('{1}', '{2}', {3}, {4})";
 const std::string SELECT_ALL_FORMAT = "SELECT * FROM {0}";
 const std::string SELECT_WHERE_FORMAT = "SELECT * FROM {0} WHERE {1}";
 const std::string SELECT_VERSION = "SELECT release_version FROM system.local";
 
-const std::string lorem_ipsum = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla porta turpis vel dui venenatis, quis viverra magna"
-                                "suscipit. Praesent pharetra facilisis turpis, et fermentum leo sollicitudin sit amet. In hac habitasse platea dictumst. Donec mattis facilisis"
-                                "diam, nec pulvinar ligula. Sed eget faucibus magna. Donec vitae fermentum augue. Ut nec accumsan ligula. Sed a viverra leo, sed semper augue."
-                                "Pellentesque auctor nisl varius, imperdiet est non, porttitor risus. Donec aliquam elementum sollicitudin. Maecenas ultrices mattis mauris,"
-                                "fringilla congue nunc sodales sed. Fusce ac neque quis erat hendrerit porta at nec massa. Maecenas blandit ut felis sed ultrices. Sed fermentum"
-                                "pharetra lacus sodales cursus.";
+const std::string lorem_ipsum =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla porta turpis vel dui "
+    "venenatis, quis viverra magna"
+    "suscipit. Praesent pharetra facilisis turpis, et fermentum leo sollicitudin sit amet. In hac "
+    "habitasse platea dictumst. Donec mattis facilisis"
+    "diam, nec pulvinar ligula. Sed eget faucibus magna. Donec vitae fermentum augue. Ut nec "
+    "accumsan ligula. Sed a viverra leo, sed semper augue."
+    "Pellentesque auctor nisl varius, imperdiet est non, porttitor risus. Donec aliquam elementum "
+    "sollicitudin. Maecenas ultrices mattis mauris,"
+    "fringilla congue nunc sodales sed. Fusce ac neque quis erat hendrerit porta at nec massa. "
+    "Maecenas blandit ut felis sed ultrices. Sed fermentum"
+    "pharetra lacus sodales cursus.";
 const char ALPHA_NUMERIC[] = { "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" };
 
 //-----------------------------------------------------------------------------------
 
 CCM::CassVersion MultipleNodesTest::version("0.0.0");
 
-MultipleNodesTest::MultipleNodesTest(unsigned int num_nodes_dc1,
-  unsigned int num_nodes_dc2, unsigned int protocol_version,
-  bool with_vnodes /* = false */, bool is_ssl /* = false */)
-  : ccm(new CCM::Bridge("config.txt")) {
+MultipleNodesTest::MultipleNodesTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2,
+                                     unsigned int protocol_version, bool with_vnodes /* = false */,
+                                     bool is_ssl /* = false */)
+    : ccm(new CCM::Bridge("config.txt")) {
   // Only start the cluster if it wasn't the active cluster
   if (ccm->create_cluster(num_nodes_dc1, num_nodes_dc2, with_vnodes, is_ssl)) {
     ccm->start_cluster();
@@ -275,15 +306,13 @@ MultipleNodesTest::~MultipleNodesTest() {
   cass_cluster_free(cluster);
 }
 
-SingleSessionTest::SingleSessionTest(unsigned int num_nodes_dc1,
-                                     unsigned int num_nodes_dc2, bool with_session /* = true */,
-  unsigned int protocol_version, bool with_vnodes /* = false */,
-  bool is_ssl /* = false */)
-  : MultipleNodesTest(num_nodes_dc1, num_nodes_dc2, protocol_version,
-    with_vnodes, is_ssl)
-  , session(NULL)
-  , ssl(NULL) {
-  //SSL verification flags must be set before establishing session
+SingleSessionTest::SingleSessionTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2,
+                                     bool with_session /* = true */, unsigned int protocol_version,
+                                     bool with_vnodes /* = false */, bool is_ssl /* = false */)
+    : MultipleNodesTest(num_nodes_dc1, num_nodes_dc2, protocol_version, with_vnodes, is_ssl)
+    , session(NULL)
+    , ssl(NULL) {
+  // SSL verification flags must be set before establishing session
   if (!is_ssl) {
     if (with_session) {
       create_session();
@@ -315,7 +344,7 @@ SingleSessionTest::~SingleSessionTest() {
 }
 
 void initialize_contact_points(CassCluster* cluster, std::string prefix,
-  unsigned int num_of_nodes) {
+                               unsigned int num_of_nodes) {
   for (unsigned int i = 0; i < num_of_nodes; ++i) {
     std::string contact_point(prefix + boost::lexical_cast<std::string>(i + 1));
     cass_cluster_set_contact_points(cluster, contact_point.c_str());
@@ -338,11 +367,8 @@ CassSessionPtr create_session(CassCluster* cluster, CassError* code, cass_durati
   return session;
 }
 
-void execute_query(CassSession* session,
-                   const std::string& query,
-                   CassResultPtr* result,
-                   CassConsistency consistency,
-                   cass_duration_t timeout) {
+void execute_query(CassSession* session, const std::string& query, CassResultPtr* result,
+                   CassConsistency consistency, cass_duration_t timeout) {
   CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
   cass_statement_set_consistency(statement.get(), consistency);
   CassFuturePtr future(cass_session_execute(session, statement.get()));
@@ -352,16 +378,14 @@ void execute_query(CassSession* session,
   }
 }
 
-CassError execute_query_with_error(CassSession* session,
-                                   const std::string& query,
-                                   CassResultPtr* result,
-                                   CassConsistency consistency,
+CassError execute_query_with_error(CassSession* session, const std::string& query,
+                                   CassResultPtr* result, CassConsistency consistency,
                                    cass_duration_t timeout) {
   CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
   cass_statement_set_consistency(statement.get(), consistency);
   CassFuturePtr future(cass_session_execute(session, statement.get()));
   CassError code = wait_and_return_error(future.get(), timeout);
-  if(result != NULL) {
+  if (result != NULL) {
     *result = CassResultPtr(cass_future_get_result(future.get()));
   }
   return code;
@@ -379,7 +403,8 @@ void wait_and_check_error(CassFuture* future, cass_duration_t timeout) {
   if (code != CASS_OK) {
     CassString message;
     cass_future_error_message(future, &message.data, &message.length);
-    BOOST_FAIL("Error occurred during query '" << std::string(message.data, message.length) << "' (" << boost::format("0x%08X") % code << ")");
+    BOOST_FAIL("Error occurred during query '" << std::string(message.data, message.length) << "' ("
+                                               << boost::format("0x%08X") % code << ")");
   }
 }
 
@@ -415,13 +440,14 @@ CCM::CassVersion get_version(CassSession* session /* = NULL */) {
     execute_query(session, SELECT_VERSION, &result);
 
     // Only one row should be returned; get the first row
-    const CassRow *row = cass_result_first_row(result.get());
+    const CassRow* row = cass_result_first_row(result.get());
 
     // Convert the release_version value to a string
     CassString version_cass_string;
     const CassValue* value = cass_row_get_column_by_name(row, "release_version");
     cass_value_get_string(value, &version_cass_string.data, &version_cass_string.length);
-    version_string = std::string(version_cass_string.data, version_cass_string.length); // Needed for null termination
+    version_string = std::string(version_cass_string.data,
+                                 version_cass_string.length); // Needed for null termination
   } else {
     return CCM::Bridge::get_cassandra_version("config.txt");
   }
@@ -463,9 +489,11 @@ std::string load_ssl_certificate(const std::string filename) {
 }
 
 std::string implode(const std::vector<std::string>& elements, const char delimiter /*= ' '*/,
-  const char* delimiter_prefix /*= NULL*/, const char* delimiter_suffix /*= NULL*/) {
+                    const char* delimiter_prefix /*= NULL*/,
+                    const char* delimiter_suffix /*= NULL*/) {
   std::string result;
-  for (std::vector<std::string>::const_iterator iterator = elements.begin(); iterator < elements.end(); ++iterator) {
+  for (std::vector<std::string>::const_iterator iterator = elements.begin();
+       iterator < elements.end(); ++iterator) {
     result += *iterator;
     if ((iterator + 1) != elements.end()) {
       if (delimiter_prefix) {
@@ -486,9 +514,11 @@ void wait_for_node_connection(const std::string& ip_prefix, int node, int total_
   wait_for_node_connections(ip_prefix, nodes, total_attempts);
 }
 
-void wait_for_node_connections(const std::string& ip_prefix, std::vector<int> nodes, int total_attempts /*= 10*/) {
+void wait_for_node_connections(const std::string& ip_prefix, std::vector<int> nodes,
+                               int total_attempts /*= 10*/) {
   // Build the log messages to look for
-  for (std::vector<int>::const_iterator iterator = nodes.begin(); iterator != nodes.end(); ++iterator) {
+  for (std::vector<int>::const_iterator iterator = nodes.begin(); iterator != nodes.end();
+       ++iterator) {
     std::stringstream log_message;
     log_message << "Connected to host " << ip_prefix << *iterator;
     if (iterator == nodes.begin()) {
@@ -508,12 +538,11 @@ void wait_for_node_connections(const std::string& ip_prefix, std::vector<int> no
 std::string& trim(std::string& str) {
   // Trim front
   str.erase(str.begin(),
-            std::find_if(str.begin(), str.end(),
-                         std::not1(std::ptr_fun<int, int>(::isspace))));
+            std::find_if(str.begin(), str.end(), std::not1(std::ptr_fun<int, int>(::isspace))));
   // Trim back
-  str.erase(std::find_if(str.rbegin(), str.rend(),
-                         std::not1(std::ptr_fun<int, int>(::isspace))).base(),
-            str.end());
+  str.erase(
+      std::find_if(str.rbegin(), str.rend(), std::not1(std::ptr_fun<int, int>(::isspace))).base(),
+      str.end());
   return str;
 }
 
diff --git a/test/integration_tests/src/test_utils.hpp b/test/integration_tests/src/test_utils.hpp
index 660890bab..c0de5611a 100644
--- a/test/integration_tests/src/test_utils.hpp
+++ b/test/integration_tests/src/test_utils.hpp
@@ -16,26 +16,26 @@
 
 #pragma once
 
+#include <iomanip>
 #include <limits>
 #include <string>
-#include <iomanip>
 
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/asio/ip/address.hpp>
 #include <boost/atomic.hpp>
 #include <boost/chrono.hpp>
 #include <boost/shared_ptr.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/lockable_adapter.hpp>
 #include <boost/thread/lock_guard.hpp>
+#include <boost/thread/lockable_adapter.hpp>
+#include <boost/thread/mutex.hpp>
 
 #include <openssl/bn.h>
 #include <openssl/crypto.h>
 
 #include <uv.h>
 
-#include "cassandra.h"
 #include "bridge.hpp"
+#include "cassandra.h"
 #include "constants.hpp"
 #include "pretty_print.hpp"
 
@@ -49,37 +49,39 @@
 
 struct CassBytes {
   CassBytes()
-   : data(NULL)
-   , size(0) {}
+      : data(NULL)
+      , size(0) {}
   CassBytes(const cass_byte_t* data, size_t size)
-    : data(data), size(size) {}
+      : data(data)
+      , size(size) {}
   const cass_byte_t* data;
   size_t size;
 };
 
 struct CassString {
   CassString()
-    : data(NULL)
-    , length(0) {}
+      : data(NULL)
+      , length(0) {}
   CassString(const char* data)
-    : data(data)
-    , length(strlen(data)) {}
+      : data(data)
+      , length(strlen(data)) {}
 
   CassString(const char* data, size_t length)
-    : data(data), length(length) {}
+      : data(data)
+      , length(length) {}
   const char* data;
   size_t length;
 };
 
 struct CassDecimal {
   CassDecimal()
-    : varint(NULL)
-    , varint_size(0)
-    , scale(0) {}
-  CassDecimal(const cass_byte_t* varint, size_t varint_size,
-              cass_int32_t scale)
-    : varint(varint), varint_size(varint_size)
-    , scale(scale) {}
+      : varint(NULL)
+      , varint_size(0)
+      , scale(0) {}
+  CassDecimal(const cass_byte_t* varint, size_t varint_size, cass_int32_t scale)
+      : varint(varint)
+      , varint_size(varint_size)
+      , scale(scale) {}
   const cass_byte_t* varint;
   size_t varint_size;
   cass_int32_t scale;
@@ -87,11 +89,13 @@ struct CassDecimal {
 
 struct CassDuration {
   CassDuration()
-    : months(0)
-    , days(0)
-    , nanos(0) {}
+      : months(0)
+      , days(0)
+      , nanos(0) {}
   CassDuration(cass_int32_t months, cass_int32_t days, cass_int64_t nanos)
-    : months(months), days(days), nanos(nanos) {}
+      : months(months)
+      , days(days)
+      , nanos(nanos) {}
   cass_int32_t months;
   cass_int32_t days;
   cass_int64_t nanos;
@@ -99,21 +103,20 @@ struct CassDuration {
 
 struct CassDate {
   CassDate(cass_uint32_t date = 0)
-    : date(date) { }
+      : date(date) {}
   operator cass_uint32_t() const { return date; }
   cass_uint32_t date;
 };
 
 struct CassTime {
   CassTime(cass_int64_t time = 0)
-    : time(time) { }
+      : time(time) {}
   operator cass_int64_t() const { return time; }
   cass_int64_t time;
 };
 
 inline bool operator<(const CassUuid& u1, const CassUuid& u2) {
-  return u1.clock_seq_and_node < u2.clock_seq_and_node ||
-         u1.time_and_version < u2.time_and_version;
+  return u1.clock_seq_and_node < u2.clock_seq_and_node || u1.time_and_version < u2.time_and_version;
 }
 
 inline bool operator==(const CassUuid& u1, const CassUuid& u2) {
@@ -139,8 +142,7 @@ extern const cass_duration_t ONE_SECOND_IN_MILLISECONDS;
 extern const cass_duration_t ONE_MILLISECOND_IN_MICROS;
 extern const cass_duration_t ONE_SECOND_IN_MICROS;
 
-
-class CassLog{
+class CassLog {
 public:
   CassLog() {
     // Set the maximum log level we'll just ignore anything
@@ -154,9 +156,7 @@ class CassLog{
     log_data_.expected_log_level_ = CASS_LOG_DISABLED;
   }
 
-  static void add(const std::string& msg) {
-    log_data_.add(msg);
-  }
+  static void add(const std::string& msg) { log_data_.add(msg); }
 
   static size_t message_count();
 
@@ -171,9 +171,9 @@ class CassLog{
 private:
   struct LogData : public boost::basic_lockable_adapter<boost::mutex> {
     LogData()
-      : message_count(0)
-      , expected_log_level_(CASS_LOG_DISABLED)
-      , output_log_level(CASS_LOG_DISABLED) {}
+        : message_count(0)
+        , expected_log_level_(CASS_LOG_DISABLED)
+        , output_log_level(CASS_LOG_DISABLED) {}
 
     void reset(const std::string& msg) {
       boost::lock_guard<LogData> l(*this);
@@ -182,9 +182,7 @@ class CassLog{
       message_count = 0;
     }
 
-    void add(const std::string& msg) {
-      messages.push_back(msg);
-    }
+    void add(const std::string& msg) { messages.push_back(msg); }
 
     boost::mutex m;
     std::vector<std::string> messages;
@@ -210,17 +208,18 @@ class BigNumber {
    * @param byte_array Two's complement varint byte array
    * @return Numerical value of the varint
    */
-  static std::string decode_varint(const char *byte_array) {
+  static std::string decode_varint(const char* byte_array) {
     std::string result;
     // Assuming positive numbers only
-    //TODO: Add check for bit to return negative values
-    BIGNUM *value = BN_bin2bn(reinterpret_cast<unsigned const char *>(byte_array), static_cast<int>(strlen(byte_array)), NULL);
+    // TODO: Add check for bit to return negative values
+    BIGNUM* value = BN_bin2bn(reinterpret_cast<unsigned const char*>(byte_array),
+                              static_cast<int>(strlen(byte_array)), NULL);
     if (value) {
       char* decimal = BN_bn2dec(value);
       result = std::string(decimal);
       OPENSSL_free(decimal);
 
-      //Normalize - strip leading zeros
+      // Normalize - strip leading zeros
       for (unsigned int n = 0; n < result.size(); ++n) {
         if (result.at(n) == '0') {
           result.replace(n, 1, "");
@@ -244,9 +243,7 @@ class BigNumber {
    * @param byte_array Byte array to convert
    * @return String representation of numerical value
    */
-  static std::string to_string(const char *byte_array) {
-    return decode_varint(byte_array);
-  }
+  static std::string to_string(const char* byte_array) { return decode_varint(byte_array); }
   /**
    * Convert a <code>CassBytes<code/> object into a numerical string value
    *
@@ -263,10 +260,11 @@ class BigNumber {
    * @return String representation of numerical value
    */
   static std::string to_string(CassDecimal decimal) {
-    std::string byte_array = std::string(reinterpret_cast<const char *>(decimal.varint), decimal.varint_size);
+    std::string byte_array =
+        std::string(reinterpret_cast<const char*>(decimal.varint), decimal.varint_size);
     std::string integer_value = decode_varint(byte_array.c_str());
 
-    //Ensure the decimal has scale
+    // Ensure the decimal has scale
     if (decimal.scale > 0) {
       unsigned int period_position = integer_value.size() - decimal.scale;
       return integer_value.substr(0, period_position) + "." + integer_value.substr(period_position);
@@ -275,10 +273,10 @@ class BigNumber {
   }
 };
 
-template<class T>
+template <class T>
 struct Deleter;
 
-template<>
+template <>
 struct Deleter<CassCluster> {
   void operator()(CassCluster* ptr) {
     if (ptr != NULL) {
@@ -287,7 +285,7 @@ struct Deleter<CassCluster> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassSession> {
   void operator()(CassSession* ptr) {
     if (ptr != NULL) {
@@ -296,7 +294,7 @@ struct Deleter<CassSession> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassFuture> {
   void operator()(CassFuture* ptr) {
     if (ptr != NULL) {
@@ -305,7 +303,7 @@ struct Deleter<CassFuture> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassStatement> {
   void operator()(CassStatement* ptr) {
     if (ptr != NULL) {
@@ -314,7 +312,7 @@ struct Deleter<CassStatement> {
   }
 };
 
-template<>
+template <>
 struct Deleter<const CassResult> {
   void operator()(const CassResult* ptr) {
     if (ptr != NULL) {
@@ -323,7 +321,7 @@ struct Deleter<const CassResult> {
   }
 };
 
-template<>
+template <>
 struct Deleter<const CassErrorResult> {
   void operator()(const CassErrorResult* ptr) {
     if (ptr != NULL) {
@@ -332,7 +330,7 @@ struct Deleter<const CassErrorResult> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassIterator> {
   void operator()(CassIterator* ptr) {
     if (ptr != NULL) {
@@ -341,7 +339,7 @@ struct Deleter<CassIterator> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassCollection> {
   void operator()(CassCollection* ptr) {
     if (ptr != NULL) {
@@ -350,7 +348,7 @@ struct Deleter<CassCollection> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassDataType> {
   void operator()(CassDataType* ptr) {
     if (ptr != NULL) {
@@ -359,7 +357,7 @@ struct Deleter<CassDataType> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassTuple> {
   void operator()(CassTuple* ptr) {
     if (ptr != NULL) {
@@ -368,7 +366,7 @@ struct Deleter<CassTuple> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassUserType> {
   void operator()(CassUserType* ptr) {
     if (ptr != NULL) {
@@ -377,7 +375,7 @@ struct Deleter<CassUserType> {
   }
 };
 
-template<>
+template <>
 struct Deleter<const CassPrepared> {
   void operator()(const CassPrepared* ptr) {
     if (ptr != NULL) {
@@ -386,7 +384,7 @@ struct Deleter<const CassPrepared> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassBatch> {
   void operator()(CassBatch* ptr) {
     if (ptr != NULL) {
@@ -395,7 +393,7 @@ struct Deleter<CassBatch> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassUuidGen> {
   void operator()(CassUuidGen* ptr) {
     if (ptr != NULL) {
@@ -404,7 +402,7 @@ struct Deleter<CassUuidGen> {
   }
 };
 
-template<>
+template <>
 struct Deleter<const CassSchemaMeta> {
   void operator()(const CassSchemaMeta* ptr) {
     if (ptr != NULL) {
@@ -413,7 +411,7 @@ struct Deleter<const CassSchemaMeta> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassCustomPayload> {
   void operator()(CassCustomPayload* ptr) {
     if (ptr != NULL) {
@@ -422,7 +420,7 @@ struct Deleter<CassCustomPayload> {
   }
 };
 
-template<>
+template <>
 struct Deleter<CassRetryPolicy> {
   void operator()(CassRetryPolicy* ptr) {
     if (ptr != NULL) {
@@ -435,7 +433,7 @@ template <class T>
 class CassSharedPtr : public boost::shared_ptr<T> {
 public:
   explicit CassSharedPtr(T* ptr = NULL)
-    : boost::shared_ptr<T>(ptr, Deleter<T>()) {}
+      : boost::shared_ptr<T>(ptr, Deleter<T>()) {}
 };
 
 typedef CassSharedPtr<CassCluster> CassClusterPtr;
@@ -456,10 +454,10 @@ typedef CassSharedPtr<const CassSchemaMeta> CassSchemaMetaPtr;
 typedef CassSharedPtr<CassCustomPayload> CassCustomPayloadPtr;
 typedef CassSharedPtr<CassRetryPolicy> CassRetryPolicyPtr;
 
-template<class T>
+template <class T>
 struct Value;
 
-template<>
+template <>
 struct Value<cass_int8_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_int8_t value) {
     return cass_statement_bind_int8(statement, index, value);
@@ -481,7 +479,8 @@ struct Value<cass_int8_t> {
     return cass_user_type_set_int8(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_int8_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_int8_t value) {
     return cass_user_type_set_int8_by_name(user_type, name, value);
   }
 
@@ -489,17 +488,11 @@ struct Value<cass_int8_t> {
     return cass_value_get_int8(value, output);
   }
 
-  static bool equal(cass_int8_t a, cass_int8_t b) {
-    return a == b;
-  }
+  static bool equal(cass_int8_t a, cass_int8_t b) { return a == b; }
 
-  static cass_int8_t min_value() {
-    return std::numeric_limits<cass_int8_t>::min();
-  }
+  static cass_int8_t min_value() { return std::numeric_limits<cass_int8_t>::min(); }
 
-  static cass_int8_t max_value() {
-    return std::numeric_limits<cass_int8_t>::max();
-  }
+  static cass_int8_t max_value() { return std::numeric_limits<cass_int8_t>::max(); }
 
   static std::string to_string(cass_int8_t value) {
     std::stringstream value_stream;
@@ -508,7 +501,7 @@ struct Value<cass_int8_t> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_int16_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_int16_t value) {
     return cass_statement_bind_int16(statement, index, value);
@@ -530,7 +523,8 @@ struct Value<cass_int16_t> {
     return cass_user_type_set_int16(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_int16_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_int16_t value) {
     return cass_user_type_set_int16_by_name(user_type, name, value);
   }
 
@@ -538,17 +532,11 @@ struct Value<cass_int16_t> {
     return cass_value_get_int16(value, output);
   }
 
-  static bool equal(cass_int16_t a, cass_int16_t b) {
-    return a == b;
-  }
+  static bool equal(cass_int16_t a, cass_int16_t b) { return a == b; }
 
-  static cass_int16_t min_value() {
-    return std::numeric_limits<cass_int16_t>::min();
-  }
+  static cass_int16_t min_value() { return std::numeric_limits<cass_int16_t>::min(); }
 
-  static cass_int16_t max_value() {
-    return std::numeric_limits<cass_int16_t>::max();
-  }
+  static cass_int16_t max_value() { return std::numeric_limits<cass_int16_t>::max(); }
 
   static std::string to_string(cass_int16_t value) {
     std::stringstream value_stream;
@@ -557,7 +545,7 @@ struct Value<cass_int16_t> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_int32_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_int32_t value) {
     return cass_statement_bind_int32(statement, index, value);
@@ -579,7 +567,8 @@ struct Value<cass_int32_t> {
     return cass_user_type_set_int32(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_int32_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_int32_t value) {
     return cass_user_type_set_int32_by_name(user_type, name, value);
   }
 
@@ -587,17 +576,11 @@ struct Value<cass_int32_t> {
     return cass_value_get_int32(value, output);
   }
 
-  static bool equal(cass_int32_t a, cass_int32_t b) {
-    return a == b;
-  }
+  static bool equal(cass_int32_t a, cass_int32_t b) { return a == b; }
 
-  static cass_int32_t min_value() {
-    return std::numeric_limits<cass_int32_t>::min();
-  }
+  static cass_int32_t min_value() { return std::numeric_limits<cass_int32_t>::min(); }
 
-  static cass_int32_t max_value() {
-    return std::numeric_limits<cass_int32_t>::max();
-  }
+  static cass_int32_t max_value() { return std::numeric_limits<cass_int32_t>::max(); }
 
   static std::string to_string(cass_int32_t value) {
     std::stringstream value_stream;
@@ -606,7 +589,7 @@ struct Value<cass_int32_t> {
   }
 };
 
-template<>
+template <>
 struct Value<CassDate> {
   static CassError bind(CassStatement* statement, size_t index, CassDate value) {
     return cass_statement_bind_uint32(statement, index, value);
@@ -632,9 +615,7 @@ struct Value<CassDate> {
     return cass_value_get_uint32(value, &output->date);
   }
 
-  static bool equal(CassDate a, CassDate b) {
-    return a == b;
-  }
+  static bool equal(CassDate a, CassDate b) { return a == b; }
 
   static CassDate min_value() {
     return 2147483648u; // This is the minimum value supported by strftime()
@@ -652,7 +633,7 @@ struct Value<CassDate> {
   }
 };
 
-template<>
+template <>
 struct Value<CassTime> {
   static CassError bind(CassStatement* statement, size_t index, CassTime value) {
     return cass_statement_bind_int64(statement, index, value.time);
@@ -678,17 +659,11 @@ struct Value<CassTime> {
     return cass_value_get_int64(value, &output->time);
   }
 
-  static bool equal(CassTime a, CassTime b) {
-    return a == b;
-  }
+  static bool equal(CassTime a, CassTime b) { return a == b; }
 
-  static CassTime min_value() {
-    return 0;
-  }
+  static CassTime min_value() { return 0; }
 
-  static CassTime max_value() {
-    return 86399999999999;
-  }
+  static CassTime max_value() { return 86399999999999; }
 
   static std::string to_string(CassTime value) {
     char temp[32];
@@ -705,7 +680,7 @@ struct Value<CassTime> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_int64_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_int64_t value) {
     return cass_statement_bind_int64(statement, index, value);
@@ -727,7 +702,8 @@ struct Value<cass_int64_t> {
     return cass_user_type_set_int64(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_int64_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_int64_t value) {
     return cass_user_type_set_int64_by_name(user_type, name, value);
   }
 
@@ -735,17 +711,11 @@ struct Value<cass_int64_t> {
     return cass_value_get_int64(value, output);
   }
 
-  static bool equal(cass_int64_t a, cass_int64_t b) {
-    return a == b;
-  }
+  static bool equal(cass_int64_t a, cass_int64_t b) { return a == b; }
 
-  static cass_int64_t min_value() {
-    return std::numeric_limits<cass_int64_t>::min();
-  }
+  static cass_int64_t min_value() { return std::numeric_limits<cass_int64_t>::min(); }
 
-  static cass_int64_t max_value() {
-    return std::numeric_limits<cass_int64_t>::max();
-  }
+  static cass_int64_t max_value() { return std::numeric_limits<cass_int64_t>::max(); }
 
   static std::string to_string(cass_int64_t value) {
     std::stringstream value_stream;
@@ -754,7 +724,7 @@ struct Value<cass_int64_t> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_float_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_float_t value) {
     return cass_statement_bind_float(statement, index, value);
@@ -776,7 +746,8 @@ struct Value<cass_float_t> {
     return cass_user_type_set_float(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_float_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_float_t value) {
     return cass_user_type_set_float_by_name(user_type, name, value);
   }
 
@@ -784,17 +755,11 @@ struct Value<cass_float_t> {
     return cass_value_get_float(value, output);
   }
 
-  static bool equal(cass_float_t a, cass_float_t b) {
-    return a == b;
-  }
+  static bool equal(cass_float_t a, cass_float_t b) { return a == b; }
 
-  static cass_float_t min_value() {
-    return std::numeric_limits<cass_float_t>::min();
-  }
+  static cass_float_t min_value() { return std::numeric_limits<cass_float_t>::min(); }
 
-  static cass_float_t max_value() {
-    return std::numeric_limits<cass_float_t>::max();
-  }
+  static cass_float_t max_value() { return std::numeric_limits<cass_float_t>::max(); }
 
   static std::string to_string(cass_float_t value) {
     std::stringstream value_stream;
@@ -803,7 +768,7 @@ struct Value<cass_float_t> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_double_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_double_t value) {
     return cass_statement_bind_double(statement, index, value);
@@ -825,7 +790,8 @@ struct Value<cass_double_t> {
     return cass_user_type_set_double(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_double_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_double_t value) {
     return cass_user_type_set_double_by_name(user_type, name, value);
   }
 
@@ -833,17 +799,11 @@ struct Value<cass_double_t> {
     return cass_value_get_double(value, output);
   }
 
-  static bool equal(cass_double_t a, cass_double_t b) {
-    return a == b;
-  }
+  static bool equal(cass_double_t a, cass_double_t b) { return a == b; }
 
-  static cass_double_t min_value() {
-    return std::numeric_limits<cass_double_t>::min();
-  }
+  static cass_double_t min_value() { return std::numeric_limits<cass_double_t>::min(); }
 
-  static cass_double_t max_value() {
-    return std::numeric_limits<cass_double_t>::max();
-  }
+  static cass_double_t max_value() { return std::numeric_limits<cass_double_t>::max(); }
 
   static std::string to_string(cass_double_t value) {
     std::stringstream value_stream;
@@ -852,7 +812,7 @@ struct Value<cass_double_t> {
   }
 };
 
-template<>
+template <>
 struct Value<cass_bool_t> {
   static CassError bind(CassStatement* statement, size_t index, cass_bool_t value) {
     return cass_statement_bind_bool(statement, index, value);
@@ -874,7 +834,8 @@ struct Value<cass_bool_t> {
     return cass_user_type_set_bool(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, cass_bool_t value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         cass_bool_t value) {
     return cass_user_type_set_bool_by_name(user_type, name, value);
   }
 
@@ -882,23 +843,20 @@ struct Value<cass_bool_t> {
     return cass_value_get_bool(value, output);
   }
 
-  static bool equal(cass_bool_t a, cass_bool_t b) {
-    return a == b;
-  }
+  static bool equal(cass_bool_t a, cass_bool_t b) { return a == b; }
 
-  static std::string to_string(cass_bool_t value) {
-    return value == cass_true ? "TRUE" : "FALSE";
-  }
+  static std::string to_string(cass_bool_t value) { return value == cass_true ? "TRUE" : "FALSE"; }
 };
 
-template<>
+template <>
 struct Value<CassString> {
   static CassError bind(CassStatement* statement, size_t index, CassString value) {
     return cass_statement_bind_string_n(statement, index, value.data, value.length);
   }
 
   static CassError bind_by_name(CassStatement* statement, const char* name, CassString value) {
-    return cass_statement_bind_string_by_name_n(statement, name, strlen(name), value.data, value.length);
+    return cass_statement_bind_string_by_name_n(statement, name, strlen(name), value.data,
+                                                value.length);
   }
 
   static CassError append(CassCollection* collection, CassString value) {
@@ -913,8 +871,10 @@ struct Value<CassString> {
     return cass_user_type_set_string_n(user_type, index, value.data, value.length);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassString value) {
-    return cass_user_type_set_string_by_name_n(user_type, name, strlen(name), value.data, value.length);
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassString value) {
+    return cass_user_type_set_string_by_name_n(user_type, name, strlen(name), value.data,
+                                               value.length);
   }
 
   static CassError get(const CassValue* value, CassString* output) {
@@ -928,12 +888,10 @@ struct Value<CassString> {
     return strncmp(a.data, b.data, a.length) == 0;
   }
 
-  static std::string to_string(CassString value) {
-    return std::string(value.data, value.length);
-  }
+  static std::string to_string(CassString value) { return std::string(value.data, value.length); }
 };
 
-template<>
+template <>
 struct Value<CassBytes> {
   static CassError bind(CassStatement* statement, size_t index, CassBytes value) {
     return cass_statement_bind_bytes(statement, index, value.data, value.size);
@@ -955,7 +913,8 @@ struct Value<CassBytes> {
     return cass_user_type_set_bytes(user_type, index, value.data, value.size);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassBytes value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassBytes value) {
     return cass_user_type_set_bytes_by_name(user_type, name, value.data, value.size);
   }
 
@@ -975,7 +934,7 @@ struct Value<CassBytes> {
   }
 };
 
-template<>
+template <>
 struct Value<CassInet> {
   static CassError bind(CassStatement* statement, size_t index, CassInet value) {
     return cass_statement_bind_inet(statement, index, value);
@@ -997,7 +956,8 @@ struct Value<CassInet> {
     return cass_user_type_set_inet(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassInet value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassInet value) {
     return cass_user_type_set_inet_by_name(user_type, name, value);
   }
 
@@ -1038,7 +998,7 @@ struct Value<CassInet> {
   }
 };
 
-template<>
+template <>
 struct Value<CassUuid> {
   static CassError bind(CassStatement* statement, size_t index, CassUuid value) {
     return cass_statement_bind_uuid(statement, index, value);
@@ -1060,7 +1020,8 @@ struct Value<CassUuid> {
     return cass_user_type_set_uuid(user_type, index, value);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassUuid value) {
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassUuid value) {
     return cass_user_type_set_uuid_by_name(user_type, name, value);
   }
 
@@ -1069,8 +1030,7 @@ struct Value<CassUuid> {
   }
 
   static bool equal(CassUuid a, CassUuid b) {
-    return a.clock_seq_and_node == b.clock_seq_and_node &&
-           a.time_and_version == b.time_and_version;
+    return a.clock_seq_and_node == b.clock_seq_and_node && a.time_and_version == b.time_and_version;
   }
 
   static CassUuid min_value() {
@@ -1094,14 +1054,16 @@ struct Value<CassUuid> {
   }
 };
 
-template<>
+template <>
 struct Value<CassDecimal> {
   static CassError bind(CassStatement* statement, size_t index, CassDecimal value) {
-    return cass_statement_bind_decimal(statement, index, value.varint, value.varint_size, value.scale);
+    return cass_statement_bind_decimal(statement, index, value.varint, value.varint_size,
+                                       value.scale);
   }
 
   static CassError bind_by_name(CassStatement* statement, const char* name, CassDecimal value) {
-    return cass_statement_bind_decimal_by_name(statement, name, value.varint, value.varint_size, value.scale);
+    return cass_statement_bind_decimal_by_name(statement, name, value.varint, value.varint_size,
+                                               value.scale);
   }
 
   static CassError append(CassCollection* collection, CassDecimal value) {
@@ -1113,11 +1075,14 @@ struct Value<CassDecimal> {
   }
 
   static CassError user_type_set(CassUserType* user_type, size_t index, CassDecimal value) {
-    return cass_user_type_set_decimal(user_type, index, value.varint, value.varint_size, value.scale);
+    return cass_user_type_set_decimal(user_type, index, value.varint, value.varint_size,
+                                      value.scale);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassDecimal value) {
-    return cass_user_type_set_decimal_by_name(user_type, name, value.varint, value.varint_size, value.scale);
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassDecimal value) {
+    return cass_user_type_set_decimal_by_name(user_type, name, value.varint, value.varint_size,
+                                              value.scale);
   }
 
   static CassError get(const CassValue* value, CassDecimal* output) {
@@ -1139,14 +1104,15 @@ struct Value<CassDecimal> {
   }
 };
 
-template<>
+template <>
 struct Value<CassDuration> {
   static CassError bind(CassStatement* statement, size_t index, CassDuration value) {
     return cass_statement_bind_duration(statement, index, value.months, value.days, value.nanos);
   }
 
   static CassError bind_by_name(CassStatement* statement, const char* name, CassDuration value) {
-    return cass_statement_bind_duration_by_name(statement, name, value.months, value.days, value.nanos);
+    return cass_statement_bind_duration_by_name(statement, name, value.months, value.days,
+                                                value.nanos);
   }
 
   static CassError append(CassCollection* collection, CassDuration value) {
@@ -1161,8 +1127,10 @@ struct Value<CassDuration> {
     return cass_user_type_set_duration(user_type, index, value.months, value.days, value.nanos);
   }
 
-  static CassError user_type_set_by_name(CassUserType* user_type, const char* name, CassDuration value) {
-    return cass_user_type_set_duration_by_name(user_type, name, value.months, value.days, value.nanos);
+  static CassError user_type_set_by_name(CassUserType* user_type, const char* name,
+                                         CassDuration value) {
+    return cass_user_type_set_duration_by_name(user_type, name, value.months, value.days,
+                                               value.nanos);
   }
 
   static CassError get(const CassValue* value, CassDuration* output) {
@@ -1175,10 +1143,11 @@ struct Value<CassDuration> {
 
   static std::string to_string(CassDuration value) {
     // String representation of Duration is wonky in C*. (-3, -2, -1) is represented by
-    // -3mo2d1ns. There is no way to represent a mix of positive and negative attributes. We tippy-toe
-    // around this in our testing...
+    // -3mo2d1ns. There is no way to represent a mix of positive and negative attributes. We
+    // tippy-toe around this in our testing...
     std::ostringstream buf;
-    buf << value.months << "mo" << (value.days < 0 ? -value.days : value.days) << "d" << (value.nanos < 0 ? -value.nanos : value.nanos) << "ns";
+    buf << value.months << "mo" << (value.days < 0 ? -value.days : value.days) << "d"
+        << (value.nanos < 0 ? -value.nanos : value.nanos) << "ns";
     return buf.str();
   }
 };
@@ -1192,8 +1161,8 @@ struct Value<CassDuration> {
  */
 struct MultipleNodesTest {
   MultipleNodesTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2,
-    unsigned int protocol_version = CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION, bool with_vnodes = false,
-    bool is_ssl = false);
+                    unsigned int protocol_version = CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION,
+                    bool with_vnodes = false, bool is_ssl = false);
 
   bool check_version(const std::string& required);
   bool is_beta_protocol();
@@ -1208,8 +1177,9 @@ struct MultipleNodesTest {
 
 struct SingleSessionTest : public MultipleNodesTest {
   SingleSessionTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2,
-    bool with_session = true, unsigned int protocol_version = CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION,
-    bool with_vnodes = false, bool is_ssl = false);
+                    bool with_session = true,
+                    unsigned int protocol_version = CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION,
+                    bool with_vnodes = false, bool is_ssl = false);
 
   virtual ~SingleSessionTest();
   void create_session();
@@ -1219,8 +1189,7 @@ struct SingleSessionTest : public MultipleNodesTest {
   CassSsl* ssl;
 };
 
-void initialize_contact_points(CassCluster* cluster, std::string prefix,
-  unsigned int num_of_nodes);
+void initialize_contact_points(CassCluster* cluster, std::string prefix, unsigned int num_of_nodes);
 
 const char* get_value_type(CassValueType type);
 
@@ -1230,7 +1199,7 @@ const char* get_value_type(CassValueType type);
  * @param byte_array Byte array to convert
  * @return Hex representation of the byte array
  */
-std::string to_hex(const char *byte_array);
+std::string to_hex(const char* byte_array);
 
 /**
  * Find and replace all occurrences of a string and replace with a new value
@@ -1240,24 +1209,25 @@ std::string to_hex(const char *byte_array);
  * @param replace The string to replace with
  * @return Updated string
  */
-std::string replaceAll(const std::string& current, const std::string& search, const std::string& replace);
+std::string replaceAll(const std::string& current, const std::string& search,
+                       const std::string& replace);
 
-CassSessionPtr create_session(CassCluster* cluster, cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
-CassSessionPtr create_session(CassCluster* cluster, CassError* code, cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
+CassSessionPtr create_session(CassCluster* cluster,
+                              cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
+CassSessionPtr create_session(CassCluster* cluster, CassError* code,
+                              cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
 
-CassError execute_query_with_error(CassSession* session,
-                                   const std::string& query,
+CassError execute_query_with_error(CassSession* session, const std::string& query,
                                    CassResultPtr* result = NULL,
                                    CassConsistency consistency = CASS_CONSISTENCY_ONE,
                                    cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
 
-void execute_query(CassSession* session,
-                   const std::string& query,
-                   CassResultPtr* result = NULL,
+void execute_query(CassSession* session, const std::string& query, CassResultPtr* result = NULL,
                    CassConsistency consistency = CASS_CONSISTENCY_ONE,
                    cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
 
-CassError wait_and_return_error(CassFuture* future, cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
+CassError wait_and_return_error(CassFuture* future,
+                                cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
 void wait_and_check_error(CassFuture* future, cass_duration_t timeout = 60 * ONE_SECOND_IN_MICROS);
 
 test_utils::CassPreparedPtr prepare(CassSession* session, const std::string& query);
@@ -1334,7 +1304,7 @@ std::string load_ssl_certificate(const std::string filename);
  * @return A string representation of all the array/vector elements
  */
 std::string implode(const std::vector<std::string>& elements, const char delimiter = ' ',
-  const char* delimiter_prefix = NULL, const char* delimiter_suffix = NULL);
+                    const char* delimiter_prefix = NULL, const char* delimiter_suffix = NULL);
 
 /**
  * Wait for the driver to establish connection to a given node
@@ -1353,7 +1323,8 @@ void wait_for_node_connection(const std::string& ip_prefix, int node, int total_
  * @param total_attempts Total number of attempts to wait on connection
  *                       (default: 10)
  */
-void wait_for_node_connections(const std::string& ip_prefix, std::vector<int> nodes, int total_attempts = 10);
+void wait_for_node_connections(const std::string& ip_prefix, std::vector<int> nodes,
+                               int total_attempts = 10);
 
 /**
  * Trim whitespace from the front and back of a string
@@ -1421,9 +1392,7 @@ inline bool operator<(CassBytes a, CassBytes b) {
   return memcmp(a.data, b.data, a.size) < 0;
 }
 
-inline bool operator==(CassInet a, CassInet b) {
-  return test_utils::Value<CassInet>::equal(a, b);
-}
+inline bool operator==(CassInet a, CassInet b) { return test_utils::Value<CassInet>::equal(a, b); }
 
 inline bool operator<(CassInet a, CassInet b) {
   if (a.address_length > b.address_length) {
diff --git a/test/integration_tests/src/test_warnings.cpp b/test/integration_tests/src/test_warnings.cpp
index 821a33ff5..241a4af3e 100644
--- a/test/integration_tests/src/test_warnings.cpp
+++ b/test/integration_tests/src/test_warnings.cpp
@@ -14,33 +14,34 @@
   limitations under the License.
 */
 
-#include <boost/test/unit_test.hpp>
 #include <boost/test/debug.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include "cassandra.h"
 #include "test_utils.hpp"
 
 struct WarningsTests : public test_utils::SingleSessionTest {
-  WarningsTests() : SingleSessionTest(1, 0) { }
+  WarningsTests()
+      : SingleSessionTest(1, 0) {}
 };
 
 BOOST_AUTO_TEST_SUITE(warnings)
 
-BOOST_AUTO_TEST_CASE(aggregate_without_partition_key)
-{
+BOOST_AUTO_TEST_CASE(aggregate_without_partition_key) {
   CCM::CassVersion version = test_utils::get_version();
   if ((version.major_version >= 2 && version.minor_version >= 2) || version.major_version >= 3) {
     WarningsTests tester;
-    test_utils::CassStatementPtr statement(cass_statement_new("SELECT sum(gossip_generation) FROM system.local", 0));
+    test_utils::CassStatementPtr statement(
+        cass_statement_new("SELECT sum(gossip_generation) FROM system.local", 0));
     test_utils::CassLog::reset("Server-side warning: Aggregation query used without partition key");
     test_utils::CassFuturePtr future(cass_session_execute(tester.session, statement.get()));
     BOOST_CHECK(cass_future_error_code(future.get()) == CASS_OK);
     BOOST_CHECK(test_utils::CassLog::message_count() > 0);
   } else {
-    std::cout << "Unsupported Test for Cassandra v" << version.to_string() << ": Skipping warnings/aggregate_without_partition_key" << std::endl;
+    std::cout << "Unsupported Test for Cassandra v" << version.to_string()
+              << ": Skipping warnings/aggregate_without_partition_key" << std::endl;
     BOOST_REQUIRE(true);
   }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
-
diff --git a/tools/alloc-linter-tool/alloc_linter_tool.cpp b/tools/alloc-linter-tool/alloc_linter_tool.cpp
index 8ab552099..f462d47a9 100644
--- a/tools/alloc-linter-tool/alloc_linter_tool.cpp
+++ b/tools/alloc-linter-tool/alloc_linter_tool.cpp
@@ -14,8 +14,8 @@
   limitations under the License.
 */
 
-#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
@@ -34,47 +34,43 @@ StatementMatcher CXXDeleteMatcher = cxxDeleteExpr().bind("useDelete");
 
 class AllocLinter : public MatchFinder::MatchCallback {
 public:
-  virtual void run(const MatchFinder::MatchResult &Result) {
+  virtual void run(const MatchFinder::MatchResult& Result) {
     auto& Context = *Result.Context;
     auto& DiagnosticsEngine = Context.getDiagnostics();
     auto& SourceManager = Context.getSourceManager();
 
-    const auto *NewExpr = Result.Nodes.getNodeAs<CXXNewExpr>("useNew");
+    const auto* NewExpr = Result.Nodes.getNodeAs<CXXNewExpr>("useNew");
     if (NewExpr &&
         !SourceManager.isInSystemHeader(NewExpr->getLocStart()) && // Not in system headers
-        NewExpr->getNumPlacementArgs() == 0) { // Not placement new
+        NewExpr->getNumPlacementArgs() == 0) {                     // Not placement new
       FunctionDecl* NewFuncDecl = NewExpr->getOperatorNew();
       if (NewExpr->isGlobalNew()) {
         diag(NewExpr->getLocStart(), "Using global `::operator new%0()`", DiagnosticsEngine)
             << (NewExpr->isArray() ? "[]" : "");
-      } else if(NewFuncDecl &&
-                SourceManager.isInSystemHeader(NewFuncDecl->getLocation())) {
+      } else if (NewFuncDecl && SourceManager.isInSystemHeader(NewFuncDecl->getLocation())) {
         diag(NewExpr->getLocStart(), "Using `operator new%0()` from %1", DiagnosticsEngine)
             << (NewExpr->isArray() ? "[]" : "")
             << NewFuncDecl->getLocation().printToString(SourceManager);
       }
     }
 
-    const auto *DeleteExpr = Result.Nodes.getNodeAs<CXXDeleteExpr>("useDelete");
-    if (DeleteExpr &&
-        !DeleteExpr->getDestroyedType().isNull() &&
+    const auto* DeleteExpr = Result.Nodes.getNodeAs<CXXDeleteExpr>("useDelete");
+    if (DeleteExpr && !DeleteExpr->getDestroyedType().isNull() &&
         !DeleteExpr->getDestroyedType()->isVoidType() &&
         !SourceManager.isInSystemHeader(DeleteExpr->getLocStart())) { // Not in system headers
       FunctionDecl* DeleteFuncDecl = DeleteExpr->getOperatorDelete();
       if (DeleteExpr->isGlobalDelete()) {
         diag(DeleteExpr->getLocStart(), "Using global `::operator delete%0()`", DiagnosticsEngine)
             << (DeleteExpr->isArrayForm() ? "[]" : "");
-      } else if(DeleteFuncDecl &&
-                SourceManager.isInSystemHeader(DeleteFuncDecl->getLocation())) {
+      } else if (DeleteFuncDecl && SourceManager.isInSystemHeader(DeleteFuncDecl->getLocation())) {
         diag(DeleteExpr->getLocStart(), "Using `operator delete%0()` from %1", DiagnosticsEngine)
-            << (DeleteExpr->isArrayForm()? "[]" : "")
+            << (DeleteExpr->isArrayForm() ? "[]" : "")
             << DeleteFuncDecl->getLocation().printToString(SourceManager);
       }
     }
   }
 
-  DiagnosticBuilder diag(SourceLocation Loc,
-                         StringRef Description,
+  DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
                          DiagnosticsEngine& DiagnosticsEngine) {
     auto ID = DiagnosticsEngine.getDiagnosticIDs()->getCustomDiagID(clang::DiagnosticIDs::Error,
                                                                     Description);
@@ -91,10 +87,9 @@ static cl::extrahelp MoreHelp("\nThis is a tool for finding global "
                               "or from the standard library) and other forms "
                               "of global allocation.\n");
 
-int main(int argc, const char **argv) {
+int main(int argc, const char** argv) {
   CommonOptionsParser OptionsParser(argc, argv, AllocLinterToolCategory);
-  ClangTool Tool(OptionsParser.getCompilations(),
-                 OptionsParser.getSourcePathList());
+  ClangTool Tool(OptionsParser.getCompilations(), OptionsParser.getSourcePathList());
 
   AllocLinter Linter;
   MatchFinder Finder;
diff --git a/topics/configuration/README.md b/topics/configuration/README.md
index 4de8c7aa6..5f4baae0a 100644
--- a/topics/configuration/README.md
+++ b/topics/configuration/README.md
@@ -344,6 +344,26 @@ int main() {
           listener callbacks. Performing expensive operations in a callback
           will block or slow the driver's normal operation.
 
+### Reconnection Policy
+
+The reconnection policy controls the interval between each attempt for a given
+connection.
+
+#### Exponential Reconnection Policy
+
+The exponential reconnection policy is the default reconnection policy. It
+starts by using a base delay in milliseconds which is then exponentially
+increased (doubled) during each reconnection attempt; up to the defined maximum
+delay.
+
+**Note**: Once the connection is re-established, this policy will restart using
+          base delay if a reconnection occurs.
+
+#### Constant Reconnection Policy
+
+The constant reconnection policy is a fixed delay for each reconnection
+attempt.
+
 ### Performance Tips
 
 #### Use a single persistent session