oj 3.13.9 → 3.16.1

data/test/_test_active.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
+$LOAD_PATH << __dir__
 %w(lib ext test).each do |dir|
   $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
 end
@@ -13,14 +13,14 @@ require 'sqlite3'
 require 'active_record'
 require 'oj'
 
-#Oj.mimic_JSON()
+# Oj.mimic_JSON()
 Oj.default_options = {mode: :compat, indent: 2}
 
-#ActiveRecord::Base.logger = Logger.new(STDERR)
+# ActiveRecord::Base.logger = Logger.new(STDERR)
 
 ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => ":memory:"
+  :adapter => 'sqlite3',
+  :database => ':memory:'
 )
 
 ActiveRecord::Schema.define do
@@ -37,8 +37,8 @@ end
 class ActiveTest < Minitest::Test
 
   def test_active
-    User.find_or_create_by(first_name: "John", last_name: "Smith", email: "john@example.com")
-    User.find_or_create_by(first_name: "Joan", last_name: "Smith", email: "joan@example.com")
+    User.find_or_create_by(first_name: 'John', last_name: 'Smith', email: 'john@example.com')
+    User.find_or_create_by(first_name: 'Joan', last_name: 'Smith', email: 'joan@example.com')
 
     # Single instance.
     assert_equal(%|{
@@ -71,6 +71,5 @@ class ActiveTest < Minitest::Test
 
     # Array of instances as json. (not Oj)
     assert_equal(%|[{"id":1,"first_name":"John","last_name":"Smith","email":"john@example.com"},{"id":2,"first_name":"Joan","last_name":"Smith","email":"joan@example.com"}]|, User.all.to_json)
-
   end
 end

data/test/_test_active_mimic.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
+$LOAD_PATH << __dir__
 %w(lib ext test).each do |dir|
   $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
 end
@@ -16,11 +16,11 @@ require 'oj'
 Oj.mimic_JSON()
 Oj.default_options = {mode: :compat, indent: 2}
 
-#ActiveRecord::Base.logger = Logger.new(STDERR)
+# ActiveRecord::Base.logger = Logger.new(STDERR)
 
 ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => ":memory:"
+  :adapter => 'sqlite3',
+  :database => ':memory:'
 )
 
 ActiveRecord::Schema.define do
@@ -37,8 +37,8 @@ end
 class ActiveTest < Minitest::Test
 
   def test_active
-    User.find_or_create_by(first_name: "John", last_name: "Smith", email: "john@example.com")
-    User.find_or_create_by(first_name: "Joan", last_name: "Smith", email: "joan@example.com")
+    User.find_or_create_by(first_name: 'John', last_name: 'Smith', email: 'john@example.com')
+    User.find_or_create_by(first_name: 'Joan', last_name: 'Smith', email: 'joan@example.com')
 
     # Single instance.
     assert_equal(%|{
@@ -91,6 +91,5 @@ class ActiveTest < Minitest::Test
   }
 ]
 |, User.all.to_json)
-
   end
 end

data/test/_test_mimic_rails.rb

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
+$LOAD_PATH << __dir__
 
 require 'helper'
-#Oj.mimic_JSON
+# Oj.mimic_JSON
 require 'rails/all'
 
 require 'active_model'
@@ -36,14 +36,12 @@ end
 class MimicRails < Minitest::Test
 
   def test_mimic_exception
-    begin
-      ActiveSupport::JSON.decode("{")
-      puts "Failed"
-    rescue ActiveSupport::JSON.parse_error
-      assert(true)
-    rescue Exception
-      assert(false, 'Expected a JSON::ParserError')
-    end
+    ActiveSupport::JSON.decode('{')
+    puts 'Failed'
+  rescue ActiveSupport::JSON.parse_error
+    assert(true)
+  rescue Exception
+    assert(false, 'Expected a JSON::ParserError')
   end
 
   def test_dump_string
@@ -84,18 +82,17 @@ class MimicRails < Minitest::Test
     category = Category.new(1, 'test')
     serializer = CategorySerializer.new(category)
 
