inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp_test/Callstack.cpp

@@ -0,0 +1,392 @@
+#include "catch.hpp"
+
+#include "../inkcpp/stack.h"
+
+using ink::hash_t;
+using ink::thread_t;
+using ink::runtime::internal::value;
+using ink::runtime::internal::value_type;
+using ink::runtime::internal::frame_type;
+
+const hash_t X = ink::hash_string("X");
+const hash_t Y = ink::hash_string("Y");
+const hash_t Z = ink::hash_string("Z");
+
+value operator "" _v(unsigned long long i) {
+	return value{}.set<value_type::int32>(static_cast<int32_t>(i));
+}
+
+SCENARIO("threading with the callstack", "[callstack]")
+{
+	GIVEN("a callstack with a few temporary variables")
+	{
+		// Create the stack
+		auto stack = ink::runtime::internal::stack<50>();
+
+		// Set X and Y temporary variables
+		stack.set(X, 100_v);
+		stack.set(Y, 200_v);
+
+		WHEN("there is a fork and more is pushed")
+		{
+			thread_t thread = stack.fork_thread();
+
+			THEN("old variables aren't accessible")
+			{
+				REQUIRE(stack.get(X) == nullptr);
+				REQUIRE(stack.get(Y) == nullptr);
+			}
+
+			// Push something onto the thread
+			stack.set(X, 200_v);
+			REQUIRE(stack.get(X)->get<value_type::int32>() == 200);
+
+			WHEN("when that thread ends")
+			{
+				stack.complete_thread(thread);
+
+				WHEN("we collapse to the thread")
+				{
+					stack.collapse_to_thread(thread);
+
+					THEN("we should have the value from that thread")
+					{
+						REQUIRE(stack.get(X)->get<value_type::int32>() == 200);
+					}
+				}
+
+				WHEN("we collapse to the main thraed")
+				{
+					stack.collapse_to_thread(~0);
+
+					THEN("we should have the value from the original thread")
+					{
+						REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
+						REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+					}
+				}
+
+				THEN("we should be able to access original thread values")
+				{
+					REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+				}
+
+				WHEN("we push more on the main thread")
+				{
+					stack.set(Z, 500_v);
+
+					THEN("collapsing to the thread shouldn't have the values anymore")
+					{
+						stack.collapse_to_thread(thread);
+						REQUIRE(stack.get(Z) == nullptr);
+					}
+
+					WHEN("we start a second thread that closes")
+					{
+						thread_t thread2 = stack.fork_thread();
+						stack.set(X, 999_v);
+						stack.complete_thread(thread2);
+
+						THEN("we can still collapse to the main thread")
+						{
+							stack.collapse_to_thread(~0);
+							REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
+							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+						}
+
+						THEN("we can still collapse to the first thread")
+						{
+							stack.collapse_to_thread(thread);
+							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+							REQUIRE(stack.get(Z) == nullptr);
+						}
+					}
+				}
+			}
+
+			WHEN("that thread also forks a thread")
+			{
+				thread_t thread2 = stack.fork_thread();
+
+				// Put something on this thread
+				stack.set(X, 999_v);
+
+				WHEN("that inner thread and outer thread complete")
+				{
+					stack.complete_thread(thread2);
+					stack.complete_thread(thread);
+
+					WHEN("we collapse to the inner thread")
+					{
+						stack.collapse_to_thread(thread2);
+
+						THEN("we should have the value from that thread")
+						{
+							REQUIRE(stack.get(X)->get<value_type::int32>() == 999);
+						}
+					}
+
+					WHEN("we collapse to the outer thread")
+					{
+						stack.collapse_to_thread(thread);
+
+						THEN("we should have the value from that thread")
+						{
+							REQUIRE(stack.get(X)->get<value_type::int32>() == 200);
+						}
+					}
+
+					WHEN("we collapse to the main thraed")
+					{
+						stack.collapse_to_thread(~0);
+
+						THEN("we should have the value from the original thread")
+						{
+							REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
+							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+						}
+					}
+				}
+			}
+		}
+
+		WHEN("there is a fork with a tunnel that finishes")
+		{
+			thread_t thread = stack.fork_thread();
+			stack.push_frame<frame_type::tunnel>(555, false);
+			stack.complete_thread(thread);
+
+			THEN("there should be no frames on the stack")
+			{
+				REQUIRE(stack.has_frame() == false);
+			}
+		}
+	}
+
+	GIVEN("a callstack with a single tunnel pushed")
+	{
+		// Create the stack
+		auto stack = ink::runtime::internal::stack<50>();
+
+		// Set X and Y temporary variables
+		stack.set(X, 100_v);
+		stack.set(Y, 200_v);
+
+		// Push a tunnel
+		stack.push_frame<frame_type::tunnel>(505, false);
+
+		// Push some more temps
+		stack.set(X, 101_v);
+		stack.set(Y, 201_v);
+
+		bool eval_mode;
+
+		WHEN("a thread is forked")
+		{
+			thread_t thread = stack.fork_thread();
+
+			WHEN("that thread does a tunnel return")
+			{
+				frame_type type;
+				auto offset = stack.pop_frame(&type, eval_mode);
+				
+				THEN("that thread should be outside the tunnel")
+				{
+					REQUIRE(type == frame_type::tunnel);
+					REQUIRE(offset == 505);
+
+					REQUIRE(stack.get(X)->get<value_type::int32>() == 100);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+				}
+
+				stack.complete_thread(thread);
+
+				WHEN("we collapse to that thread")
+				{
+					stack.collapse_to_thread(thread);
+					THEN("the stack should be outside the tunnel")
+					{
+						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);
+						REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+					}
+				}
+
+				WHEN("we collapse back to the main thread")
+				{
+					stack.collapse_to_thread(~0);
+					THEN("the stack should be inside the tunnel")
+					{
+						REQUIRE(stack.get(X)->type() == value_type::int32);
+						REQUIRE(stack.get(X)->get<value_type::int32>() == 101);
+						REQUIRE(stack.get(Y)->type() == value_type::int32);
+						REQUIRE(stack.get(Y)->get<value_type::int32>() == 201);
+					}
+
+					WHEN("we do a tunnel return")
+					{
+						frame_type type;
+						auto offset = stack.pop_frame(&type, eval_mode);
+
+						THEN("we should be back outside")
+						{
+							REQUIRE(type == frame_type::tunnel);
+							REQUIRE(offset == 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);
+							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+						}
+					}
+				}
+			}
+
+			WHEN("that thread completes and we pop off the main thread")
+			{
+				stack.complete_thread(thread);
+				frame_type type;
+				auto offset = stack.pop_frame(&type, eval_mode);
+
+				THEN("we should be outside the tunnel")
+				{
+					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);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+				}
+
+				THEN("collapsing to the thread will have the correct callstack")
+				{
+					stack.collapse_to_thread(thread);
+
+					REQUIRE(stack.get(X)->type() == value_type::int32);
+					REQUIRE(stack.get(X)->get<value_type::int32>() == 101);
+					REQUIRE(stack.get(Y)->type() == value_type::int32);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 201);
+				}
+			}
+		}
+	}
+
+	GIVEN("A thread with a frame pushed")
+	{
+		// Create the stack
+		auto stack = ink::runtime::internal::stack<50>();
+		
+		// Create the thread
+		thread_t thread = stack.fork_thread();
+
+		// Set X and Y temporary variables
+		stack.set(X, 100_v);
+		stack.set(Y, 200_v);
+
+		// Push a tunnel
+		stack.push_frame<frame_type::tunnel>(505, false);
+
+		// Push some more temps
+		stack.set(X, 101_v);
+		stack.set(Y, 201_v);
+
+		bool eval_mode;
+
+		WHEN("a second thread is forked off the first")
+		{
+			thread_t thread2 = stack.fork_thread();
+
+			WHEN("the second thread ends")
+			{
+				stack.complete_thread(thread2);
+
+				WHEN("the first thread does a pop")
+				{
+					frame_type _ignore;
+					stack.pop_frame(&_ignore, eval_mode);
+
+					THEN("accessing the variable should return the original")
+					{
+						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);
+						REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+					}
+
+					WHEN("the first thread ends")
+					{
+						stack.complete_thread(thread);
+
+						THEN("collapsing to the first thread should return the correct variables")
+						{
+							stack.collapse_to_thread(thread);
+
+							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);
+							REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	GIVEN("A thread with two frames pushed")
+	{
+		// Create the stack
+		auto stack = ink::runtime::internal::stack<50>();
+
+		// Create the thread
+		thread_t thread = stack.fork_thread();
+
+		// Set X and Y temporary variables
+		stack.set(X, 100_v);
+		stack.set(Y, 200_v);
+
+		// Push a tunnel
+		stack.push_frame<frame_type::tunnel>(505, false);
+
+		// Push some more temps
+		stack.set(X, 101_v);
+		stack.set(Y, 201_v);
+
+		// Push another tunnel
+		stack.push_frame<frame_type::tunnel>(505, false);
+
+		// Push some more temps
+		stack.set(X, 102_v);
+		stack.set(Y, 202_v);
+
+		WHEN("another thread is started and completed on top of it")
+		{
+			thread_t thread2 = stack.fork_thread();
+			stack.complete_thread(thread2);
+
+			WHEN("we then try to pop both frames")
+			{
+				frame_type _ignore;
+				bool eval_mode;
+				stack.pop_frame(&_ignore, eval_mode);
+				stack.pop_frame(&_ignore, eval_mode);
+
+				THEN("we should have access to the original variables")
+				{
+					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);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+				}
+
+				THEN("collapsing to the thread should also get us the original variables")
+				{
+					stack.complete_thread(thread);
+					stack.collapse_to_thread(thread);
+					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);
+					REQUIRE(stack.get(Y)->get<value_type::int32>() == 200);
+				}
+			}
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/EmptyStringForDivert.cpp

@@ -0,0 +1,36 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+SCENARIO("a story with a white space infront of an conditional Divert", "[Output]")
+{
+	// based on https://github.com/JBenda/inkcpp/issues/71
+	GIVEN("A story")
+	{
+		auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "EmptyStringForDivert.bin");
+		runner thread = ink->new_runner();
+
+		WHEN("run")
+		{
+			THEN("print 'This displays first'")
+			{
+				thread->getall();
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				REQUIRE(thread->getall() == "This displays first\n");
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				REQUIRE(thread->getall() == "This is the continuation.\n");
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				REQUIRE(thread->getall() == "");
+				REQUIRE(! thread->has_choices());
+			}
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/ExternalFunctionsExecuteProperly.cpp

@@ -0,0 +1,34 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+SCENARIO("a story with an external function evaluates the function at the right time", "[story]")
+{
+	GIVEN("a story with an external function")
+	{
+		auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "ExternalFunctionsExecuteProperly.bin");
+		runner thread = ink->new_runner();
+
+		int line_count = 0;
+
+
+		thread->bind("GET_LINE_COUNT", [&line_count]() { return line_count; });
+
+		WHEN("run thread")
+		{
+			THEN("thread has correct line counts")
+			{
+				while (thread->can_continue()) {
+					auto line = thread->getline();
+					REQUIRE(line == "Line count: " + std::to_string(line_count) + "\n");
+					line_count++;
+				}
+			}
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/FallbackFunction.cpp

@@ -0,0 +1,77 @@
+#include "catch.hpp"
+
+#include <system.h>
+#include <story.h>
+#include <runner.h>
+#include <globals.h>
+#include <compiler.h>
+
+#include <cmath>
+
+using namespace ink::runtime;
+
+SCENARIO("run a story with external function and fallback function", "[external function]")
+{
+	GIVEN("story with two external functions, one with fallback")
+	{
+		auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "FallBack.bin");
+		runner thread = ink->new_runner();
+
+		WHEN("bind both external functions")
+		{
+			int  cnt_sqrt = 0;
+			auto fn_sqrt  = [&cnt_sqrt](int x) -> int {
+        ++cnt_sqrt;
+        return sqrt(x);
+			};
+			int  cnt_greeting = 0;
+			auto fn_greeting  = [&cnt_greeting]() -> const char* {
+        ++cnt_greeting;
+        return "Hohooh";
+			};
+
+			thread->bind("sqrt", fn_sqrt);
+			thread->bind("greeting", fn_greeting);
+
+			std::string out;
+			REQUIRE_NOTHROW(out = thread->getall());
+			THEN("Both function should be called the correct amount of times")
+			{
+				REQUIRE(
+				    out
+				    == "Hohooh ! A small demonstration of my power:\nMath 4 * 4 = 16, stunning i would "
+				       "say\n"
+				);
+				REQUIRE(cnt_sqrt == 2);
+				REQUIRE(cnt_greeting == 1);
+			}
+		}
+		WHEN("only bind function without fallback")
+		{
+			int  cnt_sqrt = 0;
+			auto fn_sqrt  = [&cnt_sqrt](int x) -> int {
+        ++cnt_sqrt;
+        return sqrt(x);
+			};
+
+			thread->bind("sqrt", fn_sqrt);
+
+			std::string out;
+			REQUIRE_NOTHROW(out = thread->getall());
+			;
+			THEN("Sqrt should be falled twice, and uses default greeting")
+			{
+				REQUIRE(
+				    out
+				    == "Hello ! A small demonstration of my power:\nMath 4 * 4 = 16, stunning i would say\n"
+				);
+				REQUIRE(cnt_sqrt == 2);
+			}
+		}
+		WHEN("bind no function")
+		{
+			std::string out;
+			REQUIRE_THROWS_AS(out = thread->getall(), ink::ink_exception);
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/Globals.cpp

@@ -0,0 +1,73 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+SCENARIO("run story with global variable", "[global variables]")
+{
+	GIVEN ("a story with global variables")
+	{
+		auto    ink       = story::from_file(INK_TEST_RESOURCE_DIR "GlobalStory.bin");
+		globals globStore = ink->new_globals();
+		runner thread = ink->new_runner(globStore);
+
+		WHEN( "just runs")
+		{
+			THEN("variables should contain values as in inkScript")
+			{
+				REQUIRE(thread->getall() == "My name is Jean Passepartout, but my friend's call me Jackie. I'm 23 years old.\nFoo:23\n");
+				REQUIRE(*globStore->get<int32_t>("age") == 23);
+				REQUIRE(*globStore->get<const char*>("friendly_name_of_player") == std::string{"Jackie"});
+			}
+		}
+		WHEN ("edit number")
+		{
+			bool resi
+				= globStore->set<int32_t>("age", 30);
+			bool resc
+				= globStore->set<const char*>("friendly_name_of_player", "Freddy");
+			THEN("execution should success")
+			{
+				REQUIRE(resi == true);
+				REQUIRE(resc == true);
+			}
+			THEN("variable should contain new value")
+			{
+				REQUIRE(thread->getall() == "My name is Jean Passepartout, but my friend's call me Freddy. I'm 30 years old.\nFoo:30\n");
+				REQUIRE(*globStore->get<int32_t>("age") == 30);
+				REQUIRE(*globStore->get<const char*>("friendly_name_of_player") == std::string{"Freddy"});
+			}
+			WHEN ("something added to string")
+			{
+				// concat in GlobalsStory.ink
+				thread->getall();
+				THEN("get should return the whole string")
+				{
+					REQUIRE(*globStore->get<const char*>("concat") == std::string{"Foo:30"});
+				}
+			}
+		}
+		WHEN ("name or type not exist")
+		{
+			auto wrongType = globStore->get<uint32_t>("age");
+			auto notExistingName = globStore->get<int32_t>("foo");
+			THEN("should return nullptr")
+			{
+				REQUIRE(wrongType.has_value() == false);
+				REQUIRE(notExistingName.has_value() == false);
+			}
+
+			bool rest = globStore->set<uint32_t>("age", 3);
+			bool resn = globStore->set<int32_t>("foo", 3);
+			THEN("should return false")
+			{
+				REQUIRE(rest == false);
+				REQUIRE(resn == false);
+			}
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/InkyJson.cpp

@@ -0,0 +1,34 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+static constexpr const char* OUTPUT_PART_1 = "Once upon a time...\n";
+static constexpr const char* OUTPUT_PART_2
+    = "There were two choices.\nThey lived happily ever after.\n";
+static constexpr size_t CHOICE = 0;
+
+SCENARIO("run inklecate 1.1.1 story")
+{
+	auto compiler = GENERATE("inklecate", "inky");
+	GIVEN(compiler)
+	{
+		auto input_file = std::string(INK_TEST_RESOURCE_DIR "simple-1.1.1-") + compiler + ".json";
+		ink::compiler::run(input_file.c_str(), "simple.bin");
+		auto   ink    = story::from_file("simple.bin");
+		runner thread = ink->new_runner();
+
+		THEN("Expect normal output")
+		{
+			REQUIRE(thread->getall() == OUTPUT_PART_1);
+			REQUIRE(thread->has_choices());
+			REQUIRE(thread->num_choices() == 2);
+			thread->choose(CHOICE);
+			REQUIRE(thread->getall() == OUTPUT_PART_2);
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_test/LabelCondition.cpp

@@ -0,0 +1,60 @@
+#include "catch.hpp"
+
+#include <choice.h>
+#include <compiler.h>
+#include <globals.h>
+#include <runner.h>
+#include <story.h>
+
+using namespace ink::runtime;
+
+SCENARIO( "run story with hidden choice" )
+{
+	GIVEN( "a story with choice visibale by second visit" )
+	{
+		auto    ink     = story::from_file(INK_TEST_RESOURCE_DIR "LabelConditionStory.bin");
+		globals globals = ink->new_globals();
+		runner  thread  = ink->new_runner( globals );
+
+		WHEN( "normal run" )
+		{
+			std::string out = thread->getall();
+			REQUIRE( thread->num_choices() == 1 );
+			std::string choice1a = thread->get_choice( 0 )->text();
+			thread->choose( 0 );
+			std::string out2 = thread->getall();
+			REQUIRE( thread->num_choices() == 1 );
+			std::string choice2a = thread->get_choice( 0 )->text();
+
+			THEN( "second choice keeps hidden" )
+			{
+				REQUIRE( out == "" );
+				REQUIRE( choice1a == "labeled choice" );
+				REQUIRE( out2 == "" );
+				REQUIRE( choice2a == "labeled choice" );
+			}
+		}
+
+		WHEN( "set global variable to enable hidden choice" )
+		{
+			globals->set<bool>( "bool_variable", false );
+			std::string out = thread->getall();
+			REQUIRE( thread->num_choices() == 1 );
+			std::string choice1a = thread->get_choice( 0 )->text();
+			thread->choose( 0 );
+			std::string out2 = thread->getall();
+			REQUIRE( thread->num_choices() == 2 );
+			std::string choice2a = thread->get_choice( 0 )->text();
+			std::string choice2b = thread->get_choice( 1 )->text();
+
+			THEN( "second choice is visible" )
+			{
+				REQUIRE( out == "" );
+				REQUIRE( choice1a == "labeled choice" );
+				REQUIRE( out2 == "" );
+				REQUIRE( choice2a == "labeled choice" );
+				REQUIRE( choice2b == "hidden choice" );
+			}
+		}
+	}
+}