From 6629859d637a38e41df3c33c27f45fabc4b3b7a0 Mon Sep 17 00:00:00 2001
From: kiyoshika <zachlweaver00@gmail.com>
Date: Sun, 3 Dec 2023 13:36:58 -0500
Subject: [PATCH] rename render_tree to rendertree in C API

---
 crates/gosub-bindings/Makefile                |   4 +-
 crates/gosub-bindings/include/gosub_api.h     |  22 ++--
 crates/gosub-bindings/include/nodes.h         |  30 ++---
 crates/gosub-bindings/include/nodes/text.h    |  10 +-
 crates/gosub-bindings/src/gosub_api.c         |  54 ++++----
 crates/gosub-bindings/src/lib.rs              |  38 +++---
 crates/gosub-bindings/src/nodes.c             |  28 ++--
 crates/gosub-bindings/src/nodes/text.c        |  10 +-
 crates/gosub-bindings/src/wrapper.rs          |   2 +-
 crates/gosub-bindings/src/wrapper/text.rs     |   2 +-
 .../gosub-bindings/tests/render_tree_test.c   | 121 ------------------
 crates/gosub-bindings/tests/rendertree_test.c | 121 ++++++++++++++++++
 12 files changed, 221 insertions(+), 221 deletions(-)
 delete mode 100644 crates/gosub-bindings/tests/render_tree_test.c
 create mode 100644 crates/gosub-bindings/tests/rendertree_test.c

diff --git a/crates/gosub-bindings/Makefile b/crates/gosub-bindings/Makefile
index d6deff0ef..796c1fe1b 100644
--- a/crates/gosub-bindings/Makefile
+++ b/crates/gosub-bindings/Makefile
@@ -47,8 +47,8 @@ endif
 
 TEST_SRC_DIR := tests
 test: # build and run tests for bindings
-	$(CC) $(TEST_SRC_DIR)/render_tree_test.c -L./ -lgosub $(LDFLAGS) -lgosub_bindings -lsqlite3 -lm -o $(TEST_SRC_DIR)/render_tree_test $(CPPFLAGS) $(CFLAGS)
-	./$(TEST_SRC_DIR)/render_tree_test
+	$(CC) $(TEST_SRC_DIR)/rendertree_test.c -L./ -lgosub $(LDFLAGS) -lgosub_bindings -lsqlite3 -lm -o $(TEST_SRC_DIR)/rendertree_test $(CPPFLAGS) $(CFLAGS)
+	./$(TEST_SRC_DIR)/rendertree_test
 
 format:
 	cargo clippy --fix --allow-dirty --allow-staged
diff --git a/crates/gosub-bindings/include/gosub_api.h b/crates/gosub-bindings/include/gosub_api.h
index 03b6db1e8..c0a7389ab 100644
--- a/crates/gosub-bindings/include/gosub_api.h
+++ b/crates/gosub-bindings/include/gosub_api.h
@@ -3,15 +3,15 @@
 
 #include "nodes.h"
 
