summaryrefslogtreecommitdiff
path: root/test/json
diff options
context:
space:
mode:
Diffstat (limited to 'test/json')
-rw-r--r--test/json/json_addition_test.rb6
-rw-r--r--test/json/json_common_interface_test.rb34
-rw-r--r--test/json/json_encoding_test.rb9
-rw-r--r--test/json/json_ext_parser_test.rb21
-rw-r--r--test/json/json_fixtures_test.rb2
-rwxr-xr-x[-rw-r--r--]test/json/json_generator_test.rb67
-rw-r--r--test/json/json_generic_object_test.rb4
-rw-r--r--test/json/json_parser_test.rb85
-rw-r--r--test/json/json_string_matching_test.rb2
-rw-r--r--test/json/ractor_test.rb8
10 files changed, 167 insertions, 71 deletions
diff --git a/test/json/json_addition_test.rb b/test/json/json_addition_test.rb
index 614c735567..3a7a58176a 100644
--- a/test/json/json_addition_test.rb
+++ b/test/json/json_addition_test.rb
@@ -1,5 +1,5 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
require 'json/add/core'
require 'json/add/complex'
require 'json/add/rational'
@@ -183,14 +183,14 @@ class JSONAdditionTest < Test::Unit::TestCase
def test_bigdecimal
assert_equal BigDecimal('3.141', 23), JSON(JSON(BigDecimal('3.141', 23)), :create_additions => true)
assert_equal BigDecimal('3.141', 666), JSON(JSON(BigDecimal('3.141', 666)), :create_additions => true)
- end
+ end if defined?(::BigDecimal)
def test_ostruct
o = OpenStruct.new
# XXX this won't work; o.foo = { :bar => true }
o.foo = { 'bar' => true }
assert_equal o, parse(JSON(o), :create_additions => true)
- end
+ end if defined?(::OpenStruct)
def test_set
s = Set.new([:a, :b, :c, :a])
diff --git a/test/json/json_common_interface_test.rb b/test/json/json_common_interface_test.rb
index 9148b78c8b..c16f6ceaaf 100644
--- a/test/json/json_common_interface_test.rb
+++ b/test/json/json_common_interface_test.rb
@@ -1,5 +1,5 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
require 'stringio'
require 'tempfile'
@@ -99,18 +99,26 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
def test_dump
too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
- assert_equal too_deep, dump(eval(too_deep))
- assert_kind_of String, Marshal.dump(eval(too_deep))
- 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
- dump(eval(too_deep), output)
- assert_equal too_deep, output.string
- output = StringIO.new
- dump(eval(too_deep), output, 101)
- assert_equal too_deep, output.string
+ obj = eval(too_deep)
+ assert_equal too_deep, dump(obj)
+ assert_kind_of String, Marshal.dump(obj)
+ assert_raise(ArgumentError) { dump(obj, 100) }
+ assert_raise(ArgumentError) { Marshal.dump(obj, 100) }
+ assert_equal too_deep, dump(obj, 101)
+ assert_kind_of String, Marshal.dump(obj, 101)
+
+ assert_equal too_deep, JSON.dump(obj, StringIO.new, 101, strict: false).string
+ assert_equal too_deep, dump(obj, StringIO.new, 101, strict: false).string
+ assert_raise(JSON::GeneratorError) { JSON.dump(Object.new, StringIO.new, 101, strict: true).string }
+ assert_raise(JSON::GeneratorError) { dump(Object.new, StringIO.new, 101, strict: true).string }
+
+ assert_equal too_deep, dump(obj, nil, nil, strict: false)
+ assert_equal too_deep, dump(obj, nil, 101, strict: false)
+ assert_equal too_deep, dump(obj, StringIO.new, nil, strict: false).string
+ assert_equal too_deep, dump(obj, nil, strict: false)
+ assert_equal too_deep, dump(obj, 101, strict: false)
+ assert_equal too_deep, dump(obj, StringIO.new, strict: false).string
+ assert_equal too_deep, dump(obj, strict: false)
end
def test_dump_should_modify_defaults
diff --git a/test/json/json_encoding_test.rb b/test/json/json_encoding_test.rb
index cc7b71553a..be87f3c3d6 100644
--- a/test/json/json_encoding_test.rb
+++ b/test/json/json_encoding_test.rb
@@ -1,6 +1,5 @@
-# encoding: utf-8
-#frozen_string_literal: false
-require 'test_helper'
+# frozen_string_literal: false
+require_relative 'test_helper'
class JSONEncodingTest < Test::Unit::TestCase
include JSON
@@ -86,9 +85,7 @@ class JSONEncodingTest < Test::Unit::TestCase
def test_chars
(0..0x7f).each do |i|
json = '["\u%04x"]' % i
- if RUBY_VERSION >= "1.9."
- i = i.chr
- end
+ i = i.chr
assert_equal i, parse(json).first[0]
if i == ?\b
generated = generate(["" << i])
diff --git a/test/json/json_ext_parser_test.rb b/test/json/json_ext_parser_test.rb
index c5a030ea8a..f49f88b596 100644
--- a/test/json/json_ext_parser_test.rb
+++ b/test/json/json_ext_parser_test.rb
@@ -1,8 +1,10 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
class JSONExtParserTest < Test::Unit::TestCase
if defined?(JSON::Ext::Parser)
+ include JSON
+
def test_allocate
parser = JSON::Ext::Parser.new("{}")
assert_raise(TypeError, '[ruby-core:35079]') do
@@ -11,5 +13,22 @@ class JSONExtParserTest < Test::Unit::TestCase
parser = JSON::Ext::Parser.allocate
assert_raise(TypeError, '[ruby-core:35079]') { parser.source }
end
+
+ def test_error_messages
+ ex = assert_raise(ParserError) { parse('Infinity') }
+ assert_equal "unexpected token at 'Infinity'", ex.message
+
+ unless RUBY_PLATFORM =~ /java/
+ ex = assert_raise(ParserError) { parse('-Infinity') }
+ assert_equal "unexpected token at '-Infinity'", ex.message
+ end
+
+ ex = assert_raise(ParserError) { parse('NaN') }
+ assert_equal "unexpected token at 'NaN'", ex.message
+ end
+
+ def parse(json)
+ JSON::Ext::Parser.new(json).parse
+ end
end
end
diff --git a/test/json/json_fixtures_test.rb b/test/json/json_fixtures_test.rb
index 845abb4867..acc8749965 100644
--- a/test/json/json_fixtures_test.rb
+++ b/test/json/json_fixtures_test.rb
@@ -1,5 +1,5 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
class JSONFixturesTest < Test::Unit::TestCase
def setup
diff --git a/test/json/json_generator_test.rb b/test/json/json_generator_test.rb
index f31b6b290e..526bb8c1fe 100644..100755
--- a/test/json/json_generator_test.rb
+++ b/test/json/json_generator_test.rb
@@ -1,8 +1,7 @@
#!/usr/bin/env ruby
-# encoding: utf-8
# frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
class JSONGeneratorTest < Test::Unit::TestCase
include JSON
@@ -62,6 +61,14 @@ EOT
assert_equal '666', generate(666)
end
+ def test_dump_unenclosed_hash
+ assert_equal '{"a":1,"b":2}', dump(a: 1, b: 2)
+ end
+
+ def test_dump_strict
+ assert_equal '{}', dump({}, strict: true)
+ end
+
def test_generate_pretty
json = pretty_generate({})
assert_equal(<<'EOT'.chomp, json)
@@ -149,7 +156,8 @@ EOT
:ascii_only => false,
:buffer_initial_length => 1024,
:depth => 0,
- :escape_slash => false,
+ :script_safe => false,
+ :strict => false,
:indent => " ",
:max_nesting => 100,
:object_nl => "\n",
@@ -166,7 +174,8 @@ EOT
:ascii_only => false,
:buffer_initial_length => 1024,
:depth => 0,
- :escape_slash => false,
+ :script_safe => false,
+ :strict => false,
:indent => "",
:max_nesting => 100,
:object_nl => "",
@@ -183,7 +192,8 @@ EOT
:ascii_only => false,
:buffer_initial_length => 1024,
:depth => 0,
- :escape_slash => false,
+ :script_safe => false,
+ :strict => false,
:indent => "",
:max_nesting => 0,
:object_nl => "",
@@ -233,7 +243,7 @@ EOT
def test_gc
if respond_to?(:assert_in_out_err) && !(RUBY_PLATFORM =~ /java/)
- assert_in_out_err(%w[-rjson --disable-gems], <<-EOS, [], [])
+ assert_in_out_err(%w[-rjson], <<-EOS, [], [])
bignum_too_long_to_embed_as_string = 1234567890123456789012345
expect = bignum_too_long_to_embed_as_string.to_s
GC.stress = true
@@ -336,7 +346,13 @@ EOT
def test_json_generate
assert_raise JSON::GeneratorError do
- assert_equal true, generate(["\xea"])
+ generate(["\xea"])
+ end
+ end
+
+ def test_json_generate_unsupported_types
+ assert_raise JSON::GeneratorError do
+ generate(Object.new, strict: true)
end
end
@@ -370,6 +386,18 @@ EOT
#
data = [ '/' ]
json = '["\/"]'
+ assert_equal json, generate(data, :script_safe => true)
+ #
+ data = [ "\u2028\u2029" ]
+ json = '["\u2028\u2029"]'
+ assert_equal json, generate(data, :script_safe => true)
+ #
+ data = [ "ABC \u2028 DEF \u2029 GHI" ]
+ json = '["ABC \u2028 DEF \u2029 GHI"]'
+ assert_equal json, generate(data, :script_safe => true)
+ #
+ data = [ "/\u2028\u2029" ]
+ json = '["\/\u2028\u2029"]'
assert_equal json, generate(data, :escape_slash => true)
#
data = ['"']
@@ -391,6 +419,31 @@ EOT
end
end
+ if defined?(JSON::Ext::Generator) and RUBY_PLATFORM != "java"
+ def test_string_ext_included_calls_super
+ included = false
+
+ Module.send(:alias_method, :included_orig, :included)
+ Module.send(:remove_method, :included)
+ Module.send(:define_method, :included) do |base|
+ included_orig(base)
+ included = true
+ end
+
+ Class.new(String) do
+ include JSON::Ext::Generator::GeneratorMethods::String
+ end
+
+ assert included
+ ensure
+ if Module.private_method_defined?(:included_orig)
+ Module.send(:remove_method, :included) if Module.method_defined?(:included)
+ Module.send(:alias_method, :included, :included_orig)
+ Module.send(:remove_method, :included_orig)
+ end
+ end
+ end
+
if defined?(Encoding)
def test_nonutf8_encoding
assert_equal("\"5\u{b0}\"", "5\xb0".force_encoding("iso-8859-1").to_json)
diff --git a/test/json/json_generic_object_test.rb b/test/json/json_generic_object_test.rb
index 82742dcd63..d6d7e30816 100644
--- a/test/json/json_generic_object_test.rb
+++ b/test/json/json_generic_object_test.rb
@@ -1,5 +1,5 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
class JSONGenericObjectTest < Test::Unit::TestCase
include JSON
@@ -79,4 +79,4 @@ class JSONGenericObjectTest < Test::Unit::TestCase
ensure
JSON::GenericObject.json_creatable = false
end
-end
+end if defined?(JSON::GenericObject)
diff --git a/test/json/json_parser_test.rb b/test/json/json_parser_test.rb
index 00b254fc6a..49c7c8565d 100644
--- a/test/json/json_parser_test.rb
+++ b/test/json/json_parser_test.rb
@@ -1,10 +1,16 @@
# encoding: utf-8
# frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
require 'stringio'
require 'tempfile'
-require 'ostruct'
-require 'bigdecimal'
+begin
+ require 'ostruct'
+rescue LoadError
+end
+begin
+ require 'bigdecimal'
+rescue LoadError
+end
class JSONParserTest < Test::Unit::TestCase
include JSON
@@ -21,6 +27,9 @@ class JSONParserTest < Test::Unit::TestCase
end if defined?(Encoding::UTF_16)
def test_error_message_encoding
+ # https://github.com/flori/json/actions/runs/6478148162/job/17589572890
+ pend if RUBY_ENGINE == 'truffleruby'
+
bug10705 = '[ruby-core:67386] [Bug #10705]'
json = ".\"\xE2\x88\x9A\"".force_encoding(Encoding::UTF_8)
e = assert_raise(JSON::ParserError) {
@@ -113,6 +122,10 @@ class JSONParserTest < Test::Unit::TestCase
def test_parse_bigdecimals
assert_equal(BigDecimal, JSON.parse('{"foo": 9.01234567890123456789}', decimal_class: BigDecimal)["foo"].class)
assert_equal(BigDecimal("0.901234567890123456789E1"),JSON.parse('{"foo": 9.01234567890123456789}', decimal_class: BigDecimal)["foo"] )
+ end if defined?(::BigDecimal)
+
+ def test_parse_string_mixed_unicode
+ assert_equal(["éé"], JSON.parse("[\"\\u00e9é\"]"))
end
if Array.method_defined?(:permutation)
@@ -402,21 +415,6 @@ EOT
end
end
- class SubOpenStruct < OpenStruct
- def [](k)
- __send__(k)
- end
-
- def []=(k, v)
- @item_set = true
- __send__("#{k}=", v)
- end
-
- def item_set?
- @item_set
- end
- end
-
def test_parse_object_custom_hash_derived_class
res = parse('{"foo":"bar"}', :object_class => SubHash)
assert_equal({"foo" => "bar"}, res)
@@ -424,24 +422,41 @@ EOT
assert res.item_set?
end
- def test_parse_object_custom_non_hash_derived_class
- res = parse('{"foo":"bar"}', :object_class => SubOpenStruct)
- assert_equal "bar", res.foo
- assert_equal(SubOpenStruct, res.class)
- assert res.item_set?
- end
+ if defined?(::OpenStruct)
+ class SubOpenStruct < OpenStruct
+ def [](k)
+ __send__(k)
+ end
- def test_parse_generic_object
- res = parse(
- '{"foo":"bar", "baz":{}}',
- :object_class => JSON::GenericObject
- )
- assert_equal(JSON::GenericObject, res.class)
- assert_equal "bar", res.foo
- assert_equal "bar", res["foo"]
- assert_equal "bar", res[:foo]
- assert_equal "bar", res.to_hash[:foo]
- assert_equal(JSON::GenericObject, res.baz.class)
+ def []=(k, v)
+ @item_set = true
+ __send__("#{k}=", v)
+ end
+
+ def item_set?
+ @item_set
+ end
+ end
+
+ def test_parse_object_custom_non_hash_derived_class
+ res = parse('{"foo":"bar"}', :object_class => SubOpenStruct)
+ assert_equal "bar", res.foo
+ assert_equal(SubOpenStruct, res.class)
+ assert res.item_set?
+ end
+
+ def test_parse_generic_object
+ res = parse(
+ '{"foo":"bar", "baz":{}}',
+ :object_class => JSON::GenericObject
+ )
+ assert_equal(JSON::GenericObject, res.class)
+ assert_equal "bar", res.foo
+ assert_equal "bar", res["foo"]
+ assert_equal "bar", res[:foo]
+ assert_equal "bar", res.to_hash[:foo]
+ assert_equal(JSON::GenericObject, res.baz.class)
+ end
end
def test_generate_core_subclasses_with_new_to_json
diff --git a/test/json/json_string_matching_test.rb b/test/json/json_string_matching_test.rb
index 5d55dc31b0..b9cf904aaa 100644
--- a/test/json/json_string_matching_test.rb
+++ b/test/json/json_string_matching_test.rb
@@ -1,5 +1,5 @@
#frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
require 'time'
class JSONStringMatchingTest < Test::Unit::TestCase
diff --git a/test/json/ractor_test.rb b/test/json/ractor_test.rb
index 71105e55ec..ba9bf7a7f6 100644
--- a/test/json/ractor_test.rb
+++ b/test/json/ractor_test.rb
@@ -1,7 +1,11 @@
-# encoding: utf-8
# frozen_string_literal: false
-require 'test_helper'
+require_relative 'test_helper'
+
+begin
+ require_relative './lib/helper'
+rescue LoadError
+end
class JSONInRactorTest < Test::Unit::TestCase
def test_generate
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-23 19:54:54 +0000