inkcpp_rb 0.1.0

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

@@ -0,0 +1,224 @@
+#include "catch.hpp"
+
+#include "../inkcpp/simple_restorable_stack.h"
+
+using ink::runtime::internal::simple_restorable_stack;
+
+template<typename T, ink::size_t N>
+using fixed_restorable_stack = ink::runtime::internal::managed_restorable_stack<T,false,N>;
+
+template<typename T, int SIZE>
+void stack_matches(const simple_restorable_stack<T>& stack, T (&expected)[SIZE])
+{
+	// Iterate stack and check that it matches the expected array
+	int count = 0;
+	const int* iter = nullptr;
+	while (stack.iter(iter)) {
+		REQUIRE(count < SIZE);
+		REQUIRE(*iter == expected[SIZE - count - 1]);
+		count++;
+	}
+}
+
+SCENARIO("simple_restorable_stack can be pushed and popped", "[stack]") {
+
+	GIVEN("An empty stack") {
+		fixed_restorable_stack<int, 10> stack(~0);
+
+		WHEN("items are added") {
+			stack.push(1);
+			stack.push(2);
+			stack.push(3);
+
+			THEN("the size has increased") {
+				REQUIRE(!stack.empty());
+				REQUIRE(stack.size() == 3);
+			}
+
+			THEN("the correct item is at the top") {
+				REQUIRE(stack.top() == 3);
+			}
+
+			THEN("we can iterate the stack") {
+				int expected[] = { 1, 2, 3 };
+				stack_matches(stack, expected);
+			}
+
+			WHEN("they are popped") {
+				int pop = stack.pop();
+
+				THEN("the correct item is popped") {
+					REQUIRE(pop == 3);
+				}
+
+				THEN("there are fewer items") {
+					REQUIRE(stack.size() == 2);
+				}
+
+				THEN("there is a new item on top") {
+					REQUIRE(stack.top() == 2);
+				}
+
+				THEN("we can still iterate") {
+					int expected[] = { 1, 2 };
+					stack_matches(stack, expected);
+				}
+			}
+		}
+	}
+}
+
+SCENARIO("simple_restorable_stack supports save/restore", "[stack]") {
+	GIVEN("a stack with a few items that has been saved") {
+		fixed_restorable_stack<int, 20> stack(~0);
+
+		stack.push(1); 
+		stack.push(2);
+		stack.push(3);
+		stack.save();
+
+		auto check_restore = [&stack]() {
+			WHEN("we restore the stack") {
+				stack.restore();
+
+				THEN("we should be back to having 4 items") {
+					REQUIRE(stack.size() == 3);
+				}
+
+				THEN("they should match exactly the original items") {
+					int expected[] = { 1, 2, 3 };
+					stack_matches(stack, expected);
+				}
+			}
+		};
+
+		WHEN("new items are pushed") {
+			stack.push(4);
+
+			THEN("the pushed item is on top") {
+				REQUIRE(stack.top() == 4);
+			}
+			THEN("the size has increased") {
+				REQUIRE(stack.size() == 4);
+			}
+
+			WHEN("the state is restored") {
+				stack.restore();
+
+				THEN("the original item is back on top") {
+					REQUIRE(stack.size() == 3);
+					REQUIRE(stack.top() == 3);
+				}
+			}
+
+			WHEN("the state is finalized") {
+				stack.forget();
+
+				THEN("the new item is still on top") {
+					REQUIRE(stack.size() == 4);
+					REQUIRE(stack.top() == 4);
+				}
+			}
+		}
+
+		WHEN("items are popped") {
+			stack.pop(); stack.pop();
+
+			THEN("the stack has shrunk") {
+				REQUIRE(stack.size() == 1);
+				REQUIRE(stack.top() == 1);
+			}
+
+			WHEN("more items are pushed") {
+				stack.push(90);
+				stack.push(91);
+
+				THEN("the stack has the correct size") {
+					REQUIRE(stack.size() == 3);
+					REQUIRE(stack.top() == 91);
+				}
+
+				THEN("iteration only covers items that ought to be in the stack") {
+					int expected[] = { 1, 90, 91 };
+					stack_matches(stack, expected);
+				}
+
+				THEN("we can pop all items from the stack") {
+					REQUIRE(stack.pop() == 91);
+					REQUIRE(stack.pop() == 90);
+					REQUIRE(stack.pop() == 1);
+					REQUIRE(stack.empty());
+
+					// Check that the stack can restore
+					check_restore();
+
+					THEN("we can add more items to the stack")
+					{
+						// Push more items
+						stack.push(100);
+						stack.push(101);
+						int expected[] = { 100, 101 };
+						stack_matches(stack, expected);
+
+						// Check that we can still restore
+						check_restore();
+					}
+				}
+
+				// Check that the stack can restore
+				check_restore();
+
+				THEN("we can finalize the stack") {
+					stack.forget();
+
+					int expected[] = { 1, 90, 91 };
+					stack_matches(stack, expected);
+				}
+
+				WHEN("we pop them back off") {
+					stack.pop(); stack.pop();
+
+					THEN("the correct entry is on top") {
+						REQUIRE(stack.top() == 1);
+						REQUIRE(stack.size() == 1);
+					}
+				}
+			}
+		}
+	}
+
+	GIVEN("a stack with one entry that has been saved")
+	{
+		fixed_restorable_stack<int, 10> stack(~0);
+		stack.push(0);
+		stack.save();
+
+		WHEN("an item is popped, pushed, and popped again")
+		{
+			stack.pop();
+			stack.push(1);
+			stack.pop();
+
+			THEN("the stack should be considered 'empty'")
+			{
+				REQUIRE(stack.size() == 0); 
+				REQUIRE(stack.empty());
+			}
+		}
+
+		WHEN("an item is popped and pushed and then we forget()")
+		{
+			stack.pop();
+			stack.push(1);
+			stack.pop();
+			stack.forget();
+
+			THEN("the stack should be empty")
+			{
+				REQUIRE(stack.size() == 0);
+				REQUIRE(stack.empty());
+			}
+
+		}
+	}
+}

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

