Lexer: Added ::typeName and ::typeToString for testing

src/Lexer.cpp

@@ -58,6 +58,19 @@ bool Lexer::token (std::string& token, Lexer::Type& type)
   return false;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// No L10N - these are for internal purposes.
+const std::string Lexer::typeName (const Lexer::Type& type)
+{
+  switch (type)
+  {
+  case Lexer::Type::string:       return "string";
+  case Lexer::Type::word:         return "word";
+  }
+
+  return "unknown";
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Complete Unicode whitespace list.
 //
@@ -244,6 +257,15 @@ bool Lexer::isWord (std::string& token, Lexer::Type& type)
   return false;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Static
+std::string Lexer::typeToString (Lexer::Type type)
+{
+       if (type == Lexer::Type::string)       return std::string ("\033[38;5;7m\033[48;5;3m")    + "string"       + "\033[0m";
+  else if (type == Lexer::Type::word)         return std::string ("\033[38;5;15m\033[48;5;236m") + "word"         + "\033[0m";
+  else                                        return std::string ("\033[37;41m")                 + "unknown"      + "\033[0m";
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Full implementation of a quoted word.  Includes:
 //   '\''

src/Lexer.h

@@ -40,8 +40,10 @@ public:
 
   Lexer (const std::string&);
   bool token (std::string&, Lexer::Type&);
+  static std::string typeToString (Lexer::Type);
 
   // Static helpers.
+  static const std::string typeName          (const Lexer::Type&);
   static bool isWhitespace                   (int);
   static bool isHexDigit                     (int);
   static bool isSingleCharOperator           (int);

test/lexer.t.cpp

@@ -34,7 +34,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 int main (int, char**)
 {
-  UnitTest t (74);
+  UnitTest t (82);
 
   std::vector <std::pair <std::string, Lexer::Type>> tokens;
   std::string token;
@@ -126,6 +126,57 @@ int main (int, char**)
   t.ok (Lexer::readWord (text, cursor, word),               "readWord \"one     \" --> true");
   t.is (word, "one",                                        "  word '" + word + "'");
 
+  // Test all Lexer types.
+  #define NO {"",Lexer::Type::word}
+  struct
+  {
+    const char* input;
+    struct
+    {
+      const char* token;
+      Lexer::Type type;
+    } results[5];
+  } lexerTests[] =
+  {
+    // Word
+    { "1.foo.bar",                                    { { "1.foo.bar",                                    Lexer::Type::word         }, NO, NO, NO, NO }, },
+  };
+  #define NUM_TESTS (sizeof (lexerTests) / sizeof (lexerTests[0]))
+
+  for (unsigned int i = 0; i < NUM_TESTS; i++)
+  {
+    // The isolated test puts the input string directly into the Lexer.
+    Lexer isolated (lexerTests[i].input);
+
+    for (int j = 0; j < 5; j++)
+    {
+      if (lexerTests[i].results[j].token[0])
+      {
+        // Isolated: "<token>"
+        t.ok (isolated.token (token, type),                  "Isolated Lexer::token(...) --> true");
+        t.is (token, lexerTests[i].results[j].token,         "  token --> " + token);
+        t.is ((int)type, (int)lexerTests[i].results[j].type, "  type --> Lexer::Type::" + Lexer::typeToString (type));
+      }
+    }
+
+    // The embedded test surrounds the input string with a space.
+    Lexer embedded (std::string (" ") + lexerTests[i].input + " ");
+
+    for (int j = 0; j < 5; j++)
+    {
+      if (lexerTests[i].results[j].token[0])
+      {
+        // Embedded: "<token>"
+        t.ok (embedded.token (token, type),                  "Embedded Lexer::token(...) --> true");
+        t.is (token, lexerTests[i].results[j].token,         "  token --> " + token);
+        t.is ((int)type, (int)lexerTests[i].results[j].type, "  type --> Lexer::Type::" + Lexer::typeToString (type));
+      }
+    }
+  }
+
+  t.is (Lexer::typeName (Lexer::Type::string),       "string",       "Lexer::typeName (Lexer::Type::string)");
+  t.is (Lexer::typeName (Lexer::Type::word),         "word",         "Lexer::typeName (Lexer::Type::word)");
+
   // std::string Lexer::trimLeft (const std::string& in, const std::string&)
   t.is (Lexer::trimLeft (""),                     "",            "Lexer::trimLeft '' -> ''");
   t.is (Lexer::trimLeft ("   "),                  "",            "Lexer::trimLeft '   ' -> ''");