json 0.4.3 → 1.0.0

data/lib/json/pure/parser.rb

@@ -0,0 +1,210 @@
+require 'strscan'
+
+module JSON
+  module Pure
+    # This class implements the JSON parser that is used to parse a JSON string
+    # into a Ruby data structure.
+    class Parser < StringScanner
+      STRING                = /" ((?:[^\x0-\x1f"\\] |
+                                  \\["\\\/bfnrt] |
+                                  \\u[0-9a-fA-F]{4})*)
+                              "/x
+      INTEGER               = /(-?0|-?[1-9]\d*)/
+      FLOAT                 = /(-?
+                                (?:0|[1-9]\d*)
+                                (?:
+                                  \.\d+(?i:e[+-]?\d+) |
+                                  \.\d+ |
+                                  (?i:e[+-]?\d+)
+                                )
+                                )/x
+      OBJECT_OPEN           = /\{/
+      OBJECT_CLOSE          = /\}/
+      ARRAY_OPEN            = /\[/
+      ARRAY_CLOSE           = /\]/
+      PAIR_DELIMITER        = /:/
+      COLLECTION_DELIMITER  = /,/
+      TRUE                  = /true/
+      FALSE                 = /false/
+      NULL                  = /null/
+      IGNORE                = %r(
+        (?:
+         //[^\n\r]*[\n\r]| # line comments
+         /\*               # c-style comments
+         (?:
+          [^*/]|        # normal chars
+          /[^*]|        # slashes that do not start a nested comment
+          \*[^/]|       # asterisks that do not end this comment
+          /(?=\*/)      # single slash before this comment's end 
+         )*
+           \*/               # the End of this comment
+           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        )+
+      )mx
+
+      UNPARSED = Object.new
+
+      # Creates a new JSON::Pure::Parser instance for the string _source_.
+      def initialize(source)
+        super
+        @create_id = JSON.create_id
+      end
+
+      alias source string
+
+      # Parses the current JSON string _source_ and returns the complete data
+      # structure as a result.
+      def parse
+        reset
+        obj = nil
+        until eos?
+          case
+          when scan(OBJECT_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            obj = parse_object
+          when scan(ARRAY_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            obj = parse_array
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "source '#{peek(20)}' not in JSON!"
+          end
+        end
+        obj or raise ParserError, "source did not contain any JSON!"
+        obj
+      end
+
+      private
+
+      def parse_string
+        if scan(STRING)
+          return '' if self[1].empty?
+          self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+))) do
+            case $~[0]
+            when '\\"'  then '"'
+            when '\\\\' then '\\'
+            when '\\/'  then '/'
+            when '\\b'  then "\b"
+            when '\\f'  then "\f"
+            when '\\n'  then "\n"
+            when '\\r'  then "\r"
+            when '\\t'  then "\t"
+            else
+              bytes = ''
+              c = $~[0]
+              i = 0
+              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u 
+                bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+                i += 1
+              end
+              JSON::UTF16toUTF8.iconv(bytes)
+            end
+          end
+        else
+          UNPARSED
+        end
+      rescue Iconv::Failure => e
+        raise GeneratorError, "Caught #{e.class}: #{e}"
+      end
+
+      def parse_value
+        case
+        when scan(FLOAT)
+          Float(self[1])
+        when scan(INTEGER)
+          Integer(self[1])
+        when scan(TRUE)
+          true
+        when scan(FALSE)
+          false
+        when scan(NULL)
+          nil
+        when (string = parse_string) != UNPARSED
+          string
+        when scan(ARRAY_OPEN)
+          parse_array
+        when scan(OBJECT_OPEN)
+          parse_object
+        else
+          UNPARSED
+        end
+      end
+
+      def parse_array
+        result = []
+        delim = false
+        until eos?
+          case
+          when (value = parse_value) != UNPARSED
+            delim = false
+            result << value
+            skip(IGNORE)
+            if scan(COLLECTION_DELIMITER)
+              delim = true
+            elsif match?(ARRAY_CLOSE)
+              ;
+            else
+              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+            end
+          when scan(ARRAY_CLOSE)
+            if delim
+              raise ParserError, "expected next element in array at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+
+      def parse_object
+        result = {}
+        delim = false
+        until eos?
+          case
+          when (string = parse_string) != UNPARSED
+            skip(IGNORE)
+            unless scan(PAIR_DELIMITER)
+              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+            end
+            skip(IGNORE)
+            unless (value = parse_value).equal? UNPARSED
+              result[string] = value
+              delim = false
+              skip(IGNORE)
+              if scan(COLLECTION_DELIMITER)
+                delim = true
+              elsif match?(OBJECT_CLOSE)
+                ;
+              else
+                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+              end
+            else
+              raise ParserError, "expected value in object at '#{peek(20)}'!"
+            end
+          when scan(OBJECT_CLOSE)
+            if delim
+              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+            end
+            if klassname = result[@create_id]
+              klass = JSON.deep_const_get klassname
+              break unless klass and klass.json_creatable?
+              result = klass.json_create(result)
+              result
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/json/version.rb