-    json = serializer.to_json()
+    serializer.to_json()
     puts "*** serializer.to_json() #{serializer.to_json()}"
-    json = serializer.as_json()
+    serializer.as_json()
     puts "*** serializer.as_json() #{serializer.as_json()}"
-    json = JSON.dump(serializer)
+    JSON.dump(serializer)
     puts "*** JSON.dump(serializer) #{JSON.dump(serializer)}"
 
     puts "*** category.to_json() #{category.to_json()}"
     puts "*** category.as_json() #{category.as_json()}"
     puts "*** JSON.dump(serializer) #{JSON.dump(category)}"
     puts "*** Oj.dump(serializer) #{Oj.dump(category)}"
-
   end
 
   def test_dump_object_array
@@ -104,7 +101,7 @@ class MimicRails < Minitest::Test
     cat2 = Category.new(2, 'test')
     a = Array.wrap([cat1, cat2])
 
-    #serializer = CategorySerializer.new(a)
+    # serializer = CategorySerializer.new(a)
 
     puts "*** a.to_json() #{a.to_json()}"
     puts "*** a.as_json() #{a.as_json()}"
@@ -114,13 +111,13 @@ class MimicRails < Minitest::Test
 
   def test_dump_time
     Oj.default_options= {:indent => 2}
-    now = ActiveSupport::TimeZone['America/Chicago'].parse("2014-11-01 13:20:47")
+    now = ActiveSupport::TimeZone['America/Chicago'].parse('2014-11-01 13:20:47')
     json = Oj.dump(now, mode: :object, time_format: :xmlschema)
-    #puts "*** json: #{json}"
+    # puts "*** json: #{json}"
 
     oj_dump = Oj.load(json, mode: :object, time_format: :xmlschema)
-    #puts "Now: #{now}\n Oj: #{oj_dump}"
-    assert_equal("2014-11-01T13:20:47-05:00", oj_dump.xmlschema)
+    # puts "Now: #{now}\n Oj: #{oj_dump}"
+    assert_equal('2014-11-01T13:20:47-05:00', oj_dump.xmlschema)
   end
 
 end # MimicRails

data/test/activerecord/result_test.rb

@@ -13,13 +13,12 @@ Oj.default_options = { mode: :rails }
 
 class ActiveRecordResultTest < Minitest::Test
   def test_hash_rows
-
     result = ActiveRecord::Result.new(["one", "two"],
-				      [
-					["row 1 col 1", "row 1 col 2"],
-					["row 2 col 1", "row 2 col 2"],
-					["row 3 col 1", "row 3 col 2"],
-				      ])
+                                      [
+                                        ["row 1 col 1", "row 1 col 2"],
+                                        ["row 2 col 1", "row 2 col 2"],
+                                        ["row 3 col 1", "row 3 col 2"],
+                                      ])
     #puts "*** result: #{Oj.dump(result, indent: 2)}"
     json_result = if ActiveRecord.version >= Gem::Version.new("6")
                     result.to_a

data/test/{activesupport5 → activesupport7}/abstract_unit.rb

@@ -2,6 +2,7 @@
 
 ORIG_ARGV = ARGV.dup
 
+require "bundler/setup"
 require "active_support/core_ext/kernel/reporting"
 
 silence_warnings do
@@ -27,19 +28,22 @@ ActiveSupport.to_time_preserves_timezone = ENV["PRESERVE_TIMEZONES"] == "1"
 I18n.enforce_available_locales = false
 
 class ActiveSupport::TestCase
-  include ActiveSupport::Testing::MethodCallAssertions
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
+  if Process.respond_to?(:fork) && !Gem.win_platform?
+    parallelize
+  else
+    parallelize(with: :threads)
   end
 
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
+  include ActiveSupport::Testing::MethodCallAssertions
 
