Mailing-List: contact common-commits-help@hadoop.apache.org; run by ezmlm
Precedence: bulk
Reply-To: common-dev@hadoop.apache.org
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: jhc@apache.org
To: common-commits@hadoop.apache.org
Message-Id: <9946666e7f7b476cab46ae1d4af7dc0f@git.apache.org>
Subject: hadoop git commit: HDFS-9117. Config file reader / options classes
 for libhdfs++. Contributed by Bob Hansen.
Date: Wed, 25 Nov 2015 17:10:23 +0000 (UTC)

Repository: hadoop
Updated Branches:
  refs/heads/HDFS-8707 8b7769557 -> 8c6a84fdd


HDFS-9117.  Config file reader / options classes for libhdfs++.  Contributed by Bob Hansen.


Project: http://git-wip-us.apache.org/repos/asf/hadoop/repo
Commit: http://git-wip-us.apache.org/repos/asf/hadoop/commit/8c6a84fd
Tree: http://git-wip-us.apache.org/repos/asf/hadoop/tree/8c6a84fd
Diff: http://git-wip-us.apache.org/repos/asf/hadoop/diff/8c6a84fd

Branch: refs/heads/HDFS-8707
Commit: 8c6a84fdd55350791268bb4624b1f2b3163bc90b
Parents: 8b77695
Author: James <jhc@apache.org>
Authored: Wed Nov 25 12:09:13 2015 -0500
Committer: James <jhc@apache.org>
Committed: Wed Nov 25 12:09:13 2015 -0500