@@ -0,0 +1,8 @@
+module JSON
+  # JSON version
+  VERSION         = '1.0.0'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/tests/fixtures/fail1.json

@@ -0,0 +1 @@
+"A JSON payload should be an object or array, not a string."

data/tests/fixtures/fail10.json

@@ -0,0 +1 @@
+{"Extra value after close": true} "misplaced quoted value"

data/tests/fixtures/fail11.json

@@ -0,0 +1 @@
+{"Illegal expression": 1 + 2}

data/tests/fixtures/fail12.json

@@ -0,0 +1 @@
+{"Illegal invocation": alert()}

data/tests/fixtures/fail13.json

@@ -0,0 +1 @@
+{"Numbers cannot have leading zeroes": 013}

data/tests/fixtures/fail14.json

@@ -0,0 +1 @@
+{"Numbers cannot be hex": 0x14}

data/tests/fixtures/fail15.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \x15"]

data/tests/fixtures/fail16.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \'"]

data/tests/fixtures/fail17.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \017"]

data/tests/fixtures/fail19.json

@@ -0,0 +1 @@
+{"Missing colon" null}

data/tests/fixtures/fail2.json

@@ -0,0 +1 @@
+["Unclosed array"

data/tests/fixtures/fail20.json

@@ -0,0 +1 @@
+{"Double colon":: null}

data/tests/fixtures/fail21.json

@@ -0,0 +1 @@
+{"Comma instead of colon", null}

data/tests/fixtures/fail22.json

@@ -0,0 +1 @@
+["Colon instead of comma": false]

data/tests/fixtures/fail23.json

@@ -0,0 +1 @@
+["Bad value", truth]

data/tests/fixtures/fail24.json

@@ -0,0 +1 @@
+['single quote']

data/tests/fixtures/fail25.json

@@ -0,0 +1 @@
+["tab	character	in	string	"]

data/tests/fixtures/fail26.json

@@ -0,0 +1 @@
+["tab\   character\   in\  string\  "]

data/tests/fixtures/fail27.json

@@ -0,0 +1,2 @@
+["line
+break"]

data/tests/fixtures/fail28.json

@@ -0,0 +1,2 @@
+["line\
+break"]

data/tests/fixtures/fail3.json

@@ -0,0 +1 @@
+{unquoted_key: "keys must be quoted"}

data/tests/fixtures/fail4.json

@@ -0,0 +1 @@
+["extra comma",]

data/tests/fixtures/fail5.json

@@ -0,0 +1 @@
+["double extra comma",,]

data/tests/fixtures/fail6.json

@@ -0,0 +1 @@
+[   , "<-- missing value"]

data/tests/fixtures/fail7.json

@@ -0,0 +1 @@
+["Comma after the close"],

data/tests/fixtures/fail8.json

@@ -0,0 +1 @@
+["Extra close"]]

data/tests/fixtures/fail9.json

@@ -0,0 +1 @@
+{"Extra comma": true,}

data/tests/fixtures/pass1.json

@@ -0,0 +1,56 @@
+[
+    "JSON Test Pattern pass1",
+    {"object with 1 member":["array with 1 element"]},
+    {},
+    [],
+    -42,
+    true,
+    false,
+    null,
+    {
+        "integer": 1234567890,
+        "real": -9876.543210,
+        "e": 0.123456789e-12,
+        "E": 1.234567890E+34,
+        "":  23456789012E666,
+        "zero": 0,
+        "one": 1,
+        "space": " ",
+        "quote": "\"",
+        "backslash": "\\",
+        "controls": "\b\f\n\r\t",
+        "slash": "/ & \/",
+        "alpha": "abcdefghijklmnopqrstuvwyz",
+        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+        "digit": "0123456789",
+        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+        "true": true,
+        "false": false,
+        "null": null,
+        "array":[  ],
+        "object":{  },
+        "address": "50 St. James Street",
+        "url": "http://www.JSON.org/",
+        "comment": "// /* <!-- --",
+        "# -- --> */": " ",
+        " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5        ,          6           ,7        ],
+        "compact": [1,2,3,4,5,6,7],
+        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
+        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+    },
+    0.5 ,98.6
+,
+99.44
+,
+
+1066
+
+
+,"rosebud"]

data/tests/fixtures/pass18.json

@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]] // No, we don't limit our depth: Moved to pass...