-  def frozen_error_class
-    Object.const_defined?(:FrozenError) ? FrozenError : RuntimeError
-  end
+  private
+    # Skips the current run on Rubinius using Minitest::Assertions#skip
+    def rubinius_skip(message = "")
+      skip message if RUBY_ENGINE == "rbx"
+    end
+
+    # Skips the current run on JRuby using Minitest::Assertions#skip
+    def jruby_skip(message = "")
+      skip message if defined?(JRUBY_VERSION)
+    end
 end

data/test/{activesupport5 → activesupport7}/decoding_test.rb

@@ -5,18 +5,9 @@ require "active_support/json"
 require "active_support/time"
 require_relative "time_zone_test_helpers"
 
-require 'oj'
-
-Oj::Rails.set_decoder()
-
 class TestJSONDecoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
 
-  # Added for testing if Oj is used.
-  test "oj is used as an encoder" do
-    assert_equal ActiveSupport.json_encoder, Oj::Rails::Encoder
-  end
-
   class Foo
     def self.json_create(object)
       "Foo"
@@ -49,6 +40,8 @@ class TestJSONDecoding < ActiveSupport::TestCase
     # needs to be *exact*
     %({"a": " 2007-01-01 01:12:34 Z "})          => { "a" => " 2007-01-01 01:12:34 Z " },
     %({"a": "2007-01-01 : it's your birthday"})  => { "a" => "2007-01-01 : it's your birthday" },
+    %({"a": "Today is:\\n2020-05-21"})           => { "a" => "Today is:\n2020-05-21" },
+    %({"a": "2007-01-01 01:12:34 Z\\nwas my birthday"}) => { "a" => "2007-01-01 01:12:34 Z\nwas my birthday" },
     %([])    => [],
     %({})    => {},
     %({"a":1}) => { "a" => 1 },
@@ -122,7 +115,6 @@ class TestJSONDecoding < ActiveSupport::TestCase
   end
 
   private
-
     def with_parse_json_times(value)
       old_value = ActiveSupport.parse_json_times
       ActiveSupport.parse_json_times = value

data/test/{activesupport5 → activesupport7}/encoding_test.rb

@@ -3,28 +3,14 @@
 require "securerandom"
 require_relative "abstract_unit"
 require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/regexp"
 require "active_support/json"
 require "active_support/time"
 require_relative "time_zone_test_helpers"
 require_relative "encoding_test_cases"
 
-require 'oj'
-
-# Sets the ActiveSupport encoder to be Oj and also wraps the setting of
-# globals.
-Oj::Rails.set_encoder()
-#Oj::Rails.optimize(Hash, Array, BigDecimal, Time, Range, Regexp, ActiveSupport::TimeWithZone)
-Oj::Rails.optimize()
-
 class TestJSONEncoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
 
-  # Added for testing if Oj is used.
-  test "oj is used as an encoder" do
-    assert_equal ActiveSupport.json_encoder, Oj::Rails::Encoder
-  end
-
   def sorted_json(json)
     if json.start_with?("{") && json.end_with?("}")
       "{" + json[1..-2].split(",").sort.join(",") + "}"
@@ -35,20 +21,18 @@ class TestJSONEncoding < ActiveSupport::TestCase
 
   JSONTest::EncodingTestCases.constants.each do |class_tests|
     define_method("test_#{class_tests[0..-6].underscore}") do
-      begin
-        prev = ActiveSupport.use_standard_json_time_format
-
-        standard_class_tests = /Standard/.match?(class_tests)
-
-        ActiveSupport.escape_html_entities_in_json  = !standard_class_tests
-        ActiveSupport.use_standard_json_time_format = standard_class_tests
-        JSONTest::EncodingTestCases.const_get(class_tests).each do |pair|
-          assert_equal pair.last, sorted_json(ActiveSupport::JSON.encode(pair.first))
-        end
-      ensure
-        ActiveSupport.escape_html_entities_in_json  = false
-        ActiveSupport.use_standard_json_time_format = prev
+      prev = ActiveSupport.use_standard_json_time_format
+
+      standard_class_tests = /Standard/.match?(class_tests)
+
+      ActiveSupport.escape_html_entities_in_json  = !standard_class_tests
+      ActiveSupport.use_standard_json_time_format = standard_class_tests
+      JSONTest::EncodingTestCases.const_get(class_tests).each do |pair|
+        assert_equal pair.last, sorted_json(ActiveSupport::JSON.encode(pair.first))
       end
