IT: reimplement get_attempted_hosts_from_future

`get_attempted_hosts_from_future` was originally implemented in C++
using the internal C++ Driver API. This commit reimplements it using
the new exposed Rust API, namely `testing_future_get_attempted_hosts`.

To finish up, the commit also reimplements `set_record_attempted_hosts`,
which is tightly coupled with the previous function, using
`testing_statement_set_recording_history_listener` (introduced a couple
of commits ago).
This completes the re-implementation of this testing functionality in
Rust.

I'd like to enable some tests that depend on this functionality,
but none of them has all the requirements met yet. Once I rework
the DCAware LBP in a follow-up, I'll be able to enable its tests
thanks to this commit.

Author: wprzytula

src/testing.cpp

@@ -16,21 +16,17 @@
 
 #include "testing.hpp"
 
-#include "address.hpp"
-#include "external.hpp"
 #include "get_time.hpp"
-#include "logger.hpp"
 #include "murmur3.hpp"
-#include <iostream>
+#include <cstring>
+#include <sstream>
 
 extern "C" {
 #include "testing_rust_impls.h"
 }
 
 namespace datastax { namespace internal { namespace testing {
 
-using namespace core;
-
 String get_host_from_future(CassFuture* future) {
   char* host;
   size_t host_length;
@@ -51,7 +47,44 @@ String get_host_from_future(CassFuture* future) {
 }
 
 StringVec get_attempted_hosts_from_future(CassFuture* future) {
-  throw std::runtime_error("Unimplemented 'get_attempted_hosts_from_future'!");
+    // Original implementation commented out for reference.
+    /*
+    if (future->type() != Future::FUTURE_TYPE_RESPONSE) {
+        return StringVec();
+    }
+
+    StringVec attempted_hosts;
+    ResponseFuture* response_future = static_cast<ResponseFuture*>(future->from());
+
+    AddressVec attempted_addresses = response_future->attempted_addresses();
+    for (const auto& address : attempted_addresses) {
+        attempted_hosts.push_back(address.to_string());
+    }
+    std::sort(attempted_hosts.begin(), attempted_hosts.end());
+    return attempted_hosts;
+    */
+
+    StringVec attempted_hosts;
+
+    char* const concatenated_attempted_addresses = testing_future_get_attempted_hosts(future);
+
+    std::string concatenated_addresses = concatenated_attempted_addresses;
+    std::stringstream stream{concatenated_addresses};
+    while (true) {
+        String address;
+        if (std::getline(stream, address, '\n')) {
+            if (!address.empty()) {
+                attempted_hosts.push_back(address);
+            }
+        } else {
+            break; // No more addresses to read.
+        }
+    }
+    std::sort(attempted_hosts.begin(), attempted_hosts.end());
+
+    testing_free_cstring(concatenated_attempted_addresses);
+
+    return attempted_hosts;
 }
 
 unsigned get_connect_timeout_from_cluster(CassCluster* cluster) {
@@ -110,7 +143,7 @@ String get_server_name(CassFuture* future) {
 }
 
 void set_record_attempted_hosts(CassStatement* statement, bool enable) {
-  throw std::runtime_error("Unimplemented 'set_record_attempted_hosts'!");
+    testing_statement_set_recording_history_listener(statement, (cass_bool_t) enable);
 }
 
 void set_sleeping_history_listener_on_statement(CassStatement* statement, uint64_t sleep_time_ms) {

src/testing_rust_impls.h

@@ -40,6 +40,19 @@ CASS_EXPORT void testing_batch_set_sleeping_history_listener(CassBatch *batch,
     cass_uint64_t sleep_time_ms);
 }
 
+// Sets a recording history listener on the statement.
+// This can be used to collect addresses of hosts attempted during statement execution.
+// Those can be later retrieved using `testing_future_get_attempted_hosts`.
+CASS_EXPORT void testing_statement_set_recording_history_listener(CassStatement *statement,
+    cass_bool_t enable);
+
+// Retrieves a concatenated string of attempted hosts from the future.
+// Hosts are delimited with '\n' character.
+// Hosts are recorded only if `testing_statement_set_recording_history_listener`
+// was called on the statement previously.
+// The returned pointer is allocated and must be freed with `testing_free_cstring`.
+CASS_EXPORT char* testing_future_get_attempted_hosts(CassFuture *future);
+
 /**
  * Creates a new ignoring retry policy.
  *