@@ -0,0 +1,131 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+#include <choice.h>
+
+using namespace ink::runtime;
+
+SCENARIO("tags", "[tags]")
+{
+	auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "AHF.bin");
+	runner thread = ink->new_runner();
+	thread->move_to(ink::hash_string("test_knot"));
+	while(thread->can_continue()) {
+		auto line = thread->getline();
+	}
+	REQUIRE(thread->can_continue() == false);
+}
+
+SCENARIO("run story with tags", "[tags]")
+{
+	GIVEN("a story with tags")
+	{
+		auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "TagsStory.bin");
+		runner thread = ink->new_runner();
+		WHEN("start thread")
+		{
+			THEN("No tags")
+			{
+				REQUIRE(thread->has_tags() == false);
+			}
+			WHEN("approach first line")
+			{
+				std::string line = thread->getall();
+				THEN("print no tags")
+				{
+					REQUIRE(line == "Hello\n");
+				}
+				THEN("collect all previous Tags (global, knot, line) in correct order")
+				{
+					REQUIRE(thread->has_tags() == true);
+					REQUIRE(thread->num_tags() == 4);
+					REQUIRE(std::string(thread->get_tag(0)) == "global_tag");
+					REQUIRE(std::string(thread->get_tag(1)) == "knot_tag_start");
+					REQUIRE(std::string(thread->get_tag(2)) == "second_knot_tag_start");
+					REQUIRE(std::string(thread->get_tag(3)) == "output_tag_h");
+				}
+				WHEN("print choices")
+				{
+					auto itr = thread->begin();
+					std::string choices[2] = {
+						itr[0].text(),
+						itr[1].text()
+					};
+					THEN("choices won't print tags, tags are still the same, but they can contain tags")
+					{
+						REQUIRE(choices[0] == "a");
+						REQUIRE(choices[1] == "b");
+						REQUIRE(thread->has_tags());
+						REQUIRE(thread->num_tags() == 4);
+						REQUIRE(std::string(thread->get_tag(0)) == "global_tag");
+						REQUIRE(std::string(thread->get_tag(1)) == "knot_tag_start");
+						REQUIRE(std::string(thread->get_tag(2)) == "second_knot_tag_start");
+						REQUIRE(std::string(thread->get_tag(3)) == "output_tag_h");
+
+						REQUIRE_FALSE(itr[0].has_tags());
+						REQUIRE(itr[0].num_tags() == 0);
+						REQUIRE(itr[1].has_tags());
+
+						REQUIRE(itr[1].num_tags() == 2);
+						REQUIRE(std::string(itr[1].get_tag(0)) == "choice_tag_b");
+						REQUIRE(std::string(itr[1].get_tag(1)) == "choice_tag_b_2");
+					}
+					WHEN("choose divert")
+					{
+						thread->choose(1);
+						THEN("choosing won't add tags!")
+						{
+							REQUIRE_FALSE(thread->has_tags());
+							REQUIRE(thread->num_tags() == 0);
+						}
+						WHEN("proceed")
+						{
+							std::string line = thread->getall();
+							THEN("new knot tag and now line tag, also choice tag. AND dont print tag in choice")
+							{
+								REQUIRE(line == "Knot2\n");
+								REQUIRE(thread->has_tags());
+								REQUIRE(thread->num_tags() == 2);
+								REQUIRE(std::string(thread->get_tag(0)) == "knot_tag_2");
+								REQUIRE(std::string(thread->get_tag(1)) == "output_tag_k");
+
+								auto itr = thread->begin();
+								REQUIRE(std::string(itr[0].text()) == "e");
+								REQUIRE(std::string(itr[1].text()) == "f with detail");
+								REQUIRE(std::string(itr[2].text()) == "g");
+
+								REQUIRE_FALSE(itr[0].has_tags());
+								REQUIRE(itr[0].num_tags() == 0);
+								REQUIRE(itr[1].has_tags());
+								REQUIRE(itr[1].num_tags() == 4);
+								REQUIRE(std::string(itr[1].get_tag(0)) == "shared_tag");
+								REQUIRE(std::string(itr[1].get_tag(1)) == "shared_tag_2");
+								REQUIRE(std::string(itr[1].get_tag(2)) == "choice_tag");
+								REQUIRE(std::string(itr[1].get_tag(3)) == "choice_tag_2");
+								REQUIRE(itr[2].has_tags());
+								REQUIRE(itr[2].num_tags() == 1);
+							}
+							WHEN("choose choice with tag, and proceed to end")
+							{
+								thread->choose(1);
+								auto line = thread->getall();
+
+								REQUIRE(line == "f and content\nout");
+								REQUIRE(thread->has_tags());
+								REQUIRE(thread->num_tags() == 5);
+								REQUIRE(std::string(thread->get_tag(0)) == "shared_tag");
+								REQUIRE(std::string(thread->get_tag(1)) == "shared_tag_2");
+								REQUIRE(std::string(thread->get_tag(2)) == "content_tag");
+								REQUIRE(std::string(thread->get_tag(3)) == "content_tag_2");
+								REQUIRE(std::string(thread->get_tag(4)) == "close_tag");
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,38 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <globals.h>
+#include <runner.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+SCENARIO(
+    "a story with a bracketed choice as a second choice, and then a third choice, chooses properly",
+    "[choices]"
+)
+{
+	GIVEN("a story with brackets and nested choices")
+	{
+		auto   ink    = story::from_file(INK_TEST_RESOURCE_DIR "ThirdTierChoiceAfterBracketsStory.bin");
+		runner thread = ink->new_runner();
+
+		WHEN("start thread")
+		{
+			THEN("thread doesn't error")
+			{
+				thread->getall();
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				thread->getall();
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				thread->getall();
+				REQUIRE(thread->has_choices());
+				thread->choose(0);
+				thread->getall();
+				REQUIRE(! thread->has_choices());
+			}
+		}
+	}
+}

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

@@ -0,0 +1,56 @@
+#include "catch.hpp"
+
+#include <story.h>
+#include <runner.h>
+#include <compiler.h>
+
+#include <sstream>
+#include <fstream>
+
+using namespace ink::runtime;
+
+SCENARIO("a story supports UTF-8", "[utf-8]")
+{
+	GIVEN("a story with UTF8 characters")
+	{
+		ink::compiler::run(INK_TEST_RESOURCE_DIR "UTF8Story.ink.json", "UTF8Story.bin");
+		auto ink = story::from_file("UTF8Story.bin");
+		runner thread = ink->new_runner();
+
+		std::ifstream demoFile("ink/UTF-8-demo.txt");
+		if (!demoFile.is_open()) {
+			throw std::runtime_error("cannot open UTF-8 demo file");
+		}
+
+		char byte;
+		std::stringstream demo;
+		std::stringstream current;
+		while (demoFile.get(byte)) {
+			if (byte == '\r') continue; // skip windows carriage-return newlines
+			else if (byte == '\n' || byte == 0) { // newline or null byte
+				std::string s = current.str();
+				if (s.empty()) continue;
+				demo << s << '\n';
+				current.str("");
+			}
+			else { // normal char
+				current << byte;
+			}
+		}
+		std::string s = current.str();
+		if (!s.empty()) demo << s << '\n';
+		
+
+		WHEN("consume lines") {
+			std::stringstream content;
+			while (thread->can_continue()) {
+				content << thread->getline();
+			}
+			THEN("lines match test file") {
+				std::string c = content.str();
+				std::string d = demo.str();
+				REQUIRE(c == d);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,210 @@
+#include "catch.hpp"
+
+#include <compiler.h>
+#include <story.h>
+
+#include "../inkcpp/string_table.h"
+#include "../inkcpp/list_table.h"
+#include "../inkcpp/random.h"
+#include "../inkcpp/output.h"
+#include "../inkcpp/executioner.h"
+#include "../shared/private/command.h"
+
+#include "../inkcpp/story_impl.h"
+#include "../inkcpp/runner_impl.h"
+#include "../inkcpp/globals_impl.h"
+
+using ink::runtime::internal::value;
+using ink::runtime::internal::value_type;
+using ink::runtime::internal::string_table;
+using ink::runtime::internal::list_table;
+using ink::runtime::internal::prng;
+using stream = ink::runtime::internal::stream<128>;
+using ink::runtime::internal::executer;
+using eval_stack = ink::runtime::internal::eval_stack<28, false>;
+using ink::Command;
+
+using ink::runtime::internal::story_impl;
+using ink::runtime::internal::globals_impl;
+using ink::runtime::globals;
+using ink::runtime::runner;
+
+void cp_str(char* dst, const char* src) {
+	while(*src) { *dst++ = *src++; }
+	*dst = 0;
+}
+
+SCENARIO("compare concatenated values")
+{
+	string_table str_table;
+	list_table lst_table{};
+	prng rng;
+	eval_stack stack;
+	story_impl    story(INK_TEST_RESOURCE_DIR "ListStory.bin");
+	globals globs_ptr = story.new_globals();
+	runner run = story.new_runner(globs_ptr);
+	globals_impl& globs = *globs_ptr.cast<globals_impl>();
+	executer ops(rng, story, globs, globs.strings(), globs.lists(), *run);
+		
+	GIVEN("just single strings")
+	{
+		const char str_1[] = "Hello World!";
+		const char str_1_again[] = "Hello World!";
+		const char str_2[] = "Bye World!";
+		WHEN("equal")
+		{
+			stack.push(value{}.set<value_type::string>(str_1));
+			stack.push(value{}.set<value_type::string>(str_1_again));
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== results in true")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == true);
+			}
+		}
+		WHEN("not equal")
+		{
+			stack.push(value{}.set<value_type::string>(str_1));
+			stack.push(value{}.set<value_type::string>(str_2));
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== results in false")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == false);
+			}
+		}
+	}
+	GIVEN("string and numbers")
+	{
+		stream out{};
+		char* str_hello = str_table.create(6);
+		cp_str(str_hello, "hello");
+		char* str_5hello = str_table.create(7);
+		cp_str(str_5hello, "5hello");
+		char* str_4 = str_table.create(2);
+		cp_str(str_4, "4");
+		char* str_32_4 = str_table.create(33);
+		for (int i = 0; i < 32; ++i) { str_32_4[i] = '4'; }
+		str_32_4[32] = 0;
+
+		int int_4 = 4;
+		int int_45 = 45;
+		WHEN("concatenated string representation matches (2 fields)")
+		{
+			stack.push(value{}.set<value_type::int32>(int_4));
+			stack.push(value{}.set<value_type::string>(str_5hello));
+			ops(Command::ADD, stack);
+			stack.push(value{}.set<value_type::int32>(int_45));
+			stack.push(value{}.set<value_type::string>(str_hello));
+			ops(Command::ADD, stack);
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== returns true")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == true);
+			}
+		}
+		WHEN("concatenated string representation match (many fields)")
+		{
+			stack.push(value{}.set<value_type::string>(str_4));
+			for (int i = 0; i < 31; ++i) {
+				stack.push(value{}.set<value_type::int32>(int_4));
+				ops(Command::ADD, stack);
+			}
+			stack.push(value{}.set<value_type::string>(str_32_4));
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== results true")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == true);
+			}
+		}
+		WHEN("concatenated string representation won't match")
+		{
+			stack.push(value{}.set<value_type::int32>(int_45));
+			stack.push(value{}.set<value_type::string>(str_5hello));
+			ops(Command::ADD, stack);
+			stack.push(value{}.set<value_type::int32>(int_4));
+			stack.push(value{}.set<value_type::string>(str_hello));
+			ops(Command::ADD, stack);
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== returns false")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == false);
+			}
+		}
+	}
+	GIVEN("numbers")
+	{
+		int i5 = 5;
+		int i8 = 8;
+		float f5 = 5.f;
+		WHEN("numbers are same")
+		{
+			stack.push(value{}.set<value_type::int32>(i8));
+			stack.push(value{}.set<value_type::int32>(i8));
+			ops(Command::IS_EQUAL, stack);
+			value res1 = stack.pop();
+			stack.push(value{}.set<value_type::float32>(f5));
+			stack.push(value{}.set<value_type::float32>(f5));
+			ops(Command::IS_EQUAL, stack);
+			value res2 = stack.pop();
+			THEN("== returns true")
+			{
+				REQUIRE(res1.type() == value_type::boolean);
+				REQUIRE(res1.get<value_type::boolean>() == true);
+				REQUIRE(res2.type() == value_type::boolean);
+				REQUIRE(res2.get<value_type::boolean>() == true);
+			}
+		}
+		WHEN("numbers equal, but different encoding")
+		{
+			stack.push(value{}.set<value_type::int32>(i5));
+			stack.push(value{}.set<value_type::float32>(f5));
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== returns true")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == true);
+			}
+		}
+		WHEN("numbers value and encoding differs")
+		{
+			stack.push(value{}.set<value_type::float32>(f5));
+			stack.push(value{}.set<value_type::int32>(i8));
+			ops(Command::IS_EQUAL, stack);
+			value res = stack.pop();
+			THEN("== returns false")
+			{
+				REQUIRE(res.type() == value_type::boolean);
+				REQUIRE(res.get<value_type::boolean>() == false);
+			}
+		}
+		WHEN("calculate with float and int (5.,8)")
+		{
+			stack.push(value{}.set<value_type::float32>(f5));
+			stack.push(value{}.set<value_type::int32>(i8));
+			THEN("adding results 13.")
+			{
+				ops(Command::ADD, stack);
+				value res = stack.pop();
+				REQUIRE(res.type() == value_type::float32);
+				REQUIRE(res.get<value_type::float32>() == 13.f);
+			}
+			THEN("dividing results in 0.625")
+			{
+				ops(Command::DIVIDE, stack);
+				value res = stack.pop();
+				REQUIRE(res.type() == value_type::float32);
+				REQUIRE(res.get<value_type::float32>() == 0.625f);
+			}
+		}
+	}
+}