data/tests/fixtures/pass2.json

@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]

data/tests/fixtures/pass3.json

@@ -0,0 +1,6 @@
+{
+    "JSON Test Pattern pass3": {
+        "The outermost value": "must be an object or array.",
+        "In this test": "It is an object."
+    }
+}

data/tests/runner.rb

@@ -3,15 +3,21 @@
 require 'test/unit/ui/console/testrunner'
 require 'test/unit/testsuite'
 $:.unshift File.expand_path(File.dirname($0))
-$:.unshift 'lib'
-$:.unshift '../lib'
 $:.unshift 'tests'
 require 'test_json'
+require 'test_json_generate'
+require 'test_json_unicode'
+require 'test_json_addition'
+require 'test_json_fixtures'
 
 class TS_AllTests
   def self.suite
     suite = Test::Unit::TestSuite.new name
+    suite << TC_JSONGenerate.suite
     suite << TC_JSON.suite
+    suite << TC_JSONUnicode.suite
+    suite << TC_JSONAddition.suite
+    suite << TC_JSONFixtures.suite
   end
 end
 Test::Unit::UI::Console::TestRunner.run(TS_AllTests)

data/tests/test_json.rb

@@ -6,29 +6,6 @@ require 'json'
 class TC_JSON < Test::Unit::TestCase
   include JSON
 
-  class A
-    def initialize(a)
-      @a = a
-    end
-
-    attr_reader :a
-
-    def ==(other)
-      a == other.a
-    end
-    
-    def self.json_create(object)
-      new(*object['args'])
-    end
-
-    def to_json(*args)
-      {
-        'json_class'  => self.class,
-        'args'        => [ @a ],
-      }.to_json(*args)
-    end
-  end
-
   def setup
     $KCODE = 'UTF8'
     @ary = [1, "foo", 3.14, 4711.0, 2.718, nil, [1,-2,3], false, true].map do
@@ -50,35 +27,101 @@ class TC_JSON < Test::Unit::TestCase
     }
     @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
       '"g":"\\"\\u0000\\u001f","h":1.0E3,"i":1.0E-3}'
-    @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
-      '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
-    @json3 = <<'EOT'.chomp
-{
-  "a": 2,
-  "b": 3.141,
-  "c": "c",
-  "d": [
-    1,
-    "b",
-    3.14
-  ],
-  "e": {
-    "foo": "bar"
-  },
-  "g": "\"\u0000\u001f",
-  "h": 1000.0,
-  "i": 0.001
-}
-EOT
+  end
+    suite << TC_JSON.suite
+
+  def test_construction
+    parser = JSON::Parser.new('test')
+    assert_equal 'test', parser.source
   end
 
