common: Add strict_strtof, strict_strtod, unittest

Signed-off-by: Colin McCabe <colin.mccabe@dreamhost.com>

diff --git a/src/Makefile.am b/src/Makefile.am
index b1c5e74ab7aa8f51b5d5f29bc34fb28f2a81e8bb..a9dd6f9964fe11b93283f514aaa52403d89f0243 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -434,6 +434,12 @@ unittest_rgw_escape_LDADD = libcommon.a ${UNITTEST_LDADD}
 unittest_rgw_escape_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
 check_PROGRAMS += unittest_rgw_escape
 
+unittest_strtol_SOURCES = test/strtol.cc
+unittest_strtol_LDFLAGS = -pthread ${AM_LDFLAGS}
+unittest_strtol_LDADD = libcommon.a ${UNITTEST_LDADD}
+unittest_strtol_CXXFLAGS = ${AM_CXXFLAGS} ${UNITTEST_CXXFLAGS}
+check_PROGRAMS += unittest_strtol
+
 # shell scripts
 editpaths = sed \
        -e 's|@bindir[@]|$(bindir)|g' \

diff --git a/src/common/strtol.cc b/src/common/strtol.cc
index a94c5f7b97a33181d401b6ef938239ab7a44e6a1..8f12f08f19bee8c53bdaa7c50691e1a14e683984 100644 (file)
--- a/src/common/strtol.cc
+++ b/src/common/strtol.cc
@@ -45,6 +45,7 @@ long long strict_strtoll(const char *str, int base, std::string *err)
     *err = oss.str();
     return 0;
   }
+  *err = "";
   return ret;
 }
 
@@ -67,3 +68,59 @@ int strict_strtol(const char *str, int base, std::string *err)
   }
   return static_cast<int>(ret);
 }
+
+double strict_strtod(const char *str, std::string *err)
+{
+  char *endptr;
+  errno = 0; /* To distinguish success/failure after call (see man page) */
+  double ret = strtod(str, &endptr);
+  if (errno == ERANGE) {
+    ostringstream oss;
+    oss << "strict_strtod: floating point overflow or underflow parsing '"
+       << str << "'";
+    *err = oss.str();
+    return 0.0;
+  }
+  if (endptr == str) {
+    ostringstream oss;
+    oss << "strict_strtod: expected double, got: '" << str << "'";
+    *err = oss.str();
+    return 0;
+  }
+  if (*endptr != '\0') {
+    ostringstream oss;
+    oss << "strict_strtod: garbage at end of string. got: '" << str << "'";
+    *err = oss.str();
+    return 0;
+  }
+  *err = "";
+  return ret;
+}
+
+float strict_strtof(const char *str, std::string *err)
+{
+  char *endptr;
+  errno = 0; /* To distinguish success/failure after call (see man page) */
+  float ret = strtof(str, &endptr);
+  if (errno == ERANGE) {
+    ostringstream oss;
+    oss << "strict_strtof: floating point overflow or underflow parsing '"
+       << str << "'";
+    *err = oss.str();
+    return 0.0;
+  }
+  if (endptr == str) {
+    ostringstream oss;
+    oss << "strict_strtof: expected float, got: '" << str << "'";
+    *err = oss.str();
+    return 0;
+  }
+  if (*endptr != '\0') {
+    ostringstream oss;
+    oss << "strict_strtof: garbage at end of string. got: '" << str << "'";
+    *err = oss.str();
+    return 0;
+  }
+  *err = "";
+  return ret;
+}

diff --git a/src/common/strtol.h b/src/common/strtol.h
index 31cac53dfab5b68553663d621fe5cacea4149c1a..80b5a3f9f922469aade68fcba41fd0898b4ada4b 100644 (file)
--- a/src/common/strtol.h
+++ b/src/common/strtol.h
@@ -21,4 +21,8 @@ long long strict_strtoll(const char *str, int base, std::string *err);
 
 int strict_strtol(const char *str, int base, std::string *err);
 
