livetext 0.9.21 → 0.9.22

data/test/unit/formatline.rb

@@ -4,94 +4,188 @@ require_relative '../../lib/livetext'
 
 class TestingLivetext < MiniTest::Test
 
-# Some (most) methods were generated via...
+  # Some (most) methods were generated via the code
+  # seen in the comment at the bottom of this file...
 
-=begin
-  TestLines = []
-
-  items = []
-  formatting_tests = File.open("test/snapshots/formatting-tests.txt")
-  loop do 
-    4.times { items << formatting_tests.gets.chomp }
-    # Blank line terminates each "stanza"
-    raise "Oops? #{items.inspect}" unless items.last.empty?
-    TestLines << items
-    break if formatting_tests.eof?
+  def test_simple_string
+    parse = FormatLine.new("only testing")
+    tokens = parse.tokenize
+    assert_equal tokens, [[:str, "only testing"]], "Tokens were: #{tokens.inspect}"
+    expected = "only testing"
+    result = parse.evaluate
+    assert_equal expected, result
   end
 
-  STDERR.puts <<~RUBY
-    require 'minitest/autorun'
+  def test_variable_interpolation
+    parse = FormatLine.new("File is $File and user is $User")
+    tokens = parse.tokenize
+    expected_tokens = [[:str, "File is "],
+                       [:var, "File"],
+                       [:str, " and user is "],
+                       [:var, "User"]]
+    assert_equal expected_tokens, tokens
+    result = parse.evaluate
+    expected = "File is [File is undefined] and user is [User is undefined]"
+    assert_equal expected, result
+  end
 
-    require_relative '../lib/livetext'
+  def test_func_expansion
+    parse = FormatLine.new("myfunc() results in $$myfunc apparently.")
+    tokens = parse.tokenize
+    expected_tokens = [[:str, "myfunc() results in "],
+                       [:func, "myfunc"],
+                       [:str, " apparently."]]
+    assert_equal expected_tokens, tokens
+    result = parse.evaluate
+    expected = "myfunc() results in [Error evaluating $$myfunc()] apparently."
+    assert_equal expected, result
+  end
+
+# These tests follow this form:
+#
+#  def test_func_SUFFIX
+#    str = "WHATEVER"
+#    parse = FormatLine.new(str)
+#    tokens_expected = [[], [], ...]
+#    tokens = parse.tokenize
+#    assert_equal tokens_expected, tokens
+#    result = parse.evaluate
+#    regex_expected = /Today is ....-..-../
+#    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+#  end
+
+  def test_func_2
+    str = "Today is $$date"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Today is "], [:func, "date"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+    result = parse.evaluate
+    regex_expected = /Today is ....-..-../
+    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+  end
 
-    # Just another testing class. Chill.
+  def test_var_before_comma
+    str = "User name is $User, and all is well"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "User name is "], [:var, "User"], [:str, ", and all is well"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+    result = parse.evaluate
+    regex_expected = /User name is .*, /
+    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+  end
 
-    class TestingLivetext < MiniTest::Test
-  RUBY
+  def test_var_at_EOS
+    str = "File name is $File"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "File name is "], [:var, "File"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "File name is [File is undefined]"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
 
-  TestLines.each.with_index do |item, num|
-    msg, src, exp, blank = *item
-    # generate tests...
-    name = "test_formatting_#{'%02d' % (num + 1)}"
-    method_source = <<~RUBY
-      def #{name}   # #{msg}
-        msg, src, exp = <<~STUFF.split("\\n")
-        #{msg}
-        #{src}
-        #{exp}
-        STUFF
+  def test_var_starts_string
+    str = "$File is my file name"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:var, "File"], [:str, " is my file name"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "[File is undefined] is my file name"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
 
-        actual = FormatLine.parse!(src)
-        # FIXME could simplify assert logic?
-        if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
-          exp = Regexp.compile(exp[1..-2])   # skip slashes
-          assert_match(exp, actual, msg)
-        else
-          assert_equal(exp, actual, msg)
-        end
-      end
+# Next one is/will be a problem... 
+# I permit periods *inside* variable names
 
-    RUBY
-    STDERR.puts method_source
+  def test_var_before_period
+    str = "This is $File."
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "This is "], [:var, "File"], [:str, "."]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "This is [File is undefined]."
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
   end
