fable: Add and use gtest utility functions

Author: cassava

fable/include/fable/utility/gtest.hpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2020 Robert Bosch GmbH
+ *
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * \file fable/utility/gtest.hpp
+ */
+
+#pragma once
+#ifndef FABLE_UTILITY_GTEST_HPP_
+#define FABLE_UTILITY_GTEST_HPP_
+
+#include <iostream>  // for cerr
+
+#include <gtest/gtest.h>  // for ASSERT_THROW, ASSERT_EQ
+
+#include <fable/conf.hpp>      // for Conf, Json
+#include <fable/confable.hpp>  // for Confable
+#include <fable/error.hpp>     // for SchemaError
+#include <fable/utility.hpp>   // for pretty_print
+
+namespace fable {
+
+inline void assert_eq(const Json& j, const Json& k) {
+  ASSERT_EQ(std::string(j.dump(2)), std::string(k.dump(2)));
+}
+
+inline void assert_ne(const Json& j, const Json& k) {
+  ASSERT_NE(std::string(j.dump(2)), std::string(k.dump(2)));
+}
+
+inline void assert_schema_eq(const Confable& x, const Json& expect) {
+  assert_eq(x.schema().json_schema(), expect);
+}
+
+inline void assert_schema_eq(const Confable& x, const char expect[]) {
+  assert_eq(x.schema().json_schema(), Json::parse(expect));
+}
+
+inline void assert_validate(const Confable& x, const Conf& input) {
+  try {
+    x.schema().validate(input);
+  } catch (SchemaError& e) {
+    pretty_print(e, std::cerr);
+    throw;
+  };
+}
+
+inline void assert_validate(const Confable& x, const char json_input[]) {
+  assert_validate(x, Conf{Json::parse(json_input)});
+}
+
+inline void assert_invalidate(const Confable& x, const Conf& input) {
+  ASSERT_THROW(x.schema().validate(input), SchemaError);
+}
+
+inline void assert_invalidate(const Confable& x, const char json_input[]) {
+  assert_invalidate(x, Conf{Json::parse(json_input)});
+}
+
+template <typename T>
+inline void assert_to_json(const T& x, const Json& expect) {
+  assert_eq(x.to_json(), expect);
+}
+
+template <typename T>
+inline void assert_to_json(const T& x, const char json_expect[]) {
+  assert_to_json(x, Json::parse(json_expect));
+}
+
+inline void assert_from_conf_throw(Confable& x, const Conf& input) {
+  Json before = x.to_json();
+  ASSERT_THROW(x.from_conf(input), SchemaError);
+  assert_eq(x.to_json(), before);
+}
+
+inline void assert_from_conf_throw(Confable& x, const char json_input[]) {
+  assert_from_conf_throw(x, Conf{Json::parse(json_input)});
+}
+
+template <typename T>
+inline void assert_from_conf(T& x, const Conf& input) {
+  x.from_conf(input);
+}
+
+template <typename T>
+inline void assert_from_conf(T& x, const char json_input[]) {
+  assert_from_conf(x, Conf{Json::parse(json_input)});
+}
+
+template <typename T>
+inline void assert_from_eq_to(T& x, const Json& identity) {
+  assert_from_conf(x, Conf{identity});
+  assert_to_json(x, identity);
+}
+
+template <typename T>
+inline void assert_from_eq_to(T& x, const char json_input[]) {
+  assert_from_eq_to(x, Json::parse(json_input));
+}
+
+}  // namespace fable
+
+#endif  // FABLE_UTILITY_GTEST_HPP_

fable/src/fable/schema/const_test.cpp

@@ -20,14 +20,13 @@
  * \see  fable/schema/const.hpp
  */
 
-#include <iostream>   // for cout, endl
-#include <string>     // for string
-using namespace std;  // NOLINT(build/namespaces)
+#include <gtest/gtest.h>  // for TEST
 
-#include <gtest/gtest.h>
+#include <fable/confable.hpp>       // for Confable
+#include <fable/schema.hpp>         // for Const
+#include <fable/utility/gtest.hpp>  // for assert_validate
 
