internal/cpe: add token.go, part.go, and tests

1 files changed, 0 insertions, 144 deletions

diff --git a/internal/cpe/cpe_test.go b/internal/cpe/cpe_test.go
index e842c75..0f121b6 100644
--- a/internal/cpe/cpe_test.go
+++ b/internal/cpe/cpe_test.go
@@ -1,145 +1 @@
 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",
-  }}
-
-  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)
-      }
-    })
-  }
-}