       assert.equal tl[2][0].value, "b"
       assert.equal tl[2][0].mx_hash.tail_space, "0"
     
-    it "should parse 'a / b / c' as 5 tokens (not regexp!)", ()->
+    it "should tokenize 'a / b / c' as 5 tokens (not regexp!)", ()->
       tl = g._tokenize "a / b / c"
       assert.equal tl.length, 5
       assert.equal tl[0][0].mx_hash.hash_key, "identifier"

      assert.equal tl[6][0].mx_hash.hash_key, "decimal_literal"
      assert.equal tl[7][0].mx_hash.hash_key, "comment"
    
    it "should parse '### 2 + 2 = 4\\n4 + 4 = 8\\n###' as comment", ()->
      tl = g._tokenize "### 2 + 2 = 4\n4 + 4 = 8\n###"
      assert.equal tl.length, 1
      assert.equal tl[0][0].mx_hash.hash_key, "comment"
    
    it "should parse '####################### COMMENT\\n' as comment", ()->
      tl = g._tokenize "####################### COMMENT\n"
      assert.equal tl.length, 1
      assert.equal tl[0][0].mx_hash.hash_key, "comment"
      assert.equal tl[0][0].value, "####################### COMMENT\n"
  
  describe "Whitespace", ()->
    it "should parse \\n as 0 tokens", ()->
      tl = g._tokenize "\n"
      assert.equal tl.length, 0
    
    it "should parse \\n1 as 2 tokens", ()->
      tl = g._tokenize "\n1"
      assert.equal tl.length, 2
    
    it "should parse \\n\\n1 as 2 tokens", ()->
      tl = g._tokenize "\n\n1"
      assert.equal tl.length, 2
    
    it "should parse \\n\\n\\n1 as 2 tokens", ()->
      tl = g._tokenize "\n\n\n1"
      assert.equal tl.length, 2
    
    it "should parse 'a + b' as 'a', '+', 'b' with tail_space 1 1 0", ()->
      tl = g._tokenize "a + b"
      assert.equal tl.length, 3
      assert.equal tl[0][0].value, "a"

            , /Error: can't tokenize /

  describe "Regexp", ()->
    it "should tokenize 'a/b/c' as 3 tokens with regexp in the middle", ()->
      tl = g._tokenize "a/b/c"
      assert.equal tl.length, 3
      assert.equal tl[1][0].mx_hash.hash_key, "regexp_literal"
    
    it "should tokenize 'a/b' as 3 tokens without regexp", ()->
      tl = g._tokenize "a/b"
      assert.equal tl.length, 3
      assert.notEqual tl[1][0].mx_hash.hash_key, "regexp_literal"
    
    it "should tokenize 'a//b' as 3 tokens without regexp", ()->
      tl = g._tokenize "a//b"
      assert.equal tl.length, 3
      assert.notEqual tl[1][0].mx_hash.hash_key, "regexp_literal"