+    ensure
+      ActiveSupport.escape_html_entities_in_json  = false
+      ActiveSupport.use_standard_json_time_format = prev
     end
   end
 
@@ -78,12 +62,6 @@ class TestJSONEncoding < ActiveSupport::TestCase
   end
 
   def test_utf8_string_encoded_properly
-    # The original test seems to expect that
-    # ActiveSupport.escape_html_entities_in_json reverts to true even after
-    # being set to false. I haven't been able to figure that out so the value is
-    # set to true, the default, before running the test. This might be wrong but
-    # for now it will have to do.
-    ActiveSupport.escape_html_entities_in_json = true
     result = ActiveSupport::JSON.encode("€2.99")
     assert_equal '"€2.99"', result
     assert_equal(Encoding::UTF_8, result.encoding)
@@ -177,6 +155,15 @@ class TestJSONEncoding < ActiveSupport::TestCase
     assert_equal({ "foo" => "hello" }, JSON.parse(json))
   end
 
+  def test_struct_to_json_with_options_nested
+    klass = Struct.new(:foo, :bar)
+    struct = klass.new "hello", "world"
+    parent_struct = klass.new struct, "world"
+    json = parent_struct.to_json only: [:foo]
+
+    assert_equal({ "foo" => { "foo" => "hello" } }, JSON.parse(json))
+  end
+
   def test_hash_should_pass_encoding_options_to_children_in_as_json
     person = {
       name: "John",
@@ -478,7 +465,6 @@ EXPECTED
   end
 
   private
-
     def object_keys(json_object)
       json_object[1..-2].scan(/([^{}:,\s]+):/).flatten.sort
     end

data/test/{activesupport5 → activesupport7}/encoding_test_cases.rb

@@ -68,6 +68,10 @@ module JSONTest
                      [ :this,  %("this") ],
                      [ :"a b", %("a b")  ]]
 
