Skip to content

Update Hash syntax in tests #1063

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
byroot merged 1 commit into from
Aug 17, 2026
+102 −102
Merged

Update Hash syntax in tests #1063

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 12 additions & 12 deletions Rakefile
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -143,10 +143,10 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
end

desc "Compiling jruby extension"
task :compile => JAVA_CLASSES
task compile: JAVA_CLASSES

desc "Package the jruby gem"
task :jruby_gem => :create_jar do
task jruby_gem: :create_jar do
mkdir_p 'pkg'
sh "gem build -o pkg/json-#{PKG_VERSION}-java.gem json.gemspec"
end
Expand All @@ -158,7 +158,7 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
t.options = '-v'
end
desc "Testing library (jruby)"
task :test => [:create_jar ]
task test: [:create_jar ]

file JRUBY_PARSER_JAR => :compile do
cd 'java/src' do
Expand All @@ -178,7 +178,7 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
end

desc "Create parser jar"
task :create_parser_jar => JRUBY_PARSER_JAR
task create_parser_jar: JRUBY_PARSER_JAR

file JRUBY_GENERATOR_JAR => :compile do
cd 'java/src' do
Expand All @@ -198,15 +198,15 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
end

desc "Create generator jar"
task :create_generator_jar => JRUBY_GENERATOR_JAR
task create_generator_jar: JRUBY_GENERATOR_JAR

desc "Create parser and generator jars"
task :create_jar => [ :create_parser_jar, :create_generator_jar ]
task create_jar: [ :create_parser_jar, :create_generator_jar ]

desc "Build all gems and archives for a new release of the jruby extension."
task :build => [ :clean, :jruby_gem ]
task build: [ :clean, :jruby_gem ]

task :release => :build
task release: :build
else
require 'rake/extensiontask'

Expand All @@ -224,7 +224,7 @@ else
end

desc "Testing library (extension)"
task :test => [ :compile ]
task test: [ :compile ]

begin
require "ruby_memcheck"
Expand All @@ -249,10 +249,10 @@ else
end

desc "Build all gems and archives for a new release of json"
task :build => [ :clean, :package ]
task build: [ :clean, :package ]

task :release => :build
task release: :build
end

desc "Compile in the the source directory"
task :default => [ :clean, :test ]
task default: [ :clean, :test ]
26 changes: 13 additions & 13 deletions test/json/json_common_interface_test.rb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -158,16 +158,16 @@ def test_load_with_proc

def test_load_with_options
json = '{ "foo": NaN }'
assert JSON.load(json, nil, :allow_nan => true)['foo'].nan?
assert JSON.load(json, :allow_nan => true)['foo'].nan?
assert JSON.load(json, nil, allow_nan: true)['foo'].nan?
assert JSON.load(json, allow_nan: true)['foo'].nan?
end

def test_load_null
assert_equal nil, JSON.load(nil, nil, :allow_blank => true)
assert_raise(TypeError) { JSON.load(nil, nil, :allow_blank => false) }
assert_raise(JSON::ParserError) { JSON.load('', nil, :allow_blank => false) }
assert_raise(TypeError) { JSON.load([], nil, :allow_blank => true) }
assert_raise(TypeError) { JSON.load({}, nil, :allow_blank => true) }
assert_equal nil, JSON.load(nil, nil, allow_blank: true)
assert_raise(TypeError) { JSON.load(nil, nil, allow_blank: false) }
assert_raise(JSON::ParserError) { JSON.load('', nil, allow_blank: false) }
assert_raise(TypeError) { JSON.load([], nil, allow_blank: true) }
assert_raise(TypeError) { JSON.load({}, nil, allow_blank: true) }
end

def test_unsafe_load
Expand Down Expand Up @@ -240,16 +240,16 @@ def test_unsafe_load_default_options