----------------------------------------------------------------------
 .../src/main/native/libhdfspp/CMakeLists.txt    |   2 +
 .../native/libhdfspp/lib/common/CMakeLists.txt  |   2 +-
 .../libhdfspp/lib/common/configuration.cc       | 231 ++++++++++++
 .../native/libhdfspp/lib/common/configuration.h |  94 +++++
 .../main/native/libhdfspp/tests/CMakeLists.txt  |   4 +
 .../libhdfspp/tests/configuration_test.cc       | 363 +++++++++++++++++++
 .../native/libhdfspp/tests/configuration_test.h |  73 ++++
 7 files changed, 768 insertions(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/CMakeLists.txt b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/CMakeLists.txt
index 18e4cb0..d1b60be 100644
--- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/CMakeLists.txt
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/CMakeLists.txt
@@ -49,7 +49,9 @@ include_directories(
   lib
   ${PROJECT_BINARY_DIR}/lib/proto
   third_party/asio-1.10.2/include
+  third_party/rapidxml-1.13
   third_party/gmock-1.7.0
+  third_party/tr2
   ${OPENSSL_INCLUDE_DIR}
   ../libhdfs/include
 )

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/CMakeLists.txt b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/CMakeLists.txt
index b03f00b..8dbcd03 100644
--- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/CMakeLists.txt
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/CMakeLists.txt
@@ -1 +1 @@
-add_library(common base64.cc options.cc status.cc sasl_digest_md5.cc hdfs_public_api.cc)
+add_library(common base64.cc status.cc sasl_digest_md5.cc hdfs_public_api.cc options.cc configuration.cc)

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.cc
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.cc
new file mode 100644
index 0000000..2baf84b
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.cc
@@ -0,0 +1,231 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+/*
+ * The following features are not currently implemented
+ * - Deprecated values
+ * - Make filename and config file contents unicode-safe
+ * - Config redirection/environment substitution
+ *
+ * - getInts (comma separated))
+ * - getStrings (comma separated))
+ * - getIntegerRange
+ * - getSocketAddr
+ * - getTimeDuration
+ * - getBytes (e.g. 1M or 1G)
+ * - hex values
+ */
+
+#include "configuration.h"
+
+#include <strings.h>
+#include <sstream>
+#include <map>
+#include <rapidxml/rapidxml.hpp>
+#include <rapidxml/rapidxml_utils.hpp>
+
+namespace hdfs {
+
+/*
+ * Configuration class
+ */
+
+Configuration::Configuration() {}
+
+bool is_valid_bool(const std::string& raw) {
+  if (!strcasecmp(raw.c_str(), "true")) {
+    return true;
+  }
+  if (!strcasecmp(raw.c_str(), "false")) {
+    return true;
+  }
+  return false;
+}
+
+bool str_to_bool(const std::string& raw) {
+  if (!strcasecmp(raw.c_str(), "true")) {
+    return true;
+  }
+
+  return false;
+}
+
+optional<Configuration> Configuration::Load(const std::string& xmlData) {
+  Configuration result;
+  return result.OverlayResourceString(xmlData);
+}
+
+optional<Configuration> Configuration::OverlayResourceString(
+    const std::string& xmlData) const {
+  if (xmlData.size() == 0) {
+    return optional<Configuration>();
+  }
+
+  int length = xmlData.size();
+  std::vector<char> raw_bytes;
+  raw_bytes.reserve(length + 1);
+  std::copy(xmlData.begin(), xmlData.end(), std::back_inserter(raw_bytes));
+  raw_bytes.push_back('\0');
+
+  ConfigMap map(raw_values_);
+  bool success = UpdateMapWithResource(map, raw_bytes);
+
+  if (success) {
+    return optional<Configuration>(Configuration(map));
+  } else {
+    return optional<Configuration>();
+  }
+}
+
+bool Configuration::UpdateMapWithResource(ConfigMap& map,
+                                          std::vector<char>& raw_bytes) {
+  rapidxml::xml_document<> dom;
+  dom.parse<rapidxml::parse_trim_whitespace>(&raw_bytes[0]);
+
+  /* File must contain a single <configuration> stanza */
+  auto config_node = dom.first_node("configuration", 0, false);
+  if (!config_node) {
+    return false;
+  }
+
+  /* Walk all of the <property> nodes, ignoring the rest */
+  for (auto property_node = config_node->first_node("property", 0, false);
+       property_node;
+       property_node = property_node->next_sibling("property", 0, false)) {
+    auto name_node = property_node->first_node("name", 0, false);
+    auto value_node = property_node->first_node("value", 0, false);
+
+    if (name_node && value_node) {
+      auto mapValue = map.find(name_node->value());
+      if (mapValue != map.end() && mapValue->second.final) {
+        continue;
+      }
+
+      map[name_node->value()] = value_node->value();
+      auto final_node = property_node->first_node("final", 0, false);
+      if (final_node && is_valid_bool(final_node->value())) {
+        map[name_node->value()].final = str_to_bool(final_node->value());
+      }
+    }
+
+    auto name_attr = property_node->first_attribute("name", 0, false);
+    auto value_attr = property_node->first_attribute("value", 0, false);
+
+    if (name_attr && value_attr) {
+      auto mapValue = map.find(name_attr->value());
+      if (mapValue != map.end() && mapValue->second.final) {
+        continue;
+      }
+
+      map[name_attr->value()] = value_attr->value();
+      auto final_attr = property_node->first_attribute("final", 0, false);
+      if (final_attr && is_valid_bool(final_attr->value())) {
+        map[name_attr->value()].final = str_to_bool(final_attr->value());
+      }
+    }
+  }
+
+  return true;
+}
+
+optional<std::string> Configuration::Get(const std::string& key) const {
+  auto found = raw_values_.find(key);
+  if (found != raw_values_.end()) {
+    return std::experimental::make_optional(found->second.value);
+  } else {
+    return optional<std::string>();
+  }
+}
+
+std::string Configuration::GetWithDefault(
+    const std::string& key, const std::string& default_value) const {
+  return Get(key).value_or(default_value);
+}
+
+optional<int64_t> Configuration::GetInt(const std::string& key) const {
+  auto raw = Get(key);
+  if (raw) {
+    errno = 0;
+    char* end = nullptr;
+    auto result =
+        std::experimental::make_optional(strtol(raw->c_str(), &end, 10));
+    if (end == raw->c_str()) {
+      /* strtoll will set end to input if no conversion was done */
+      return optional<int64_t>();
+    }
+    if (errno == ERANGE) {
+      return optional<int64_t>();
+    }
+
+    return result;
+  } else {
+    return optional<int64_t>();
+  }
+}
+
+int64_t Configuration::GetIntWithDefault(const std::string& key,
+                                         int64_t default_value) const {
+  return GetInt(key).value_or(default_value);
+}
+
+optional<double> Configuration::GetDouble(const std::string& key) const {
+  auto raw = Get(key);
+  if (raw) {
+    errno = 0;
+    char* end = nullptr;
+    auto result = std::experimental::make_optional(strtod(raw->c_str(), &end));
+    if (end == raw->c_str()) {
+      /* strtod will set end to input if no conversion was done */
+      return optional<double>();
+    }
+    if (errno == ERANGE) {
+      return optional<double>();
+    }
+
+    return result;
+  } else {
+    return optional<double>();
+  }
+}
+
+double Configuration::GetDoubleWithDefault(const std::string& key,
+                                           double default_value) const {
+  return GetDouble(key).value_or(default_value);
+}
+
+optional<bool> Configuration::GetBool(const std::string& key) const {
+  auto raw = Get(key);
+  if (!raw) {
+    return optional<bool>();
+  }
+
+  if (!strcasecmp(raw->c_str(), "true")) {
+    return std::experimental::make_optional(true);
+  }
+  if (!strcasecmp(raw->c_str(), "false")) {
+    return std::experimental::make_optional(false);
+  }
+
+  return optional<bool>();
+}
+
+bool Configuration::GetBoolWithDefault(const std::string& key,
+                                       bool default_value) const {
+  return GetBool(key).value_or(default_value);
+}
+}

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.h
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.h
new file mode 100644
index 0000000..54ada94
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/common/configuration.h
@@ -0,0 +1,94 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 COMMON_CONFIGURATION_H_
+#define COMMON_CONFIGURATION_H_
+
+#include <string>
+#include <map>
+#include <vector>
+#include <set>
+#include <istream>
+#include <stdint.h>
+#include <optional.hpp>
+
+namespace hdfs {
+
+template <class T>
+using optional = std::experimental::optional<T>;
+
+/**
+ * Configuration class that parses XML.
+ *
+ * Files should be an XML file of the form
+ * <configuration>
+ *  <property>
+ *    <name>Name</name>
+ *    <value>Value</value>
+ *  </property>
+ * <configuration>
+ *
+ * This class is not thread-safe.
+ */
+class Configuration {
+ public:
+  /* Creates a new Configuration from input xml */
+  static optional<Configuration> Load(const std::string &xml_data);
+
+  /* Constructs a configuration with no resources loaded */
+  Configuration();
+
+  /* Loads resources from a file or a stream */
+  optional<Configuration> OverlayResourceString(
+      const std::string &xml_data) const;
+
+  // Gets values
+  std::string GetWithDefault(const std::string &key,
+                             const std::string &default_value) const;
+  optional<std::string> Get(const std::string &key) const;
+  int64_t GetIntWithDefault(const std::string &key, int64_t default_value) const;
+  optional<int64_t> GetInt(const std::string &key) const;
+  double GetDoubleWithDefault(const std::string &key,
+                              double default_value) const;
+  optional<double> GetDouble(const std::string &key) const;
+  bool GetBoolWithDefault(const std::string &key, bool default_value) const;
+  optional<bool> GetBool(const std::string &key) const;
+
+ private:
+  /* Transparent data holder for property values */
+  struct ConfigData {
+    std::string value;
+    bool final;
+    ConfigData() : final(false){};
+    ConfigData(const std::string &value) : value(value), final(false) {}
+    void operator=(const std::string &new_value) {
+      value = new_value;
+      final = false;
+    }
+  };
+  typedef std::map<std::string, ConfigData> ConfigMap;
+
+  Configuration(ConfigMap &src_map) : raw_values_(src_map){};
+  static bool UpdateMapWithResource(ConfigMap &map,
+                                    std::vector<char> &raw_bytes);
+
+  const ConfigMap raw_values_;
+};
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt
index abd3858..7d06141 100644
--- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt
@@ -68,6 +68,10 @@ add_executable(node_exclusion_test node_exclusion_test.cc)
 target_link_libraries(node_exclusion_test fs gmock_main common ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
 add_test(node_exclusion node_exclusion_test)
 
+add_executable(configuration_test configuration_test.cc)
+target_link_libraries(configuration_test common gmock_main ${CMAKE_THREAD_LIBS_INIT})
+add_test(configuration configuration_test)
+
 build_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static expect.c test_libhdfs_threaded.c ${OS_DIR}/thread.c)
 link_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static fs reader rpc proto common ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} native_mini_dfs ${JAVA_JVM_LIBRARY})
 add_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static)

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.cc
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.cc
new file mode 100644
index 0000000..067fb8f
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.cc
@@ -0,0 +1,363 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "configuration_test.h"
+#include "common/configuration.h"
+#include <gmock/gmock.h>
+#include <cstdio>
+#include <fstream>
+
+using ::testing::_;
+
+using namespace hdfs;
+
+namespace hdfs {
+
+TEST(ConfigurationTest, TestDegenerateInputs) {
+  /* Completely empty stream */
+  {
+    std::stringstream stream;
+    optional<Configuration> config = Configuration::Load("");
+    EXPECT_FALSE(config && "Empty stream");
+  }
+
+  /* No values */
+  {
+    std::string data = "<configuration></configuration>";
+    optional<Configuration> config = Configuration::Load(data);
+    EXPECT_TRUE(config && "Blank config");
+  }
+
+  /* Extraneous values */
+  {
+    std::string data = "<configuration><spam></spam></configuration>";
+    optional<Configuration> config = Configuration::Load(data);
+    EXPECT_TRUE(config && "Extraneous values");
+  }
+}
+
+TEST(ConfigurationTest, TestBasicOperations) {
+  /* Single value */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "value1");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+  }
+
+  /* Multiple values */
+  {
+    optional<Configuration> config =
+        simpleConfig("key1", "value1", "key2", "value2");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+    EXPECT_EQ("value2", config->GetWithDefault("key2", ""));
+  }
+
+  /* No defaults */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "value1");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    optional<std::string> value = config->Get("key1");
+    EXPECT_TRUE((bool)value);
+    EXPECT_EQ("value1", *value);
+    EXPECT_FALSE(config->Get("key2"));
+  }
+}
+
+TEST(ConfigurationTest, TestCompactValues) {
+  {
+    std::stringstream stream;
+    stream << "<configuration><property name=\"key1\" "
+              "value=\"value1\"/></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Compact value parse");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+  }
+}
+
+TEST(ConfigurationTest, TestMultipleResources) {
+  /* Single value */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "value1");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key2", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value1", config2->GetWithDefault("key1", ""));
+    EXPECT_EQ("value2", config2->GetWithDefault("key2", ""));
+  }
+}
+
+TEST(ConfigurationTest, TestStringResource) {
+  /* Single value */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "value1");
+    std::string str = stream.str();
+
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+  }
+}
+
+TEST(ConfigurationTest, TestFinal) {
+  {
+    /* Explicitly non-final non-compact value */
+    std::stringstream stream;
+    stream << "<configuration><property><name>key1</name><value>value1</"
+              "value><final>false</final></property></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value2", config2->GetWithDefault("key1", ""));
+  }
+  {
+    /* Explicitly final non-compact value */
+    std::stringstream stream;
+    stream << "<configuration><property><name>key1</name><value>value1</"
+              "value><final>true</final></property></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value1", config2->GetWithDefault("key1", ""));
+  }
+  {
+    /* Explicitly non-final compact value */
+    std::stringstream stream;
+    stream << "<configuration><property name=\"key1\" value=\"value1\" "
+              "final=\"false\"/></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value2", config2->GetWithDefault("key1", ""));
+  }
+  {
+    /* Explicitly final compact value */
+    std::stringstream stream;
+    stream << "<configuration><property name=\"key1\" value=\"value1\" "
+              "final=\"true\"/></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value1", config2->GetWithDefault("key1", ""));
+  }
+  {
+    /* Bogus final value */
+    std::stringstream stream;
+    stream << "<configuration><property><name>key1</name><value>value1</"
+              "value><final>spam</final></property></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value2", config2->GetWithDefault("key1", ""));
+  }
+  {
+    /* Blank final value */
+    std::stringstream stream;
+    stream << "<configuration><property><name>key1</name><value>value1</"
+              "value><final></final></property></configuration>";
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse first stream");
+    EXPECT_EQ("value1", config->GetWithDefault("key1", ""));
+
+    std::stringstream stream2;
+    simpleConfigStream(stream2, "key1", "value2");
+    optional<Configuration> config2 =
+        config->OverlayResourceString(stream2.str());
+    EXPECT_TRUE(config2 && "Parse second stream");
+    EXPECT_EQ("value2", config2->GetWithDefault("key1", ""));
+  }
+}
+TEST(ConfigurationTest, TestIntConversions) {
+  /* No defaults */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "1");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    optional<int64_t> value = config->GetInt("key1");
+    EXPECT_TRUE((bool)value);
+    EXPECT_EQ(1, *value);
+    EXPECT_FALSE(config->GetInt("key2"));
+  }
+
+  {
+    optional<Configuration> config = simpleConfig("key1", "1");
+    EXPECT_EQ(1, config->GetIntWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "-100");
+    EXPECT_EQ(-100, config->GetIntWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", " 1 ");
+    EXPECT_EQ(1, config->GetIntWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "");
+    EXPECT_EQ(-1, config->GetIntWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "spam");
+    EXPECT_EQ(-1, config->GetIntWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key2", "");
+    EXPECT_EQ(-1, config->GetIntWithDefault("key1", -1));
+  }
+}
+
+TEST(ConfigurationTest, TestDoubleConversions) {
+  /* No defaults */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "1");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    optional<double> value = config->GetDouble("key1");
+    EXPECT_TRUE((bool)value);
+    EXPECT_EQ(1, *value);
+    EXPECT_FALSE(config->GetDouble("key2"));
+  }
+
+  {
+    optional<Configuration> config = simpleConfig("key1", "1");
+    EXPECT_EQ(1, config->GetDoubleWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "-100");
+    EXPECT_EQ(-100, config->GetDoubleWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", " 1 ");
+    EXPECT_EQ(1, config->GetDoubleWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "");
+    EXPECT_EQ(-1, config->GetDoubleWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "spam");
+    EXPECT_EQ(-1, config->GetDoubleWithDefault("key1", -1));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key2", "");
+    EXPECT_EQ(-1, config->GetDoubleWithDefault("key1", -1));
+  }
+  { /* Out of range */
+    optional<Configuration> config = simpleConfig("key2", "1e9999");
+    EXPECT_EQ(-1, config->GetDoubleWithDefault("key1", -1));
+  }
+}
+
+TEST(ConfigurationTest, TestBoolConversions) {
+  /* No defaults */
+  {
+    std::stringstream stream;
+    simpleConfigStream(stream, "key1", "true");
+    optional<Configuration> config = Configuration::Load(stream.str());
+    EXPECT_TRUE(config && "Parse single value");
+    optional<bool> value = config->GetBool("key1");
+    EXPECT_TRUE((bool)value);
+    EXPECT_EQ(true, *value);
+    EXPECT_FALSE(config->GetBool("key2"));
+  }
+
+  {
+    optional<Configuration> config = simpleConfig("key1", "true");
+    EXPECT_EQ(true, config->GetBoolWithDefault("key1", false));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "tRuE");
+    EXPECT_EQ(true, config->GetBoolWithDefault("key1", false));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "false");
+    EXPECT_FALSE(config->GetBoolWithDefault("key1", true));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "FaLsE");
+    EXPECT_FALSE(config->GetBoolWithDefault("key1", true));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", " FaLsE ");
+    EXPECT_FALSE(config->GetBoolWithDefault("key1", true));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "");
+    EXPECT_EQ(true, config->GetBoolWithDefault("key1", true));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "spam");
+    EXPECT_EQ(true, config->GetBoolWithDefault("key1", true));
+  }
+  {
+    optional<Configuration> config = simpleConfig("key1", "");
+    EXPECT_EQ(true, config->GetBoolWithDefault("key2", true));
+  }
+}
+
+int main(int argc, char *argv[]) {
+  /*
+   *  The following line must be executed to initialize Google Mock
+   * (and Google Test) before running the tests.
+   */
+  ::testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+}

