Merge branch 'trunk' of https://github.com/nobu/json into nobu-trunk

9 files changed, 66 insertions, 47 deletions

diff --git a/tests/json_addition_test.rb b/tests/json_addition_test.rb
index 128f34a..a028e0f 100644
--- a/tests/json_addition_test.rb
+++ b/tests/json_addition_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 require 'json/add/core'
 require 'json/add/complex'
@@ -108,7 +109,7 @@ class JSONAdditionTest < Test::Unit::TestCase
     c = C.new
     assert !C.json_creatable?
     json = generate(c)
-    assert_raises(ArgumentError, NameError) { parse(json, :create_additions => true) }
+    assert_raise(ArgumentError, NameError) { parse(json, :create_additions => true) }
   end
 
   def test_raw_strings
@@ -147,7 +148,7 @@ class JSONAdditionTest < Test::Unit::TestCase
     assert_equal s, JSON(JSON(s), :create_additions => true)
     struct = Struct.new :foo, :bar
     s = struct.new 4711, 'foot'
-    assert_raises(JSONError) { JSON(s) }
+    assert_raise(JSONError) { JSON(s) }
     begin
       raise TypeError, "test me"
     rescue TypeError => e
diff --git a/tests/json_common_interface_test.rb b/tests/json_common_interface_test.rb
index 38136fa..b2051d4 100644
--- a/tests/json_common_interface_test.rb
+++ b/tests/json_common_interface_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 require 'stringio'
 require 'tempfile'
@@ -100,8 +101,8 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
     too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     assert_equal too_deep, dump(eval(too_deep))
     assert_kind_of String, Marshal.dump(eval(too_deep))
-    assert_raises(ArgumentError) { dump(eval(too_deep), 100) }
-    assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    assert_raise(ArgumentError) { dump(eval(too_deep), 100) }
+    assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
     assert_equal too_deep, dump(eval(too_deep), 101)
     assert_kind_of String, Marshal.dump(eval(too_deep), 101)
     output = StringIO.new
diff --git a/tests/json_encoding_test.rb b/tests/json_encoding_test.rb
index d983e12..86c4df8 100644
--- a/tests/json_encoding_test.rb
+++ b/tests/json_encoding_test.rb
@@ -1,4 +1,6 @@
 # encoding: utf-8
+#frozen_string_literal: false
+
 require 'test_helper'
 
 class JSONEncodingTest < Test::Unit::TestCase
diff --git a/tests/json_ext_parser_test.rb b/tests/json_ext_parser_test.rb
index ade9784..c5a030e 100644
--- a/tests/json_ext_parser_test.rb
+++ b/tests/json_ext_parser_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 
 class JSONExtParserTest < Test::Unit::TestCase
diff --git a/tests/json_fixtures_test.rb b/tests/json_fixtures_test.rb
index 6681b8d..01954fe 100644
--- a/tests/json_fixtures_test.rb
+++ b/tests/json_fixtures_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 
 class JSONFixturesTest < Test::Unit::TestCase
@@ -22,7 +23,7 @@ class JSONFixturesTest < Test::Unit::TestCase
 
   def test_failing
     for name, source in @failed
-      assert_raises(JSON::ParserError, JSON::NestingError,
+      assert_raise(JSON::ParserError, JSON::NestingError,
         "Did not fail for fixture '#{name}': #{source.inspect}") do
         JSON.parse(source)
       end
diff --git a/tests/json_generator_test.rb b/tests/json_generator_test.rb
index 7087471..18b0833 100644
--- a/tests/json_generator_test.rb
+++ b/tests/json_generator_test.rb
@@ -118,12 +118,12 @@ EOT
     assert s[:check_circular?]
     h = { 1=>2 }
     h[3] = h
-    assert_raises(JSON::NestingError) {  generate(h) }
-    assert_raises(JSON::NestingError) {  generate(h, s) }
+    assert_raise(JSON::NestingError) {  generate(h) }
+    assert_raise(JSON::NestingError) {  generate(h, s) }
     s = JSON.state.new
     a = [ 1, 2 ]
     a << a
-    assert_raises(JSON::NestingError) {  generate(a, s) }
+    assert_raise(JSON::NestingError) {  generate(a, s) }
     assert s.check_circular?
     assert s[:check_circular?]
   end
@@ -177,34 +177,34 @@ EOT
   end
 
   def test_allow_nan
-    assert_raises(GeneratorError) { generate([JSON::NaN]) }
+    assert_raise(GeneratorError) { generate([JSON::NaN]) }
     assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
-    assert_raises(GeneratorError) { fast_generate([JSON::NaN]) }
-    assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
+    assert_raise(GeneratorError) { fast_generate([JSON::NaN]) }
+    assert_raise(GeneratorError) { pretty_generate([JSON::NaN]) }
     assert_equal "[\n  NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
-    assert_raises(GeneratorError) { generate([JSON::Infinity]) }
+    assert_raise(GeneratorError) { generate([JSON::Infinity]) }
     assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
-    assert_raises(GeneratorError) { fast_generate([JSON::Infinity]) }
-    assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
+    assert_raise(GeneratorError) { fast_generate([JSON::Infinity]) }
+    assert_raise(GeneratorError) { pretty_generate([JSON::Infinity]) }
     assert_equal "[\n  Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
-    assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
+    assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) }
     assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