def test_unsafe_load_with_options
nan_json = '{ "foo": NaN }'
assert_raise(JSON::ParserError) { JSON.unsafe_load(nan_json, nil, :allow_nan => false)['foo'].nan? }
assert_raise(JSON::ParserError) { JSON.unsafe_load(nan_json, nil, allow_nan: false)['foo'].nan? }
# make sure it still uses the defaults when something is provided
assert JSON.unsafe_load(nan_json, nil, :allow_blank => true)['foo'].nan?
assert JSON.unsafe_load(nan_json, :allow_nan => true)['foo'].nan?
assert JSON.unsafe_load(nan_json, nil, allow_blank: true)['foo'].nan?
assert JSON.unsafe_load(nan_json, allow_nan: true)['foo'].nan?
end

def test_unsafe_load_null
assert_equal nil, JSON.unsafe_load(nil, nil, :allow_blank => true)
assert_raise(TypeError) { JSON.unsafe_load(nil, nil, :allow_blank => false) }
assert_raise(JSON::ParserError) { JSON.unsafe_load('', nil, :allow_blank => false) }
assert_equal nil, JSON.unsafe_load(nil, nil, allow_blank: true)
assert_raise(TypeError) { JSON.unsafe_load(nil, nil, allow_blank: false) }
assert_raise(JSON::ParserError) { JSON.unsafe_load('', nil, allow_blank: false) }
end

def test_dump
Expand Down
110 changes: 55 additions & 55 deletions test/json/json_generator_test.rb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -175,7 +175,7 @@ def test_generate_pretty
end

def test_generate_pretty_custom
state = State.new(:space_before => "<psb>", :space => "<ps>", :indent => "<pi>", :object_nl => "\n<po_nl>\n", :array_nl => "<pa_nl>")
state = State.new(space_before: "<psb>", space: "<ps>", indent: "<pi>", object_nl: "\n<po_nl>\n", array_nl: "<pa_nl>")
json = pretty_generate({1=>{}, 2=>['a','b'], 3=>4}, state)
assert_equal(<<~'JSON'.chomp, json)
{
Expand Down Expand Up @@ -244,7 +244,7 @@ def test_generate_sort_keys_with_proc
end

def test_generate_custom
state = State.new(:space_before => " ", :space => " ", :indent => "<i>", :object_nl => "\n", :array_nl => "<a_nl>")
state = State.new(space_before: " ", space: " ", indent: "<i>", object_nl: "\n", array_nl: "<a_nl>")
json = generate({1=>{2=>3,4=>[5,6]}}, state)
assert_equal(<<~'JSON'.chomp, json)
{
Expand Down Expand Up @@ -307,62 +307,62 @@ def test_falsy_state
def test_state_defaults
state = JSON::State.new
assert_equal({
:allow_duplicate_key => false,
:allow_nan => false,
:array_nl => "",
:as_json => false,
:ascii_only => false,
:buffer_initial_length => 1024,
:depth => 0,
:script_safe => false,
:strict => false,
:indent => "",
:max_nesting => 100,
:object_nl => "",
:space => "",
:space_before => "",
:sort_keys => false,
allow_duplicate_key: false,
allow_nan: false,
array_nl: "",
as_json: false,
ascii_only: false,
buffer_initial_length: 1024,
depth: 0,
script_safe: false,
strict: false,
indent: "",
max_nesting: 100,
object_nl: "",
space: "",
space_before: "",
sort_keys: false,
}.sort_by { |n,| n.to_s }.to_h, state.to_h.sort_by { |n,| n.to_s }.to_h)

state = JSON::State.new(allow_duplicate_key: true)
assert_equal({
:allow_duplicate_key => true,
:allow_nan => false,
:array_nl => "",
:as_json => false,
:ascii_only => false,
:buffer_initial_length => 1024,
:depth => 0,
:script_safe => false,
:strict => false,
:indent => "",
:max_nesting => 100,
:object_nl => "",
:space => "",
:space_before => "",
:sort_keys => false,
allow_duplicate_key: true,
allow_nan: false,
array_nl: "",
as_json: false,
ascii_only: false,
buffer_initial_length: 1024,
depth: 0,
script_safe: false,
strict: false,
indent: "",
max_nesting: 100,
object_nl: "",
space: "",
space_before: "",
sort_keys: false,
}.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
end

def test_allow_nan
error = assert_raise(GeneratorError) { generate([JSON::NaN]) }
assert_same JSON::NaN, error.invalid_object
assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
assert_equal '[NaN]', generate([JSON::NaN], allow_nan: true)
assert_raise(GeneratorError) { generate([JSON::NaN]) }
assert_raise(GeneratorError) { pretty_generate([JSON::NaN]) }
assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], allow_nan: true)
error = assert_raise(GeneratorError) { generate([JSON::Infinity]) }
assert_same JSON::Infinity, error.invalid_object
assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
assert_equal '[Infinity]', generate([JSON::Infinity], allow_nan: true)
assert_raise(GeneratorError) { generate([JSON::Infinity]) }
assert_raise(GeneratorError) { pretty_generate([JSON::Infinity]) }
assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], allow_nan: true)
error = assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) }
assert_same JSON::MinusInfinity, error.invalid_object
assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
assert_equal '[-Infinity]', generate([JSON::MinusInfinity], allow_nan: true)
assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) }
assert_raise(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], allow_nan: true)
end