-  def test_parse_value
+  def assert_equal_float(expected, is)
+    assert_in_delta(expected.first, is.first, 1e-2)
+  end
+
+  def test_parse_simple_arrays
+    assert_equal([], parse('[]'))
+    assert_equal([], parse('  [  ] '))
+    assert_equal([nil], parse('[null]'))
+    assert_equal([false], parse('[false]'))
+    assert_equal([true], parse('[true]'))
+    assert_equal([-23], parse('[-23]'))
+    assert_equal([23], parse('[23]'))
+    assert_equal([0.23], parse('[0.23]'))
+    assert_raises(JSON::ParserError) { parse('[+23.2]') }
+    assert_raises(JSON::ParserError) { parse('[+23]') }
+    assert_raises(JSON::ParserError) { parse('[.23]') }
+    assert_raises(JSON::ParserError) { parse('[023]') }
+    assert_equal_float [3.141], parse('[3.141]')
+    assert_equal_float [-3.141], parse('[-3.141]')
+    assert_equal_float [3.141], parse('[3141e-3]')
+    assert_equal_float [3.141], parse('[3141.1e-3]')
+    assert_equal_float [3.141], parse('[3141E-3]')
+    assert_equal_float [3.141], parse('[3141.0E-3]')
+    assert_equal_float [-3.141], parse('[-3141.0e-3]')
+    assert_equal_float [-3.141], parse('[-3141e-3]')
+    assert_equal([""], parse('[""]'))
+    assert_equal(["foobar"], parse('["foobar"]'))
+    assert_equal([{}], parse('[{}]'))
+  end
+
+  def test_parse_simple_objects
+    assert_equal({}, parse('{}'))
+    assert_equal({}, parse(' {   }   '))
+    assert_equal({ "a" => nil }, parse('{   "a"   :  null}'))
+    assert_equal({ "a" => nil }, parse('{"a":null}'))
+    assert_equal({ "a" => false }, parse('{   "a"  :  false  }  '))
+    assert_equal({ "a" => false }, parse('{"a":false}'))
+    assert_raises(JSON::ParserError) { parse('{false}') }
+    assert_equal({ "a" => true }, parse('{"a":true}'))
+    assert_equal({ "a" => true }, parse('  { "a" :  true  }   '))
+    assert_equal({ "a" => -23 }, parse('  {  "a"  :  -23  }  '))
+    assert_equal({ "a" => -23 }, parse('  { "a" : -23 } '))
+    assert_equal({ "a" => 23 }, parse('{"a":23  } '))
+    assert_equal({ "a" => 23 }, parse('  { "a"  : 23  } '))
+    assert_equal({ "a" => 0.23 }, parse(' { "a"  :  0.23 }  '))
+    assert_equal({ "a" => 0.23 }, parse('  {  "a"  :  0.23  }  '))
+  end
+
+  begin
+    require 'permutation'
+    def test_parse_more_complex_arrays
+      a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
+      perms = Permutation.for a
+      perms.each do |perm|
+        orig_ary = perm.project
+        json = pretty_generate(orig_ary)
+        assert_equal orig_ary, parse(json)
+      end
+    end
+
+    def test_parse_complex_objects
+      a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
+      perms = Permutation.for a
+      perms.each do |perm|
+        s = "a"
+        orig_obj = perm.project.inject({}) { |h, x| h[s.dup] = x; s = s.succ; h }
+        json = pretty_generate(orig_obj)
+        assert_equal orig_obj, parse(json)
+      end
+    end
+  rescue LoadError
+    warn "Skipping permutation tests."
+  end
+
+  def test_parse_arrays
+    assert_equal([1,2,3], parse('[1,2,3]'))
+    assert_equal([1.2,2,3], parse('[1.2,2,3]'))
+    assert_equal([[],[[],[]]], parse('[[],[[],[]]]'))
+  end
+
+  def test_parse_values
     assert_equal([""], parse('[""]'))
     assert_equal(["\\"], parse('["\\\\"]'))
     assert_equal(['"'], parse('["\""]'))
     assert_equal(['\\"\\'], parse('["\\\\\\"\\\\"]'))
-    assert_equal(["\\a\"\b\f\n\r\t\0\037"],
-      parse('["\\a\"\b\f\n\r\t\u0000\u001f"]'))
+    assert_equal(["\"\b\n\r\t\0\037"],
+      parse('["\"\b\n\r\t\u0000\u001f"]'))
     for i in 0 ... @ary.size
       assert_equal(@ary[i], parse(@ary_to_parse[i]))
     end
@@ -93,7 +136,7 @@ EOT
       parse('[[1],["foo"],[3.14],[47.11e+2],[2718.0E-3],[null],[[1,-2,3]]'\
       ',[false],[true]]'))
     assert_equal(@ary, parse(%Q{   [   [1] , ["foo"]  ,  [3.14] \t ,  [47.11e+2] 
-      , [2718.0E-3 ],\n[ null] , [[1, -2, 3 ]], [false ],[ true]\n ]  }))
+      , [2718.0E-3 ],\r[ null] , [[1, -2, 3 ]], [false ],[ true]\n ]  }))
   end
 
   def test_parse_object
@@ -103,64 +146,12 @@ EOT
     assert_equal({'foo'=>'bar'}, parse('    { "foo"  :   "bar"   }   '))
   end
 
-  def test_unparse
-    json = unparse(@hash)
-    assert_equal(@json2, json)
-    parsed_json = parse(json)
-    assert_equal(@hash, parsed_json)
-    json = generate({1=>2})
-    assert_equal('{"1":2}', json)
-    parsed_json = parse(json)
-    assert_equal({"1"=>2}, parsed_json)
-  end
-
-  def test_unparse
-    json = pretty_unparse(@hash)
-    assert_equal(@json3, json)
-    parsed_json = parse(json)
-    assert_equal(@hash, parsed_json)
-    json = pretty_generate({1=>2})
-    assert_equal(<<'EOT'.chomp, json)
-{
-  "1": 2
-}
-EOT
-    parsed_json = parse(json)
-    assert_equal({"1"=>2}, parsed_json)
-  end
-
-
   def test_parser_reset
     parser = Parser.new(@json)
     assert_equal(@hash, parser.parse)
     assert_equal(@hash, parser.parse)
   end
 