-#include <fable/confable.hpp>  // for Confable
-#include <fable/schema.hpp>    // for Const
+namespace {
 
 struct MyConstStruct : public fable::Confable {
   CONFABLE_SCHEMA(MyConstStruct) {
@@ -39,14 +38,11 @@ struct MyConstStruct : public fable::Confable {
   }
 };
 
-inline void assert_json_eq(const fable::Json& j, const fable::Json& k) {
-  ASSERT_EQ(std::string(j.dump()), std::string(k.dump()));
-}
+}  // anonymous namespace
 
 TEST(fable_schema_const, schema) {
   MyConstStruct tmp;
-
-  fable::Json expect = R"({
+  fable::assert_schema_eq(tmp, R"({
     "type": "object",
     "properties": {
       "release": {
@@ -60,34 +56,30 @@ TEST(fable_schema_const, schema) {
     },
     "required": ["release"],
     "additionalProperties": false
-  })"_json;
-
-  assert_json_eq(tmp.schema().json_schema(), expect);
+  })");
 }
 
 TEST(fable_schema_const, validate) {
   MyConstStruct tmp;
 
-  tmp.schema().validate(fable::Conf{R"({
+  fable::assert_validate(tmp, R"({
     "release": "2"
-  })"_json});
+  })");
 
-  tmp.schema().validate(fable::Conf{R"({
+  fable::assert_validate(tmp, R"({
     "release": "2",
     "major": 2
-  })"_json});
+  })");
 
-  fable::Conf wrong{R"({
+  fable::assert_invalidate(tmp, R"({
     "release": "wrong"
-  })"_json};
-  ASSERT_ANY_THROW(tmp.schema().validate(wrong));
+  })");
 }
 
 TEST(fable_schema_const, to_json) {
   MyConstStruct tmp;
-  fable::Json expect = R"({
+  fable::assert_to_json(tmp, R"({
     "release": "2",
     "major": 2
-  })"_json;
-  assert_json_eq(tmp.schema().to_json(), expect);
+  })");
 }

fable/src/fable/schema/enum_test.cpp

@@ -22,9 +22,9 @@
 
 #include <gtest/gtest.h>
 
-#include <fable/confable.hpp>
-#include <fable/schema.hpp>
-using namespace fable;  // NOLINT(build/namespaces)
+#include <fable/confable.hpp>       // for Confable
+#include <fable/schema.hpp>         // for Struct, ...
+#include <fable/utility/gtest.hpp>  // for assert_to_json, ...
 
 namespace logger {
 enum LogLevel {
@@ -44,84 +44,46 @@ FABLE_ENUM_SERIALIZATION(logger::LogLevel, ({
 
 using LogLevel = logger::LogLevel;
 
-struct LoggerStruct : public Confable {
+struct LoggerStruct : public fable::Confable {
   boost::optional<LogLevel> level;
 
   CONFABLE_SCHEMA(LoggerStruct) {
-    using namespace schema;  // NOLINT(build/namespaces)
+    using namespace fable::schema;  // NOLINT(build/namespaces)
     return Struct{
         {"level", make_schema(&level, "")},
     };
   }
 };
 
 TEST(fable_schema_enum, struct_enum) {
-  LoggerStruct s;
-  Json empty = R"({
-  })"_json;
-  Json input = R"({
-    "level": "info"
-  })"_json;
-  Json filled = R"({
-    "level": "info"
-  })"_json;
-
-  ASSERT_NO_THROW({
-    ASSERT_EQ(s.to_json().dump(2), empty.dump(2));
-    s.from_conf(Conf{input});
-    ASSERT_EQ(s.to_json().dump(2), filled.dump(2));
-  });
+  LoggerStruct l;
+  fable::assert_to_json(l, "{}");
+  fable::assert_from_eq_to(l, fable::Json{{"level", "info"}});
 }
 
 TEST(fable_schema_enum, vector_enum_ok) {
-  using namespace schema;  // NOLINT(build/namespaces)
+  using namespace fable::schema;  // NOLINT(build/namespaces)
   std::vector<LogLevel> xs;
   Array<LogLevel, Enum<LogLevel>> s{&xs, ""};
 
-  Json empty = R"([])"_json;
-  Json input = R"([
-    "info"
-  ])"_json;
-  Json filled = R"([
+  fable::assert_to_json(s, "[]");
+  fable::assert_from_eq_to(s, R"([
     "info"
-  ])"_json;
-
-  Json j;
-  s.to_json(j);
-  ASSERT_EQ(j.dump(2), empty.dump(2));
-
-  s.from_conf(Conf{input});
+  ])");
   ASSERT_EQ(xs.size(), 1);
   ASSERT_EQ(xs[0], LogLevel::info);
