transit-ruby 0.8.467

data/spec/transit/rolling_cache_spec.rb

@@ -0,0 +1,94 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+module Transit
+  describe RollingCache do
+    describe 'writing' do
+      it 'returns the value the first time it sees it' do
+        assert { RollingCache.new.write('abcd') == 'abcd' }
+      end
+
+      it 'returns a key the 2nd thru n times it sees a value' do
+        rc = RollingCache.new
+        assert { rc.write('abcd') == 'abcd' }
+
+        key = rc.write('abcd')
+        assert { key != 'abcd' }
+
+        100.times do
+          assert { rc.write('abcd') == key }
+        end
+      end
+
+      it 'can handle CACHE_SIZE different values' do
+        rc = RollingCache.new
+        RollingCache::CACHE_SIZE.times do |i|
+          assert { rc.write("value#{i}") == "value#{i}" }
+        end
+
+        assert { rc.size == RollingCache::CACHE_SIZE }
+      end
+
+      it 'resets after CACHE_SIZE different values' do
+        rc = RollingCache.new
+        (RollingCache::CACHE_SIZE+1).times do |i|
+          assert{ rc.write("value#{i}") == "value#{i}" }
+        end
+
+        assert { rc.size == 1 }
+      end
+    end
+
+    describe ".cacheable?" do
+      it 'returns false for small strings' do
+        cache = RollingCache.new
+
+        names = random_strings(3, 500)
+        1000.times do |i|
+          name = names.sample
+          assert { !cache.cacheable?(name, false) }
+          assert { !cache.cacheable?(name, true)  }
+        end
+      end
+
+      it 'returns false for non map-keys' do
+        cache = RollingCache.new
+
+        names = random_strings(200, 500)
+        1000.times do |i|
+          name = names.sample
+          assert { !cache.cacheable?(name, false) }
+        end
+      end
+    end
+
+    describe ".cache_key?" do
+      it 'special cases map-as-array key as false' do
+        cache = RollingCache.new
+        assert { !cache.cache_key?(Transit::MAP_AS_ARRAY) }
+      end
+    end
+
+    describe 'reading' do
+      it 'returns the value, given a key that has a value in the cache' do
+        rc = RollingCache.new
+        rc.write 'abcd'
+        key = rc.write 'abcd'
+        assert { rc.read(key) == 'abcd' }
+      end
+    end
+  end
+end

data/spec/transit/round_trip_spec.rb

