ffi-yajl 2.2.3-universal-java → 2.4.0-universal-java

data/spec/ffi_yajl/encoder_spec.rb

@@ -1,221 +0,0 @@
-# encoding: UTF-8
-# Copyright (c) 2015 Lamont Granquist
-# Copyright (c) 2015 Chef Software, Inc.
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'spec_helper'
-require 'date'
-
-describe "FFI_Yajl::Encoder" do
-  let(:options) { {} }
-
-  let(:encoder) { FFI_Yajl::Encoder.new(options) }
-
-  it "encodes hashes in keys as strings", ruby_gte_193: true do
-    ruby = { { 'a' => 'b' } => 2 }
-    expect(encoder.encode(ruby)).to eq('{"{\"a\"=>\"b\"}":2}')
-  end
-
-  it "encodes arrays in keys as strings", ruby_gte_193: true do
-    ruby = { [0, 1] => 2 }
-    expect(encoder.encode(ruby)).to eq('{"[0, 1]":2}')
-  end
-
-  it "encodes nil in keys as strings" do
-    ruby = { nil => 2 }
-    expect(encoder.encode(ruby)).to eq('{"":2}')
-  end
-
-  it "encodes true in keys as strings" do
-    ruby = { true => 2 }
-    expect(encoder.encode(ruby)).to eq('{"true":2}')
-  end
-
-  it "encodes false in keys as strings" do
-    ruby = { false => 2 }
-    expect(encoder.encode(ruby)).to eq('{"false":2}')
-  end
-
-  it "encodes fixnums in keys as strings" do
-    ruby = { 1 => 2 }
-    expect(encoder.encode(ruby)).to eq('{"1":2}')
-  end
-
-  it "encodes floats in keys as strings" do
-    ruby = { 1.1 => 2 }
-    expect(encoder.encode(ruby)).to eq('{"1.1":2}')
-  end
-
-  it "encodes bignums in keys as strings" do
-    ruby = { 12_345_678_901_234_567_890 => 2 }
-    expect(encoder.encode(ruby)).to eq('{"12345678901234567890":2}')
-  end
-
-  it "encodes objects in keys as strings" do
-    o = Object.new
-    ruby = { o => 2 }
-    expect(encoder.encode(ruby)).to eq(%{{"#{o}":2}})
-  end
-
-  it "encodes an object in a key which has a #to_json method as strings" do
-    class Thing
-      def to_json(*a)
-        "{}"
-      end
-    end
-    o = Thing.new
-    ruby = { o => 2 }
-    expect(encoder.encode(ruby)).to eq(%{{"#{o}":2}})
-  end
-
-  # XXX: 127 == YAJL_MAX_DEPTH hardcodedness, zero control for us, it isn't even a twiddleable #define
-  it "raises an exception for deeply nested arrays" do
-    root = []
-    a = root
-    127.times { |_| a << []; a = a[0] }
-    expect { encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
-  end
-
-  it "raises an exception for deeply nested hashes" do
-    root = {}
-    a = root
-    127.times { |_| a["a"] = {}; a = a["a"] }
-    expect { encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
-  end
-
-  it "encodes symbols in keys as strings" do
-    ruby = { thing: 1 }
-    expect(encoder.encode(ruby)).to eq('{"thing":1}')
-  end
-
-  it "encodes symbols in values as strings" do
-    ruby = { "thing" => :one }
-    expect(encoder.encode(ruby)).to eq('{"thing":"one"}')
-  end
-
-  it "can encode 32-bit unsigned ints" do
-    ruby = { "gid" => 4_294_967_294 }
-    expect(encoder.encode(ruby)).to eq('{"gid":4294967294}')
-  end
-
-  context "when the encoder has nil passed in for options" do
-    let(:encoder) { FFI_Yajl::Encoder.new(nil) }
-
-    it "does not throw an exception" do
-      ruby = { "foo" => "bar" }
-      expect(encoder.encode(ruby)).to eq("{\"foo\":\"bar\"}")
-    end
-  end
-
-  it "can encode Date objects" do
-    ruby = Date.parse('2001-02-03')
-    expect(encoder.encode(ruby)).to eq( '"2001-02-03"' )
-  end
-
-  it "can encode StringIOs" do
-    ruby = { "foo" => StringIO.new('THING') }
-    expect(encoder.encode(ruby)).to eq("{\"foo\":\"THING\"}")
-  end
-
-  context "when encoding Time objects in UTC timezone" do
-    before do
-      @saved_tz = ENV['TZ']
-      ENV['TZ'] = 'UTC'
-    end
-
-    after do
-      ENV['TZ'] = @saved_tz
-    end
-
-    it "encodes them correctly" do
-      ruby = Time.local(2001, 02, 02, 21, 05, 06)
-      expect(encoder.encode(ruby)).to eq( '"2001-02-02 21:05:06 +0000"' )
-    end
-  end
-
-  it "can encode DateTime objects" do
-    ruby = DateTime.parse('2001-02-03T04:05:06.1+07:00')
-    expect(encoder.encode(ruby)).to eq( '"2001-02-03T04:05:06+07:00"' )
-  end
-
-  describe "testing .to_json for Objects" do
-    class NoToJson; end
-    class HasToJson
-      def to_json(*args)
-        "{}"
-      end
-    end
-
-    it "calls .to_s for objects without .to_json" do
-      expect(encoder.encode(NoToJson.new)).to match(/^"#<NoToJson:\w+>"$/)
-    end
-
-    it "calls .to_json for objects wit .to_json" do
-      expect(encoder.encode(HasToJson.new)).to eq("{}")
-    end
-  end
-
-  context "when encoding invalid utf-8" do
-    ruby = {
-      "automatic" => {
-        "etc" => {
-          "passwd" => {
-            "root" => { "dir" => "/root", "gid" => 0, "uid" => 0, "shell" => "/bin/sh", "gecos" => "Elan Ruusam\xc3\xa4e" },
-            "glen" => { "dir" => "/home/glen", "gid" => 500, "uid" => 500, "shell" => "/bin/bash", "gecos" => "Elan Ruusam\xE4e" },
-            "helmüt" => { "dir" => "/home/helmüt", "gid" => 500, "uid" => 500, "shell" => "/bin/bash", "gecos" => "Hañs Helmüt" },
-          },
-        },
-      },
-    }
-
-    it "raises an error on invalid json" do
-      expect { encoder.encode(ruby) }.to raise_error(FFI_Yajl::EncodeError, /Invalid UTF-8 string 'Elan Ruusam.*': cannot encode to UTF-8/)
-    end
-
-    context "when validate_utf8 is off" do
-      let(:options) {  { validate_utf8: false } }
-
-      it "does not raise an error" do
-        expect { encoder.encode(ruby) }.not_to raise_error
-      end
-
-      it "returns utf8" do
-        expect( encoder.encode(ruby).encoding ).to eq(Encoding::UTF_8)
-      end
-
-      it "returns valid utf8" do
-        expect( encoder.encode(ruby).valid_encoding? ).to be true
-      end
-
-      it "does not mangle valid utf8" do
-        json = encoder.encode(ruby)
-        expect(json).to match(/Hañs Helmüt/)
-      end
-
-      it "does not grow after a round trip" do
-        json = encoder.encode(ruby)
-        ruby2 = FFI_Yajl::Parser.parse(json)
-        json2 = encoder.encode(ruby2)
-        expect(json).to eql(json2)
-      end
-    end
-  end
-end

data/spec/ffi_yajl/map_library_name_spec.rb

@@ -1,115 +0,0 @@
-# Copyright (c) 2015 Lamont Granquist
-# Copyright (c) 2015 Chef Software, Inc.
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'spec_helper'
-
-class Test
-  extend FFI_Yajl::MapLibraryName
-end
-
-host_os_library_name_mapping = {
-  "mingw"    => [ "libyajl.so", "yajl.dll" ],
-  "mswin"    => [ "libyajl.so", "yajl.dll" ],
-  "cygwin"   => [ "libyajl.so", "cygyajl.dll" ],
-  "darwin"   => [ "libyajl.bundle", "libyajl.dylib" ],
-  "solaris2" => [ "libyajl.so" ],
-  "linux"    => [ "libyajl.so" ],
-  "aix"      => [ "libyajl.so" ],
-  "hpux"     => [ "libyajl.so" ],
-  "netbsd"   => [ "libyajl.so" ],
-  "openbsd"  => [ "libyajl.so" ],
-  "freebsd"  => [ "libyajl.so" ],
-}
-
-describe "FFI_Yajl::MapLibraryName" do
-  let(:libyajl2_opt_path) { "/libyajl2/lib" }
-  before do
-    allow(Libyajl2).to receive(:opt_path).and_return(libyajl2_opt_path)
-  end
-
-  host_os_library_name_mapping.each do |host_os, library_names|
-    context "#library_names" do
-      it "maps #{host_os} correctly" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        expect(Test.send(:library_names)).to eq(library_names)
-      end
-    end
-
-    context "#expanded_library_names" do
-      it "maps #{host_os} correctly" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        expanded_library_names = []
-        library_names.each do |library_name|
-          path = File.expand_path(File.join(libyajl2_opt_path, library_name))
-          expanded_library_names.push(path)
-          expect(File).to receive(:file?).with(path).and_return(true)
-        end
-        expect(Test.send(:expanded_library_names)).to eq(expanded_library_names)
-      end
-    end
-
-    context "#dlopen_yajl_library" do
-      it "should call dlopen against an expanded library name if it finds it on #{host_os}" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        library_names.each do |library_name|
-          path = File.expand_path(File.join(libyajl2_opt_path, library_name))
-          allow(File).to receive(:file?).with(path).and_return(true)
-          allow(Test).to receive(:dlopen).with(path).and_return(nil)
-        end
-        Test.send(:dlopen_yajl_library)
-      end
-      it "if dlopen calls all raise it should still use the short names on #{host_os}" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        library_names.each do |library_name|
-          path = File.expand_path(File.join(libyajl2_opt_path, library_name))
-          allow(File).to receive(:file?).with(path).and_return(true)
-          allow(Test).to receive(:dlopen).with(path).and_raise(ArgumentError)
-        end
-        allow(Test).to receive(:dlopen).with(library_names.first).and_return(nil)
-        Test.send(:dlopen_yajl_library)
-      end
-    end
-
-    context "ffi_open_yajl_library" do
-      it "should call ffi_lib against an expanded library name if it finds it on #{host_os}" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        library_names.each do |library_name|
-          path = File.expand_path(File.join(libyajl2_opt_path, library_name))
-          allow(File).to receive(:file?).with(path).and_return(true)
-          allow(Test).to receive(:ffi_lib).with(path).and_return(nil)
-        end
-        Test.send(:ffi_open_yajl_library)
-      end
-
-      it "if dlopen calls all raise it should still use 'yajl' on #{host_os}" do
-        allow(Test).to receive(:host_os).and_return(host_os)
-        library_names.each do |library_name|
-          path = File.expand_path(File.join(libyajl2_opt_path, library_name))
-          allow(File).to receive(:file?).with(path).and_return(true)
-          allow(Test).to receive(:ffi_lib).with(path).and_raise(LoadError)
-        end
-        allow(Test).to receive(:ffi_lib).with('yajl').and_return(nil)
-        Test.send(:ffi_open_yajl_library)
-      end
-    end
-  end
-end

data/spec/ffi_yajl/parser_spec.rb

@@ -1,569 +0,0 @@
-# encoding: UTF-8
-# Copyright (c) 2015 Lamont Granquist
-# Copyright (c) 2015 Chef Software, Inc.
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'spec_helper'
-
-describe "FFI_Yajl::Parser" do
-  shared_examples_for "correct json parsing" do
-    context "when json has 23456789012E666" do
-      let(:json) {  '{"key": 23456789012E666}' }
-
-      it "should return infinity" do
-        infinity = (1.0 / 0)
-        expect(parser).to eq("key" => infinity)
-      end
-    end
-
-    context "when parsing nil" do
-      let(:json) { nil }
-      it "should not coredump ruby" do
-        expect { parser }.to raise_error(FFI_Yajl::ParseError)
-      end
-    end
-
-    context "when parsing bare int" do
-      let(:json) { "1" }
-      it "should parse to the int value" do
-        expect( parser ).to eq(1)
-      end
-    end
-
-    context "when parsing bare string" do
-      let(:json) { '"a"' }
-      it "should parse to the string value" do
-        expect( parser ).to eq("a")
-      end
-    end
-
-    context "when parsing bare true" do
-      let(:json) { "true" }
-      it "should parse to the true value" do
-        expect( parser ).to eq(true)
-      end
-    end
-
-    context "when parsing bare false" do
-      let(:json) { "false" }
-      it "should parse to the false value" do
-        expect( parser ).to eq(false)
-      end
-    end
-
-    context "when parsing bare null" do
-      let(:json) { "null" }
-      it "should parse to the nil value" do
-        expect( parser ).to eq(nil)
-      end
-    end
-
-    context "when parsing bare float" do
-      let(:json) { "1.1" }
-      it "should parse to the a float" do
-        expect( parser ).to eq(1.1)
-      end
-    end
-
-    context "when json has comments" do
-      let(:json) { '{"key": /* this is a comment */ "value"}' }
-
-      context "when allow_comments is false" do
-        let(:options) { { allow_comments: false } }
-
-        it "should not parse" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when allow_comments is true" do
-        let(:options) { { allow_comments: true } }
-
-        it "should parse" do
-          expect(parser).to eq("key" => "value")
-        end
-      end
-
-      context "by default" do
-        let(:options) {}
-
-        it "should parse" do
-          expect(parser).to eq("key" => "value")
-        end
-      end
-    end
-
-    context "when json has multiline comments" do
-      let(:json) { %{{"key": \n/*\n this is a multiline comment \n*/\n "value"}} }
-
-      context "when allow_comments is false" do
-        let(:options) { { allow_comments: false } }
-
-        it "should not parse" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when allow_comments is true" do
-        let(:options) { { allow_comments: true } }
-
-        it "should parse" do
-          expect(parser).to eq("key" => "value")
-        end
-      end
-    end
-
-    context "when json has inline comments" do
-      let(:json) { %{{"key": \n// this is an inline comment\n "value"}} }
-
-      context "when allow_comments is false" do
-        let(:options) { { allow_comments: false } }
-
-        it "should not parse" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when allow_comments is true" do
-        let(:options) { { allow_comments: true } }
-
-        it "should parse" do
-          expect(parser).to eq("key" => "value")
-        end
-      end
-    end
-
-    context "when json is invalid UTF8" do
-      let(:json) { "[\"\201\203\"]" }
-
-      it "should not parse by default" do
-        expect { parser }.to raise_error(FFI_Yajl::ParseError)
-      end
-
-      context "when :dont_validate_strings is set to true" do
-        let(:options) { { dont_validate_strings: true } }
-
-        it "should parse" do
-          expect(parser).to eq(["\x81\x83"])
-        end
-      end
-
-      context "when :dont_validate_strings is set to false" do
-        let(:options) { { dont_validate_strings: false } }
-
-        it "should not parse" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when :check_utf8 is set to true" do
-        let(:options) { { check_utf8: true } }
-
-        it "should not parse" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-
-        context "when :dont_validate_strings is set to true" do
-          let(:options) { { check_utf8: true, dont_validate_strings: true } }
-
-          it "should raise an ArgumentError" do
-            expect { parser }.to raise_error(ArgumentError)
-          end
-        end
-
-        context "when :dont_validate_strings is set to false" do
-          let(:options) { { check_utf8: true, dont_validate_strings: false } }
-
-          it "should not parse" do
-            expect { parser }.to raise_error(FFI_Yajl::ParseError)
-          end
-        end
-      end
-
-      context "when :check_utf8 is set to false" do
-        let(:options) { { check_utf8: false } }
-
-        it "should parse" do
-          expect(parser).to eq(["\x81\x83"])
-        end
-
-        context "when :dont_validate_strings is set to true" do
-          let(:options) { { check_utf8: false, dont_validate_strings: true } }
-
-          it "should parse" do
-            expect(parser).to eq(["\x81\x83"])
-          end
-        end
-
-        context "when :dont_validate_strings is set to false" do
-          let(:options) { { check_utf8: false, dont_validate_strings: false } }
-
-          it "should raise an ArgumentError" do
-            expect { parser }.to raise_error(ArgumentError)
-          end
-        end
-      end
-    end
-
-    context "when JSON is a StringIO" do
-      let(:json) { StringIO.new('{"key": 1234}') }
-
-      it "should parse" do
-        expect(parser).to eq("key" => 1234)
-      end
-    end
-
-    context "when parsing a JSON string" do
-      let(:json) { '{"key": 1234}' }
-
-      it "should parse correctly" do
-        expect(parser).to eq("key" => 1234)
-      end
-
-      context "when symbolize_keys is true" do
-        let(:options) { { symbolize_keys: true } }
-
-        it "should symbolize keys correctly" do
-          expect(parser).to eq(key: 1234)
-        end
-      end
-
-      context "when passing a block" do
-        it "should parse correctly" do
-          skip "handle blocks"
-          output = nil
-          parser do |obj|
-            output = obj
-          end
-          expect(output).to eq("key" => 1234)
-        end
-      end
-    end
-
-    context "when parsing a JSON hash with only strings" do
-      let(:json) { '{"key": "value"}' }
-
-      if RUBY_VERSION.to_f >= 1.9
-        context "when Encoding.default_internal is nil" do
-          before do
-            @saved_encoding = Encoding.default_internal
-            Encoding.default_internal = nil
-          end
-          after do
-            Encoding.default_internal = @saved_encoding
-          end
-          it "encodes keys to UTF-8" do
-            expect(parser.keys.first.encoding).to eql(Encoding.find('utf-8'))
-          end
-          it "encodes values to UTF-8" do
-            expect(parser.values.first.encoding).to eql(Encoding.find('utf-8'))
-          end
-        end
-
-        %w{utf-8 us-ascii}.each do |encoding|
-          context "when Encoding.default_internal is #{encoding}" do
-            before do
-              @saved_encoding = Encoding.default_internal
-              Encoding.default_internal = nil
-            end
-            after do
-              Encoding.default_internal = @saved_encoding
-            end
-            it "encodes keys to #{encoding}" do
-              skip "fix us-ascii" if encoding == "us-ascii"
-              expect(parser.keys.first.encoding).to eql(Encoding.find(encoding))
-            end
-            it "encodes values to #{encoding}" do
-              skip "fix us-ascii" if encoding == "us-ascii"
-              expect(parser.values.first.encoding).to eql(Encoding.find(encoding))
-            end
-          end
-        end
-      end
-    end
-
-    context "when a parsed key has utf-8 multibyte characters" do
-      let(:json) { '{"日本語": 1234}' }
-
-      it "should parse correctly" do
-        expect(parser).to eq("日本語" => 1234)
-      end
-
-      context "when symbolize_keys is true" do
-        let(:options) { { symbolize_keys: true } }
-
-        it "should symbolize keys correctly" do
-          expect(parser).to eq(:"日本語" => 1234) # rubocop:disable Style/HashSyntax
-        end
-
-        if RUBY_VERSION.to_f >= 1.9
-          it "should parse non-ascii symbols in UTF-8" do
-            expect(parser.keys.fetch(0).encoding).to eq(Encoding::UTF_8)
-          end
-        end
-      end
-    end
-
-    context "when parsing 2147483649" do
-      let(:json) { "{\"id\": 2147483649}" }
-
-      it "should parse corectly" do
-        expect(parser).to eql("id" => 2_147_483_649)
-      end
-    end
-
-    context "when parsing 5687389800" do
-      let(:json) { "{\"id\": 5687389800}" }
-
-      it "should parse corectly" do
-        expect(parser).to eql("id" => 5_687_389_800)
-      end
-    end
-
-    context "when parsing 1046289770033519442869495707521600000000" do
-      let(:json) { "{\"id\": 1046289770033519442869495707521600000000}" }
-
-      it "should parse corectly" do
-        expect(parser).to eql("id" => 1_046_289_770_033_519_442_869_495_707_521_600_000_000)
-      end
-    end
-
-    # NOTE: we are choosing to be compatible with yajl-ruby here vs. JSON
-    # gem and libyajl C behavior (which is to throw an exception in this case)
-    context "when the JSON is empty string" do
-      let(:json) { '' }
-
-      it "returns nil" do
-        expect(parser).to be_nil
-      end
-    end
-
-    # NOTE: this fixes yajl-ruby being too permissive
-    context "when dealing with too much or too little input" do
-      context "when trailing braces are missing" do
-        let(:json) { '{"foo":{"foo": 1234}' }
-
-        it "raises an exception" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when trailing brackets are missing" do
-        let(:json) { '[["foo", "bar"]' }
-
-        it "raises an exception" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-
-      context "when an extra brace is present" do
-        let(:json) { '{"foo":{"foo": 1234}}}' }
-
-        it "raises an exception" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-
-        context "with allow_trailing_garbage" do
-          let(:options) { { allow_trailing_garbage: true } }
-          it "parses" do
-            expect(parser).to eq("foo" => { "foo" => 1234 })
-          end
-        end
-      end
-
-      context "when an extra bracket is present" do
-        let(:json) { '[["foo", "bar"]]]' }
-
-        it "raises an exception" do
-          expect { parser }.to raise_error(FFI_Yajl::ParseError)
-        end
-      end
-    end
-
-    context "when parsing heavy metal umlauts in keys" do
-      let(:json) { '{"München": "Bayern"}' }
-
-      it "correctly parses" do
-        expect(parser).to eql( "München" => "Bayern" )
-      end
-    end
-
-    context "when parsing floats" do
-      context "parses simple floating point values" do
-        let(:json) { '{"foo": 3.14159265358979}' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 3.14159265358979 )
-        end
-      end
-
-      context "parses simple negative floating point values" do
-        let(:json) { '{"foo":-2.00231930436153}' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => -2.00231930436153 )
-        end
-      end
-
-      context "parses floats with negative exponents and a large E" do
-        let(:json) { '{"foo": 1.602176565E-19}' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 1.602176565e-19 )
-        end
-      end
-
-      context "parses floats with negative exponents and a small e" do
-        let(:json) { '{"foo": 6.6260689633e-34 }' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 6.6260689633e-34 )
-        end
-      end
-
-      context "parses floats with positive exponents and a large E" do
-        let(:json) { '{"foo": 6.0221413E+23}' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 6.0221413e+23 )
-        end
-      end
-
-      context "parses floats with positive exponents and a small e" do
-        let(:json) { '{"foo": 8.9875517873681764e+9 }' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 8.9875517873681764e+9 )
-        end
-      end
-
-      context "parses floats with an exponent without a sign and a large E" do
-        let(:json) { '{"foo": 2.99792458E8  }' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 2.99792458e+8 )
-        end
-      end
-
-      context "parses floats with an exponent without a sign and a small e" do
-        let(:json) { '{"foo": 1.0973731568539e7 }' }
-
-        it "correctly parses" do
-          expect(parser).to eql( "foo" => 1.0973731568539e+7 )
-        end
-      end
-    end
-
-    # NOTE: parsing floats with 8 million digits on windows has some kind of huge
-    #       perf issues likely in ruby and/or the underlying windows libs
-    context "when parsing big floats", ruby_gte_193: true, unix_only: true do
-      let(:json) { '[0.' + '1' * 2**23 + ']' }
-
-      it "parses" do
-        expect { parser }.not_to raise_error
-      end
-    end
-
-    context "when parsing long hash keys with symbolize_keys option", ruby_gte_193: true do
-      let(:json) { '{"' + 'a' * 2**23 + '": 0}' }
-      let(:options) { { symbolize_keys: true } }
-
-      it "parses" do
-        expect { parser }.not_to raise_error
-      end
-    end
-
-    context "should ignore repeated keys by default" do
-      let(:json) { '{"foo":"bar","foo":"baz"}' }
-      it "should replace the first hash key with the second" do
-        expect(parser).to eql( "foo" => "baz" )
-      end
-    end
-
-    context "should raise an exception for repeated keys" do
-      let(:json) { '{"foo":"bar","foo":"baz"}' }
-      let(:options) { { unique_key_checking: true } }
-      it "should raise" do
-        expect { parser }.to raise_error(FFI_Yajl::ParseError)
-      end
-    end
-  end
-
-  context "when options are set to empty hash" do
-    let(:options) { {} }
-
-    context "when using a parsing object" do
-      let(:parser) { FFI_Yajl::Parser.new(options).parse(json) }
-
-      it_behaves_like "correct json parsing"
-    end
-
-    context "when using the class method" do
-      let(:parser) { FFI_Yajl::Parser.parse(json, options) }
-
-      it_behaves_like "correct json parsing"
-    end
-  end
-
-  context "when options are set to nil" do
-    let(:options) { nil }
-
-    context "when using a parsing object" do
-      let(:parser) { FFI_Yajl::Parser.new(options).parse(json) }
-
-      it_behaves_like "correct json parsing"
-    end
-
-    context "when using the class method" do
-      let(:parser) { FFI_Yajl::Parser.parse(json, options) }
-
-      it_behaves_like "correct json parsing"
-    end
-  end
-
-  context "when options default to nothing" do
-    let(:options) { nil }
-
-    context "when using a parsing object" do
-      let(:parser) do
-        if options.nil?
-          FFI_Yajl::Parser.new.parse(json)
-        else
-          FFI_Yajl::Parser.new(options).parse(json)
-        end
-      end
-
-      it_behaves_like "correct json parsing"
-    end
-
-    context "when using the class method" do
-      let(:parser) do
-        if options.nil?
-          FFI_Yajl::Parser.parse(json)
-        else
-          FFI_Yajl::Parser.parse(json, options)
-        end
-      end
-
-      it_behaves_like "correct json parsing"
-    end
-  end
-end