refactor: remove msvc compile warnings

JBenda · JBenda · commit 23746e195353 · 2026-01-12T12:04:29.000+01:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -48,7 +48,7 @@ set(CMAKE_INSTALL_LIBRARY_DIR lib)
 set(CMAKE_INSTALL_INCLUDE_DIR include)
 if(MSVC)
 	# disable: aligment problems non explicit switch case
-	add_compile_options(/W4 /wd4820 /wd4061)
+	add_compile_options(/W4 /wd4820 /wd4061 -D_CRT_SECURE_NO_WARNINGS)
 else()
 	add_compile_options(-Wall -Wextra -Wpedantic)
 endif()
diff --git a/inkcpp/array.h b/inkcpp/array.h
@@ -464,7 +464,7 @@ class fixed_restorable_array : public basic_restorable_array<T>
 };
 
 template<typename T>
-class allocated_restorable_array final : public basic_restorable_array<T>
+class allocated_restorable_array : public basic_restorable_array<T>
 {
 	using base = basic_restorable_array<T>;
 
diff --git a/inkcpp/runner_impl.h b/inkcpp/runner_impl.h
@@ -277,7 +277,7 @@ class runner_impl
 		{
 			if (index >= _threadDone.capacity()) {
 				inkAssert(index == _threadDone.capacity(), "Threads should only be created incremental");
-				_threadDone.resize(_threadDone.capacity() * 1.5);
+				_threadDone.resize(static_cast<size_t>(_threadDone.capacity() * 1.5));
 			}
 			_threadDone.set(index, value);
 		}
diff --git a/inkcpp_c/include/inkcpp.h b/inkcpp_c/include/inkcpp.h
@@ -3,7 +3,6 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdlib.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -185,7 +184,7 @@ typedef struct HInkSTory    HInkStory;
 	 * contain any value! It is use e.g. at @ref HInkGlobals::ink_globals_get() "ink_globals_get()"
 	 */
 	struct InkValue {
-		union {
+		union InkValueTypeUnion {
 			int bool_v; ///< contains value if #type == @ref InkValue::Type::ValueTypeBool "ValueTypeBool"
 			uint32_t    uint32_v; ///< contains value if #type == @ref InkValue::Type::ValueTypeUint32
 			                      ///< "ValueTypeUint32"
@@ -197,7 +196,7 @@ typedef struct HInkSTory    HInkStory;
 			                      ///< "ValueTypeFloat"
 			HInkList*
 			    list_v; ///< contains value if #type == @ref InkValue::Type::ValueTypeList "ValueTypeList"
-		};
+		} value;
 
 		/// indicates which type is contained in the value
 		enum Type {
diff --git a/inkcpp_c/inkcpp.cpp b/inkcpp_c/inkcpp.cpp
@@ -74,13 +74,16 @@ extern "C" {
 		FILE* file = fopen(filename, "rb");
 		fseek(file, 0, SEEK_END);
 		long file_length = ftell(file);
+		if (file_length < 0) {
+			return NULL;
+		}
 		fseek(file, 0, SEEK_SET);
 		unsigned char* data = static_cast<unsigned char*>(malloc(file_length));
 		inkAssert(data, "Malloc of size %u failed", file_length);
-		unsigned length = fread(data, sizeof(unsigned char), file_length, file);
+		size_t length = fread(data, sizeof(unsigned char), file_length, file);
 		inkAssert(
-		    file_length == length, "Expected to read file of size %u, but only read %u", file_length,
-		    length
+		    static_cast<size_t>(file_length) == length,
+		    "Expected to read file of size %u, but only read %u", file_length, length
 		);
 		fclose(file);
 		return reinterpret_cast<HInkStory*>(story::from_binary(data, file_length));
@@ -91,13 +94,16 @@ extern "C" {
 		FILE* file = fopen(filename, "rb");
 		fseek(file, 0, SEEK_END);
 		long file_length = ftell(file);
+		if (file_length < 0) {
+			return NULL;
+		}
 		fseek(file, 0, SEEK_SET);
 		unsigned char* data = static_cast<unsigned char*>(malloc(file_length));
 		inkAssert(data, "Malloc of size %u failed", file_length);
-		unsigned length = fread(data, sizeof(unsigned char), file_length, file);
+		size_t length = fread(data, sizeof(unsigned char), file_length, file);
 		inkAssert(
-		    file_length == length, "Expected to read file of size %u, but only read %u", file_length,
-		    length
+		    static_cast<size_t>(file_length) == length,
+		    "Expected to read file of size %u, but only read %u", file_length, length
 		);
 		fclose(file);
 		return reinterpret_cast<HInkSnapshot*>(snapshot::from_binary(data, file_length));
@@ -107,7 +113,7 @@ extern "C" {
 	{
 		FILE*           file = fopen(filename, "wb");
 		const snapshot& snap = *reinterpret_cast<const snapshot*>(self);
-		unsigned length = fwrite(snap.get_data(), sizeof(unsigned char), snap.get_data_len(), file);
+		size_t length = fwrite(snap.get_data(), sizeof(unsigned char), snap.get_data_len(), file);
 		inkAssert(
 		    length == snap.get_data_len(),
 		    "Snapshot write failed, snapshot of size %u, but only %u bytes where written.",
@@ -119,13 +125,17 @@ extern "C" {
 
 	HInkStory* ink_story_from_binary(const unsigned char* data, size_t length, bool freeOnDestroy)
 	{
-		return reinterpret_cast<HInkStory*>(story::from_binary(data, length, freeOnDestroy));
+		return reinterpret_cast<HInkStory*>(
+		    story::from_binary(data, static_cast<ink::size_t>(length), freeOnDestroy)
+		);
 	}
 
 	HInkSnapshot*
 	    ink_snapshot_from_binary(const unsigned char* data, size_t length, bool freeOnDestroy)
 	{
-		return reinterpret_cast<HInkSnapshot*>(snapshot::from_binary(data, length, freeOnDestroy));
+		return reinterpret_cast<HInkSnapshot*>(
+		    snapshot::from_binary(data, static_cast<ink::size_t>(length), freeOnDestroy)
+		);
 	}
 
 	void ink_snapshot_get_binary(
@@ -291,7 +301,7 @@ extern "C" {
 		    function_name,
 		    [callback](size_t len, const value* vals) {
 			    InkValue* c_vals = reinterpret_cast<InkValue*>(const_cast<value*>(vals));
-			    int       c_len  = len;
+			    int       c_len  = static_cast<int>(len);
 			    for (int i = 0; i < c_len; ++i) {
 				    c_vals[i] = inkvar_to_c(const_cast<value&>(vals[i]));
 			    }
@@ -310,7 +320,7 @@ extern "C" {
 		    function_name,
 		    [callback](size_t len, const value* vals) -> value {
 			    InkValue* c_vals = reinterpret_cast<InkValue*>(const_cast<value*>(vals));
-			    int       c_len  = len;
+			    int       c_len  = static_cast<int>(len);
 			    for (int i = 0; i < c_len; ++i) {
 				    c_vals[i] = inkvar_to_c(const_cast<value&>(vals[i]));
 			    }
diff --git a/inkcpp_c/tests/ExternalFunction.c b/inkcpp_c/tests/ExternalFunction.c
@@ -17,16 +17,16 @@ InkValue my_sqrt(int argc, const InkValue argv[])
 	InkValue v = argv[0];
 	switch (v.type) {
 		case ValueTypeFloat: v.float_v = sqrtf(v.float_v); break;
-		case ValueTypeInt32: v.int32_v = sqrt(v.int32_v); break;
-		case ValueTypeUint32: v.uint32_v = sqrtf(v.uint32_v); break;
+		case ValueTypeInt32: v.int32_v = ( int32_t ) sqrt(v.int32_v); break;
+		case ValueTypeUint32: v.uint32_v = ( uint32_t ) sqrt(v.uint32_v); break;
 		default: assert(0);
 	}
 	return v;
 }
 
 int cnt_greeting = 0;
 
-InkValue greeting(int argc, const InkValue argv[])
+InkValue greeting(int argc, const InkValue*)
 {
 	cnt_greeting += 1;
 	assert(argc == 0);
diff --git a/inkcpp_test/Array.cpp b/inkcpp_test/Array.cpp
@@ -12,12 +12,11 @@ SCENARIO("a restorable array can hold values", "[array]")
 	GIVEN("an empty array")
 	{
 		const ink::size_t length = 10;
-		test_array array = test_array(length, 0, ~0);
+		test_array        array  = test_array(length, 0U, ~0U);
 
 		THEN("the default values should be zero")
 		{
-			for (ink::size_t i = 0; i < length; i++)
-			{
+			for (ink::size_t i = 0; i < length; i++) {
 				REQUIRE(array[i] == 0);
 			}
 		}
@@ -26,15 +25,11 @@ SCENARIO("a restorable array can hold values", "[array]")
 		{
 			array.set(3, 15);
 
-			THEN("the value should be set")
-			{
-				REQUIRE(array[3] == 15);
-			}
+			THEN("the value should be set") { REQUIRE(array[3] == 15); }
 
 			THEN("the other values should be zero still")
 			{
-				for (ink::size_t i = 0; i < length; i++)
-				{
+				for (ink::size_t i = 0; i < length; i++) {
 					if (i == 3)
 						continue;
 
@@ -50,7 +45,7 @@ SCENARIO("a restorable array can save/restore/forget", "[array]")
 	GIVEN("a saved array with a few values")
 	{
 		// Load up the array
-		test_array array = test_array(5, 0, ~0);
+		test_array array = test_array(5, 0U, ~0U);
 		array.set(0, 0);
 		array.set(1, 1);
 		array.set(2, 2);
diff --git a/inkcpp_test/Callstack.cpp b/inkcpp_test/Callstack.cpp
@@ -58,7 +58,7 @@ SCENARIO("threading with the callstack", "[callstack]")
 
 				WHEN("we collapse to the main thraed")
 				{
-					stack.collapse_to_thread(~0);
+					stack.collapse_to_thread(~0U);
 
 					THEN("we should have the value from the original thread")
 					{
@@ -91,7 +91,7 @@ SCENARIO("threading with the callstack", "[callstack]")
 
 						THEN("we can still collapse to the main thread")
 						{
-							stack.collapse_to_thread(~0);
+							stack.collapse_to_thread(~0U);
 							REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
 							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
 						}
@@ -140,7 +140,7 @@ SCENARIO("threading with the callstack", "[callstack]")
 
 					WHEN("we collapse to the main thraed")
 					{
-						stack.collapse_to_thread(~0);
+						stack.collapse_to_thread(~0U);
 
 						THEN("we should have the value from the original thread")
 						{
@@ -214,7 +214,7 @@ SCENARIO("threading with the callstack", "[callstack]")
 
 				WHEN("we collapse back to the main thread")
 				{
-					stack.collapse_to_thread(~0);
+					stack.collapse_to_thread(~0U);
 					THEN("the stack should be inside the tunnel")
 					{
 						REQUIRE(stack.get(X)->type() == value_type::int32);
@@ -225,13 +225,13 @@ SCENARIO("threading with the callstack", "[callstack]")
 
 					WHEN("we do a tunnel return")
 					{
-						frame_type type;
-						auto       offset = stack.pop_frame(&type, eval_mode);
+						frame_type ftype;
+						auto       foffset = stack.pop_frame(&ftype, eval_mode);
 
 						THEN("we should be back outside")
 						{
-							REQUIRE(type == frame_type::tunnel);
-							REQUIRE(offset == 505);
+							REQUIRE(ftype == frame_type::tunnel);
+							REQUIRE(foffset == 505);
 							REQUIRE(stack.get(X)->type() == value_type::int32);
 							REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
 							REQUIRE(stack.get(Y)->type() == value_type::int32);
diff --git a/inkcpp_test/FallbackFunction.cpp b/inkcpp_test/FallbackFunction.cpp
@@ -22,7 +22,7 @@ SCENARIO("run a story with external function and fallback function", "[external
 			int  cnt_sqrt = 0;
 			auto fn_sqrt  = [&cnt_sqrt](int x) -> int {
         ++cnt_sqrt;
-        return sqrt(x);
+        return static_cast<int>(sqrt(x));
 			};
 			int  cnt_greeting = 0;
 			auto fn_greeting  = [&cnt_greeting]() -> const char* {
@@ -51,7 +51,7 @@ SCENARIO("run a story with external function and fallback function", "[external
 			int  cnt_sqrt = 0;
 			auto fn_sqrt  = [&cnt_sqrt](int x) -> int {
         ++cnt_sqrt;
-        return sqrt(x);
+        return static_cast<int>(sqrt(x));
 			};
 
 			thread->bind("sqrt", fn_sqrt);
diff --git a/inkcpp_test/Fixes.cpp b/inkcpp_test/Fixes.cpp
@@ -63,7 +63,8 @@ SCENARIO("unknown command _ #109", "[fixes]")
 			for (size_t i = 0; i < out_str.size(); ++i) {
 				data[i] = out_str[i];
 			}
-			std::unique_ptr<story> ink{story::from_binary(data, out_str.size())};
+			std::unique_ptr<story> ink{story::from_binary(data, static_cast<ink::size_t>(out_str.size()))
+			};
 			globals                globStore = ink->new_globals();
 			runner                 main      = ink->new_runner(globStore);
 			std::string            story     = main->getall();
@@ -158,11 +159,11 @@ SCENARIO(
 		{
 			thread->getall();
 			std::unique_ptr<snapshot> snap{thread->create_snapshot()};
-			runner                    thread = ink->new_runner_from_snapshot(*snap);
+			runner                    thread2 = ink->new_runner_from_snapshot(*snap);
 			const size_t s = reinterpret_cast<internal::snapshot_impl*>(snap.get())->strings().size();
 			THEN("loading it again will not change the string_table size")
 			{
-				runner       thread2 = ink->new_runner_from_snapshot(*snap);
+				runner       thread3 = ink->new_runner_from_snapshot(*snap);
 				const size_t s2 = reinterpret_cast<internal::snapshot_impl*>(snap.get())->strings().size();
 				REQUIRE(s == s2);
 			}
@@ -227,9 +228,9 @@ SCENARIO("Using knot visit count as condition _ #139", "[fixes]")
 				WHEN("go to 'one' twice")
 				{
 					thread->choose(1);
-					std::string content = thread->getall();
+					std::string content2 = thread->getall();
 					REQUIRE(thread->num_choices() == 3);
-					THEN("get both one strings") { REQUIRE(content == "Check\nBeen here before\n"); }
+					THEN("get both one strings") { REQUIRE(content2 == "Check\nBeen here before\n"); }
 				}
 			}
 		}
@@ -266,7 +267,7 @@ SCENARIO("Provoke thread array expension _ #142", "[fixes]")
 				REQUIRE(thread->num_choices() == 15);
 				const char options[] = "abcdefghijklmno";
 				for (const char* c = options; *c; ++c) {
-					CHECK(thread->get_choice(c - options)->text()[0] == *c);
+					CHECK(thread->get_choice(static_cast<size_t>(c - options))->text()[0] == *c);
 				}
 			}
 		}
@@ -288,7 +289,7 @@ SCENARIO("Provoke thread array expension _ #142", "[fixes]")
 				REQUIRE(thread->num_choices() == 10);
 				const char* options = "bdfhjklmno";
 				for (const char* c = options; *c; ++c) {
-					CHECK(thread->get_choice(c - options)->text()[0] == *c);
+					CHECK(thread->get_choice(static_cast<size_t>(c - options))->text()[0] == *c);
 				}
 			}
 		}

Original file line number	Diff line number	Diff line change
`@@ -464,7 +464,7 @@ class fixed_restorable_array : public basic_restorable_array<T>`
`464`	`464`	`};`
`465`	`465`
`466`	`466`	`template<typename T>`
`467`		`-class allocated_restorable_array final : public basic_restorable_array<T>`
	`467`	`+class allocated_restorable_array : public basic_restorable_array<T>`
`468`	`468`	`{`
`469`	`469`	`using base = basic_restorable_array<T>;`
`470`	`470`
Original file line number	Diff line number	Diff line change
`@@ -277,7 +277,7 @@ class runner_impl`
`277`	`277`	`{`
`278`	`278`	`if (index >= _threadDone.capacity()) {`
`279`	`279`	`inkAssert(index == _threadDone.capacity(), "Threads should only be created incremental");`
`280`		`- _threadDone.resize(_threadDone.capacity() * 1.5);`
	`280`	`+ _threadDone.resize(static_cast<size_t>(_threadDone.capacity() * 1.5));`
`281`	`281`	`}`
`282`	`282`	`_threadDone.set(index, value);`
`283`	`283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,16 +17,16 @@ InkValue my_sqrt(int argc, const InkValue argv[])`
`17`	`17`	`InkValue v = argv[0];`
`18`	`18`	`switch (v.type) {`
`19`	`19`	`case ValueTypeFloat: v.float_v = sqrtf(v.float_v); break;`
`20`		`- case ValueTypeInt32: v.int32_v = sqrt(v.int32_v); break;`
`21`		`- case ValueTypeUint32: v.uint32_v = sqrtf(v.uint32_v); break;`
	`20`	`+ case ValueTypeInt32: v.int32_v = ( int32_t ) sqrt(v.int32_v); break;`
	`21`	`+ case ValueTypeUint32: v.uint32_v = ( uint32_t ) sqrt(v.uint32_v); break;`
`22`	`22`	`default: assert(0);`
`23`	`23`	`}`
`24`	`24`	`return v;`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`int cnt_greeting = 0;`
`28`	`28`
`29`		`-InkValue greeting(int argc, const InkValue argv[])`
	`29`	`+InkValue greeting(int argc, const InkValue*)`
`30`	`30`	`{`
`31`	`31`	`cnt_greeting += 1;`
`32`	`32`	`assert(argc == 0);`
Original file line number	Diff line number	Diff line change
`@@ -12,12 +12,11 @@ SCENARIO("a restorable array can hold values", "[array]")`
`12`	`12`	`GIVEN("an empty array")`
`13`	`13`	`{`
`14`	`14`	`const ink::size_t length = 10;`
`15`		`- test_array array = test_array(length, 0, ~0);`
	`15`	`+ test_array array = test_array(length, 0U, ~0U);`
`16`	`16`
`17`	`17`	`THEN("the default values should be zero")`
`18`	`18`	`{`
`19`		`- for (ink::size_t i = 0; i < length; i++)`
`20`		`- {`
	`19`	`+ for (ink::size_t i = 0; i < length; i++) {`
`21`	`20`	`REQUIRE(array[i] == 0);`
`22`	`21`	`}`
`23`	`22`	`}`
`@@ -26,15 +25,11 @@ SCENARIO("a restorable array can hold values", "[array]")`
`26`	`25`	`{`
`27`	`26`	`array.set(3, 15);`
`28`	`27`
`29`		`- THEN("the value should be set")`
`30`		`- {`
`31`		`- REQUIRE(array[3] == 15);`
`32`		`- }`
	`28`	`+ THEN("the value should be set") { REQUIRE(array[3] == 15); }`
`33`	`29`
`34`	`30`	`THEN("the other values should be zero still")`
`35`	`31`	`{`
`36`		`- for (ink::size_t i = 0; i < length; i++)`
`37`		`- {`
	`32`	`+ for (ink::size_t i = 0; i < length; i++) {`
`38`	`33`	`if (i == 3)`
`39`	`34`	`continue;`
`40`	`35`
`@@ -50,7 +45,7 @@ SCENARIO("a restorable array can save/restore/forget", "[array]")`
`50`	`45`	`GIVEN("a saved array with a few values")`
`51`	`46`	`{`
`52`	`47`	`// Load up the array`
`53`		`- test_array array = test_array(5, 0, ~0);`
	`48`	`+ test_array array = test_array(5, 0U, ~0U);`
`54`	`49`	`array.set(0, 0);`
`55`	`50`	`array.set(1, 1);`
`56`	`51`	`array.set(2, 2);`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ SCENARIO("threading with the callstack", "[callstack]")`
`58`	`58`
`59`	`59`	`WHEN("we collapse to the main thraed")`
`60`	`60`	`{`
`61`		`- stack.collapse_to_thread(~0);`
	`61`	`+ stack.collapse_to_thread(~0U);`
`62`	`62`
`63`	`63`	`THEN("we should have the value from the original thread")`
`64`	`64`	`{`
`@@ -91,7 +91,7 @@ SCENARIO("threading with the callstack", "[callstack]")`
`91`	`91`
`92`	`92`	`THEN("we can still collapse to the main thread")`
`93`	`93`	`{`
`94`		`- stack.collapse_to_thread(~0);`
	`94`	`+ stack.collapse_to_thread(~0U);`
`95`	`95`	`REQUIRE(stack.get(X)->get<value_type::int32>() == 100);`
`96`	`96`	`REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);`
`97`	`97`	`}`
`@@ -140,7 +140,7 @@ SCENARIO("threading with the callstack", "[callstack]")`
`140`	`140`
`141`	`141`	`WHEN("we collapse to the main thraed")`
`142`	`142`	`{`
`143`		`- stack.collapse_to_thread(~0);`
	`143`	`+ stack.collapse_to_thread(~0U);`
`144`	`144`
`145`	`145`	`THEN("we should have the value from the original thread")`
`146`	`146`	`{`
`@@ -214,7 +214,7 @@ SCENARIO("threading with the callstack", "[callstack]")`
`214`	`214`
`215`	`215`	`WHEN("we collapse back to the main thread")`
`216`	`216`	`{`
`217`		`- stack.collapse_to_thread(~0);`
	`217`	`+ stack.collapse_to_thread(~0U);`
`218`	`218`	`THEN("the stack should be inside the tunnel")`
`219`	`219`	`{`
`220`	`220`	`REQUIRE(stack.get(X)->type() == value_type::int32);`
`@@ -225,13 +225,13 @@ SCENARIO("threading with the callstack", "[callstack]")`
`225`	`225`
`226`	`226`	`WHEN("we do a tunnel return")`
`227`	`227`	`{`
`228`		`- frame_type type;`
`229`		`- auto offset = stack.pop_frame(&type, eval_mode);`
	`228`	`+ frame_type ftype;`
	`229`	`+ auto foffset = stack.pop_frame(&ftype, eval_mode);`
`230`	`230`
`231`	`231`	`THEN("we should be back outside")`
`232`	`232`	`{`
`233`		`- REQUIRE(type == frame_type::tunnel);`
`234`		`- REQUIRE(offset == 505);`
	`233`	`+ REQUIRE(ftype == frame_type::tunnel);`
	`234`	`+ REQUIRE(foffset == 505);`
`235`	`235`	`REQUIRE(stack.get(X)->type() == value_type::int32);`
`236`	`236`	`REQUIRE(stack.get(X)->get<value_type::int32>() == 100);`
`237`	`237`	`REQUIRE(stack.get(Y)->type() == value_type::int32);`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,8 @@ SCENARIO("unknown command _ #109", "[fixes]")`
`63`	`63`	`for (size_t i = 0; i < out_str.size(); ++i) {`
`64`	`64`	`data[i] = out_str[i];`
`65`	`65`	`}`
`66`		`- std::unique_ptr<story> ink{story::from_binary(data, out_str.size())};`
	`66`	`+ std::unique_ptr<story> ink{story::from_binary(data, static_cast<ink::size_t>(out_str.size()))`
	`67`	`+ };`
`67`	`68`	`globals globStore = ink->new_globals();`
`68`	`69`	`runner main = ink->new_runner(globStore);`
`69`	`70`	`std::string story = main->getall();`
`@@ -158,11 +159,11 @@ SCENARIO(`
`158`	`159`	`{`
`159`	`160`	`thread->getall();`
`160`	`161`	`std::unique_ptr<snapshot> snap{thread->create_snapshot()};`
`161`		`- runner thread = ink->new_runner_from_snapshot(*snap);`
	`162`	`+ runner thread2 = ink->new_runner_from_snapshot(*snap);`
`162`	`163`	`const size_t s = reinterpret_cast<internal::snapshot_impl*>(snap.get())->strings().size();`
`163`	`164`	`THEN("loading it again will not change the string_table size")`
`164`	`165`	`{`
`165`		`- runner thread2 = ink->new_runner_from_snapshot(*snap);`
	`166`	`+ runner thread3 = ink->new_runner_from_snapshot(*snap);`
`166`	`167`	`const size_t s2 = reinterpret_cast<internal::snapshot_impl*>(snap.get())->strings().size();`
`167`	`168`	`REQUIRE(s == s2);`
`168`	`169`	`}`
`@@ -227,9 +228,9 @@ SCENARIO("Using knot visit count as condition _ #139", "[fixes]")`
`227`	`228`	`WHEN("go to 'one' twice")`
`228`	`229`	`{`
`229`	`230`	`thread->choose(1);`
`230`		`- std::string content = thread->getall();`
	`231`	`+ std::string content2 = thread->getall();`
`231`	`232`	`REQUIRE(thread->num_choices() == 3);`
`232`		`- THEN("get both one strings") { REQUIRE(content == "Check\nBeen here before\n"); }`
	`233`	`+ THEN("get both one strings") { REQUIRE(content2 == "Check\nBeen here before\n"); }`
`233`	`234`	`}`
`234`	`235`	`}`
`235`	`236`	`}`
`@@ -266,7 +267,7 @@ SCENARIO("Provoke thread array expension _ #142", "[fixes]")`
`266`	`267`	`REQUIRE(thread->num_choices() == 15);`
`267`	`268`	`const char options[] = "abcdefghijklmno";`
`268`	`269`	`for (const char* c = options; *c; ++c) {`
`269`		`- CHECK(thread->get_choice(c - options)->text()[0] == *c);`
	`270`	`+ CHECK(thread->get_choice(static_cast<size_t>(c - options))->text()[0] == *c);`
`270`	`271`	`}`
`271`	`272`	`}`
`272`	`273`	`}`
`@@ -288,7 +289,7 @@ SCENARIO("Provoke thread array expension _ #142", "[fixes]")`
`288`	`289`	`REQUIRE(thread->num_choices() == 10);`
`289`	`290`	`const char* options = "bdfhjklmno";`
`290`	`291`	`for (const char* c = options; *c; ++c) {`
`291`		`- CHECK(thread->get_choice(c - options)->text()[0] == *c);`
	`292`	`+ CHECK(thread->get_choice(static_cast<size_t>(c - options))->text()[0] == *c);`
`292`	`293`	`}`
`293`	`294`	`}`
`294`	`295`	`}`