-extern void *gosub_render_tree_init(const char *html);
-extern void *gosub_render_tree_iterator_init(void *render_tree);
-extern const void *gosub_render_tree_next_node(void *tree_iterator);
-extern void gosub_render_tree_get_node_data(const void *current_node,
+extern void *gosub_rendertree_init(const char *html);
+extern void *gosub_rendertree_iterator_init(void *rendertree);
+extern const void *gosub_rendertree_next_node(void *tree_iterator);
+extern void gosub_rendertree_get_node_data(const void *current_node,
                                             struct node_t *node);
-extern void gosub_render_tree_iterator_free(void *tree_iterator);
-extern void gosub_render_tree_free(void *render_free);
+extern void gosub_rendertree_iterator_free(void *tree_iterator);
+extern void gosub_rendertree_free(void *render_free);
 
-struct render_tree_t {
+struct rendertree_t {
   void *tree;
   void *iterator;
   const void *current_node;
@@ -21,17 +21,17 @@ struct render_tree_t {
 /// Initialize a render tree by passing a stack-allocated
 /// struct by address.
 /// Returns 0 on success or -1 if a failure occurred.
-int8_t render_tree_init(struct render_tree_t *render_tree, const char *html);
+int8_t rendertree_init(struct rendertree_t *rendertree, const char *html);
 
 /// Get the next node in the render tree as a read-only pointer.
 /// Returns NULL when reaching end of tree.
-const struct node_t *render_tree_next(struct render_tree_t *render_tree);
+const struct node_t *rendertree_next(struct rendertree_t *rendertree);
 
 /// Get the type of the current node the render tree is pointing to.
 enum node_type_e
-render_tree_get_current_node_type(const struct render_tree_t *render_tree);
+rendertree_get_current_node_type(const struct rendertree_t *rendertree);
 
 /// Free all memory tied to the render tree
-void render_tree_free(struct render_tree_t *render_tree);
+void rendertree_free(struct rendertree_t *rendertree);
 
 #endif
diff --git a/crates/gosub-bindings/include/nodes.h b/crates/gosub-bindings/include/nodes.h
index facbecb4b..d4c55c369 100644
--- a/crates/gosub-bindings/include/nodes.h
+++ b/crates/gosub-bindings/include/nodes.h
@@ -9,8 +9,8 @@
 #include "nodes/text.h"
 #include "properties.h"
 
-struct node_t *render_tree_node_init();
-void render_tree_node_free(struct node_t **node);
+struct node_t *rendertree_node_init();
+void rendertree_node_free(struct node_t **node);
 
 enum node_type_e { NODE_TYPE_ROOT = 0u, NODE_TYPE_TEXT };
 
@@ -25,18 +25,18 @@ struct node_t {
   } data;
 };
 
-struct node_t *render_tree_node_init();
-double render_tree_node_get_x(const struct node_t *node);
-double render_tree_node_get_y(const struct node_t *node);
-double render_tree_node_get_margin_top(const struct node_t *node);
-double render_tree_node_get_margin_left(const struct node_t *node);
-double render_tree_node_get_margin_right(const struct node_t *node);
-double render_tree_node_get_margin_bottom(const struct node_t *node);
-double render_tree_node_get_padding_top(const struct node_t *node);
-double render_tree_node_get_padding_left(const struct node_t *node);
-double render_tree_node_get_padding_right(const struct node_t *node);
-double render_tree_node_get_padding_bottom(const struct node_t *node);
-void render_tree_node_free_data(struct node_t *node);
-void render_tree_node_free(struct node_t **node);
+struct node_t *rendertree_node_init();
+double rendertree_node_get_x(const struct node_t *node);
+double rendertree_node_get_y(const struct node_t *node);
+double rendertree_node_get_margin_top(const struct node_t *node);
+double rendertree_node_get_margin_left(const struct node_t *node);
+double rendertree_node_get_margin_right(const struct node_t *node);
+double rendertree_node_get_margin_bottom(const struct node_t *node);
+double rendertree_node_get_padding_top(const struct node_t *node);
+double rendertree_node_get_padding_left(const struct node_t *node);
+double rendertree_node_get_padding_right(const struct node_t *node);
+double rendertree_node_get_padding_bottom(const struct node_t *node);
+void rendertree_node_free_data(struct node_t *node);
+void rendertree_node_free(struct node_t **node);
 
 #endif
diff --git a/crates/gosub-bindings/include/nodes/text.h b/crates/gosub-bindings/include/nodes/text.h
index 604049309..9873a0193 100644
--- a/crates/gosub-bindings/include/nodes/text.h
+++ b/crates/gosub-bindings/include/nodes/text.h
@@ -15,11 +15,11 @@ struct node_text_t {
   bool is_bold;
 };
 
-void render_tree_node_text_free_data(struct node_text_t *text);
+void rendertree_node_text_free_data(struct node_text_t *text);
 
-const char *render_tree_node_text_get_value(const struct node_t *node);
-const char *render_tree_node_text_get_font(const struct node_t *node);
-double render_tree_node_text_get_font_size(const struct node_t *node);
-bool render_tree_node_text_get_bold(const struct node_t *node);
+const char *rendertree_node_text_get_value(const struct node_t *node);
+const char *rendertree_node_text_get_font(const struct node_t *node);
+double rendertree_node_text_get_font_size(const struct node_t *node);
+bool rendertree_node_text_get_bold(const struct node_t *node);
 
 #endif
diff --git a/crates/gosub-bindings/src/gosub_api.c b/crates/gosub-bindings/src/gosub_api.c
index b4ae7fb08..005a9c1e5 100644
--- a/crates/gosub-bindings/src/gosub_api.c
+++ b/crates/gosub-bindings/src/gosub_api.c
@@ -1,50 +1,50 @@
 #include "gosub_api.h"
 
-int8_t render_tree_init(struct render_tree_t *render_tree, const char *html) {
+int8_t rendertree_init(struct rendertree_t *rendertree, const char *html) {
 
-  render_tree->tree = gosub_render_tree_init(html);
-  if (!render_tree->tree) {
+  rendertree->tree = gosub_rendertree_init(html);
+  if (!rendertree->tree) {
     return -1;
   }
 
-  render_tree->iterator = gosub_render_tree_iterator_init(render_tree->tree);
-  if (!render_tree->iterator) {
-    gosub_render_tree_free(render_tree->tree);
+  rendertree->iterator = gosub_rendertree_iterator_init(rendertree->tree);
+  if (!rendertree->iterator) {
+    gosub_rendertree_free(rendertree->tree);
     return -1;
   }
 
-  render_tree->current_node = NULL;
+  rendertree->current_node = NULL;
 
-  render_tree->data = render_tree_node_init();
-  if (!render_tree->data) {
-    gosub_render_tree_iterator_free(render_tree->iterator);
-    gosub_render_tree_free(render_tree->tree);
+  rendertree->data = rendertree_node_init();
+  if (!rendertree->data) {
+    gosub_rendertree_iterator_free(rendertree->iterator);
+    gosub_rendertree_free(rendertree->tree);
     return -1;
   }
 
   return 0;
 }
 
-const struct node_t *render_tree_next(struct render_tree_t *render_tree) {
-  render_tree_node_free_data(render_tree->data);
-  render_tree->current_node =
-      gosub_render_tree_next_node(render_tree->iterator);
-  if (!render_tree->current_node)
+const struct node_t *rendertree_next(struct rendertree_t *rendertree) {
+  rendertree_node_free_data(rendertree->data);
+  rendertree->current_node =
+      gosub_rendertree_next_node(rendertree->iterator);
+  if (!rendertree->current_node)
     return NULL;
-  gosub_render_tree_get_node_data(render_tree->current_node, render_tree->data);
-  return (const struct node_t *)render_tree->data;
+  gosub_rendertree_get_node_data(rendertree->current_node, rendertree->data);
+  return (const struct node_t *)rendertree->data;
 }
 
 enum node_type_e
-render_tree_get_current_node_type(const struct render_tree_t *render_tree) {
-  return render_tree->data->type;
+rendertree_get_current_node_type(const struct rendertree_t *rendertree) {
+  return rendertree->data->type;
 }
 
-void render_tree_free(struct render_tree_t *render_tree) {
-  gosub_render_tree_iterator_free(render_tree->iterator);
-  render_tree->iterator = NULL;
-  gosub_render_tree_free(render_tree->tree);
-  render_tree->tree = NULL;
-  render_tree_node_free(&render_tree->data);
-  render_tree->data = NULL;
+void rendertree_free(struct rendertree_t *rendertree) {
+  gosub_rendertree_iterator_free(rendertree->iterator);
+  rendertree->iterator = NULL;
+  gosub_rendertree_free(rendertree->tree);
+  rendertree->tree = NULL;
+  rendertree_node_free(&rendertree->data);
+  rendertree->data = NULL;
 }
diff --git a/crates/gosub-bindings/src/lib.rs b/crates/gosub-bindings/src/lib.rs
index ab9bb7d42..cdbafc4d7 100644
--- a/crates/gosub-bindings/src/lib.rs
+++ b/crates/gosub-bindings/src/lib.rs
@@ -23,10 +23,10 @@ use wrapper::node::CNode;
 /// to build a render tree. DO NOT take ownership of this pointer in Rust or the
 /// universe might collapse.
 ///
-/// Moves an owning pointer to the render_tree using Box::into_raw() to the C API.
-/// This pointer MUST be passed to gosub_render_tree_free() after usage for proper cleanup.
+/// Moves an owning pointer to the rendertree using Box::into_raw() to the C API.
+/// This pointer MUST be passed to gosub_rendertree_free() after usage for proper cleanup.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut RenderTree {
+pub unsafe extern "C" fn gosub_rendertree_init(html: *const c_char) -> *mut RenderTree {
     let html_str = unsafe {
         if let Ok(html_str) = CStr::from_ptr(html).to_str() {
             html_str
@@ -42,10 +42,10 @@ pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut Ren
     let parse_result = Html5Parser::parse_document(&mut chars, Document::clone(&doc), None);
 
     if parse_result.is_ok() {
-        let mut render_tree = Box::new(RenderTree::new(&doc));
-        render_tree.build();
+        let mut rendertree = Box::new(RenderTree::new(&doc));
+        rendertree.build();
 
-        Box::into_raw(render_tree)
+        Box::into_raw(rendertree)
     } else {
         ptr::null_mut()
     }
@@ -55,24 +55,24 @@ pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut Ren
 ///
 /// # Safety
 /// Moves an owning pointer to the tree iterator using Box::into_raw() to the C API.
-/// This pointer MUST be passed to gosub_render_tree_iterator_free() after usage for proper cleanup.
+/// This pointer MUST be passed to gosub_rendertree_iterator_free() after usage for proper cleanup.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_iterator_init(
-    render_tree: *const RenderTree,
+pub unsafe extern "C" fn gosub_rendertree_iterator_init(
+    rendertree: *const RenderTree,
 ) -> *mut TreeIterator {
-    let tree_iterator = Box::new(TreeIterator::new(&(*render_tree)));
+    let tree_iterator = Box::new(TreeIterator::new(&(*rendertree)));
     Box::into_raw(tree_iterator)
 }
 
 /// Takes a tree_iterator and returns a non-owning pointer to the next node
 ///
 /// # Safety
-/// Takes a tree_iterator pointer (owned by the C API generated by gosub_render_tree_iterator_init())
+/// Takes a tree_iterator pointer (owned by the C API generated by gosub_rendertree_iterator_init())
 /// and modifies it to point to the next tree-order node in the tree. Any heap-allocated data
 /// on the current node is free'd before pointing to the next node. Returns a ready-only pointer
 /// to the next node.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_next_node(
+pub unsafe extern "C" fn gosub_rendertree_next_node(
     tree_iterator: *mut TreeIterator,
 ) -> *const Node {
     let next = (*tree_iterator).next();
@@ -86,28 +86,28 @@ pub unsafe extern "C" fn gosub_render_tree_next_node(
 /// Fetch the node data according to the NodeType of the current node.
 ///
 /// # Safety
-/// Uses a read-only pointer obtained from gosub_render_tree_next_node()
+/// Uses a read-only pointer obtained from gosub_rendertree_next_node()
 /// and a mutable pointer owned by the C API to write (copy) the contents
 /// of the read-only pointer into the mutable pointer.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_get_node_data(node: *const Node, c_node: *mut CNode) {
+pub unsafe extern "C" fn gosub_rendertree_get_node_data(node: *const Node, c_node: *mut CNode) {
     // Change this to a match when we have more types
     if let NodeType::Text(text_node) = &(*node).node_type {
         *c_node = CNode::new_text(&*node, text_node);
     }
 }
 
-/// Free the iterator pointer obtained from gosub_render_tree_iterator_init()
+/// Free the iterator pointer obtained from gosub_rendertree_iterator_init()
 ///
 /// # Safety
 /// This takes ownership of the pointer from the C API and transfers it to Rust so it can
 /// be deallocated.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_iterator_free(tree_iterator: *mut TreeIterator) {
+pub unsafe extern "C" fn gosub_rendertree_iterator_free(tree_iterator: *mut TreeIterator) {
     let _ = Box::from_raw(tree_iterator);
 }
 
-/// Free the render_tree pointer obtained from gosub_render_tree_init()
+/// Free the rendertree pointer obtained from gosub_rendertree_init()
 ///
 /// # Safety
 /// This takes ownership of the pointer from the C API and transfers it to Rust so it can
@@ -117,6 +117,6 @@ pub unsafe extern "C" fn gosub_render_tree_iterator_free(tree_iterator: *mut Tre
 // check with valgrind) although I cannot figure out how to resolve this memory leak...
 // needs more investigation; I've tried various methods.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_free(render_tree: *mut RenderTree) {
-    let _ = Box::from_raw(render_tree);
+pub unsafe extern "C" fn gosub_rendertree_free(rendertree: *mut RenderTree) {
+    let _ = Box::from_raw(rendertree);
 }
diff --git a/crates/gosub-bindings/src/nodes.c b/crates/gosub-bindings/src/nodes.c
index 084499af7..4e88c52dd 100644
--- a/crates/gosub-bindings/src/nodes.c
+++ b/crates/gosub-bindings/src/nodes.c
@@ -1,6 +1,6 @@
 #include "nodes.h"
 
-struct node_t *render_tree_node_init() {
+struct node_t *rendertree_node_init() {
   struct node_t *node = malloc(sizeof(*node));
   if (!node)
     return NULL;
@@ -11,57 +11,57 @@ struct node_t *render_tree_node_init() {
   return node;
 }
 
-void render_tree_node_free_data(struct node_t *node) {
+void rendertree_node_free_data(struct node_t *node) {
   switch (node->type) {
   case NODE_TYPE_ROOT:
     break;
   case NODE_TYPE_TEXT:
-    render_tree_node_text_free_data(&node->data.text);
+    rendertree_node_text_free_data(&node->data.text);
     break;
   }
 }
 
-double render_tree_node_get_x(const struct node_t *node) {
+double rendertree_node_get_x(const struct node_t *node) {
   return node->position.x;
 }
 
-double render_tree_node_get_y(const struct node_t *node) {
+double rendertree_node_get_y(const struct node_t *node) {
   return node->position.y;
 }
 
-double render_tree_node_get_margin_top(const struct node_t *node) {
+double rendertree_node_get_margin_top(const struct node_t *node) {
   return node->margin.top;
 }
 
-double render_tree_node_get_margin_left(const struct node_t *node) {
+double rendertree_node_get_margin_left(const struct node_t *node) {
   return node->margin.left;
 }
 
-double render_tree_node_get_margin_right(const struct node_t *node) {
+double rendertree_node_get_margin_right(const struct node_t *node) {
   return node->margin.right;
 }
 
-double render_tree_node_get_margin_bottom(const struct node_t *node) {
+double rendertree_node_get_margin_bottom(const struct node_t *node) {
   return node->margin.bottom;
 }
 
-double render_tree_node_get_padding_top(const struct node_t *node) {
+double rendertree_node_get_padding_top(const struct node_t *node) {
   return node->padding.top;
 }
 
-double render_tree_node_get_padding_left(const struct node_t *node) {
+double rendertree_node_get_padding_left(const struct node_t *node) {
   return node->padding.left;
 }
 
-double render_tree_node_get_padding_right(const struct node_t *node) {
+double rendertree_node_get_padding_right(const struct node_t *node) {
   return node->padding.right;
 }
 
-double render_tree_node_get_padding_bottom(const struct node_t *node) {
+double rendertree_node_get_padding_bottom(const struct node_t *node) {
   return node->padding.bottom;
 }
 
-void render_tree_node_free(struct node_t **node) {
+void rendertree_node_free(struct node_t **node) {
   free(*node);
   *node = NULL;
 }
diff --git a/crates/gosub-bindings/src/nodes/text.c b/crates/gosub-bindings/src/nodes/text.c
index e830de9cb..76780ce25 100644
--- a/crates/gosub-bindings/src/nodes/text.c
+++ b/crates/gosub-bindings/src/nodes/text.c
@@ -1,7 +1,7 @@
 #include "text.h"
 #include "nodes.h"
 
-void render_tree_node_text_free_data(struct node_text_t *text) {
+void rendertree_node_text_free_data(struct node_text_t *text) {
   free(text->value);
   text->value = NULL;
 
@@ -9,28 +9,28 @@ void render_tree_node_text_free_data(struct node_text_t *text) {
   text->font = NULL;
 }
 
-const char *render_tree_node_text_get_value(const struct node_t *node) {
+const char *rendertree_node_text_get_value(const struct node_t *node) {
   if (!node)
     return NULL;
 
   return (const char *)node->data.text.value;
 }
 
-const char *render_tree_node_text_get_font(const struct node_t *node) {
+const char *rendertree_node_text_get_font(const struct node_t *node) {
   if (!node)
     return NULL;
 
   return (const char *)node->data.text.font;
 }
 
-double render_tree_node_text_get_font_size(const struct node_t *node) {
+double rendertree_node_text_get_font_size(const struct node_t *node) {
   if (!node)
     return 0.0;
 
   return node->data.text.font_size;
 }
 
-bool render_tree_node_text_get_bold(const struct node_t *node) {
+bool rendertree_node_text_get_bold(const struct node_t *node) {
   if (!node)
     return false;
 
diff --git a/crates/gosub-bindings/src/wrapper.rs b/crates/gosub-bindings/src/wrapper.rs
index 731b1f9a6..705f04f73 100644
--- a/crates/gosub-bindings/src/wrapper.rs
+++ b/crates/gosub-bindings/src/wrapper.rs
@@ -1,7 +1,7 @@
 pub mod node;
 pub mod text;
 
-/// Numerical values that map render_tree::NodeType to C
+/// Numerical values that map rendertree::NodeType to C
 #[repr(C)]
 pub enum CNodeType {
     Root = 0,
diff --git a/crates/gosub-bindings/src/wrapper/text.rs b/crates/gosub-bindings/src/wrapper/text.rs
index 01598fd4e..af4ae0a31 100644
--- a/crates/gosub-bindings/src/wrapper/text.rs
+++ b/crates/gosub-bindings/src/wrapper/text.rs
@@ -2,7 +2,7 @@ use gosub_engine::render_tree::text::TextNode;
 use std::ffi::c_char;
 use std::ffi::CString;
 
-/// This is a C-friendly wrapper around gosub_engine::render_tree::text::TextNode
+/// This is a C-friendly wrapper around gosub_engine::rendertree::text::TextNode
 /// that converts Rust Strings to owned pointers to pass to the C API.
 #[repr(C)]
 pub struct CTextNode {
diff --git a/crates/gosub-bindings/tests/render_tree_test.c b/crates/gosub-bindings/tests/render_tree_test.c
deleted file mode 100644
index 52179fddd..000000000
--- a/crates/gosub-bindings/tests/render_tree_test.c
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "gosub_api.h"
-#include <assert.h>
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-
-int main() {
-  const char *html = "<html>"
-                     "<h1>this is heading 1</h1>"
-                     "<h2>this is heading 2</h2>"
-                     "<h3>this is heading 3</h3>"
-                     "<h4>this is heading 4</h4>"
-                     "<h5>this is heading 5</h5>"
-                     "<h6>this is heading 6</h6>"
-                     "<p>this is a paragraph</p>"
-                     "</html>";
-  struct render_tree_t render_tree;
-  assert(render_tree_init(&render_tree, html) == 0);
-
-  const struct node_t *node = NULL;
-
-  // <html>
-  node = render_tree_next(&render_tree);
-  assert(node->type == NODE_TYPE_ROOT);
-
-  const double tol = 0.00001;
-
-  double y = 0.00;
-
-  // <h1>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 1") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 37.0) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <h2>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 2") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 27.5) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <h3>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 3") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 21.5) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <h4>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 4") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 18.5) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <h5>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 5") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 15.5) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <h6>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is heading 6") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 12.0) < tol);
-  assert(render_tree_node_text_get_bold(node) == true);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-  y += (render_tree_node_text_get_font_size(node) + render_tree_node_get_margin_bottom(node));
-
-  // <p>
-  node = render_tree_next(&render_tree);
-  y += render_tree_node_get_margin_top(node);
-  assert(node->type == NODE_TYPE_TEXT);
-  assert(strcmp(render_tree_node_text_get_value(node), "this is a paragraph") == 0);
-  assert(strcmp(render_tree_node_text_get_font(node), "Times New Roman") == 0);
-  assert(fabs(render_tree_node_text_get_font_size(node) - 18.5) < tol);
-  assert(render_tree_node_text_get_bold(node) == false);
-  assert(fabs(render_tree_node_get_x(node) - 0.00) < tol);
-  assert(fabs(render_tree_node_get_y(node) - y) < tol);
-
-  // end of iterator, last node is free'd
-  node = render_tree_next(&render_tree);
-  assert(node == NULL);
-
-  render_tree_free(&render_tree);
-
-  printf("\033[0;32mrender_tree_test.c: All assertions passed\n\033[0;30m");
-  return 0;
-}
diff --git a/crates/gosub-bindings/tests/rendertree_test.c b/crates/gosub-bindings/tests/rendertree_test.c
new file mode 100644
index 000000000..dd8104214
--- /dev/null
+++ b/crates/gosub-bindings/tests/rendertree_test.c
@@ -0,0 +1,121 @@
+#include "gosub_api.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+int main() {
+  const char *html = "<html>"
+                     "<h1>this is heading 1</h1>"
+                     "<h2>this is heading 2</h2>"
+                     "<h3>this is heading 3</h3>"
+                     "<h4>this is heading 4</h4>"
+                     "<h5>this is heading 5</h5>"
+                     "<h6>this is heading 6</h6>"
+                     "<p>this is a paragraph</p>"
+                     "</html>";
+  struct rendertree_t rendertree;
+  assert(rendertree_init(&rendertree, html) == 0);
+
+  const struct node_t *node = NULL;
+
+  // <html>
+  node = rendertree_next(&rendertree);
+  assert(node->type == NODE_TYPE_ROOT);
+
+  const double tol = 0.00001;
+
+  double y = 0.00;
+
+  // <h1>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 1") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 37.0) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <h2>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 2") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 27.5) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <h3>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 3") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 21.5) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <h4>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 4") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 18.5) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <h5>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 5") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 15.5) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <h6>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is heading 6") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 12.0) < tol);
+  assert(rendertree_node_text_get_bold(node) == true);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+  y += (rendertree_node_text_get_font_size(node) + rendertree_node_get_margin_bottom(node));
+
+  // <p>
+  node = rendertree_next(&rendertree);
+  y += rendertree_node_get_margin_top(node);
+  assert(node->type == NODE_TYPE_TEXT);
+  assert(strcmp(rendertree_node_text_get_value(node), "this is a paragraph") == 0);
+  assert(strcmp(rendertree_node_text_get_font(node), "Times New Roman") == 0);
+  assert(fabs(rendertree_node_text_get_font_size(node) - 18.5) < tol);
+  assert(rendertree_node_text_get_bold(node) == false);
+  assert(fabs(rendertree_node_get_x(node) - 0.00) < tol);
+  assert(fabs(rendertree_node_get_y(node) - y) < tol);
+
+  // end of iterator, last node is free'd
+  node = rendertree_next(&rendertree);
+  assert(node == NULL);
+
+  rendertree_free(&rendertree);
+
+  printf("\033[0;32mrendertree_test.c: All assertions passed\n\033[0;30m");
+  return 0;
+}