-  ASSERT_NO_THROW({
-    s.to_json(j);
-    ASSERT_EQ(j.dump(2), filled.dump(2));
-  });
 }
 
 TEST(fable_schema_enum, vector_struct_enum) {
-  using namespace schema;  // NOLINT(build/namespaces)
+  using namespace fable::schema;  // NOLINT(build/namespaces)
   std::vector<LoggerStruct> xs;
   Array<LoggerStruct, FromConfable<LoggerStruct>> s{&xs, ""};
 
-  Json empty = R"([])"_json;
-  Json input = R"([{
-    "level": "info"
-  }])"_json;
-  Json filled = R"([{
-    "level": "info"
-  }])"_json;
-
-  Json j;
-  s.to_json(j);
-  ASSERT_EQ(j.dump(2), empty.dump(2));
+  fable::assert_to_json(s, "[]");
+  fable::assert_from_eq_to(s, R"([
+    {"level": "info"}
+  ])");
 
-  s.from_conf(Conf{input});
   ASSERT_EQ(xs.size(), 1);
   ASSERT_EQ(*(xs[0].level), LogLevel::info);
-  ASSERT_EQ(Json(xs).dump(2), filled.dump(2));
-  ASSERT_NO_THROW({
-    s.to_json(j);
-    ASSERT_EQ(j.dump(2), filled.dump(2));
-  });
 }

fable/src/fable/schema/number_test.cpp

@@ -26,8 +26,9 @@ using namespace std;  // NOLINT(build/namespaces)
 
 #include <gtest/gtest.h>
 
-#include <fable/confable.hpp>  // for Confable
-#include <fable/schema.hpp>    // for Number
+#include <fable/confable.hpp>       // for Confable
+#include <fable/schema.hpp>         // for Number
+#include <fable/utility/gtest.hpp>  // for assert_validate
 
 struct MyNumberStruct : public fable::Confable {
   uint8_t number;
@@ -39,13 +40,9 @@ struct MyNumberStruct : public fable::Confable {
   }
 };
 
-inline void assert_json_eq(const fable::Json& j, const fable::Json& k) {
-  ASSERT_EQ(std::string(j.dump()), std::string(k.dump()));
-}
-
 TEST(fable_schema_number, schema) {
   MyNumberStruct tmp;
-  fable::Json expect = R"({
+  fable::assert_schema_eq(tmp, R"({
     "type": "object",
     "properties": {
       "number": {
@@ -59,23 +56,23 @@ TEST(fable_schema_number, schema) {
       }
     },
     "additionalProperties": false
-  })"_json;
-
-  assert_json_eq(tmp.schema().json_schema(), expect);
+  })");
 }
 
 TEST(fable_schema_number, validate) {
   MyNumberStruct tmp;
 
   std::vector<uint8_t> ok{0, 1, 2, 3, 4, 5, 6, 7, 15};
   for (auto x : ok) {
-    fable::Conf c{fable::Json{{"number", x}}};
-    ASSERT_NO_THROW(tmp.schema().validate(c));
+    fable::assert_validate(tmp, fable::Json{
+                                    {"number", x},
+                                });
   };
 
   std::vector<uint8_t> wrong{8, 16, 32, 255};
   for (auto x : wrong) {
-    fable::Conf c{fable::Json{{"number", x}}};
-    ASSERT_ANY_THROW(tmp.schema().validate(c));
+    fable::assert_invalidate(tmp, fable::Json{
+                                      {"number", x},
+                                  });
   }
 }