+double strict_strtod(const char *str, std::string *err);
+
+float strict_strtof(const char *str, std::string *err);
+
 #endif

diff --git a/src/test/strtol.cc b/src/test/strtol.cc
new file mode 100644 (file)
index 0000000..d3f0ae0
--- /dev/null
+++ b/src/test/strtol.cc
@@ -0,0 +1,136 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2011 Dreamhost
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation.  See file COPYING.
+ *
+ */
+
+#include "common/strtol.h"
+#include <string>
+
+#include "gtest/gtest.h"
+
+static void test_strict_strtoll(const char *str, long long expected)
+{
+  std::string err;
+  long long val = strict_strtoll(str, 10, &err);
+  if (!err.empty()) {
+    ASSERT_EQ(err, "");
+  }
+  else {
+    ASSERT_EQ(val, expected);
+  }
+}
+
+static void test_strict_strtol(const char *str, long expected)
+{
+  std::string err;
+  long val = strict_strtol(str, 10, &err);
+  if (!err.empty()) {
+    ASSERT_EQ(err, "");
+  }
+  else {
+    ASSERT_EQ(val, expected);
+  }
+}
+
+static void test_strict_strtod(const char *str, double expected)
+{
+  std::string err;
+  double val = strict_strtod(str, &err);
+  if (!err.empty()) {
+    ASSERT_EQ(err, "");
+  }
+  else {
+    // when comparing floats, use a margin of error
+    if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
+      ASSERT_EQ(val, expected);
+    }
+  }
+}
+
+static void test_strict_strtof(const char *str, float expected)
+{
+  std::string err;
+  float val = strict_strtof(str, &err);
+  if (!err.empty()) {
+    ASSERT_EQ(err, "");
+  }
+  else {
+    // when comparing floats, use a margin of error
+    if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
+      ASSERT_EQ(val, expected);
+    }
+  }
+}
+
+TEST(StrToL, Simple1) {
+  test_strict_strtoll("123", 123);
+  test_strict_strtoll("0", 0);
+  test_strict_strtoll("-123", -123);
+  test_strict_strtoll("8796093022208", 8796093022208LL);
+  test_strict_strtoll("-8796093022208", -8796093022208LL);
+
+  test_strict_strtol("208", 208);
+  test_strict_strtol("-4", -4);
+  test_strict_strtol("0", 0);
+  test_strict_strtol("2147483646", 2147483646);
+
+  test_strict_strtof("0.05", 0.05);
+  test_strict_strtof("0", 0.0);
+  test_strict_strtof("-0", 0.0);
+  test_strict_strtof("10000000.5", 10000000.5);
+
+  test_strict_strtod("-0.2", -0.2);
+  test_strict_strtod("0.1", 0.1);
+  test_strict_strtod("0", 0.0);
+}
+
+static void test_strict_strtoll_err(const char *str)
+{
+  std::string err;
+  strict_strtoll(str, 10, &err);
+  ASSERT_NE(err, "");
+}
+
+static void test_strict_strtol_err(const char *str)
+{
+  std::string err;
+  strict_strtol(str, 10, &err);
+  ASSERT_NE(err, "");
+}
+
+static void test_strict_strtod_err(const char *str)
+{
+  std::string err;
+  strict_strtod(str, &err);
+  ASSERT_NE(err, "");
+}
+
+static void test_strict_strtof_err(const char *str)
+{
+  std::string err;
+  strict_strtof(str, &err);
+  ASSERT_NE(err, "");
+}
+
+TEST(StrToL, Error1) {
+  test_strict_strtoll_err("604462909807314587353088"); // overflow
+  test_strict_strtoll_err("aw shucks"); // invalid
+  test_strict_strtoll_err("343245 aw shucks"); // invalid chars at end
+
+  test_strict_strtol_err("35 aw shucks"); // invalid chars at end
+  test_strict_strtol_err("--0");
+
+  test_strict_strtod_err("345345.0-");
+  test_strict_strtod_err("34.0 garbo");
+
+  test_strict_strtof_err("0.05.0");
+}