-  def test_unicode
-    assert_equal '""', ''.to_json
-    assert_equal '"\\b"', "\b".to_json
-    assert_equal '"\u0001"', 0x1.chr.to_json
-    assert_equal '"\u001f"', 0x1f.chr.to_json
-    assert_equal '" "', ' '.to_json
-    assert_equal "\"#{0x7f.chr}\"", 0x7f.chr.to_json
-    if JSON.support_unicode?
-      utf8 = [ '© ≠ €!' ]
-      json = '["\u00a9 \u2260 \u20ac!"]'
-      assert_equal json, utf8.to_json
-      assert_equal utf8, parse(json)
-      utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
-      json = '["\u3042\u3044\u3046\u3048\u304a"]'
-      assert_equal json, utf8.to_json
-      assert_equal utf8, parse(json)
-      utf8 = ['საქართველო']
-      json = '["\u10e1\u10d0\u10e5\u10d0\u10e0\u10d7\u10d5\u10d4\u10da\u10dd"]'
-      assert_equal json, utf8.to_json
-      assert_equal utf8, parse(json)
-    else
-      warn "No unicode support found - skipping test"
-    end
-  end
-
   def test_comments
     json = <<EOT
 {
@@ -201,69 +192,26 @@ EOT
     assert_equal({ "key1" => "value1" }, parse(json))
   end
 
-  def test_extended_json
-    a = A.new(666)
-    json = generate(a)
-    a_again = JSON.parse(json)
-    assert_kind_of a.class, a_again
-    assert_equal a, a_again
-  end
-
-  def test_raw_strings
-    raw = ''
-    raw_array = []
-    for i in 0..255
-      raw << i
-      raw_array << i
-    end
-    json = raw.to_json_raw
-    json_raw_object = raw.to_json_raw_object
-    hash = { 'json_class' => 'String', 'raw'=> raw_array }
-    assert_equal hash, json_raw_object
-    json_raw = <<EOT.chomp
-{\"json_class\":\"String\",\"raw\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255]}
-EOT
-# "
-    assert_equal json_raw, json
-    raw_again = JSON.parse(json)
-    assert_equal raw, raw_again
-  end
-
-  def test_utf8_mode
-    unless JSON.support_unicode?
-      warn "No unicode support found - skipping test"
-      return
-    end
-    $KCODE = 'NONE'
-    utf8 = ["© ≠ €! - \001"]
-    json = "[\"© ≠ €! - \\u0001\"]"
-    assert_equal json, generate(utf8)
-    assert_equal utf8, parse(json)
-    assert JSON.support_unicode?
-    $KCODE = 'UTF8'
-    utf8 = ['© ≠ €!']
-    json = '["\u00a9 \u2260 \u20ac!"]'
-    assert_equal json, unparse(utf8)
-    assert_equal utf8, parse(json)
-    JSON.support_unicode = false
-    assert !JSON.support_unicode?
-    utf8 = ["© ≠ €! - \001"]
-    json = "[\"© ≠ €! - \\u0001\"]"
-    assert_equal json, unparse(utf8)
-    assert_equal utf8, parse(json)
-  end
-
   def test_backslash
+    data = [ '\\.(?i:gif|jpe?g|png)$' ]
     json = '["\\\\.(?i:gif|jpe?g|png)$"]'
-    data = JSON.parse(json)
     assert_equal json, JSON.unparse(data)
-    json = '["\\""]'
-    data = JSON.parse(json)
+    assert_equal data, JSON.parse(json)
+    #
+    data = [ '\\"' ]
+    json = '["\\\\\""]'
     assert_equal json, JSON.unparse(data)
+    assert_equal data, JSON.parse(json)
+    #
     json = '["\/"]'
     data = JSON.parse(json)
     assert_equal ['/'], data
     assert_equal json, JSON.unparse(data)
+    #
+    json = '["\""]'
+    data = JSON.parse(json)
+    assert_equal ['"'], data
+    assert_equal json, JSON.unparse(data)
   end
 
   def test_wrong_inputs