-  STDERR.puts "\nend"
-end
-=end
 
-  def test_simple_string
-    parse = FormatLine.new("only testing")
+  def test_func_needing_parameter_colon_eos  # colon, param, EOS
+    str = "Square root of 225 is $$isqrt:225"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Square root of 225 is "], [:func, "isqrt"], [:colon, "225"]]
     tokens = parse.tokenize
-    assert_equal tokens, [[:str, "only testing"]]
-    expected = "only testing"
+    assert_equal tokens_expected, tokens
     result = parse.evaluate
-    assert result == expected
+    string_expected = "Square root of 225 is 15"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
   end
 
-  def test_variable_interpolation
-    parse = FormatLine.new("File is $File and user is $User")
+  def test_func_needing_parameter_colon  # colon, param, more chars
+    str = "Answer is $$isqrt:225 today"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Answer is "], 
+                       [:func, "isqrt"], 
+                       [:colon, "225"], 
+                       [:str, " today"]]
     tokens = parse.tokenize
-    assert_equal tokens, [[:str, "File is "],
-                          [:var, "File"],
-                          [:str, " and user is "],
-                          [:var, "User"]
-                         ]
+    assert_equal tokens_expected, tokens
     result = parse.evaluate
-    expected = "File is [File is undefined] and user is [User is undefined]"
-    assert result == expected
+    string_expected = "Answer is 15 today"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
   end
 
-  def test_func_expansion
-    parse = FormatLine.new("myfunc() results in $$myfunc apparently.")
+  # isqrt: Not real tests?? 
+
+  def test_isqrt_empty_colon_param
+    str = "Calculate $$isqrt:"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt"]  # , [:colon, ""]
+                      ] 
+    # If param is null, we don't get [:colon, value]!
+    # ^ FIXME function should be more like:  [:func, name, param]
     tokens = parse.tokenize
-    assert_equal tokens, [[:str, "myfunc() results in "],
-                          [:func, "myfunc"],
-                          [:str, " apparently."]
-                        ]
+    assert_equal tokens_expected, tokens
     result = parse.evaluate
-    expected = "myfunc() results in [Error evaluating $$myfunc()] apparently."
-    assert result == expected
+    string_expected = "Calculate [Error evaluating $$isqrt(NO PARAM)]"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_isqrt_empty_bracket_param
+    str = "Calculate $$isqrt[]"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt"]  # , [:colon, ""]
+                      ] 
+    # If param is null, we don't get [:colon, value]!
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "Calculate [Error evaluating $$isqrt(NO PARAM)]"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_isqrt_malformed_number
+    str = "Calculate $$isqrt[3a5]"
+    parse = FormatLine.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt"],
+                       [:brackets, "3a5"]
+                      ] 
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "Calculate [Error evaluating $$isqrt(3a5)]"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
   end
 
+# ...end of this group
+
   def test_func_with_colon
     parse = FormatLine.new("Calling $$myfunc:foo here.")
     tokens = parse.tokenize
@@ -102,22 +196,22 @@ end
                         ]
     result = parse.evaluate
     expected = "Calling [Error evaluating $$myfunc(foo)] here."
-    assert result == expected
+    assert_equal expected, result
   end
 
   def test_func_with_brackets
     parse = FormatLine.new("Calling $$myfunc2[foo bar] here.")
     tokens = parse.tokenize
     assert_kind_of Array, tokens
-    assert tokens.size == 4
-    assert_equal tokens, [[:str, "Calling "],
-                          [:func, "myfunc2"],
-                          [:brackets, "foo bar"],
-                          [:str, " here."]
-                         ]
+    assert_equal 4, tokens.size
+    expected_tokens = [[:str, "Calling "],
+                       [:func, "myfunc2"],
+                       [:brackets, "foo bar"],
+                       [:str, " here."]]
+    assert_equal expected_tokens, tokens
     result = parse.evaluate
     expected = "Calling [Error evaluating $$myfunc2(foo bar)] here."
-    assert result == expected
+    assert_equal expected, result
   end
 
   def test_formatting_01   # Check output of $$date