+    ModuleTests   = [[ Module, %("Module") ],
+                     [ Class,  %("Class")  ],
+                     [ ActiveSupport,                   %("ActiveSupport")                   ],
+                     [ ActiveSupport::MessageEncryptor, %("ActiveSupport::MessageEncryptor") ]]
     ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
     HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
     StructTests   = [[ MyStruct.new(:foo, "bar"), %({\"name\":\"foo\",\"value\":\"bar\"}) ],
@@ -86,6 +90,8 @@ module JSONTest
 
     PathnameTests = [[ Pathname.new("lib/index.rb"), %("lib/index.rb") ]]
 
+    IPAddrTests   = [[  IPAddr.new("127.0.0.1"), %("127.0.0.1") ]]
+
     DateTests     = [[ Date.new(2005, 2, 1), %("2005/02/01") ]]
     TimeTests     = [[ Time.utc(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]
     DateTimeTests = [[ DateTime.civil(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]

data/test/{activesupport5 → activesupport7}/time_zone_test_helpers.rb

@@ -36,4 +36,12 @@ module TimeZoneTestHelpers
     ActiveSupport::TimeZone::MAPPING.clear
     ActiveSupport::TimeZone::MAPPING.merge!(old_mappings)
   end
+
+  def with_utc_to_local_returns_utc_offset_times(value)
+    old_tzinfo2_format = ActiveSupport.utc_to_local_returns_utc_offset_times
+    ActiveSupport.utc_to_local_returns_utc_offset_times = value
+    yield
+  ensure
+    ActiveSupport.utc_to_local_returns_utc_offset_times = old_tzinfo2_format
+  end
 end

data/test/files.rb

@@ -1,29 +1,29 @@
 #!/usr/bin/env ruby -wW2
+# frozen_string_literal: true
 
-if $0 == __FILE__
-  $: << '.'
-  $: << '..'
-  $: << '../lib'
-  $: << '../ext'
+if $PROGRAM_NAME == __FILE__
+  $LOAD_PATH << '.'
+  $LOAD_PATH << '..'
+  $LOAD_PATH << '../lib'
+  $LOAD_PATH << '../ext'
 end
 
-require 'pp'
 require 'sample/file'
 require 'sample/dir'
 
 def files(dir)
-  d = ::Sample::Dir.new(dir)
+  d = Sample::Dir.new(dir)
   Dir.new(dir).each do |fn|
     next if fn.start_with?('.')
+
     filename = File.join(dir, fn)
-    #filename = '.' == dir ? fn : File.join(dir, fn)
-    if File.directory?(filename)
-      d << files(filename)
-    else
-      d << ::Sample::File.new(filename)
-    end
+    # filename = '.' == dir ? fn : File.join(dir, fn)
+    d << if File.directory?(filename)
+           files(filename)
+         else
+           Sample::File.new(filename)
+         end
   end
-  #pp d
+  # pp d
   d
 end
-

data/test/foo.rb

@@ -1,20 +1,20 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-$: << '.'
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
+$LOAD_PATH << '.'
+$LOAD_PATH << File.join(__dir__, '../lib')
+$LOAD_PATH << File.join(__dir__, '../ext')
 
-# require 'json'
+require 'active_support'
+require 'json'
 require 'oj'
-Oj.mimic_JSON
 
-source = %( {"a": 1, "b": 2} )
-puts "JSON.load, no symbolize => OK"
-pp JSON.load( source )
-puts "JSON.load, do symbolize => KO: keys are not symbols"
-#pp JSON.load( source, nil, symbolize_names: true, create_additions: false )
-pp JSON.load( source, nil, symbolize_names: true, create_additions: false )
-puts "JSON.parse, no symbolize => OK"
-pp JSON.parse( source )
-puts "JSON.parse, do symbolize => OK"
-pp JSON.parse( source, symbolize_names: true )
+Oj.mimic_JSON()
+# Oj::Rails.mimic_JSON()
+
+begin
+  ::JSON.parse('{ "foo": 84e }')
+  #::JSON.parse('{ "foo": 84eb234 }')
+rescue Exception => e
+  puts "#{e.class}: #{e.message}"
+end

data/test/helper.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-#
+
 # Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
 # required. That can be set in the RUBYOPT environment variable.
 # export RUBYOPT=-w
@@ -15,22 +15,25 @@ require 'minitest/autorun'
 require 'stringio'
 require 'date'
 require 'bigdecimal'
-require 'pp'
 require 'oj'
 
-
-if defined?(GC.verify_compaction_references) == 'method'
+def verify_gc_compaction
   # This method was added in Ruby 3.0.0. Calling it this way asks the GC to
   # move objects around, helping to find object movement bugs.
-  GC.verify_compaction_references(double_heap: true, toward: :empty)
+  if defined?(GC.verify_compaction_references) == 'method' && RbConfig::CONFIG['host_os'] !~ /(mingw|mswin)/
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2.0')
+      GC.verify_compaction_references(expand_heap: true, toward: :empty)
+    else
+      GC.verify_compaction_references(double_heap: true, toward: :empty)
+    end
+  end
 end
 
-
 $ruby = RUBY_DESCRIPTION.split(' ')[0]
 $ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
 
 class Range
-  def to_hash()
-    { 'begin' => self.begin, 'end' => self.end, 'exclude_end' => self.exclude_end? }
+  def to_hash
+    { 'begin' => self.begin, 'end' => self.end, 'exclude_end' => exclude_end? }
   end
 end

data/test/isolated/shared.rb

@@ -21,7 +21,7 @@ class SharedMimicTest < Minitest::Test
     alias == eql?
 
     def as_json()
-      {"json_class" => self.class.to_s,"x" => @x,"y" => @y}
+      {"json_class" => self.class.to_s, "x" => @x, "y" => @y}
     end
 
     def self.json_create(h)
@@ -207,7 +207,6 @@ class SharedMimicTest < Minitest::Test
 --],#
 --"a"~:*1#
 }} == json)
-
   end
 
 # fast_generate
@@ -261,6 +260,8 @@ class SharedMimicTest < Minitest::Test
     obj = JSON.parse(json, :create_additions => true)
     JSON.create_id = 'json_class'
     assert_equal(jam, obj)
+
+    assert_nothing_raised { JSON.create_id = nil }
   end
   def test_parse_bang
     json = %{{"a":1,"b":[true,false]}}

data/test/json_gem/json_addition_test.rb

@@ -191,9 +191,9 @@ class JSONAdditionTest < Test::Unit::TestCase
     assert_equal d, JSON.parse(d.to_json, :create_additions => true)
     d = DateTime.parse(now.utc.to_s) # of = 0
     assert_equal d, JSON.parse(d.to_json, :create_additions => true)
-    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(1,24))
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(1, 24))
     assert_equal d, JSON.parse(d.to_json, :create_additions => true)
-    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(12,24))
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(12, 24))
     assert_equal d, JSON.parse(d.to_json, :create_additions => true)
   end
 