# An object that changes state.depth when it receives to_json(state)
Expand Down Expand Up @@ -489,11 +489,11 @@ def test_gc

def test_configure_using_configure_and_merge
numbered_state = {
:indent => "1",
:space => '2',
:space_before => '3',
:object_nl => '4',
:array_nl => '5'
indent: "1",
space: '2',
space_before: '3',
object_nl: '4',
array_nl: '5'
}
state1 = JSON.state.new
state1.merge(numbered_state)
Expand All @@ -513,7 +513,7 @@ def test_configure_using_configure_and_merge

def test_configure_hash_conversion
state = JSON.state.new
state.configure(:indent => '1')
state.configure(indent: '1')
assert_equal '1', state.indent
state = JSON.state.new
foo = 'foo'.dup
Expand Down Expand Up @@ -595,14 +595,14 @@ def test_nesting
too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
too_deep_ary = eval too_deep
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_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
ok = generate too_deep_ary, max_nesting: nil
assert_equal too_deep, ok
ok = generate too_deep_ary, :max_nesting => false
ok = generate too_deep_ary, max_nesting: false
assert_equal too_deep, ok
ok = generate too_deep_ary, :max_nesting => 0
ok = generate too_deep_ary, max_nesting: 0
assert_equal too_deep, ok

assert_raise(TypeError) { generate too_deep_ary, max_nesting: "garbage" }
Expand Down Expand Up @@ -631,27 +631,27 @@ def test_backslash
#
data = [ '/' ]
json = '["\/"]'
assert_equal json, generate(data, :script_safe => true)
assert_equal json, generate(data, script_safe: true)
#
data = [ '///////////' ]
json = '["\/\/\/\/\/\/\/\/\/\/\/"]'
assert_equal json, generate(data, :script_safe => true)
assert_equal json, generate(data, script_safe: true)
#
data = [ '///////////////////////////////////////////////////////' ]
json = '["\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/"]'
assert_equal json, generate(data, :script_safe => true)
assert_equal json, generate(data, script_safe: true)
#
data = [ "\u2028\u2029" ]
json = '["\u2028\u2029"]'
assert_equal json, generate(data, :script_safe => true)
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)
assert_equal json, generate(data, script_safe: true)
#
data = [ "/\u2028\u2029" ]
json = '["\/\u2028\u2029"]'
assert_equal json, generate(data, :script_safe => true)
assert_equal json, generate(data, script_safe: true)
#
data = ['"']
json = '["\""]'
Expand Down
Loading
Loading