@@ -128,8 +222,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -145,8 +238,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -162,8 +254,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -179,8 +270,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -196,8 +286,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -213,8 +302,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -230,8 +318,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -247,8 +334,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -264,8 +350,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -281,8 +366,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -298,8 +382,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -315,8 +398,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -332,8 +414,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -349,8 +430,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -366,8 +446,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -383,8 +462,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -400,8 +478,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -417,8 +494,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -434,8 +510,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -451,8 +526,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -468,8 +542,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -485,8 +558,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -502,8 +574,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -519,8 +590,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -536,8 +606,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -553,8 +622,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -570,8 +638,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -587,8 +654,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -604,8 +670,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -621,8 +686,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -638,8 +702,7 @@ end
     STUFF
 
     actual = FormatLine.parse!(src)
-    # FIXME could simplify assert logic?
-    if exp[0] == "/" # regex!   FIXME doesn't honor %r[...]
+    if exp[0] == "/" 
       exp = Regexp.compile(exp[1..-2])   # skip slashes
       assert_match(exp, actual, msg)
     else
@@ -648,3 +711,57 @@ end
   end
 
 end
+
+# Test generation logic:
+
+=begin
+  TestLines = []
+
+  items = []
+  formatting_tests = File.open("test/snapshots/formatting-tests.txt")
+  loop do 
+    4.times { items << formatting_tests.gets.chomp }
+    # Blank line terminates each "stanza"
+    raise "Oops? #{items.inspect}" unless items.last.empty?
+    TestLines << items
+    break if formatting_tests.eof?
+  end
+
+  STDERR.puts <<~RUBY
+    require 'minitest/autorun'
+
+    require_relative '../lib/livetext'
+
+    # Just another testing class. Chill.
+
+    class TestingLivetext < MiniTest::Test
+  RUBY
+
+  TestLines.each.with_index do |item, num|
+    msg, src, exp, blank = *item
+    # generate tests...
+    name = "test_formatting_#{'%02d' % (num + 1)}"
+    method_source = <<~RUBY
+      def #{name}   # #{msg}
+        msg, src, exp = <<~STUFF.split("\\n")
+        #{msg}
+        #{src}
+        #{exp}
+        STUFF
+
+        actual = FormatLine.parse!(src)
+        # FIXME could simplify assert logic?
+        if exp[0] == "/" 
+          exp = Regexp.compile(exp[1..-2])   # skip slashes
+          assert_match(exp, actual, msg)
+        else
+          assert_equal(exp, actual, msg)
+        end
+      end
+
+    RUBY
+    STDERR.puts method_source
+  end
+  STDERR.puts "\nend"
+end
+=end

data/test/unit/parser/set.rb

@@ -137,30 +137,26 @@ class TestParseSet < MiniTest::Test
     #  - allow/disallow escaping??
   end
 
-  # BUG: FormatLine doesn't know variables in this context!
-
   def test_var_eq_var
     set = ParseSet.new("file = $File").parse
     set = set.first  # [["var", "value"]]
     assert_equal set.first, "file"
-    refute set.last =~ /undefined/, "Found 'undefined' for variable value"
+    assert set.last =~ /undefined/, "Found 'undefined' for variable value"
+    # ^ ParseSet isn't smart enough to know about variables/functions
   end
 
-  # BUG: ...or functions.
-  # (Additional bug: Failing silently seems wrong.)
-
   def test_var_eq_func
     set = ParseSet.new("date = $$date").parse
     set = set.first  # [["var", "value"]]
     assert_equal set.first, "date"
-    refute set.last =~ /undefined/, "Found 'undefined' for variable value"
-    assert set.last =~ /^\d\d.\d\d.\d\d/, "Did not find 6-digit date with two separators"
+    assert set.last =~ /undefined/, "Found 'undefined' for variable value"
+    # ^ ParseSet isn't smart enough to know about variables/functions
   end
 
   def test_two_strings
-    line = %[bday="May_31", date="5/31"]
+    line = %[bday="May 31", date='5/31']
     set = ParseSet.new(line).parse
-    assert set == [["bday", "May_31"], ["date", "5/31"]]
+    assert set == [["bday", "May 31"], ["date", "5/31"]]
   end
 
 end