data/test/json_gem/json_common_interface_test.rb

@@ -29,7 +29,7 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
     #@json = '{"a":2,"b":5.23683071,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
     #'"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
     @json = '{"a":2,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
-	    '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+            '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
   end
 
   def test_index
@@ -43,15 +43,15 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
   # functionality and perform better.
 
   def test_parser
-    assert_match /::Parser\z/, JSON.parser.name
+    assert_match(/::Parser\z/, JSON.parser.name)
   end
 
   def test_generator
-    assert_match /::Generator\z/, JSON.generator.name
+    assert_match(/::Generator\z/, JSON.generator.name)
   end
 
   def test_state
-    assert_match /::Generator::State\z/, JSON.state.name
+    assert_match(/::Generator::State\z/, JSON.state.name)
   end
 
   # This doesn't have anything to do with JSON parsing or generation. It seems
@@ -128,8 +128,10 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
     too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     assert_equal too_deep, JSON.dump(eval(too_deep))
     assert_kind_of String, Marshal.dump(eval(too_deep))
-    assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
-    assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    if RUBY_ENGINE != 'truffleruby'
+      assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
+      assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    end
     assert_equal too_deep, JSON.dump(eval(too_deep), 101)
     assert_kind_of String, Marshal.dump(eval(too_deep), 101)
     output = StringIO.new

data/test/json_gem/json_ext_parser_test.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 #frozen_string_literal: false
+
 require 'json_gem/test_helper'
 
 class JSONExtParserTest < Test::Unit::TestCase

data/test/json_gem/json_fixtures_test.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 #frozen_string_literal: false
+
 require 'json_gem/test_helper'
 
 class JSONFixturesTest < Test::Unit::TestCase
@@ -16,7 +17,7 @@ class JSONFixturesTest < Test::Unit::TestCase
     for name, source in @passed
       begin
         assert JSON.parse(source),
-          "Did not pass for fixture '#{name}': #{source.inspect}"
+               "Did not pass for fixture '#{name}': #{source.inspect}"
       rescue => e
         warn "\nCaught #{e.class}(#{e}) for fixture '#{name}': #{source.inspect}\n#{e.backtrace * "\n"}"
         raise e
@@ -27,7 +28,7 @@ class JSONFixturesTest < Test::Unit::TestCase
   def test_failing
     for name, source in @failed
       assert_raise(JSON::ParserError, JSON::NestingError,
-        "Did not fail for fixture '#{name}': #{source.inspect}") do
+                   "Did not fail for fixture '#{name}': #{source.inspect}") do
         JSON.parse(source)
       end
     end