From e3a6bc8502a0366aee9040e938789a6016e2fa4a Mon Sep 17 00:00:00 2001
From: Paul Duncan <pabs@pablotron.org>
Date: Wed, 2 Feb 2022 21:45:23 -0500
Subject: internal/cpe: add token.go, part.go, and tests

---
 internal/cpe/token_test.go | 149 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 149 insertions(+)
 create mode 100644 internal/cpe/token_test.go

(limited to 'internal/cpe/token_test.go')

diff --git a/internal/cpe/token_test.go b/internal/cpe/token_test.go
new file mode 100644
index 0000000..595df2c
--- /dev/null
+++ b/internal/cpe/token_test.go
@@ -0,0 +1,149 @@
+package cpe
+
+import (
+  "reflect"
+  "testing"
+)
+
+func TestTokenTypeString(t *testing.T) {
+  tests := []struct {
+    val tokenType
+    exp string
+  } {
+    { anyToken, "any" },
+    { naToken, "na" },
+    { valToken, "val" },
+    { tokenType(255), "tokenType(255)" },
+  }
+
+  for _, test := range(tests) {
+    t.Run(test.exp, func(t *testing.T) {
+      got := test.val.String()
+      if got != test.exp {
+        t.Errorf("got \"%s\", exp \"%s\"", got, test.exp)
+      }
+    })
+  }
+}
+
+func TestNewToken(t *testing.T) {
+  passTests := []struct {
+    name string
+    val string
+    exp token
+  } {
+    { "any", "*", token { Type: anyToken } },
+    { "na", "-", token { Type: naToken } },
+    { "empty", "", token { Type: valToken } },
+    { "foo", "foo", token { Type: valToken, Val: "foo" } },
+  }
+
+  for _, test := range(passTests) {
+    t.Run(test.name, func(t *testing.T) {
+      got := newToken([]byte(test.val))
+      if got.Type != test.exp.Type {
+        t.Errorf("token: got %s, exp %s", got.Type, test.exp.Type)
+      } else if got.Type == valToken && got.Val != test.exp.Val {
+        t.Errorf("value: got \"%s\", exp \"%s\"", got.Val, test.exp.Val)
+      }
+    })
+  }
+}
+
+func TestTokenize(t *testing.T) {
+  passTests := []struct {
+    val string
+    exp []token
+  } {{
+    val: "foo",
+    exp: []token { token { Type: valToken, Val: "foo" } },
+  }, {
+    val: "foo:bar",
+    exp: []token {
+      token { Type: valToken, Val: "foo" },
+      token { Type: valToken, Val: "bar" },
+    },
+  }, {
+    val: "*",
+    exp: []token { token { Type: anyToken } },
+  }, {
+    val: "-",
+    exp: []token { token { Type: naToken } },
+  }, {
+    val: "*:bar",
+    exp: []token {
+      token { Type: anyToken },
+      token { Type: valToken, Val: "bar" },
+    },
+  }, {
+    val: "foo:*",
+    exp: []token {
+      token { Type: valToken, Val: "foo" },
+      token { Type: anyToken },
+    },
+  }, {
+    val: "-:bar",
+    exp: []token {
+      token { Type: naToken },
+      token { Type: valToken, Val: "bar" },
+    },
+  }, {
+    val: "foo:-",
+    exp: []token {
+      token { Type: valToken, Val: "foo" },
+      token { Type: naToken },
+    },
+  }, {
+    val: "foo\\*:-",
+    exp: []token {
+      token { Type: valToken, Val: "foo*" },
+      token { Type: naToken },
+    },
+  }}
+
+  for _, test := range(passTests) {
+    t.Run(test.val, func(t *testing.T) {
+      // tokenize, check for error
+      got, err := tokenize([]byte(test.val))
+      if err != nil {
+        t.Error(err)
+        return
+      }
+
+      if !reflect.DeepEqual(got, test.exp) {
+        t.Errorf("token: got %v, exp %v", got, test.exp)
+        return
+      }
+    })
+  }
+
+  failTests := []struct {
+    id  string
+    val string
+    exp string
+  } {{
+    id:  "invalid escape",
+    val: "foo\\.",
+    exp: "invalid escape byte: 0x2e",
+  }, {
+    id:  "invalid byte",
+    val: "\n",
+    exp: "invalid byte: 0x0a",
+  }, {
+    id:  "unterminated escape",
+    val: "\\",
+    exp: "unterminated escape at end of buffer",
+  }}
+
+  for _, test := range(failTests) {
+    t.Run(test.id, func(t *testing.T) {
+      // tokenize, check for error
+      got, err := tokenize([]byte(test.val))
+      if err == nil {
+        t.Errorf("got %v, exp error", got)
+      } else if err.Error() != test.exp {
+        t.Errorf("got \"%s\", exp \"%s\"", err.Error(), test.exp)
+      }
+    })
+  }
+}
-- 
cgit v1.2.3