Change the boolean ints to bool #212

kaorut · kaorut · commit 28aed6027c27 · 2022-01-01T22:31:22.000+09:00
diff --git a/library/lattice/test/src/usage_tetengo.lattice.viterbi_c.c b/library/lattice/test/src/usage_tetengo.lattice.viterbi_c.c
@@ -8,6 +8,7 @@
 
 // [viterbi]
 #include <assert.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -240,7 +241,7 @@ tetengo_lattice_vocabulary_t* build_vocabulary()
     return p_vocabulary;
 }
 
-static const char* value_of(const tetengo_lattice_node_t* const p_node, const int first)
+static const char* value_of(const tetengo_lattice_node_t* const p_node, const bool first)
 {
     // The value is accessible by the handle.
     const char* const value = (const char*)tetengo_lattice_entryView_valueOf(p_node->value_handle);
diff --git a/library/property/c/include/tetengo/property/propertySet.h b/library/property/c/include/tetengo/property/propertySet.h
@@ -57,7 +57,7 @@ void tetengo_property_propertySet_destroy(const tetengo_property_propertySet_t*
 bool tetengo_property_propertySet_getBool(
     const tetengo_property_propertySet_t* p_property_set,
     const char*                           key,
-    int*                                  p_value);
+    bool*                                 p_value);
 
 /*!
     \brief Sets a value in a boolean.
@@ -66,7 +66,7 @@ bool tetengo_property_propertySet_getBool(
     \param key            A key.
     \param value          A value.
 */
-void tetengo_property_propertySet_setBool(tetengo_property_propertySet_t* p_property_set, const char* key, int value);
+void tetengo_property_propertySet_setBool(tetengo_property_propertySet_t* p_property_set, const char* key, bool value);
 
 /*!
     \brief Returns the value in an unsigned 32-bit integer.
diff --git a/library/property/c/include/tetengo/property/storage.h b/library/property/c/include/tetengo/property/storage.h
@@ -7,7 +7,6 @@
 #if !defined(TETENGO_PROPERTY_STORAGE_H)
 #define TETENGO_PROPERTY_STORAGE_H
 
-
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h> // IWYU pragma: keep
@@ -40,7 +39,7 @@ void tetengo_property_storage_destroy(const tetengo_property_storage_t* p_storag
     \retval true  When the value is set to p_value.
     \retval false Otherwise.
 */
-bool tetengo_property_storage_getBool(const tetengo_property_storage_t* p_storage, const char* key, int* p_value);
+bool tetengo_property_storage_getBool(const tetengo_property_storage_t* p_storage, const char* key, bool* p_value);
 
 /*!
     \brief Sets a value in a boolean.
@@ -49,7 +48,7 @@ bool tetengo_property_storage_getBool(const tetengo_property_storage_t* p_storag
     \param key       A key.
     \param value     A value.
 */
-void tetengo_property_storage_setBool(tetengo_property_storage_t* p_storage, const char* key, int value);
+void tetengo_property_storage_setBool(tetengo_property_storage_t* p_storage, const char* key, bool value);
 
 /*!
     \brief Returns the value in an unsigned 32-bit integer.
diff --git a/library/property/c/src/tetengo_property_propertySet.cpp b/library/property/c/src/tetengo_property_propertySet.cpp
@@ -80,7 +80,7 @@ void tetengo_property_propertySet_destroy(const tetengo_property_propertySet_t*
 bool tetengo_property_propertySet_getBool(
     const tetengo_property_propertySet_t* const p_property_set,
     const char* const                           key,
-    int* const                                  p_value)
+    bool* const                                 p_value)
 {
     try
     {
@@ -100,7 +100,7 @@ bool tetengo_property_propertySet_getBool(
         const auto o_cpp_value = p_property_set->p_cpp_property_set->get_bool(key);
         if (o_cpp_value)
         {
-            *p_value = *o_cpp_value ? 1 : 0;
+            *p_value = *o_cpp_value;
         }
         return static_cast<bool>(o_cpp_value);
     }
@@ -113,7 +113,7 @@ bool tetengo_property_propertySet_getBool(
 void tetengo_property_propertySet_setBool(
     tetengo_property_propertySet_t* const p_property_set,
     const char* const                     key,
-    const int                             value)
+    const bool                            value)
 {
     try
     {
diff --git a/library/property/c/src/tetengo_property_storage.cpp b/library/property/c/src/tetengo_property_storage.cpp
@@ -53,7 +53,7 @@ void tetengo_property_storage_destroy(const tetengo_property_storage_t* const p_
 bool tetengo_property_storage_getBool(
     const tetengo_property_storage_t* const p_storage,
     const char* const                       key,
-    int* const                              p_value)
+    bool* const                             p_value)
 {
     try
     {
@@ -73,7 +73,7 @@ bool tetengo_property_storage_getBool(
         const auto o_cpp_value = p_storage->p_cpp_storage->get_bool(key);
         if (o_cpp_value)
         {
-            *p_value = *o_cpp_value ? 1 : 0;
+            *p_value = *o_cpp_value;
         }
         return static_cast<bool>(o_cpp_value);
     }
@@ -86,7 +86,7 @@ bool tetengo_property_storage_getBool(
 void tetengo_property_storage_setBool(
     tetengo_property_storage_t* const p_storage,
     const char* const                 key,
-    const int                         value)
+    const bool                        value)
 {
     try
     {
diff --git a/library/property/test/src/test_tetengo.property.file_storage.cpp b/library/property/test/src/test_tetengo.property.file_storage.cpp
@@ -442,7 +442,7 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST_REQUIRE(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST_REQUIRE(result);
             BOOST_TEST(value);
@@ -532,7 +532,7 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST_REQUIRE(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST(!result);
         }
@@ -565,7 +565,7 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST_REQUIRE(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST(!result);
         }
@@ -598,7 +598,7 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST_REQUIRE(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST(!result);
         }
@@ -631,7 +631,7 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST_REQUIRE(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST_REQUIRE(result);
             BOOST_TEST(value);
diff --git a/library/property/test/src/test_tetengo.property.property_set.cpp b/library/property/test/src/test_tetengo.property.property_set.cpp
@@ -89,12 +89,12 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_property_set);
 
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);
         BOOST_TEST(!result);
     }
     {
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_propertySet_getBool(nullptr, "alpha", &value);
         BOOST_TEST(!result);
     }
@@ -109,7 +109,7 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_property_set);
 
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_propertySet_getBool(p_property_set, nullptr, &value);
         BOOST_TEST(!result);
     }
@@ -163,8 +163,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_property_set);
 
-        tetengo_property_propertySet_setBool(p_property_set, "alpha", 0);
-        auto       value = static_cast<int>(0);
+        tetengo_property_propertySet_setBool(p_property_set, "alpha", false);
+        auto       value = false;
         const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);
         BOOST_TEST_REQUIRE(result);
         BOOST_TEST(!value);
@@ -180,14 +180,14 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_property_set);
 
-        tetengo_property_propertySet_setBool(p_property_set, "alpha", 1);
-        auto       value = static_cast<int>(0);
+        tetengo_property_propertySet_setBool(p_property_set, "alpha", true);
+        auto       value = false;
         const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);
         BOOST_TEST_REQUIRE(result);
         BOOST_TEST(value);
     }
     {
-        tetengo_property_propertySet_setBool(nullptr, "alpha", 0);
+        tetengo_property_propertySet_setBool(nullptr, "alpha", false);
     }
     {
         auto* const p_storage_loader = tetengo_property_storageLoader_createMemoryStorageLoader();
@@ -200,7 +200,7 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_property_set);
 
-        tetengo_property_propertySet_setBool(p_property_set, nullptr, 0);
+        tetengo_property_propertySet_setBool(p_property_set, nullptr, false);
     }
 }
 
diff --git a/library/property/test/src/test_tetengo.property.storage.cpp b/library/property/test/src/test_tetengo.property.storage.cpp
@@ -96,12 +96,12 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_TEST_REQUIRE(p_storage);
 
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));
     }
     {
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         BOOST_TEST(!tetengo_property_storage_getBool(nullptr, key.string().c_str(), &value));
     }
     {
@@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        auto value = static_cast<int>(0);
+        auto value = false;
         BOOST_TEST(!tetengo_property_storage_getBool(p_storage, nullptr, &value));
     }
     {
@@ -186,8 +186,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_TEST_REQUIRE(p_storage);
 
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        tetengo_property_storage_setBool(p_storage, key.string().c_str(), 0);
-        auto value = static_cast<int>(0);
+        tetengo_property_storage_setBool(p_storage, key.string().c_str(), false);
+        auto value = false;
         BOOST_TEST(tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));
         BOOST_TEST(!value);
     }
@@ -208,8 +208,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_TEST_REQUIRE(p_storage);
 
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        tetengo_property_storage_setBool(p_storage, key.string().c_str(), 1);
-        auto value = static_cast<int>(0);
+        tetengo_property_storage_setBool(p_storage, key.string().c_str(), true);
+        auto value = false;
         BOOST_TEST(tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));
         BOOST_TEST(value);
     }
@@ -230,8 +230,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_TEST_REQUIRE(p_storage);
 
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        tetengo_property_storage_setBool(nullptr, key.string().c_str(), 1);
-        auto value = static_cast<int>(0);
+        tetengo_property_storage_setBool(nullptr, key.string().c_str(), true);
+        auto value = false;
         BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));
     }
     {
@@ -251,8 +251,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_TEST_REQUIRE(p_storage);
 
         const auto key = std::filesystem::path{ "hoge" } / "fuga";
-        tetengo_property_storage_setBool(p_storage, nullptr, 1);
-        auto value = static_cast<int>(0);
+        tetengo_property_storage_setBool(p_storage, nullptr, true);
+        auto value = false;
         BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));
     }
 }
diff --git a/library/property/test/src/test_tetengo.property.storage_proxy.cpp b/library/property/test/src/test_tetengo.property.storage_proxy.cpp
@@ -62,12 +62,12 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
         BOOST_TEST(!result);
     }
     {
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_storage_getBool(nullptr, "alpha", &value);
         BOOST_TEST(!result);
     }
@@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(get_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        auto       value = static_cast<int>(0);
+        auto       value = false;
         const auto result = tetengo_property_storage_getBool(p_storage, nullptr, &value);
         BOOST_TEST(!result);
     }
@@ -158,8 +158,8 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        tetengo_property_storage_setBool(p_storage, "alpha", 0);
-        auto       value = static_cast<int>(0);
+        tetengo_property_storage_setBool(p_storage, "alpha", false);
+        auto       value = false;
         const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
         BOOST_TEST_REQUIRE(result);
         BOOST_TEST(!value);
@@ -181,14 +181,14 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        tetengo_property_storage_setBool(p_storage, "alpha", 1);
-        auto       value = static_cast<int>(0);
+        tetengo_property_storage_setBool(p_storage, "alpha", true);
+        auto       value = false;
         const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
         BOOST_TEST_REQUIRE(result);
         BOOST_TEST(value);
     }
     {
-        tetengo_property_storage_setBool(nullptr, "alpha", 0);
+        tetengo_property_storage_setBool(nullptr, "alpha", false);
     }
     {
         auto* const       p_real_loader = tetengo_property_storageLoader_createMemoryStorageLoader();
@@ -207,7 +207,7 @@ BOOST_AUTO_TEST_CASE(set_bool)
         BOOST_SCOPE_EXIT_END;
         BOOST_TEST_REQUIRE(p_storage);
 
-        tetengo_property_storage_setBool(p_storage, nullptr, 0);
+        tetengo_property_storage_setBool(p_storage, nullptr, false);
     }
 }
 
diff --git a/library/property/test/src/test_tetengo.property.windows_registry_storage.cpp b/library/property/test/src/test_tetengo.property.windows_registry_storage.cpp
@@ -292,12 +292,12 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST(!result);
         }
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "bravo", &value);
             BOOST_TEST(!result);
         }
@@ -330,13 +330,13 @@ BOOST_AUTO_TEST_CASE(load)
         BOOST_TEST(p_storage);
 
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);
             BOOST_TEST_REQUIRE(result);
             BOOST_TEST(!value);
         }
         {
-            auto       value = static_cast<int>(0);
+            auto       value = false;
             const auto result = tetengo_property_storage_getBool(p_storage, "bravo", &value);
             BOOST_TEST_REQUIRE(result);
             BOOST_TEST(value);

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`
`9`	`9`	`// [viterbi]`
`10`	`10`	`#include <assert.h>`
	`11`	`+#include <stdbool.h>`
`11`	`12`	`#include <stdio.h>`
`12`	`13`	`#include <stdlib.h>`
`13`	`14`	`#include <string.h>`
`@@ -240,7 +241,7 @@ tetengo_lattice_vocabulary_t* build_vocabulary()`
`240`	`241`	`return p_vocabulary;`
`241`	`242`	`}`
`242`	`243`
`243`		`-static const char* value_of(const tetengo_lattice_node_t* const p_node, const int first)`
	`244`	`+static const char* value_of(const tetengo_lattice_node_t* const p_node, const bool first)`
`244`	`245`	`{`
`245`	`246`	`// The value is accessible by the handle.`
`246`	`247`	`const char* const value = (const char*)tetengo_lattice_entryView_valueOf(p_node->value_handle);`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ void tetengo_property_propertySet_destroy(const tetengo_property_propertySet_t*`
`80`	`80`	`bool tetengo_property_propertySet_getBool(`
`81`	`81`	`const tetengo_property_propertySet_t* const p_property_set,`
`82`	`82`	`const char* const key,`
`83`		`- int* const p_value)`
	`83`	`+ bool* const p_value)`
`84`	`84`	`{`
`85`	`85`	`try`
`86`	`86`	`{`
`@@ -100,7 +100,7 @@ bool tetengo_property_propertySet_getBool(`
`100`	`100`	`const auto o_cpp_value = p_property_set->p_cpp_property_set->get_bool(key);`
`101`	`101`	`if (o_cpp_value)`
`102`	`102`	`{`
`103`		`- p_value = o_cpp_value ? 1 : 0;`
	`103`	`+ p_value = o_cpp_value;`
`104`	`104`	`}`
`105`	`105`	`return static_cast<bool>(o_cpp_value);`
`106`	`106`	`}`
`@@ -113,7 +113,7 @@ bool tetengo_property_propertySet_getBool(`
`113`	`113`	`void tetengo_property_propertySet_setBool(`
`114`	`114`	`tetengo_property_propertySet_t* const p_property_set,`
`115`	`115`	`const char* const key,`
`116`		`- const int value)`
	`116`	`+ const bool value)`
`117`	`117`	`{`
`118`	`118`	`try`
`119`	`119`	`{`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ void tetengo_property_storage_destroy(const tetengo_property_storage_t* const p_`
`53`	`53`	`bool tetengo_property_storage_getBool(`
`54`	`54`	`const tetengo_property_storage_t* const p_storage,`
`55`	`55`	`const char* const key,`
`56`		`- int* const p_value)`
	`56`	`+ bool* const p_value)`
`57`	`57`	`{`
`58`	`58`	`try`
`59`	`59`	`{`
`@@ -73,7 +73,7 @@ bool tetengo_property_storage_getBool(`
`73`	`73`	`const auto o_cpp_value = p_storage->p_cpp_storage->get_bool(key);`
`74`	`74`	`if (o_cpp_value)`
`75`	`75`	`{`
`76`		`- p_value = o_cpp_value ? 1 : 0;`
	`76`	`+ p_value = o_cpp_value;`
`77`	`77`	`}`
`78`	`78`	`return static_cast<bool>(o_cpp_value);`
`79`	`79`	`}`
`@@ -86,7 +86,7 @@ bool tetengo_property_storage_getBool(`
`86`	`86`	`void tetengo_property_storage_setBool(`
`87`	`87`	`tetengo_property_storage_t* const p_storage,`
`88`	`88`	`const char* const key,`
`89`		`- const int value)`
	`89`	`+ const bool value)`
`90`	`90`	`{`
`91`	`91`	`try`
`92`	`92`	`{`
Original file line number	Diff line number	Diff line change
`@@ -442,7 +442,7 @@ BOOST_AUTO_TEST_CASE(load)`
`442`	`442`	`BOOST_TEST_REQUIRE(p_storage);`
`443`	`443`
`444`	`444`	`{`
`445`		`- auto value = static_cast<int>(0);`
	`445`	`+ auto value = false;`
`446`	`446`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`447`	`447`	`BOOST_TEST_REQUIRE(result);`
`448`	`448`	`BOOST_TEST(value);`
`@@ -532,7 +532,7 @@ BOOST_AUTO_TEST_CASE(load)`
`532`	`532`	`BOOST_TEST_REQUIRE(p_storage);`
`533`	`533`
`534`	`534`	`{`
`535`		`- auto value = static_cast<int>(0);`
	`535`	`+ auto value = false;`
`536`	`536`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`537`	`537`	`BOOST_TEST(!result);`
`538`	`538`	`}`
`@@ -565,7 +565,7 @@ BOOST_AUTO_TEST_CASE(load)`
`565`	`565`	`BOOST_TEST_REQUIRE(p_storage);`
`566`	`566`
`567`	`567`	`{`
`568`		`- auto value = static_cast<int>(0);`
	`568`	`+ auto value = false;`
`569`	`569`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`570`	`570`	`BOOST_TEST(!result);`
`571`	`571`	`}`
`@@ -598,7 +598,7 @@ BOOST_AUTO_TEST_CASE(load)`
`598`	`598`	`BOOST_TEST_REQUIRE(p_storage);`
`599`	`599`
`600`	`600`	`{`
`601`		`- auto value = static_cast<int>(0);`
	`601`	`+ auto value = false;`
`602`	`602`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`603`	`603`	`BOOST_TEST(!result);`
`604`	`604`	`}`
`@@ -631,7 +631,7 @@ BOOST_AUTO_TEST_CASE(load)`
`631`	`631`	`BOOST_TEST_REQUIRE(p_storage);`
`632`	`632`
`633`	`633`	`{`
`634`		`- auto value = static_cast<int>(0);`
	`634`	`+ auto value = false;`
`635`	`635`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`636`	`636`	`BOOST_TEST_REQUIRE(result);`
`637`	`637`	`BOOST_TEST(value);`
Original file line number	Diff line number	Diff line change
`@@ -89,12 +89,12 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`89`	`89`	`BOOST_SCOPE_EXIT_END;`
`90`	`90`	`BOOST_TEST_REQUIRE(p_property_set);`
`91`	`91`
`92`		`- auto value = static_cast<int>(0);`
	`92`	`+ auto value = false;`
`93`	`93`	`const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);`
`94`	`94`	`BOOST_TEST(!result);`
`95`	`95`	`}`
`96`	`96`	`{`
`97`		`- auto value = static_cast<int>(0);`
	`97`	`+ auto value = false;`
`98`	`98`	`const auto result = tetengo_property_propertySet_getBool(nullptr, "alpha", &value);`
`99`	`99`	`BOOST_TEST(!result);`
`100`	`100`	`}`
`@@ -109,7 +109,7 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`109`	`109`	`BOOST_SCOPE_EXIT_END;`
`110`	`110`	`BOOST_TEST_REQUIRE(p_property_set);`
`111`	`111`
`112`		`- auto value = static_cast<int>(0);`
	`112`	`+ auto value = false;`
`113`	`113`	`const auto result = tetengo_property_propertySet_getBool(p_property_set, nullptr, &value);`
`114`	`114`	`BOOST_TEST(!result);`
`115`	`115`	`}`
`@@ -163,8 +163,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`163`	`163`	`BOOST_SCOPE_EXIT_END;`
`164`	`164`	`BOOST_TEST_REQUIRE(p_property_set);`
`165`	`165`
`166`		`- tetengo_property_propertySet_setBool(p_property_set, "alpha", 0);`
`167`		`- auto value = static_cast<int>(0);`
	`166`	`+ tetengo_property_propertySet_setBool(p_property_set, "alpha", false);`
	`167`	`+ auto value = false;`
`168`	`168`	`const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);`
`169`	`169`	`BOOST_TEST_REQUIRE(result);`
`170`	`170`	`BOOST_TEST(!value);`
`@@ -180,14 +180,14 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`180`	`180`	`BOOST_SCOPE_EXIT_END;`
`181`	`181`	`BOOST_TEST_REQUIRE(p_property_set);`
`182`	`182`
`183`		`- tetengo_property_propertySet_setBool(p_property_set, "alpha", 1);`
`184`		`- auto value = static_cast<int>(0);`
	`183`	`+ tetengo_property_propertySet_setBool(p_property_set, "alpha", true);`
	`184`	`+ auto value = false;`
`185`	`185`	`const auto result = tetengo_property_propertySet_getBool(p_property_set, "alpha", &value);`
`186`	`186`	`BOOST_TEST_REQUIRE(result);`
`187`	`187`	`BOOST_TEST(value);`
`188`	`188`	`}`
`189`	`189`	`{`
`190`		`- tetengo_property_propertySet_setBool(nullptr, "alpha", 0);`
	`190`	`+ tetengo_property_propertySet_setBool(nullptr, "alpha", false);`
`191`	`191`	`}`
`192`	`192`	`{`
`193`	`193`	`auto* const p_storage_loader = tetengo_property_storageLoader_createMemoryStorageLoader();`
`@@ -200,7 +200,7 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`200`	`200`	`BOOST_SCOPE_EXIT_END;`
`201`	`201`	`BOOST_TEST_REQUIRE(p_property_set);`
`202`	`202`
`203`		`- tetengo_property_propertySet_setBool(p_property_set, nullptr, 0);`
	`203`	`+ tetengo_property_propertySet_setBool(p_property_set, nullptr, false);`
`204`	`204`	`}`
`205`	`205`	`}`
`206`	`206`
Original file line number	Diff line number	Diff line change
`@@ -96,12 +96,12 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`96`	`96`	`BOOST_TEST_REQUIRE(p_storage);`
`97`	`97`
`98`	`98`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`99`		`- auto value = static_cast<int>(0);`
	`99`	`+ auto value = false;`
`100`	`100`	`BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));`
`101`	`101`	`}`
`102`	`102`	`{`
`103`	`103`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`104`		`- auto value = static_cast<int>(0);`
	`104`	`+ auto value = false;`
`105`	`105`	`BOOST_TEST(!tetengo_property_storage_getBool(nullptr, key.string().c_str(), &value));`
`106`	`106`	`}`
`107`	`107`	`{`
`@@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`120`	`120`	`BOOST_SCOPE_EXIT_END;`
`121`	`121`	`BOOST_TEST_REQUIRE(p_storage);`
`122`	`122`
`123`		`- auto value = static_cast<int>(0);`
	`123`	`+ auto value = false;`
`124`	`124`	`BOOST_TEST(!tetengo_property_storage_getBool(p_storage, nullptr, &value));`
`125`	`125`	`}`
`126`	`126`	`{`
`@@ -186,8 +186,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`186`	`186`	`BOOST_TEST_REQUIRE(p_storage);`
`187`	`187`
`188`	`188`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`189`		`- tetengo_property_storage_setBool(p_storage, key.string().c_str(), 0);`
`190`		`- auto value = static_cast<int>(0);`
	`189`	`+ tetengo_property_storage_setBool(p_storage, key.string().c_str(), false);`
	`190`	`+ auto value = false;`
`191`	`191`	`BOOST_TEST(tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));`
`192`	`192`	`BOOST_TEST(!value);`
`193`	`193`	`}`
`@@ -208,8 +208,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`208`	`208`	`BOOST_TEST_REQUIRE(p_storage);`
`209`	`209`
`210`	`210`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`211`		`- tetengo_property_storage_setBool(p_storage, key.string().c_str(), 1);`
`212`		`- auto value = static_cast<int>(0);`
	`211`	`+ tetengo_property_storage_setBool(p_storage, key.string().c_str(), true);`
	`212`	`+ auto value = false;`
`213`	`213`	`BOOST_TEST(tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));`
`214`	`214`	`BOOST_TEST(value);`
`215`	`215`	`}`
`@@ -230,8 +230,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`230`	`230`	`BOOST_TEST_REQUIRE(p_storage);`
`231`	`231`
`232`	`232`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`233`		`- tetengo_property_storage_setBool(nullptr, key.string().c_str(), 1);`
`234`		`- auto value = static_cast<int>(0);`
	`233`	`+ tetengo_property_storage_setBool(nullptr, key.string().c_str(), true);`
	`234`	`+ auto value = false;`
`235`	`235`	`BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));`
`236`	`236`	`}`
`237`	`237`	`{`
`@@ -251,8 +251,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`251`	`251`	`BOOST_TEST_REQUIRE(p_storage);`
`252`	`252`
`253`	`253`	`const auto key = std::filesystem::path{ "hoge" } / "fuga";`
`254`		`- tetengo_property_storage_setBool(p_storage, nullptr, 1);`
`255`		`- auto value = static_cast<int>(0);`
	`254`	`+ tetengo_property_storage_setBool(p_storage, nullptr, true);`
	`255`	`+ auto value = false;`
`256`	`256`	`BOOST_TEST(!tetengo_property_storage_getBool(p_storage, key.string().c_str(), &value));`
`257`	`257`	`}`
`258`	`258`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,12 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`62`	`62`	`BOOST_SCOPE_EXIT_END;`
`63`	`63`	`BOOST_TEST_REQUIRE(p_storage);`
`64`	`64`
`65`		`- auto value = static_cast<int>(0);`
	`65`	`+ auto value = false;`
`66`	`66`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`67`	`67`	`BOOST_TEST(!result);`
`68`	`68`	`}`
`69`	`69`	`{`
`70`		`- auto value = static_cast<int>(0);`
	`70`	`+ auto value = false;`
`71`	`71`	`const auto result = tetengo_property_storage_getBool(nullptr, "alpha", &value);`
`72`	`72`	`BOOST_TEST(!result);`
`73`	`73`	`}`
`@@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(get_bool)`
`88`	`88`	`BOOST_SCOPE_EXIT_END;`
`89`	`89`	`BOOST_TEST_REQUIRE(p_storage);`
`90`	`90`
`91`		`- auto value = static_cast<int>(0);`
	`91`	`+ auto value = false;`
`92`	`92`	`const auto result = tetengo_property_storage_getBool(p_storage, nullptr, &value);`
`93`	`93`	`BOOST_TEST(!result);`
`94`	`94`	`}`
`@@ -158,8 +158,8 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`158`	`158`	`BOOST_SCOPE_EXIT_END;`
`159`	`159`	`BOOST_TEST_REQUIRE(p_storage);`
`160`	`160`
`161`		`- tetengo_property_storage_setBool(p_storage, "alpha", 0);`
`162`		`- auto value = static_cast<int>(0);`
	`161`	`+ tetengo_property_storage_setBool(p_storage, "alpha", false);`
	`162`	`+ auto value = false;`
`163`	`163`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`164`	`164`	`BOOST_TEST_REQUIRE(result);`
`165`	`165`	`BOOST_TEST(!value);`
`@@ -181,14 +181,14 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`181`	`181`	`BOOST_SCOPE_EXIT_END;`
`182`	`182`	`BOOST_TEST_REQUIRE(p_storage);`
`183`	`183`
`184`		`- tetengo_property_storage_setBool(p_storage, "alpha", 1);`
`185`		`- auto value = static_cast<int>(0);`
	`184`	`+ tetengo_property_storage_setBool(p_storage, "alpha", true);`
	`185`	`+ auto value = false;`
`186`	`186`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`187`	`187`	`BOOST_TEST_REQUIRE(result);`
`188`	`188`	`BOOST_TEST(value);`
`189`	`189`	`}`
`190`	`190`	`{`
`191`		`- tetengo_property_storage_setBool(nullptr, "alpha", 0);`
	`191`	`+ tetengo_property_storage_setBool(nullptr, "alpha", false);`
`192`	`192`	`}`
`193`	`193`	`{`
`194`	`194`	`auto* const p_real_loader = tetengo_property_storageLoader_createMemoryStorageLoader();`
`@@ -207,7 +207,7 @@ BOOST_AUTO_TEST_CASE(set_bool)`
`207`	`207`	`BOOST_SCOPE_EXIT_END;`
`208`	`208`	`BOOST_TEST_REQUIRE(p_storage);`
`209`	`209`
`210`		`- tetengo_property_storage_setBool(p_storage, nullptr, 0);`
	`210`	`+ tetengo_property_storage_setBool(p_storage, nullptr, false);`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
Original file line number	Diff line number	Diff line change
`@@ -292,12 +292,12 @@ BOOST_AUTO_TEST_CASE(load)`
`292`	`292`	`BOOST_TEST(p_storage);`
`293`	`293`
`294`	`294`	`{`
`295`		`- auto value = static_cast<int>(0);`
	`295`	`+ auto value = false;`
`296`	`296`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`297`	`297`	`BOOST_TEST(!result);`
`298`	`298`	`}`
`299`	`299`	`{`
`300`		`- auto value = static_cast<int>(0);`
	`300`	`+ auto value = false;`
`301`	`301`	`const auto result = tetengo_property_storage_getBool(p_storage, "bravo", &value);`
`302`	`302`	`BOOST_TEST(!result);`
`303`	`303`	`}`
`@@ -330,13 +330,13 @@ BOOST_AUTO_TEST_CASE(load)`
`330`	`330`	`BOOST_TEST(p_storage);`
`331`	`331`
`332`	`332`	`{`
`333`		`- auto value = static_cast<int>(0);`
	`333`	`+ auto value = false;`
`334`	`334`	`const auto result = tetengo_property_storage_getBool(p_storage, "alpha", &value);`
`335`	`335`	`BOOST_TEST_REQUIRE(result);`
`336`	`336`	`BOOST_TEST(!value);`
`337`	`337`	`}`
`338`	`338`	`{`
`339`		`- auto value = static_cast<int>(0);`
	`339`	`+ auto value = false;`
`340`	`340`	`const auto result = tetengo_property_storage_getBool(p_storage, "bravo", &value);`
`341`	`341`	`BOOST_TEST_REQUIRE(result);`
`342`	`342`	`BOOST_TEST(value);`