http://git-wip-us.apache.org/repos/asf/hadoop/blob/8c6a84fd/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.h
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.h
new file mode 100644
index 0000000..ec04ca4
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/configuration_test.h
@@ -0,0 +1,73 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 TESTS_CONFIGURATION_H_
+#define TESTS_CONFIGURATION_H_
+
+#include "common/configuration.h"
+#include <cstdio>
+#include <fstream>
+#include <istream>
+#include <gmock/gmock.h>
+
+namespace hdfs {
+
+template <typename T, typename U>
+void simpleConfigStreamProperty(std::stringstream& out, T key, U value) {
+  out << "<property>"
+      << "<name>" << key << "</name>"
+      << "<value>" << value << "</value>"
+      << "</property>";
+}
+
+template <typename T, typename U, typename... Args>
+void simpleConfigStreamProperty(std::stringstream& out, T key, U value,
+                                Args... args) {
+  simpleConfigStreamProperty(out, key, value);
+  simpleConfigStreamProperty(out, args...);
+}
+
+template <typename... Args>
+void simpleConfigStream(std::stringstream& out, Args... args) {
+  out << "<configuration>";
+  simpleConfigStreamProperty(out, args...);
+  out << "</configuration>";
+}
+
+template <typename... Args>
+optional<Configuration> simpleConfig(Args... args) {
+  Configuration result;
+  std::stringstream stream;
+  simpleConfigStream(stream, args...);
+  optional<Configuration> parse = result.Load(stream.str());
+  EXPECT_TRUE((bool)parse);
+
+  return parse;
+}
+
+template <typename... Args>
+void writeSimpleConfig(const std::string& filename, Args... args) {
+  std::stringstream stream;
+  simpleConfigStream(stream, args...);
+
+  std::ofstream out;
+  out.open(filename);
+  out << stream.rdbuf();
+}
+}
+
+#endif