From 4e2a98bf8cb37385823c63b99db8ef910a5d140f Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Tue, 20 May 2025 13:35:03 -0600
Subject: [PATCH] Add unit test and fix

---
 README.md     |  4 +++
 template.odin | 19 ++++++----
 testing.odin  | 99 +++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 116 insertions(+), 6 deletions(-)
 create mode 100644 testing.odin

diff --git a/README.md b/README.md
index 93d7efc..9766355 100644
--- a/README.md
+++ b/README.md
@@ -27,8 +27,11 @@ main :: proc() {
         "name":  "Alice",
         "place": "Odinland",
     }
+    defer delete(values)
 
     result := template.template(fmt, values)
+    defer delete(result)
+
     fmt.println(result) // Output: Hello, Alice! Welcome to Odinland.
 }
 ```
@@ -71,3 +74,4 @@ Keys must exactly match the strings in the dictionary.
 ## Contributing
 
 Contributions are welcome! Feel free to submit issues or pull requests.
+For every issue please add a test
diff --git a/template.odin b/template.odin
index 6fbb49f..4586456 100644
--- a/template.odin
+++ b/template.odin
@@ -28,22 +28,24 @@ template :: proc(fmt: string, dict: map[string]string ) -> string {
 		case .open_bracket:
 			s=.reading_key
 		case .close_bracket:
-			strings.write_rune(&b, '}' )
+			strings.write_string(&b, "}{" )
 			s=.writing
 		case .writing:
 			s=.open_bracket
 		case .reading_key:
+			strings.write_rune(&key, '{' )
 		}
 	case '}':
 		switch s {
 		case .open_bracket:
-			strings.write_rune(&b, '{' )
-			s=.close_bracket
-		case .close_bracket:
+			strings.write_string(&b, "{}" )
 			s=.writing
+		case .close_bracket:
 			strings.write_string(&b, dict[strings.to_string(key)] )
 			strings.builder_reset(&key)
+			s=.writing
 		case .writing:
+			strings.write_rune(&b, '}' )
 		case .reading_key:
 			s=.close_bracket
 		}
@@ -52,9 +54,11 @@ template :: proc(fmt: string, dict: map[string]string ) -> string {
 		case .open_bracket:
 			strings.write_rune(&b, '{' )
 			strings.write_rune(&b, c )
+			s=.writing
 		case .close_bracket:
-			strings.write_rune(&b, '}' )
-			strings.write_rune(&b, c )
+			strings.write_rune(&key, '}' )
+			strings.write_rune(&key, c )
+			s=.reading_key
 		case .writing:
 			strings.write_rune(&b, c )
 		case .reading_key:
@@ -66,9 +70,12 @@ template :: proc(fmt: string, dict: map[string]string ) -> string {
 	case .open_bracket:
 		strings.write_rune(&b, '{' )
 	case .close_bracket:
+		strings.write_string(&b,"{{")
+		strings.write_string(&b,strings.to_string(key))
 		strings.write_rune(&b, '}' )
 	case .writing:
 	case .reading_key:
+		strings.write_string(&b,"{{")
 		strings.write_string(&b,strings.to_string(key))
 	}
 
diff --git a/testing.odin b/testing.odin
new file mode 100644
index 0000000..713e05a
--- /dev/null
+++ b/testing.odin
@@ -0,0 +1,99 @@
+package template
+
+import "core:testing"
+
+@(test)
+test1 :: proc(t: ^testing.T){
+	fmt := "{"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==fmt, tmp)
+}
+@(test)
+test2 :: proc(t: ^testing.T){
+	fmt := "}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==fmt, tmp)
+}
+@(test)
+test3 :: proc(t: ^testing.T){
+	fmt := "{{"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==fmt, tmp)
+}
+@(test)
+test4 :: proc(t: ^testing.T){
+	fmt := "{{}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==fmt, tmp)
+}
+@(test)
+test5 :: proc(t: ^testing.T){
+	fmt := "{{}}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="", tmp)
+}
+@(test)
+test6 :: proc(t: ^testing.T){
+	fmt := "{{foo}}"
+
+	dict := map[string]string{"foo"="var"}
+	defer delete(dict)
+
+	tmp := template(fmt, dict)
+	defer delete(tmp)
+	testing.expect(t, tmp=="var", tmp)
+}
+@(test)
+test7 :: proc(t: ^testing.T){
+	fmt := "{{{}}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="", tmp)
+}
+@(test)
+test8 :: proc(t: ^testing.T){
+	fmt := "{{}}}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="}", tmp)
+}
+@(test)
+test9 :: proc(t: ^testing.T){
+	fmt := "{{{}}}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="}", tmp)
+}
+@(test)
+test10 :: proc(t: ^testing.T){
+	fmt := "{{} }}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="", tmp)
+}
+@(test)
+test11 :: proc(t: ^testing.T){
+	fmt := "{{{} }}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp=="", tmp)
+}
+@(test)
+test12 :: proc(t: ^testing.T){
+	fmt := " {{{} }}"
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==" ", tmp)
+}
+@(test)
+test13 :: proc(t: ^testing.T){
+	fmt := "{{{} }} "
+	tmp := template(fmt,{})
+	defer delete(tmp)
+	testing.expect(t, tmp==" ", tmp)
+}