benofsky-yajl-ruby 0.7.6

data/spec/http/http_delete_spec.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+begin
+  require 'yajl/bzip2'
+rescue
+  warn "Couldn't load yajl/bzip2, maybe you don't have bzip2-ruby installed? Continuing without running bzip2 specs."
+end
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+def parse_off_headers(io)
+  io.each_line do |line|
+    if line == "\r\n" # end of the headers
+      break
+    end
+  end
+end
+
+describe "Yajl HTTP DELETE request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+  end
+
+  after(:each) do
+    @file_path = nil
+  end
+
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+  end
+
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.delete(@uri)
+  end
+
+  it "should parse a raw response using instance method" do
+    prepare_mock_request_dump :raw
+    @uri.should_receive(:host)
+    @uri.should_receive(:port)
+    stream = Yajl::HttpStream.new
+    @template_hash.should == stream.delete(@uri)
+  end
+
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+  end
+
+  if defined?(Yajl::Bzip2::StreamReader)
+    it "should parse a bzip2 compressed response" do
+      prepare_mock_request_dump :bzip2
+      @template_hash.should == Yajl::HttpStream.delete(@uri)
+    end
+
+    it "should parse a bzip2 compressed response and symbolize keys" do
+      prepare_mock_request_dump :bzip2
+      @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    end
+  end
+
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.delete(@uri)
+  end
+
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+  end
+
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.delete(@uri)
+  end
+
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+  end
+
+  it "should raise when an HTTP code that isn't 200 is returned" do
+    prepare_mock_request_dump :error
+    lambda { Yajl::HttpStream.delete(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+  end
+end

data/spec/http/http_error_spec.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+begin
+  require 'yajl/bzip2'
+rescue
+  warn "Couldn't load yajl/bzip2, maybe you don't have bzip2-ruby installed? Continuing without running bzip2 specs."
+end
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+describe "Yajl HTTP error" do
+  before(:all) do
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.error.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.error.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+
+    begin
+      Yajl::HttpStream.get(@uri)
+    rescue Yajl::HttpStream::HttpError => e
+      @error = e
+    end
+  end
+
+  it "should contain the error code in the message" do
+    @error.message.should match(/404/)
+  end
+
+  it "should provide the HTTP response headers" do
+    @error.headers.keys.should include('ETag', 'Content-Length', 'Server')
+  end
+end

data/spec/http/http_get_spec.rb

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+begin
+  require 'yajl/bzip2'
+rescue
+  warn "Couldn't load yajl/bzip2, maybe you don't have bzip2-ruby installed? Continuing without running bzip2 specs."
+end
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+def parse_off_headers(io)
+  io.each_line do |line|
+    if line == "\r\n" # end of the headers
+      break
+    end
+  end
+end
+
+describe "Yajl HTTP GET request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+    @chunked_body = {"item"=>{"price"=>1.99, "updated_by_id"=>nil, "cached_tag_list"=>"", "name"=>"generated", "created_at"=>"2009-03-24T05:25:09Z", "cost"=>0.597, "delta"=>false, "created_by_id"=>nil, "updated_at"=>"2009-03-24T05:25:09Z", "import_tag"=>nil, "account_id"=>16, "id"=>1, "taxable"=>true, "unit"=>nil, "sku"=>"06317-0306", "company_id"=>0, "description"=>nil, "active"=>true}}
+  end
+
+  after(:each) do
+    @file_path = nil
+  end
+
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+  end
+
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+
+  it "should parse a raw response using instance method" do
+    prepare_mock_request_dump :raw
+    @uri.should_receive(:host)
+    @uri.should_receive(:port)
+    stream = Yajl::HttpStream.new
+    @template_hash.should == stream.get(@uri)
+  end
+
+  it "should parse a chunked response using instance method" do
+    prepare_mock_request_dump :chunked
+    @uri.should_receive(:host)
+    @uri.should_receive(:port)
+    stream = Yajl::HttpStream.new
+    stream.get(@uri) do |obj|
+      obj.should eql(@chunked_body)
+    end
+  end
+
+  if defined?(Yajl::Bzip2::StreamReader)
+    it "should parse a bzip2 compressed response" do
+      prepare_mock_request_dump :bzip2
+      @template_hash.should == Yajl::HttpStream.get(@uri)
+    end
+
+    it "should parse a bzip2 compressed response and symbolize keys" do
+      prepare_mock_request_dump :bzip2
+      @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    end
+  end
+
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+
+  it "should raise when an HTTP code that isn't 200 is returned" do
+    prepare_mock_request_dump :error
+    lambda { Yajl::HttpStream.get(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+  end
+end

data/spec/http/http_post_spec.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+begin
+  require 'yajl/bzip2'
+rescue
+  warn "Couldn't load yajl/bzip2, maybe you don't have bzip2-ruby installed? Continuing without running bzip2 specs."
+end
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+def parse_off_headers(io)
+  io.each_line do |line|
+    if line == "\r\n" # end of the headers
+      break
+    end
+  end
+end
+
+describe "Yajl HTTP POST request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+    @body = "blah=foo&bar=baz"
+    @hashed_body = {:blah => 'foo', 'bar' => 'baz'}
+    @chunked_body = {"item"=>{"price"=>1.99, "updated_by_id"=>nil, "cached_tag_list"=>"", "name"=>"generated", "created_at"=>"2009-03-24T05:25:09Z", "cost"=>0.597, "delta"=>false, "created_by_id"=>nil, "updated_at"=>"2009-03-24T05:25:09Z", "import_tag"=>nil, "account_id"=>16, "id"=>1, "taxable"=>true, "unit"=>nil, "sku"=>"06317-0306", "company_id"=>0, "description"=>nil, "active"=>true}}
+  end
+
+  after(:each) do
+    @file_path = nil
+  end
+
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+  end
+
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+  end
+
+  it "should parse a raw response using instance method" do
+    prepare_mock_request_dump :raw
+    @uri.should_receive(:host)
+    @uri.should_receive(:port)
+    stream = Yajl::HttpStream.new
+    @template_hash.should == stream.post(@uri, @body)
+  end
+
+  it "should parse a raw response with hashed body" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+  end
+
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+  end
+
+  if defined?(Yajl::Bzip2::StreamReader)
+    it "should parse a bzip2 compressed response" do
+      prepare_mock_request_dump :bzip2
+      @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    end
+
+    it "should parse a bzip2 compressed response and symbolize keys" do
+      prepare_mock_request_dump :bzip2
+      @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    end
+  end
+
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+  end
+
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+  end
+
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+  end
+
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+  end
+
+  it "should parse a chunked raw response" do
+    prepare_mock_request_dump :chunked
+    Yajl::HttpStream.post(@uri, @body) do |obj|
+      obj.should eql(@chunked_body)
+    end
+  end
+
+  it "should throw Exception if chunked response and no block given" do
+    prepare_mock_request_dump :chunked
+    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Exception)
+  end
+
+  it "should throw InvalidContentType if unable to handle the MIME type" do
+    prepare_mock_request_dump :html
+    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Yajl::HttpStream::InvalidContentType)
+  end
+
+  it "should raise when an HTTP code that isn't 200 is returned" do
+    prepare_mock_request_dump :error
+    lambda { Yajl::HttpStream.post(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+  end
+end

data/spec/http/http_put_spec.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+begin
+  require 'yajl/bzip2'
+rescue
+  warn "Couldn't load yajl/bzip2, maybe you don't have bzip2-ruby installed? Continuing without running bzip2 specs."
+end
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+def parse_off_headers(io)
+  io.each_line do |line|
+    if line == "\r\n" # end of the headers
+      break
+    end
+  end
+end
+
+describe "Yajl HTTP PUT request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+    @body = "blah=foo&bar=baz"
+    @hashed_body = {:blah => 'foo', 'bar' => 'baz'}
+  end
+
+  after(:each) do
+    @file_path = nil
+  end
+
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+  end
+
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+  end
+
+  it "should parse a raw response using instance method" do
+    prepare_mock_request_dump :raw
+    @uri.should_receive(:host)
+    @uri.should_receive(:port)
+    stream = Yajl::HttpStream.new
+    @template_hash.should == stream.put(@uri, @body)
+  end
+
+  it "should parse a raw response with hashed body" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+  end
+
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+  end
+
+  if defined?(Yajl::Bzip2::StreamReader)
+    it "should parse a bzip2 compressed response" do
+      prepare_mock_request_dump :bzip2
+      @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    end
+
+    it "should parse a bzip2 compressed response and symbolize keys" do
+      prepare_mock_request_dump :bzip2
+      @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    end
+  end
+
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+  end
+
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+  end
+
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+  end
+
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+  end
+
+  it "should raise when an HTTP code that isn't 200 is returned" do
+    prepare_mock_request_dump :error
+    lambda { Yajl::HttpStream.put(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+  end
+end

data/spec/json_gem_compatibility/compatibility_spec.rb

@@ -0,0 +1,203 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+class Dummy; end
+
+describe "JSON Gem compatability API" do
+  it "shoud not mixin #to_json on base objects until compatability has been enabled" do
+    d = Dummy.new
+
+    d.respond_to?(:to_json).should_not be_true
+    "".respond_to?(:to_json).should_not be_true
+    1.respond_to?(:to_json).should_not be_true
+    "1.5".to_f.respond_to?(:to_json).should_not be_true
+    [].respond_to?(:to_json).should_not be_true
+    {:foo => "bar"}.respond_to?(:to_json).should_not be_true
+    true.respond_to?(:to_json).should_not be_true
+    false.respond_to?(:to_json).should_not be_true
+    nil.respond_to?(:to_json).should_not be_true
+  end
+
+  it "should mixin #to_json on base objects after compatability has been enabled" do
+    require 'yajl/json_gem'
+    d = Dummy.new
+
+    d.respond_to?(:to_json).should be_true
+    "".respond_to?(:to_json).should be_true
+    1.respond_to?(:to_json).should be_true
+    "1.5".to_f.respond_to?(:to_json).should be_true
+    [].respond_to?(:to_json).should be_true
+    {:foo => "bar"}.respond_to?(:to_json).should be_true
+    true.respond_to?(:to_json).should be_true
+    false.respond_to?(:to_json).should be_true
+    nil.respond_to?(:to_json).should be_true
+  end
+
+  it "should require yajl/json_gem to enable the compatability API" do
+    defined?(JSON).should be_true
+
+    JSON.respond_to?(:parse).should be_true
+    JSON.respond_to?(:generate).should be_true
+    JSON.respond_to?(:pretty_generate).should be_true
+    JSON.respond_to?(:load).should be_true
+    JSON.respond_to?(:dump).should be_true
+  end
+
+  it "should allow default parsing options be set with JSON.default_options" do
+    default = JSON.default_options[:symbolize_keys]
+    JSON.parse('{"foo": 1234}').should === {"foo" => 1234}
+    JSON.default_options[:symbolize_keys] = true
+    JSON.parse('{"foo": 1234}').should === {:foo => 1234}
+    JSON.default_options[:symbolize_keys] = default # ensure the rest of the test cases expect the default
+  end
+
+  it "should encode arbitrary classes via their default to_json method" do
+    d = Dummy.new
+    d.to_json.should == "\"#{d.to_s}\""
+
+    t = Time.now
+    t.to_json.should == "\"#{t.to_s}\""
+
+    da = Date.today
+    da.to_json.should == "\"#{da.to_s}\""
+
+    dt = DateTime.new
+    dt.to_json.should == "\"#{dt.to_s}\""
+  end
+
+  it "should have the standard parsing and encoding exceptions mapped" do
+    JSON::JSONError.new.is_a?(StandardError).should be_true
+    JSON::ParserError.new.is_a?(JSON::JSONError).should be_true
+    JSON::GeneratorError.new.is_a?(JSON::JSONError).should be_true
+
+    lambda {
+      JSON.parse("blah")
+    }.should raise_error(JSON::ParserError)
+
+    lambda {
+      JSON.generate(0.0/0.0)
+    }.should raise_error(JSON::GeneratorError)
+  end
+
+  context "ported tests for Unicode" do
+    it "should be able to encode and parse unicode" do
+      '""'.should eql(''.to_json)
+      '"\\b"'.should eql("\b".to_json)
+      '"\u0001"'.should eql(0x1.chr.to_json)
+      '"\u001F"'.should eql(0x1f.chr.to_json)
+      '" "'.should eql(' '.to_json)
+      "\"#{0x7f.chr}\"".should eql(0x7f.chr.to_json)
+      utf8 = [ "© ≠ €! \01" ]
+      json = "[\"© ≠ €! \\u0001\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+      json = "[\"あいうえお\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ['საქართველო']
+      json = "[\"საქართველო\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      '["Ã"]'.should eql(JSON.generate(["Ã"]))
+      ["€"].should eql(JSON.parse('["\u20ac"]'))
+      utf8_str = "\xf0\xa0\x80\x81"
+      utf8 = [utf8_str]
+      json = "[\"#{utf8_str}\"]"
+      json.should eql(JSON.generate(utf8))
+      utf8.should eql(JSON.parse(json))
+    end
+  end
+
+  context "ported tests for generation" do
+    before(:all) do
+      @hash = {
+        'a' => 2,
+        'b' => 3.141,
+        'c' => 'c',
+        'd' => [ 1, "b", 3.14 ],
+        'e' => { 'foo' => 'bar' },
+        'g' => "blah",
+        'h' => 1000.0,
+        'i' => 0.001
+      }
+
+      @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},"g":"blah","h":1000.0,"i":0.001}'
+
+      @json3 = %{
+        {
+          "a": 2,
+          "b": 3.141,
+          "c": "c",
+          "d": [1, "b", 3.14],
+          "e": {"foo": "bar"},
+          "g": "blah",
+          "h": 1000.0,
+          "i": 0.001
+        }
+      }.chomp
+    end
+
+    it "should be able to unparse" do
+      json = JSON.generate(@hash)
+      JSON.parse(@json2).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.generate({1=>2})
+      '{"1":2}'.should eql(json)
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+
+    it "should be able to unparse pretty" do
+      json = JSON.pretty_generate(@hash)
+      JSON.parse(@json3).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.pretty_generate({1=>2})
+      test = "{\n  \"1\": 2\n}".chomp
+      test.should == json
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+  end
+
+  context "ported fixture tests" do
+    fixtures = File.join(File.dirname(__FILE__), '../parsing/fixtures/*.json')
+    passed, failed = Dir[fixtures].partition { |f| f['pass'] }
+    JSON_PASSED = passed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    JSON_FAILED = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should raise_error(JSON::ParserError)
+      end
+    end
+
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should raise_error(JSON::ParserError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should_not raise_error(JSON::ParserError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should_not raise_error(JSON::ParserError)
+      end
+    end
+  end
+end