$(NNTRAINER_ROOT)/nntrainer/layers/lstm.cpp \
$(NNTRAINER_ROOT)/nntrainer/layers/time_dist.cpp \
$(NNTRAINER_ROOT)/nntrainer/layers/acti_func.cpp \
+ $(NNTRAINER_ROOT)/nntrainer/layers/common_properties.cpp \
$(NNTRAINER_ROOT)/nntrainer/graph/network_graph.cpp \
$(NNTRAINER_ROOT)/nntrainer/optimizers/optimizer_devel.cpp \
$(NNTRAINER_ROOT)/nntrainer/optimizers/optimizer_impl.cpp \
--- /dev/null
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
+ *
+ * @file common_properties.cpp
+ * @date 14 May 2021
+ * @brief This file contains implementation of common properties widely used
+ * across layers
+ * @see https://github.com/nnstreamer/nntrainer
+ * @author Jihoon Lee <jhoon.it.lee@samsung.com>
+ * @bug No known bugs except for NYI items
+ */
+#include <common_properties.h>
+
+#include <nntrainer_error.h>
+#include <parse_util.h>
+
+#include <regex>
+#include <vector>
+
+namespace nntrainer {
+namespace props {
+bool Name::isValid(const std::string &v) const {
+
+ static std::regex allowed("[a-zA-Z0-9][-_./a-zA-Z0-9]*");
+ return std::regex_match(v, allowed);
+}
+
+} // namespace props
+
+} // namespace nntrainer
/**
* Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
*
- * @file common_properties.h
- * @date 09 April 2021
- * @brief This file contains list of common properties widely used across layers
- * @see https://github.com/nnstreamer/nntrainer
+ * @file common_properties.h
+ * @date 09 April 2021
+ * @brief This file contains list of common properties widely used across
+ * layers
+ * @see https://github.com/nnstreamer/nntrainer
* @author Jihoon Lee <jhoon.it.lee@samsung.com>
- * @bug No known bugs except for NYI items
+ * @bug No known bugs except for NYI items
*/
#include <string>
nntrainer::Property<std::string>(value) {} /**< default value if any */
static constexpr const char *key = "name"; /**< unique key to access */
using prop_tag = str_prop_tag; /**< property type */
+
+ /**
+ * @brief name validator
+ *
+ * @param v string to validate
+ * @return true if it contains alphanumeric and/or '-', '_', '/'
+ * @return false if it is empty or contains non-valid character
+ */
+ bool isValid(const std::string &v) const override;
};
/**
'rnn.cpp',
'acti_func.cpp',
'lstm.cpp',
- 'time_dist.cpp'
+ 'time_dist.cpp',
+ 'common_properties.cpp'
]
layer_headers = [
'unittest_nntrainer_models',
'unittest_nntrainer_graph',
'unittest_nntrainer_appcontext',
- 'unittest_properties',
+ 'unittest_base_properties',
+ 'unittest_common_properties'
]
if get_option('enable-profile')
--- /dev/null
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
+ *
+ * @file unittest_base_properties.h
+ * @date 09 April 2021
+ * @brief This file contains test and specification of properties and exporter
+ * @see https://github.com/nnstreamer/nntrainer
+ * @author Jihoon Lee <jhoon.it.lee@samsung.com>
+ * @bug No known bugs except for NYI items
+ */
+#include <gtest/gtest.h>
+
+#include <array>
+#include <utility>
+#include <vector>
+
+#include <base_properties.h>
+#include <fc_layer.h>
+#include <nntrainer_error.h>
+#include <node_exporter.h>
+#include <util_func.h>
+
+namespace { /**< define a property for testing */
+
+/**
+ * @brief banana property tag for example
+ *
+ */
+struct banana_prop_tag : nntrainer::int_prop_tag {};
+
+/**
+ * @brief Number of banana property
+ *
+ */
+class NumBanana : public nntrainer::Property<int> {
+public:
+ NumBanana(int num = 1) : Property<int>(num) {} /**< default value if any */
+ static constexpr const char *key = "num_banana"; /**< unique key to access */
+ using prop_tag = banana_prop_tag; /**< property type */
+
+ bool isValid(const int &v) const override { return v >= 0; }
+};
+
+/**
+ * @brief QualityOfBanana property for example, this has to end with "good"
+ *
+ */
+class QualityOfBanana : public nntrainer::Property<std::string> {
+public:
+ QualityOfBanana(const char *value = "") : Property<std::string>(value) {}
+ static constexpr const char *key = "quality_banana";
+ using prop_tag = nntrainer::str_prop_tag;
+
+ bool isValid(const std::string &v) const override {
+ /// assuming quality of banana property must ends with word "good";
+ return nntrainer::endswith(v, "good");
+ }
+};
+
+/**
+ * @brief DimensionOfBanana property for example, this has to have batch size of
+ * 1
+ *
+ */
+class DimensionOfBanana : public nntrainer::Property<nntrainer::TensorDim> {
+public:
+ static constexpr const char *key = "banana_size";
+ using prop_tag = nntrainer::dimension_prop_tag;
+
+ bool isValid(const nntrainer::TensorDim &dim) const override {
+ std::cerr << dim;
+ return dim.batch() == 1;
+ }
+};
+} // namespace
+
+TEST(BasicProperty, tagCast) {
+ EXPECT_EQ(1, 1); /**< this is to prevent no assert tc from TCM */
+
+ { /**< tag_cast simple cast */
+ using T =
+ nntrainer::tag_cast<banana_prop_tag, nntrainer::int_prop_tag>::type;
+ ::testing::StaticAssertTypeEq<T, nntrainer::int_prop_tag>();
+ }
+
+ { /**< tag_cast ranged cast */
+ using T = nntrainer::tag_cast<banana_prop_tag, nntrainer::float_prop_tag,
+ nntrainer::int_prop_tag>::type;
+ ::testing::StaticAssertTypeEq<T, nntrainer::int_prop_tag>();
+ }
+
+ { /**< tag_cast does not have appropriate candidates */
+ using T = nntrainer::tag_cast<banana_prop_tag, int, std::string>::type;
+ ::testing::StaticAssertTypeEq<T, banana_prop_tag>();
+ }
+}
+
+/// @todo convert this to typed param test
+TEST(BasicProperty, valid_p) {
+ { /** set -> get / to_string, int*/
+ NumBanana b;
+ b.set(123);
+ int ib = b;
+ EXPECT_EQ(ib, 123);
+ EXPECT_EQ(b.get(), 123);
+ EXPECT_EQ(nntrainer::to_string(b), "123");
+ }
+
+ { /**< from_string -> get / to_string, int*/
+ NumBanana b;
+ nntrainer::from_string("3", b);
+ EXPECT_EQ(b.get(), 3);
+ EXPECT_EQ(nntrainer::to_string(b), "3");
+ }
+
+ { /** set -> get / to_string, string*/
+ QualityOfBanana q;
+ q.set("this is good");
+ std::string sq = q;
+ EXPECT_EQ(sq, "this is good");
+ EXPECT_EQ(q.get(), "this is good");
+ EXPECT_EQ(nntrainer::to_string(q), "this is good");
+ }
+
+ { /**< from_string -> get / to_string, string prop */
+ QualityOfBanana q;
+ nntrainer::from_string("this is good", q);
+ EXPECT_EQ(q.get(), "this is good");
+ EXPECT_EQ(nntrainer::to_string(q), "this is good");
+ }
+
+ { /** set -> get / to_string, dimension*/
+ DimensionOfBanana q;
+ q.set({1, 2, 3, 4});
+ EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 2, 3, 4));
+ EXPECT_EQ(nntrainer::to_string(q), "1:2:3:4");
+ }
+
+ { /**< from_string -> get / to_string, dimension */
+ DimensionOfBanana q;
+ nntrainer::from_string("1:2:3:4", q);
+ EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 2, 3, 4));
+ EXPECT_EQ(nntrainer::to_string(q), "1:2:3:4");
+ }
+
+ { /**< from_string -> get / to_string, dimension */
+ DimensionOfBanana q;
+ nntrainer::from_string("3:4", q);
+ EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 1, 3, 4));
+ EXPECT_EQ(nntrainer::to_string(q), "1:1:3:4");
+ }
+
+ { /**< from_string -> get / to_string, uint vector prop */
+ std::vector<NumBanana> bananas;
+ EXPECT_EQ(nntrainer::getPropKey(bananas), "num_banana");
+ nntrainer::from_string("1, 2,3, 4, 5", bananas);
+ auto expected = std::vector<NumBanana>({1, 2, 3, 4, 5});
+ EXPECT_EQ(bananas, expected);
+ EXPECT_EQ(nntrainer::to_string(bananas), "1,2,3,4,5");
+ }
+
+ { /**< from_string -> get / to_string, uint array prop */
+ std::array<NumBanana, 4> bananas;
+ EXPECT_EQ(nntrainer::getPropKey(bananas), "num_banana");
+ nntrainer::from_string("1, 2,3, 4", bananas);
+ auto expected = std::array<NumBanana, 4>({1, 2, 3, 4});
+ EXPECT_EQ(bananas, expected);
+ EXPECT_EQ(nntrainer::to_string(bananas), "1,2,3,4");
+ }
+
+ { /**< exporter test */
+ auto props = std::make_tuple(NumBanana(), QualityOfBanana());
+
+ nntrainer::Exporter e;
+ e.save_result(props, nntrainer::ExportMethods::METHOD_STRINGVECTOR);
+
+ auto result = e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>();
+
+ auto pair = std::pair<std::string, std::string>("num_banana", "1");
+ EXPECT_EQ(result[0], pair);
+
+ auto pair2 = std::pair<std::string, std::string>("quality_banana", "");
+ EXPECT_EQ(result[1], pair2);
+ }
+
+ { /**< export from layer */
+ auto layer = nntrainer::FullyConnectedLayer(1);
+ nntrainer::Exporter e;
+ layer.export_to(e);
+
+ auto result = e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>();
+ auto pair0 = std::pair<std::string, std::string>("name", "");
+ EXPECT_EQ(result[0], pair0);
+ auto pair1 = std::pair<std::string, std::string>("unit", "1");
+ EXPECT_EQ(result[1], pair1);
+ }
+
+ { /**< load from layer */
+ auto props =
+ std::make_tuple(NumBanana(), QualityOfBanana(), DimensionOfBanana());
+
+ auto v = nntrainer::loadProperties(
+ {"num_banana=2", "quality_banana=thisisgood", "num_banana=42",
+ "banana_size=2:2:3", "not_used=key"},
+ props);
+
+ EXPECT_EQ(v, std::vector<std::string>{"not_used=key"});
+ EXPECT_EQ(std::get<0>(props).get(), 42);
+ EXPECT_EQ(std::get<1>(props).get(), "thisisgood");
+ }
+
+ { /**< load from layer */
+ std::tuple<std::array<NumBanana, 4>, std::vector<QualityOfBanana>> props;
+
+ auto v = nntrainer::loadProperties(
+ {"num_banana=1,2, 3 ,4", "quality_banana=thisisgood, thisisverygood",
+ "not_used=key"},
+ props);
+
+ EXPECT_EQ(v, std::vector<std::string>{"not_used=key"});
+ auto expected = std::array<NumBanana, 4>({1, 2, 3, 4});
+ EXPECT_EQ(std::get<0>(props), expected);
+ auto expected2 =
+ std::vector<QualityOfBanana>({"thisisgood", "thisisverygood"});
+ EXPECT_EQ(std::get<1>(props), expected2);
+ }
+}
+
+TEST(BasicProperty, setNotValid_01_n) {
+ NumBanana b;
+ EXPECT_THROW(b.set(-1), std::invalid_argument);
+}
+
+TEST(BasicProperty, setNotValid_02_n) {
+ QualityOfBanana q;
+ EXPECT_THROW(q.set("invalid_str"), std::invalid_argument);
+}
+
+TEST(BasicProperty, setNotValid_03_n) {
+ DimensionOfBanana d;
+ EXPECT_THROW(d.set({3, 3, 2, 4}), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_01_n) {
+ NumBanana b;
+ EXPECT_THROW(nntrainer::from_string("not integer", b), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_02_n) {
+ NumBanana b;
+ EXPECT_THROW(nntrainer::from_string("-1", b), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_03_n) {
+ QualityOfBanana q;
+ EXPECT_THROW(nntrainer::from_string("invalid_str", q), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_04_n) {
+ DimensionOfBanana d;
+ EXPECT_THROW(nntrainer::from_string("1:1:2:3:5", d), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_05_n) {
+ DimensionOfBanana d;
+ EXPECT_THROW(nntrainer::from_string("2:2:3:5", d), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_06_n) {
+ DimensionOfBanana d;
+ EXPECT_THROW(nntrainer::from_string("", d), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringNotValid_07_n) {
+ DimensionOfBanana d;
+ EXPECT_THROW(nntrainer::from_string(":2:3:5", d), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringVectorElementContainNotValidString_n) {
+ std::vector<NumBanana> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, 3, not_valid", bs),
+ std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringVectorElementContainNotValidProp_n) {
+ std::vector<NumBanana> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, 3, -1", bs),
+ std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringLessArrayElementSize_n) {
+ std::array<NumBanana, 4> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, 3", bs), std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringOverArrayElementSize_n) {
+ std::array<NumBanana, 4> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, 3,4,5", bs),
+ std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringArrayNotValidString_n) {
+ std::array<NumBanana, 4> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, invalid, 4", bs),
+ std::invalid_argument);
+}
+
+TEST(BasicProperty, fromStringArrayNotValidProp_n) {
+ std::array<NumBanana, 4> bs;
+ EXPECT_THROW(nntrainer::from_string("1, 2, -1, 4", bs),
+ std::invalid_argument);
+}
+
+TEST(Exporter, invalidMethods_n) {
+ auto props = std::make_tuple(NumBanana(), QualityOfBanana());
+
+ nntrainer::Exporter e;
+ EXPECT_THROW(e.save_result(props, nntrainer::ExportMethods::METHOD_UNDEFINED),
+ nntrainer::exception::not_supported);
+}
+
+TEST(Exporter, notExported_n) {
+ auto props = std::make_tuple(NumBanana(), QualityOfBanana());
+
+ nntrainer::Exporter e;
+ /// intended comment
+ // e.save_result(props, nntrainer::ExportMethods::METHOD_STRINGVECTOR);
+
+ EXPECT_THROW(e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>(),
+ std::invalid_argument);
+}
+
+/**
+ * @brief Main gtest
+ */
+int main(int argc, char **argv) {
+ int result = -1;
+
+ try {
+ testing::InitGoogleTest(&argc, argv);
+ } catch (...) {
+ std::cerr << "Error duing IniGoogleTest" << std::endl;
+ return 0;
+ }
+
+ try {
+ result = RUN_ALL_TESTS();
+ } catch (...) {
+ std::cerr << "Error duing RUN_ALL_TESTS()" << std::endl;
+ }
+
+ return result;
+}
--- /dev/null
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
+ *
+ * @file unittest_common_properties.h
+ * @date 15 May 2021
+ * @brief This file contains test and specification of properties and exporter
+ * @see https://github.com/nnstreamer/nntrainer
+ * @author Jihoon Lee <jhoon.it.lee@samsung.com>
+ * @bug No known bugs except for NYI items
+ */
+#include <gtest/gtest.h>
+
+#include <common_properties.h>
+
+/// @todo change this to typed param test
+/// <type, list of string, value pair, list of invalid string, value pair>
+TEST(NameProperty, setPropertyValid_p) {
+ nntrainer::props::Name n;
+ EXPECT_NO_THROW(n.set("layer"));
+ EXPECT_EQ(n.get(), "layer");
+
+ EXPECT_NO_THROW(n.set("layer-"));
+ EXPECT_EQ(n.get(), "layer-");
+
+ EXPECT_NO_THROW(n.set("laye-r"));
+ EXPECT_EQ(n.get(), "laye-r");
+
+ EXPECT_NO_THROW(n.set("layer/a"));
+ EXPECT_EQ(n.get(), "layer/a");
+
+ EXPECT_NO_THROW(n.set("laye__r"));
+ EXPECT_EQ(n.get(), "laye__r");
+}
+
+TEST(NameProperty, forbiddenString_01_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("layer "), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_02_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("layer layer"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_03_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set(" layer"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_04_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("layer,"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_05_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("lay,er"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_06_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("lay, er"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_07_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set(",layer"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_08_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("layer+"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_09_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("la+ yer"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_10_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("lay+er"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_11_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("+layer"), std::invalid_argument);
+}
+
+TEST(NameProperty, forbiddenString_12_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("+ layer"), std::invalid_argument);
+}
+
+TEST(NameProperty, mustStartWithAlphaNumeric_01_n) {
+ nntrainer::props::Name n;
+ EXPECT_THROW(n.set("+layer"), std::invalid_argument);
+}
+
+/**
+ * @brief Main gtest
+ */
+int main(int argc, char **argv) {
+ int result = -1;
+
+ try {
+ testing::InitGoogleTest(&argc, argv);
+ } catch (...) {
+ std::cerr << "Error duing IniGoogleTest" << std::endl;
+ return 0;
+ }
+
+ try {
+ result = RUN_ALL_TESTS();
+ } catch (...) {
+ std::cerr << "Error duing RUN_ALL_TESTS()" << std::endl;
+ }
+
+ return result;
+}
+++ /dev/null
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
- *
- * @file unittest_properties.h
- * @date 09 April 2021
- * @brief This file contains test and specification of properties and exporter
- * @see https://github.com/nnstreamer/nntrainer
- * @author Jihoon Lee <jhoon.it.lee@samsung.com>
- * @bug No known bugs except for NYI items
- */
-#include <gtest/gtest.h>
-
-#include <array>
-#include <utility>
-#include <vector>
-
-#include <base_properties.h>
-#include <fc_layer.h>
-#include <nntrainer_error.h>
-#include <node_exporter.h>
-#include <util_func.h>
-
-namespace { /**< define a property for testing */
-
-/**
- * @brief banana property tag for example
- *
- */
-struct banana_prop_tag : nntrainer::int_prop_tag {};
-
-/**
- * @brief Number of banana property
- *
- */
-class NumBanana : public nntrainer::Property<int> {
-public:
- NumBanana(int num = 1) : Property<int>(num) {} /**< default value if any */
- static constexpr const char *key = "num_banana"; /**< unique key to access */
- using prop_tag = banana_prop_tag; /**< property type */
-
- bool isValid(const int &v) const override { return v >= 0; }
-};
-
-/**
- * @brief QualityOfBanana property for example, this has to end with "good"
- *
- */
-class QualityOfBanana : public nntrainer::Property<std::string> {
-public:
- QualityOfBanana(const char *value = "") : Property<std::string>(value) {}
- static constexpr const char *key = "quality_banana";
- using prop_tag = nntrainer::str_prop_tag;
-
- bool isValid(const std::string &v) const override {
- /// assuming quality of banana property must ends with word "good";
- return nntrainer::endswith(v, "good");
- }
-};
-
-/**
- * @brief DimensionOfBanana property for example, this has to have batch size of
- * 1
- *
- */
-class DimensionOfBanana : public nntrainer::Property<nntrainer::TensorDim> {
-public:
- static constexpr const char *key = "banana_size";
- using prop_tag = nntrainer::dimension_prop_tag;
-
- bool isValid(const nntrainer::TensorDim &dim) const override {
- std::cerr << dim;
- return dim.batch() == 1;
- }
-};
-} // namespace
-
-TEST(BasicProperty, tagCast) {
- EXPECT_EQ(1, 1); /**< this is to prevent no assert tc from TCM */
-
- { /**< tag_cast simple cast */
- using T =
- nntrainer::tag_cast<banana_prop_tag, nntrainer::int_prop_tag>::type;
- ::testing::StaticAssertTypeEq<T, nntrainer::int_prop_tag>();
- }
-
- { /**< tag_cast ranged cast */
- using T = nntrainer::tag_cast<banana_prop_tag, nntrainer::float_prop_tag,
- nntrainer::int_prop_tag>::type;
- ::testing::StaticAssertTypeEq<T, nntrainer::int_prop_tag>();
- }
-
- { /**< tag_cast does not have appropriate candidates */
- using T = nntrainer::tag_cast<banana_prop_tag, int, std::string>::type;
- ::testing::StaticAssertTypeEq<T, banana_prop_tag>();
- }
-}
-
-/// @todo convert this to typed param test
-TEST(BasicProperty, valid_p) {
- { /** set -> get / to_string, int*/
- NumBanana b;
- b.set(123);
- int ib = b;
- EXPECT_EQ(ib, 123);
- EXPECT_EQ(b.get(), 123);
- EXPECT_EQ(nntrainer::to_string(b), "123");
- }
-
- { /**< from_string -> get / to_string, int*/
- NumBanana b;
- nntrainer::from_string("3", b);
- EXPECT_EQ(b.get(), 3);
- EXPECT_EQ(nntrainer::to_string(b), "3");
- }
-
- { /** set -> get / to_string, string*/
- QualityOfBanana q;
- q.set("this is good");
- std::string sq = q;
- EXPECT_EQ(sq, "this is good");
- EXPECT_EQ(q.get(), "this is good");
- EXPECT_EQ(nntrainer::to_string(q), "this is good");
- }
-
- { /**< from_string -> get / to_string, string prop */
- QualityOfBanana q;
- nntrainer::from_string("this is good", q);
- EXPECT_EQ(q.get(), "this is good");
- EXPECT_EQ(nntrainer::to_string(q), "this is good");
- }
-
- { /** set -> get / to_string, dimension*/
- DimensionOfBanana q;
- q.set({1, 2, 3, 4});
- EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 2, 3, 4));
- EXPECT_EQ(nntrainer::to_string(q), "1:2:3:4");
- }
-
- { /**< from_string -> get / to_string, dimension */
- DimensionOfBanana q;
- nntrainer::from_string("1:2:3:4", q);
- EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 2, 3, 4));
- EXPECT_EQ(nntrainer::to_string(q), "1:2:3:4");
- }
-
- { /**< from_string -> get / to_string, dimension */
- DimensionOfBanana q;
- nntrainer::from_string("3:4", q);
- EXPECT_EQ(q.get(), nntrainer::TensorDim(1, 1, 3, 4));
- EXPECT_EQ(nntrainer::to_string(q), "1:1:3:4");
- }
-
- { /**< from_string -> get / to_string, uint vector prop */
- std::vector<NumBanana> bananas;
- EXPECT_EQ(nntrainer::getPropKey(bananas), "num_banana");
- nntrainer::from_string("1, 2,3, 4, 5", bananas);
- auto expected = std::vector<NumBanana>({1, 2, 3, 4, 5});
- EXPECT_EQ(bananas, expected);
- EXPECT_EQ(nntrainer::to_string(bananas), "1,2,3,4,5");
- }
-
- { /**< from_string -> get / to_string, uint array prop */
- std::array<NumBanana, 4> bananas;
- EXPECT_EQ(nntrainer::getPropKey(bananas), "num_banana");
- nntrainer::from_string("1, 2,3, 4", bananas);
- auto expected = std::array<NumBanana, 4>({1, 2, 3, 4});
- EXPECT_EQ(bananas, expected);
- EXPECT_EQ(nntrainer::to_string(bananas), "1,2,3,4");
- }
-
- { /**< exporter test */
- auto props = std::make_tuple(NumBanana(), QualityOfBanana());
-
- nntrainer::Exporter e;
- e.save_result(props, nntrainer::ExportMethods::METHOD_STRINGVECTOR);
-
- auto result = e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>();
-
- auto pair = std::pair<std::string, std::string>("num_banana", "1");
- EXPECT_EQ(result[0], pair);
-
- auto pair2 = std::pair<std::string, std::string>("quality_banana", "");
- EXPECT_EQ(result[1], pair2);
- }
-
- { /**< export from layer */
- auto layer = nntrainer::FullyConnectedLayer(1);
- nntrainer::Exporter e;
- layer.export_to(e);
-
- auto result = e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>();
- auto pair0 = std::pair<std::string, std::string>("name", "");
- EXPECT_EQ(result[0], pair0);
- auto pair1 = std::pair<std::string, std::string>("unit", "1");
- EXPECT_EQ(result[1], pair1);
- }
-
- { /**< load from layer */
- auto props =
- std::make_tuple(NumBanana(), QualityOfBanana(), DimensionOfBanana());
-
- auto v = nntrainer::loadProperties(
- {"num_banana=2", "quality_banana=thisisgood", "num_banana=42",
- "banana_size=2:2:3", "not_used=key"},
- props);
-
- EXPECT_EQ(v, std::vector<std::string>{"not_used=key"});
- EXPECT_EQ(std::get<0>(props).get(), 42);
- EXPECT_EQ(std::get<1>(props).get(), "thisisgood");
- }
-
- { /**< load from layer */
- std::tuple<std::array<NumBanana, 4>, std::vector<QualityOfBanana>> props;
-
- auto v = nntrainer::loadProperties(
- {"num_banana=1,2, 3 ,4", "quality_banana=thisisgood, thisisverygood",
- "not_used=key"},
- props);
-
- EXPECT_EQ(v, std::vector<std::string>{"not_used=key"});
- auto expected = std::array<NumBanana, 4>({1, 2, 3, 4});
- EXPECT_EQ(std::get<0>(props), expected);
- auto expected2 =
- std::vector<QualityOfBanana>({"thisisgood", "thisisverygood"});
- EXPECT_EQ(std::get<1>(props), expected2);
- }
-}
-
-TEST(BasicProperty, setNotValid_01_n) {
- NumBanana b;
- EXPECT_THROW(b.set(-1), std::invalid_argument);
-}
-
-TEST(BasicProperty, setNotValid_02_n) {
- QualityOfBanana q;
- EXPECT_THROW(q.set("invalid_str"), std::invalid_argument);
-}
-
-TEST(BasicProperty, setNotValid_03_n) {
- DimensionOfBanana d;
- EXPECT_THROW(d.set({3, 3, 2, 4}), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_01_n) {
- NumBanana b;
- EXPECT_THROW(nntrainer::from_string("not integer", b), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_02_n) {
- NumBanana b;
- EXPECT_THROW(nntrainer::from_string("-1", b), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_03_n) {
- QualityOfBanana q;
- EXPECT_THROW(nntrainer::from_string("invalid_str", q), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_04_n) {
- DimensionOfBanana d;
- EXPECT_THROW(nntrainer::from_string("1:1:2:3:5", d), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_05_n) {
- DimensionOfBanana d;
- EXPECT_THROW(nntrainer::from_string("2:2:3:5", d), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_06_n) {
- DimensionOfBanana d;
- EXPECT_THROW(nntrainer::from_string("", d), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringNotValid_07_n) {
- DimensionOfBanana d;
- EXPECT_THROW(nntrainer::from_string(":2:3:5", d), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringVectorElementContainNotValidString_n) {
- std::vector<NumBanana> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, 3, not_valid", bs),
- std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringVectorElementContainNotValidProp_n) {
- std::vector<NumBanana> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, 3, -1", bs),
- std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringLessArrayElementSize_n) {
- std::array<NumBanana, 4> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, 3", bs), std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringOverArrayElementSize_n) {
- std::array<NumBanana, 4> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, 3,4,5", bs),
- std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringArrayNotValidString_n) {
- std::array<NumBanana, 4> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, invalid, 4", bs),
- std::invalid_argument);
-}
-
-TEST(BasicProperty, fromStringArrayNotValidProp_n) {
- std::array<NumBanana, 4> bs;
- EXPECT_THROW(nntrainer::from_string("1, 2, -1, 4", bs),
- std::invalid_argument);
-}
-
-TEST(Exporter, invalidMethods_n) {
- auto props = std::make_tuple(NumBanana(), QualityOfBanana());
-
- nntrainer::Exporter e;
- EXPECT_THROW(e.save_result(props, nntrainer::ExportMethods::METHOD_UNDEFINED),
- nntrainer::exception::not_supported);
-}
-
-TEST(Exporter, notExported_n) {
- auto props = std::make_tuple(NumBanana(), QualityOfBanana());
-
- nntrainer::Exporter e;
- /// intended comment
- // e.save_result(props, nntrainer::ExportMethods::METHOD_STRINGVECTOR);
-
- EXPECT_THROW(e.get_result<nntrainer::ExportMethods::METHOD_STRINGVECTOR>(),
- std::invalid_argument);
-}
-
-/**
- * @brief Main gtest
- */
-int main(int argc, char **argv) {
- int result = -1;
-
- try {
- testing::InitGoogleTest(&argc, argv);
- } catch (...) {
- std::cerr << "Error duing IniGoogleTest" << std::endl;
- return 0;
- }
-
- try {
- result = RUN_ALL_TESTS();
- } catch (...) {
- std::cerr << "Error duing RUN_ALL_TESTS()" << std::endl;
- }
-
- return result;
-}
projects / platform / core / ml / nntrainer.git / commitdiff