@@ -0,0 +1,179 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+def round_trip(obj, type, opts={})
+  obj_before = obj
+
+  io = StringIO.new('', 'w+')
+  writer = Transit::Writer.new(type, io, :handlers => opts[:write_handlers])
+  writer.write(obj)
+
+  # ensure that we don't modify the object being written
+  assert { obj == obj_before }
+  reader = Transit::Reader.new(type, StringIO.new(io.string), :handlers => opts[:read_handlers])
+  reader.read
+end
+
+def assert_equal_times(actual,expected)
+  assert { Transit::DateTimeUtil.to_millis(actual) == Transit::DateTimeUtil.to_millis(expected) }
+  assert { actual.zone == expected.zone }
+end
+
+def round_trips(label, obj, type, opts={})
+  expected = opts[:expected] || obj
+
+  it "round trips #{label} at top level", :focus => !!opts[:focus], :pending => opts[:pending] do
+    case obj
+    when Date, Time, DateTime
+      assert_equal_times(round_trip(obj, type), expected)
+    else
+      actual = round_trip(obj, type, opts)
+      expect(actual).to eq(expected)
+    end
+  end
+
+  case obj
+  when Date, Time, DateTime
+    it "round trips #{label} as a map key", :focus => !!opts[:focus], :pending => opts[:pending] do
+      after = round_trip({obj => 0}, type)
+      assert_equal_times(after.keys.first, expected)
+    end
+  else
+    it "round trips #{label} as a map key", :focus => !!opts[:focus], :pending => opts[:pending] do
+      actual = round_trip({obj => 0}, type, opts)
+      wrapped_expected = {expected => 0}
+      assert { actual == wrapped_expected }
+    end
+  end
+
+  it "round trips #{label} as a map value", :focus => !!opts[:focus], :pending => opts[:pending] do
+    case obj
+    when Date, Time, DateTime
+      after = round_trip({:a => obj}, type)
+      assert_equal_times(after.values.first, expected)
+    else
+      actual = round_trip({a: obj}, type, opts)
+      assert { actual == {a: expected} }
+    end
+  end
+
+  it "round trips #{label} as an array value", :focus => !!opts[:focus], :pending => opts[:pending] do
+    case obj
+    when Date, Time, DateTime
+      after = round_trip([obj], type)
+      assert_equal_times(after.first, expected)
+    else
+      actual = round_trip([obj], type, opts)
+      assert { actual == [expected] }
+    end
+  end
+end
+
+module Transit
+  PhoneNumber = Struct.new(:area, :prefix, :suffix)
+  def PhoneNumber.parse(p)
+    area, prefix, suffix = p.split(".")
+    PhoneNumber.new(area, prefix, suffix)
+  end
+
+  class PhoneNumberHandler
+    def tag(_) "P" end
+    def rep(p) "#{p.area}.#{p.prefix}.#{p.suffix}" end
+    def string_rep(p) rep(p) end
+  end
+
+  class PhoneNumberReadHandler
+    def from_rep(v) PhoneNumber.parse(v) end
+  end
+
+  class PersonReadHandler
+    def from_rep(v)
+      Person.new(v[:first_name],v[:last_name],v[:birthdate])
+    end
+  end
+
+  shared_examples "round trips" do |type|
+    round_trips("nil", nil, type)
+    round_trips("a keyword", random_symbol, type)
+    round_trips("a string", random_string, type)
+    round_trips("a string starting with ~", "~#{random_string}", type)
+    round_trips("a string starting with ^", "^#{random_string}", type)
+    round_trips("a string starting with `", "`#{random_string}", type)
+    round_trips("true", true, type)
+    round_trips("false", false, type)
+    round_trips("a small int", 1, type)
+    round_trips("a big int", 123456789012345, type)
+    round_trips("a very big int", 123456789012345679012345678890, type)
+    round_trips("a float", 1234.56, type)
+    round_trips("a bigdec", BigDecimal.new("123.45"), type)
+    round_trips("an instant (DateTime local)", DateTime.new(2014,1,2,3,4,5, "-5"), type,
+                :expected => DateTime.new(2014,1,2, (3+5) ,4,5, "+00:00"))
+    round_trips("an instant (DateTime gmt)", DateTime.new(2014,1,2,3,4,5), type)
+    round_trips("an instant (Time local)", Time.new(2014,1,2,3,4,5, "-05:00"), type,
+                :expected => DateTime.new(2014,1,2, (3+5) ,4,5, "+00:00"))
+    round_trips("an instant (Time gmt)", Time.new(2014,1,2,3,4,5, "+00:00"), type,
+                :expected => DateTime.new(2014,1,2,3,4,5, "+00:00"))
+    round_trips("a Date", Date.new(2014,1,2), type, :expected => DateTime.new(2014,1,2))
+    round_trips("a uuid", UUID.new, type)
+    round_trips("a link", Link.new(Addressable::URI.parse("http://example.org/search"), "search"), type)
+    round_trips("a link", Link.new(Addressable::URI.parse("http://example.org/search"), "search", nil, "image"), type)
+    round_trips("a link with string uri", Link.new("http://example.org/search", "search", nil, "image"), type)
+    round_trips("a uri (url)", Addressable::URI.parse("http://example.com"), type)
+    round_trips("a uri (file)", Addressable::URI.parse("file:///path/to/file.txt"), type)
+    round_trips("a bytearray", ByteArray.new(random_string(50)), type)
+    round_trips("a Transit::Symbol", Transit::Symbol.new(random_string), type)
+    round_trips("a hash w/ stringable keys", {"this" => "~hash", "1" => 2}, type)
+    round_trips("a set", Set.new([1,2,3]), type)
+    round_trips("a set of sets", Set.new([Set.new([1,2]), Set.new([3,4])]), type)
+    round_trips("an array", [1,2,3], type)
+    round_trips("a char", TaggedValue.new("c", "x"), type, :expected => "x")
+    round_trips("a list", TaggedValue.new("list", [1,2,3]), type, :expected => [1,2,3])
+    round_trips("an array of maps w/ cacheable keys", [{"this" => "a"},{"this" => "b"}], type)
+
+    round_trips("edge case chars", %w[` ~ ^ #], type)
+
+    round_trips("an extension scalar", PhoneNumber.new("555","867","5309"), type,
+                :write_handlers => {PhoneNumber => PhoneNumberHandler.new},
+                :read_handlers  => {"P" => PhoneNumberReadHandler.new})
+    round_trips("an extension struct", Person.new("First","Last",:today), type,
+                :write_handlers => {Person => PersonHandler.new},
+                :read_handlers  => {"person" => PersonReadHandler.new})
+    round_trips("a hash with simple values", {'a' => 1, 'b' => 2, 'name' => 'russ'}, type)
+    round_trips("a hash with Transit::Symbols", {Transit::Symbol.new("foo") => Transit::Symbol.new("bar")}, type)
+    round_trips("a hash with 53 bit ints",  {2**53-1 => 2**53-2}, type)
+    round_trips("a hash with 54 bit ints",  {2**53   => 2**53+1}, type)
+    round_trips("a map with composite keys", {{a: :b} => {c: :d}}, type)
+    round_trips("a TaggedValue", TaggedValue.new("unrecognized",:value), type)
+    round_trips("an unrecognized hash encoding", {"~#unrecognized" => :value}, type)
+    round_trips("an unrecognized string encoding", "~Xunrecognized", type)
+
+    round_trips("a nested structure (map on top)", {a: [1, [{b: "~c"}]]}, type)
+    round_trips("a nested structure (array on top)", [37, {a: [1, [{b: "~c"}]]}], type)
+    round_trips("a map that looks like transit data", [{"~#set"=>[1,2,3]},{"~#set"=>[4,5,6]}], type)
+  end
+
+  describe "Transit using json" do
+    include_examples "round trips", :json
+  end
+
+  describe "Transit using json_verbose" do
+    include_examples "round trips", :json_verbose
+  end
+
+  describe "Transit using msgpack" do
+    include_examples "round trips", :msgpack
+  end
+end

data/spec/transit/transit_types_spec.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+module Transit
+  describe Transit::Symbol do
+    it 'can be made from a symbol' do
+      500.times do
+        sym = random_symbol
+        assert { Transit::Symbol.new(sym).to_sym == sym }
+      end
+    end
+
+    it 'can be made from a string' do
+      500.times do
+        str = random_string
+        assert { Transit::Symbol.new(str).to_sym == str.to_sym }
+      end
+    end
+
+    it 'is equal to another rendition of itself' do
+      500.times do
+        sym = random_symbol
+        assert { Transit::Symbol.new(sym) == Transit::Symbol.new(sym)}
+      end
+    end
+
+    it 'behaves as a hash key' do
+      keys = Set.new(Array.new(1000).map {|x| random_symbol})
+
+      test_hash = {}
+      keys.each_with_index {|k, i| test_hash[Transit::Symbol.new(k)] = i}
+
+      keys.each_with_index do |k, i|
+        new_key = Transit::Symbol.new(k)
+        value = test_hash[new_key]
+        assert { value == i }
+      end
+    end
+
+    it "provides namespace" do
+      assert { Transit::Symbol.new("foo/bar").namespace == "foo" }
+      assert { Transit::Symbol.new("foo").namespace == nil }
+    end
+
+    it "provides name" do
+      assert { Transit::Symbol.new("foo").name == "foo" }
+      assert { Transit::Symbol.new("foo/bar").name == "bar" }
+    end
+
+    it "special cases '/'" do
+      assert { Transit::Symbol.new("/").name == "/" }
+      assert { Transit::Symbol.new("/").namespace == nil }
+    end
+  end
+
+  describe UUID do
+    it 'round trips strings' do
+      10.times do
+        uuid = UUID.random
+        assert { UUID.new(uuid.to_s) == uuid }
+      end
+    end
+
+    it 'round trips ints' do
+      10.times do
+        uuid = UUID.random
+        assert { UUID.new(uuid.most_significant_bits, uuid.least_significant_bits) == uuid }
+      end
+    end
+  end
+
+  describe Link do
+    let(:href) { Addressable::URI.parse("http://example.org/search") }
+    let(:string_href) { "http://example.org/search" }
+    let(:rel) { "search" }
+    let(:prompt) { "Enter search string" }
+    let(:name) { "this is my name" }
+
+    it 'can be made from some given arugments' do
+      link = Link.new(href, rel)
+      assert { link.href == href }
+      assert { link.rel == rel }
+      assert { link.prompt == nil }
+      assert { link.name == nil }
+      assert { link.render == nil }
+    end
+
+    it 'can be made from all 5 given correct arguments' do
+      link = Link.new(href, rel, name, "Image", prompt)
+      assert { link.href == href }
+      assert { link.rel == rel }
+      assert { link.name == name }
+      assert { link.render == "image" }
+      assert { link.prompt == prompt }
+    end
+
+    it 'can be made with uri in string' do
+      link = Link.new(string_href, rel)
+      assert { link.href == Addressable::URI.parse(string_href) }
+    end
+
+    it 'raises exception if href and rel are not given' do
+      assert { rescuing { Link.new }.is_a? ArgumentError }
+      assert { rescuing { Link.new("foo") }.is_a? ArgumentError }
+    end
+
+    it 'raises exception if render is not a valid value (link|image)' do
+      assert { rescuing { Link.new(href, rel, nil, "document") }.is_a? ArgumentError }
+    end
+
+    it 'leaves the input map alone' do
+      input = {"href" => "http://example.com", "rel" => "???", "render" => "LINK"}
+      Link.new(input)
+      assert { input["href"] == "http://example.com" }
+      assert { input["render"] == "LINK" }
+    end
+
+    it 'produces a frozen map' do
+      assert { Link.new("/path", "the-rel").to_h.frozen? }
+    end
+  end
+end

data/spec/transit/writer_spec.rb

@@ -0,0 +1,277 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+require 'json'
+
+module Transit
+  describe Writer do
+    let(:io) { StringIO.new('', 'w+') }
+    let(:writer) { Writer.new(:json_verbose, io) }
+
+    describe "marshaling transit types" do
+      def self.bytes
+        @bytes ||= SecureRandom.random_bytes
+      end
+
+      def self.marshals_scalar(label, value, rep, opts={})
+        it "marshals #{label}", :focus => opts[:focus] do
+          writer.write(value)
+          assert { JSON.parse(io.string) == {"~#'" => rep} }
+        end
+      end
+
+      def self.marshals_structure(label, value, rep, opts={})
+        it "marshals #{label}", :focus => opts[:focus] do
+          writer.write(value)
+          assert { JSON.parse(io.string) == rep }
+        end
+      end
+
+      marshals_scalar("a UUID",
+                      UUID.new("dda5a83f-8f9d-4194-ae88-5745c8ca94a7"),
+                      "~udda5a83f-8f9d-4194-ae88-5745c8ca94a7")
+      marshals_scalar("a Transit::Symbol", Transit::Symbol.new("foo"), "~$foo" )
+      marshals_scalar("a Fixnum", 9007199254740999, "~i9007199254740999")
+      marshals_scalar("a Bignum", 9223372036854775806, "~i9223372036854775806")
+      marshals_scalar("a Very Bignum", 4256768765123454321897654321234567, "~n4256768765123454321897654321234567")
+      marshals_scalar("a ByteArray", ByteArray.new(bytes), "~b#{ByteArray.new(bytes).to_base64}")
+      marshals_scalar("an URI", Addressable::URI.parse("http://example.com/search"), "~rhttp://example.com/search")
+      marshals_structure("a link",
+                         Link.new(Addressable::URI.parse("http://example.com/search"), "search", nil, "link", nil),
+                         {"~#link" =>
+                           {"href" => "~rhttp://example.com/search",
+                             "rel" => "search",
+                             "name" => nil,
+                             "render" => "link",
+                             "prompt" => nil}})
+      marshals_structure("a TaggedValue", TaggedValue.new("tag", "value"), {"~#tag" => "value"})
+    end
+
+    describe "custom handlers" do
+      it "raises when a handler provides nil as a tag" do
+        handler = Class.new do
+          def tag(_) nil end
+        end
+        writer = Writer.new(:json_verbose, io, :handlers => {Date => handler.new})
+        assert { rescuing { writer.write(Date.today) }.message =~ /must provide a non-nil tag/ }
+      end
+
+      it "supports custom handlers for core types" do
+        handler = Class.new do
+          def tag(_) "s" end
+          def rep(s) "MYSTRING: #{s}" end
+          def string_rep(s) rep(s) end
+        end
+        writer = Writer.new(:json_verbose, io, :handlers => {String => handler.new})
+        writer.write("this")
+        assert { JSON.parse(io.string).values.first == "MYSTRING: this" }
+      end
+
+      it "supports custom handlers for custom types" do
+        handler = Class.new do
+          def tag(_) "person" end
+          def rep(s) {:first_name => s.first_name} end
+          def string_rep(s) s.first_name end
+        end
+        writer = Writer.new(:json_verbose, io, :handlers => {Person => handler.new})
+        writer.write(Person.new("Russ"))
+        assert { JSON.parse(io.string) == {"~#person" => { "~:first_name" => "Russ" } } }
+      end
+
+      it "supports verbose handlers" do
+        phone_class = Class.new do
+          attr_reader :p
+          def initialize(p)
+            @p = p
+          end
+        end
+        handler = Class.new do
+          def tag(_) "phone" end
+          def rep(v) v.p end
+          def string_rep(v) v.p.to_s end
+          def verbose_handler
+            Class.new do
+              def tag(_) "phone" end
+              def rep(v) "PHONE: #{v.p}" end
+              def string_rep(v) rep(v) end
+            end.new
+          end
+        end
+
+        writer = Writer.new(:json, io, :handlers => {phone_class => handler.new})
+        writer.write(phone_class.new(123456789))
+        assert { JSON.parse(io.string) == ["~#phone", 123456789] }
+
+        io.rewind
+
+        writer = Writer.new(:json_verbose, io, :handlers => {phone_class => handler.new})
+        writer.write(phone_class.new(123456789))
+        assert { JSON.parse(io.string) == {"~#phone" => "PHONE: 123456789"} }
+      end
+    end
+
+    describe "formats" do
+      describe "JSON" do
+        let(:writer) { Writer.new(:json, io) }
+
+        it "writes a map as an array prefixed with '^ '" do
+          writer.write({:a => :b, 3 => 4})
+          assert { JSON.parse(io.string) == ["^ ", "~:a", "~:b", "~i3", 4] }
+        end
+
+        it "writes a single-char tagged-value as a string" do
+          writer.write([TaggedValue.new("a","bc")])
+          assert { JSON.parse(io.string) == ["~abc"] }
+        end
+
+        it "writes a multi-char tagged-value as a 2-element array" do
+          writer.write(TaggedValue.new("abc","def"))
+          assert { JSON.parse(io.string) == ["~#abc", "def"] }
+        end
+
+        it "writes a Date as an encoded hash with ms" do
+          writer.write([Date.new(2014,1,2)])
+          assert { JSON.parse(io.string) == ["~m1388620800000"] }
+        end
+
+        it "writes a Time as an encoded hash with ms" do
+          writer.write([(Time.at(1388631845) + 0.678)])
+          assert { JSON.parse(io.string) == ["~m1388631845678"] }
+        end
+
+        it "writes a DateTime as an encoded hash with ms" do
+          writer.write([(Time.at(1388631845) + 0.678).to_datetime])
+          assert { JSON.parse(io.string) == ["~m1388631845678"] }
+        end
+
+        it "writes a quote as a tagged array" do
+          writer.write("this")
+          assert { JSON.parse(io.string) == ["~#'", "this"] }
+        end
+      end
+
+      describe "JSON_VERBOSE" do
+        let(:writer) { Writer.new(:json_verbose, io) }
+
+        it "does not use the cache" do
+          writer.write([{"this" => "that"}, {"this" => "the other"}])
+          assert { JSON.parse(io.string) == [{"this" => "that"}, {"this" => "the other"}] }
+        end
+
+        it "writes a single-char tagged-value as a string" do
+          writer.write([TaggedValue.new("a","bc")])
+          assert { JSON.parse(io.string) == ["~abc"] }
+        end
+
+        it "writes a multi-char tagged-value as a map" do
+          writer.write(TaggedValue.new("abc","def"))
+          assert { JSON.parse(io.string) == {"~#abc" => "def"} }
+        end
+
+        it "writes a Date as an encoded human-readable strings" do
+          writer.write([Date.new(2014,1,2)])
+          assert { JSON.parse(io.string) == ["~t2014-01-02T00:00:00.000Z"] }
+        end
+
+        it "writes a Time as an encoded human-readable strings" do
+          writer.write([(Time.at(1388631845) + 0.678)])
+          assert { JSON.parse(io.string) == ["~t2014-01-02T03:04:05.678Z"] }
+        end
+
+        it "writes a DateTime as an encoded human-readable strings" do
+          writer.write([(Time.at(1388631845) + 0.678).to_datetime])
+          assert { JSON.parse(io.string) == ["~t2014-01-02T03:04:05.678Z"] }
+        end
+
+        it "writes a quote as a tagged map" do
+          writer.write("this")
+          assert { JSON.parse(io.string) == {"~#'" => "this"} }
+        end
+      end
+
+      describe "MESSAGE_PACK" do
+        let(:writer) { Writer.new(:msgpack, io) }
+
+        it "writes a single-char tagged-value as a 2-element array" do
+          writer.write(TaggedValue.new("a","bc"))
+          assert { MessagePack::Unpacker.new(StringIO.new(io.string)).read == ["~#'", "~abc"] }
+        end
+
+        it "writes a multi-char tagged-value as a 2-element array" do
+          writer.write(TaggedValue.new("abc","def"))
+          assert { MessagePack::Unpacker.new(StringIO.new(io.string)).read == ["~#abc", "def"] }
+        end
+
+        it "writes a top-level scalar as a quote-tagged value" do
+          writer.write("this")
+          assert { MessagePack::Unpacker.new(StringIO.new(io.string)).read == ["~#'", "this"] }
+        end
+      end
+
+      describe "ints" do
+        it "encodes ints <= max signed 64 bit with 'i'" do
+          1.upto(5).to_a.reverse.each do |n|
+            io.rewind
+            writer.write([(2**63) - n])
+            assert { JSON.parse(io.string).first[1] == "i" }
+          end
+        end
+
+        it "encodes ints > max signed 64 bit with 'n'" do
+          0.upto(4).each do |n|
+            io.rewind
+            writer.write([(2**63) + n])
+            assert { JSON.parse(io.string).first[1] == "n" }
+          end
+        end
+      end
+
+      describe "escaped strings" do
+        [ESC, SUB, RES, "#{SUB} "].each do |c|
+          it "escapes a String starting with #{c}" do
+            writer.write("#{c}whatever")
+            assert { JSON.parse(io.string) == {"#{TAG}#{QUOTE}" => "~#{c}whatever"}}
+          end
+        end
+      end
+
+      describe "edge cases" do
+        it 'writes correct json for TaggedValues in a map-as-array (json)' do
+          writer = Writer.new(:json, io)
+          v = {7924023966712353515692932 => TaggedValue.new("ratio", [1, 3]),
+               100 => TaggedValue.new("ratio", [1, 2])}
+          writer.write(v)
+          expected = ["^ ",
+                      "~n7924023966712353515692932", ["~#ratio", [1,3]],
+                      "~i100",["^1", [1,2]]]
+          actual = io.string
+          assert { JSON.parse(io.string) == expected }
+        end
+
+        it 'writes out strings starting with `' do
+          v = "`~hello"
+          writer.write([v])
+          assert { JSON.parse(io.string).first == "~`~hello" }
+        end
+
+        it 'raises when there is no handler for the type' do
+          type = Class.new
+          obj = type.new
+          assert { rescuing { writer.write(obj) }.message =~ /Can not find a Write Handler/ }
+        end
+      end
+    end
+  end
+end