-    assert_raises(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
-    assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
+    assert_raise(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
+    assert_raise(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
     assert_equal "[\n  -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
   end
 
   def test_depth
     ary = []; ary << ary
     assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
-    assert_raises(JSON::NestingError) { generate(ary) }
+    assert_raise(JSON::NestingError) { generate(ary) }
     assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
     assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
-    assert_raises(JSON::NestingError) { JSON.pretty_generate(ary) }
+    assert_raise(JSON::NestingError) { JSON.pretty_generate(ary) }
     assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
     s = JSON.state.new
     assert_equal 0, s.depth
-    assert_raises(JSON::NestingError) { ary.to_json(s) }
+    assert_raise(JSON::NestingError) { ary.to_json(s) }
     assert_equal 100, s.depth
   end
 
@@ -330,8 +330,8 @@ EOT
   def test_nesting
     too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     too_deep_ary = eval too_deep
-    assert_raises(JSON::NestingError) { generate too_deep_ary }
-    assert_raises(JSON::NestingError) { generate too_deep_ary, :max_nesting => 100 }
+    assert_raise(JSON::NestingError) { generate too_deep_ary }
+    assert_raise(JSON::NestingError) { generate too_deep_ary, :max_nesting => 100 }
     ok = generate too_deep_ary, :max_nesting => 101
     assert_equal too_deep, ok
     ok = generate too_deep_ary, :max_nesting => nil
diff --git a/tests/json_generic_object_test.rb b/tests/json_generic_object_test.rb
index 171fdb8..82742dc 100644
--- a/tests/json_generic_object_test.rb
+++ b/tests/json_generic_object_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 
 class JSONGenericObjectTest < Test::Unit::TestCase
diff --git a/tests/json_parser_test.rb b/tests/json_parser_test.rb
index a5793f9..5120f09 100644
--- a/tests/json_parser_test.rb
+++ b/tests/json_parser_test.rb
@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: false
 
 require 'test_helper'
 require 'stringio'
@@ -19,6 +20,16 @@ class JSONParserTest < Test::Unit::TestCase
     assert_equal Encoding::UTF_16, source.encoding
   end if defined?(Encoding::UTF_16)
 
+  def test_error_message_encoding
+    bug10705 = '[ruby-core:67386] [Bug #10705]'
+    json = ".\"\xE2\x88\x9A\"".force_encoding(Encoding::UTF_8)
+    e = assert_raise(JSON::ParserError) {
+      JSON::Ext::Parser.new(json).parse
+    }
+    assert_equal(Encoding::UTF_8, e.message.encoding, bug10705)
+    assert_include(e.message, json, bug10705)
+  end if defined?(Encoding::UTF_8) and defined?(JSON::Ext::Parser)
+
   def test_parsing
     parser = JSON::Parser.new('"test"')
     assert_equal 'test', parser.parse
@@ -52,7 +63,7 @@ class JSONParserTest < Test::Unit::TestCase
     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_raise(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  }  '))
@@ -64,10 +75,10 @@ class JSONParserTest < Test::Unit::TestCase
   end
 
   def test_parse_numbers
-    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_raise(JSON::ParserError) { parse('+23.2') }
+    assert_raise(JSON::ParserError) { parse('+23') }
+    assert_raise(JSON::ParserError) { parse('.23') }
+    assert_raise(JSON::ParserError) { parse('023') }
     assert_equal 23, parse('23')
     assert_equal -23, parse('-23')
     assert_equal_float 3.141, parse('3.141')
@@ -78,11 +89,11 @@ class JSONParserTest < Test::Unit::TestCase
     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_raises(ParserError) { parse('NaN') }
+    assert_raise(ParserError) { parse('NaN') }
     assert parse('NaN', :allow_nan => true).nan?
-    assert_raises(ParserError) { parse('Infinity') }
+    assert_raise(ParserError) { parse('Infinity') }
     assert_equal 1.0/0, parse('Infinity', :allow_nan => true)
-    assert_raises(ParserError) { parse('-Infinity') }
+    assert_raise(ParserError) { parse('-Infinity') }
     assert_equal -1.0/0, parse('-Infinity', :allow_nan => true)
   end
 
@@ -165,19 +176,19 @@ class JSONParserTest < Test::Unit::TestCase
   end
 
   def test_some_wrong_inputs
-    assert_raises(ParserError) { parse('[] bla') }
-    assert_raises(ParserError) { parse('[] 1') }
-    assert_raises(ParserError) { parse('[] []') }
-    assert_raises(ParserError) { parse('[] {}') }
-    assert_raises(ParserError) { parse('{} []') }
-    assert_raises(ParserError) { parse('{} {}') }
-    assert_raises(ParserError) { parse('[NULL]') }
-    assert_raises(ParserError) { parse('[FALSE]') }
-    assert_raises(ParserError) { parse('[TRUE]') }
-    assert_raises(ParserError) { parse('[07]    ') }
-    assert_raises(ParserError) { parse('[0a]') }
-    assert_raises(ParserError) { parse('[1.]') }
-    assert_raises(ParserError) { parse('     ') }
+    assert_raise(ParserError) { parse('[] bla') }
+    assert_raise(ParserError) { parse('[] 1') }
+    assert_raise(ParserError) { parse('[] []') }
+    assert_raise(ParserError) { parse('[] {}') }
+    assert_raise(ParserError) { parse('{} []') }
+    assert_raise(ParserError) { parse('{} {}') }
+    assert_raise(ParserError) { parse('[NULL]') }
+    assert_raise(ParserError) { parse('[FALSE]') }
+    assert_raise(ParserError) { parse('[TRUE]') }
+    assert_raise(ParserError) { parse('[07]    ') }
+    assert_raise(ParserError) { parse('[0a]') }
+    assert_raise(ParserError) { parse('[1.]') }
+    assert_raise(ParserError) { parse('     ') }
   end
 
   def test_symbolize_names
@@ -212,7 +223,7 @@ EOT
                     *  comment */
 }
 EOT
-    assert_raises(ParserError) { parse(json) }
+    assert_raise(ParserError) { parse(json) }
     json = <<EOT
 {
   "key1":"value1"  /* multi line
@@ -221,7 +232,7 @@ EOT
                    and again, throw an Error */
 }
 EOT
-    assert_raises(ParserError) { parse(json) }
+    assert_raise(ParserError) { parse(json) }
     json = <<EOT
 {
   "key1":"value1"  /*/*/
@@ -233,8 +244,8 @@ EOT
   def test_nesting
     too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     too_deep_ary = eval too_deep
-    assert_raises(JSON::NestingError) { parse too_deep }
-    assert_raises(JSON::NestingError) { parse too_deep, :max_nesting => 100 }
+    assert_raise(JSON::NestingError) { parse too_deep }
+    assert_raise(JSON::NestingError) { parse too_deep, :max_nesting => 100 }
     ok = parse too_deep, :max_nesting => 101
     assert_equal too_deep_ary, ok
     ok = parse too_deep, :max_nesting => nil
diff --git a/tests/json_string_matching_test.rb b/tests/json_string_matching_test.rb
index 7fec841..5d55dc3 100644
--- a/tests/json_string_matching_test.rb
+++ b/tests/json_string_matching_test.rb
@@ -1,3 +1,4 @@
+#frozen_string_literal: false
 require 'test_helper'
 require 'time'