addressable 2.0.2 → 2.1.0

data/spec/addressable/uri_spec.rb

@@ -1,4 +1,4 @@
-# coding:utf-8
+# encoding: utf-8
 #--
 # Addressable, Copyright (c) 2006-2007 Bob Aman
 #
@@ -30,48 +30,37 @@ require "addressable/uri"
 if !"".respond_to?("force_encoding")
   class String
     def force_encoding(encoding)
-      # Do nothing, just make sure this gets called.
+      @encoding = encoding
     end
-  end
-
-  class Encoding
-    UTF_8 = Encoding.new
-    ASCII_8BIT = Encoding.new
-  end
-end
 
-class ExampleProcessor
-  def self.validate(name, value)
-    return !!(value =~ /^[\w ]+$/) if name == "query"
-    return true
+    def encoding
+      @encoding ||= Encoding::ASCII_8BIT
+    end
   end
 
-  def self.transform(name, value)
-    return value.gsub(/ /, "+") if name == "query"
-    return value
-  end
+  class Encoding
+    def initialize(name)
+      @name = name
+    end
 
-  def self.restore(name, value)
-    return value.gsub(/\+/, " ") if name == "query"
-    return value.tr("A-Za-z", "N-ZA-Mn-za-m") if name == "rot13"
-    return value
-  end
+    def to_s
+      return @name
+    end
 
-  def self.match(name)
-    return ".*?" if name == "first"
-    return ".*"
+    UTF_8 = Encoding.new("UTF-8")
+    ASCII_8BIT = Encoding.new("US-ASCII")
   end
 end
 
-class SlashlessProcessor
-  def self.match(name)
-    return "[^/\\n]*"
-  end
-end
+module URI
+  class HTTP
+    def initialize(uri)
+      @uri = uri
+    end
 
-class NoOpProcessor
-  def self.transform(name, value)
-    value
+    def to_s
+      return @uri.to_s
+    end
   end
 end
 
@@ -104,6 +93,37 @@ describe Addressable::URI, "when created from nil components" do
   it "should be an empty uri" do
     @uri.to_s.should == ""
   end
+
+  it "should still be an empty uri if the scheme is set to whitespace" do
+    @uri.scheme = "\t \n"
+    @uri.to_s.should == ""
+  end
+
+  it "should raise an error if set into an invalid state" do
+    (lambda do
+      @uri.user = "user"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    (lambda do
+      @uri.password = "pass"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    (lambda do
+      @uri.scheme = "http"
+      @uri.fragment = "fragment"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    (lambda do
+      @uri.fragment = "fragment"
+      @uri.scheme = "http"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
 end
 
 describe Addressable::URI, "when created from string components" do
@@ -139,7 +159,9 @@ end
 describe Addressable::URI, "when created with both an authority and a user" do
   it "should raise an error" do
     (lambda do
-      Addressable::URI.new(:user => "user", :authority => "user@example.com:80")
+      Addressable::URI.new(
+        :user => "user", :authority => "user@example.com:80"
+      )
     end).should raise_error(ArgumentError)
   end
 end
@@ -181,8 +203,60 @@ describe Addressable::URI, "when created with a path that hasn't been " +
   end
 end
 
+describe Addressable::URI, "when parsed from an Addressable::URI object" do
+  it "should return the object" do
+    uri = Addressable::URI.parse("http://example.com/")
+    (lambda do
+      Addressable::URI.parse(uri).object_id.should == uri.object_id
+    end).should_not raise_error
+  end
+
+  it "should return the object" do
+    uri = Addressable::URI.parse("http://example.com/")
+    (lambda do
+      Addressable::URI.heuristic_parse(uri).object_id.should == uri.object_id
+    end).should_not raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from something that looks " +
+    "like a URI object" do
+  it "should parse without error" do
+    uri = Addressable::URI.parse(URI::HTTP.new("http://example.com/"))
+    (lambda do
+      Addressable::URI.parse(uri)
+    end).should_not raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from ''" do
+  before do
+    @uri = Addressable::URI.parse("")
+  end
+
+  it "should have no scheme" do
+    @uri.scheme.should == nil
+  end
+
+  it "should not be considered to be ip-based" do
+    @uri.should_not be_ip_based
+  end
+
+  it "should have a path of ''" do
+    @uri.path.should == ""
+  end
+
+  it "should be considered relative" do
+    @uri.should be_relative
+  end
+
+  it "should be considered to be in normal form" do
+    @uri.normalize.should be_eql(@uri)
+  end
+end
+
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'ftp://ftp.is.co.za/rfc/rfc1808.txt'" do
   before do
     @uri = Addressable::URI.parse("ftp://ftp.is.co.za/rfc/rfc1808.txt")
@@ -210,7 +284,7 @@ describe Addressable::URI, " when parsed from " +
 end
 
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://www.ietf.org/rfc/rfc2396.txt'" do
   before do
     @uri = Addressable::URI.parse("http://www.ietf.org/rfc/rfc2396.txt")
@@ -287,10 +361,16 @@ describe Addressable::URI, "when parsed from " +
     @uri.omit!(:scheme, :authority)
     @uri.to_s.should == "/c=GB?objectClass?one"
   end
+
+  it "should raise an error if omission would create an invalid URI" do
+    (lambda do
+      @uri.omit(:authority, :path)
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
 end
 
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'mailto:John.Doe@example.com'" do
   before do
     @uri = Addressable::URI.parse("mailto:John.Doe@example.com")
@@ -314,7 +394,7 @@ describe Addressable::URI, " when parsed from " +
 end
 
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'news:comp.infosystems.www.servers.unix'" do
   before do
     @uri = Addressable::URI.parse("news:comp.infosystems.www.servers.unix")
@@ -362,7 +442,7 @@ describe Addressable::URI, "when parsed from " +
 end
 
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'telnet://192.0.2.16:80/'" do
   before do
     @uri = Addressable::URI.parse("telnet://192.0.2.16:80/")
@@ -394,7 +474,7 @@ describe Addressable::URI, " when parsed from " +
 end
 
 # Section 1.1.2 of RFC 3986
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'urn:oasis:names:specification:docbook:dtd:xml:4.1.2'" do
   before do
     @uri = Addressable::URI.parse(
@@ -419,7 +499,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com'" do
   before do
     @uri = Addressable::URI.parse("http://example.com")
@@ -611,6 +691,7 @@ describe Addressable::URI, " when parsed from " +
     @uri.normalized_password.should == "secret%40123%21"
     @uri.user.should == ""
     @uri.normalize.to_s.should == "http://:secret%40123%21@example.com/"
+    @uri.omit(:password).to_s.should == "http://example.com"
   end
 
   it "should have the correct user/pass after repeated assignment" do
@@ -668,7 +749,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/")
@@ -738,12 +819,12 @@ describe Addressable::URI, " when parsed from " +
     @uri.hash.should_not == @uri.to_s.hash
   end
 
-  it "should have the same hash as an equivalent URI" do
-    @uri.hash.should == Addressable::URI.parse("http://example.com:80/").hash
+  it "should have the same hash as an equal URI" do
+    @uri.hash.should == Addressable::URI.parse("http://example.com/").hash
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://@example.com/'" do
   before do
     @uri = Addressable::URI.parse("http://@example.com/")
@@ -771,7 +852,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com./'" do
   before do
     @uri = Addressable::URI.parse("http://example.com./")
@@ -790,7 +871,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://:@example.com/'" do
   before do
     @uri = Addressable::URI.parse("http://:@example.com/")
@@ -818,7 +899,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/~smith/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/~smith/")
@@ -839,7 +920,31 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/%E8'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/%E8")
+  end
+
+  it "should not raise an exception when normalized" do
+    (lambda do
+      @uri.normalize
+    end).should_not raise_error(ArgumentError)
+  end
+
+  it "should be considered to be in normal form" do
+    @uri.normalize.should be_eql(@uri)
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    Addressable::URI.normalized_encode(@uri).to_s.should ==
+      "http://example.com/%E8"
+    Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s.should ===
+      "http://example.com/%E8"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/%C3%87'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/%C3%87")
@@ -884,7 +989,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/?q=string'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/?q=string")
@@ -943,7 +1048,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com:80/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com:80/")
@@ -1055,7 +1160,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com:8080/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com:8080/")
@@ -1152,7 +1257,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com:%38%30/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com:%38%30/")
@@ -1171,7 +1276,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/path/to/resource/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/path/to/resource/")
@@ -1409,7 +1514,7 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/file.txt'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/file.txt")
@@ -1460,7 +1565,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/file.txt;parameter'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/file.txt;parameter")
@@ -1511,7 +1616,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/file.txt;x=y'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/file.txt;x=y")
@@ -1566,7 +1671,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'svn+ssh://developername@rubyforge.org/var/svn/project'" do
   before do
     @uri = Addressable::URI.parse(
@@ -1599,7 +1704,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'ssh+svn://developername@rubyforge.org/var/svn/project'" do
   before do
     @uri = Addressable::URI.parse(
@@ -1636,7 +1741,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'mailto:user@example.com'" do
   before do
     @uri = Addressable::URI.parse("mailto:user@example.com")
@@ -1663,7 +1768,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'tag:example.com,2006-08-18:/path/to/something'" do
   before do
     @uri = Addressable::URI.parse(
@@ -1692,7 +1797,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/x;y/'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/x;y/")
@@ -1703,7 +1808,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/?x=1&y=2'" do
   before do
     @uri = Addressable::URI.parse("http://example.com/?x=1&y=2")
@@ -1714,7 +1819,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'view-source:http://example.com/'" do
   before do
     @uri = Addressable::URI.parse("view-source:http://example.com/")
@@ -1733,7 +1838,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://user:pass@example.com/path/to/resource?query=x#fragment'" do
   before do
     @uri = Addressable::URI.parse(
@@ -1831,11 +1936,15 @@ describe Addressable::URI, " when parsed from " +
     @uri.scheme.should == "ftp"
     @uri.to_s.should ==
       "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
+    @uri.to_str.should ==
+      "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
     @uri.scheme = "bogus!"
     @uri.scheme.should == "bogus!"
     @uri.normalized_scheme.should == "bogus%21"
     @uri.normalize.to_s.should ==
       "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
+    @uri.normalize.to_str.should ==
+      "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
   end
 
   it "should have the correct authority segment after assignment" do
@@ -1917,10 +2026,12 @@ describe Addressable::URI, " when parsed from " +
   end
 
   it "should have the correct query string after hash assignment" do
-    @uri.query_values = {"?uestion mark"=>"=sign", "hello"=>"günther"}
+    @uri.query_values = {"?uestion mark"=>"=sign", "hello"=>"g\xC3\xBCnther"}
     @uri.query.split("&").should include("%3Fuestion%20mark=%3Dsign")
     @uri.query.split("&").should include("hello=g%C3%BCnther")
-    @uri.query_values.should == {"?uestion mark"=>"=sign", "hello"=>"günther"}
+    @uri.query_values.should == {
+      "?uestion mark"=>"=sign", "hello"=>"g\xC3\xBCnther"
+    }
   end
 
   it "should have the correct query string after flag hash assignment" do
@@ -1933,6 +2044,12 @@ describe Addressable::URI, " when parsed from " +
     }
   end
 
+  it "should raise an error if query values are set to a bogus type" do
+    (lambda do
+      @uri.query_values = "bogus"
+    end).should raise_error(TypeError)
+  end
+
   it "should have the correct fragment after assignment" do
     @uri.fragment = "newfragment"
     @uri.fragment.should == "newfragment"
@@ -2023,7 +2140,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://user@example.com'" do
   before do
     @uri = Addressable::URI.parse("http://user@example.com")
@@ -2111,7 +2228,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://user:@example.com'" do
   before do
     @uri = Addressable::URI.parse("http://user:@example.com")
@@ -2166,7 +2283,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://:pass@example.com'" do
   before do
     @uri = Addressable::URI.parse("http://:pass@example.com")
@@ -2226,7 +2343,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://:@example.com'" do
   before do
     @uri = Addressable::URI.parse("http://:@example.com")
@@ -2282,7 +2399,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'#example'" do
   before do
     @uri = Addressable::URI.parse("#example")
@@ -2309,7 +2426,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "the network-path reference '//example.com/'" do
   before do
     @uri = Addressable::URI.parse("//example.com/")
@@ -2337,7 +2454,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'feed://http://example.com/'" do
   before do
     @uri = Addressable::URI.parse("feed://http://example.com/")
@@ -2352,7 +2469,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'feed:http://example.com/'" do
   before do
     @uri = Addressable::URI.parse("feed:http://example.com/")
@@ -2381,7 +2498,7 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://example.com/indirect/path/./to/../resource/'" do
   before do
     @uri = Addressable::URI.parse(
@@ -2411,7 +2528,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://under_score.example.com/'" do
   it "should not cause an error" do
     (lambda do
@@ -2420,7 +2537,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'./this:that'" do
   before do
     @uri = Addressable::URI.parse("./this:that")
@@ -2450,7 +2567,26 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from '?one=1&two=2&three=3'" do
+describe Addressable::URI, "when parsed from '?'" do
+  before do
+    @uri = Addressable::URI.parse("?")
+  end
+
+  it "should have the correct subscript notation query values" do
+    @uri.query_values.should == {}
+    @uri.query_values(:notation => :subscript).should == {}
+  end
+
+  it "should have the correct dot notation query values" do
+    @uri.query_values(:notation => :dot).should == {}
+  end
+
+  it "should have the correct flat notation query values" do
+    @uri.query_values(:notation => :flat).should == {}
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
   before do
     @uri = Addressable::URI.parse("?one=1&two=2&three=3")
   end
@@ -2466,7 +2602,7 @@ describe Addressable::URI, " when parsed from '?one=1&two=2&three=3'" do
   end
 end
 
-describe Addressable::URI, " when parsed from '?one[two][three]=four'" do
+describe Addressable::URI, "when parsed from '?one[two][three]=four'" do
   before do
     @uri = Addressable::URI.parse("?one[two][three]=four")
   end
@@ -2482,7 +2618,7 @@ describe Addressable::URI, " when parsed from '?one[two][three]=four'" do
   end
 end
 
-describe Addressable::URI, " when parsed from '?one.two.three=four'" do
+describe Addressable::URI, "when parsed from '?one.two.three=four'" do
   before do
     @uri = Addressable::URI.parse("?one.two.three=four")
   end
@@ -2500,7 +2636,7 @@ describe Addressable::URI, " when parsed from '?one.two.three=four'" do
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'?one[two][three]=four&one[two][five]=six'" do
   before do
     @uri = Addressable::URI.parse("?one[two][three]=four&one[two][five]=six")
@@ -2520,7 +2656,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'?one.two.three=four&one.two.five=six'" do
   before do
     @uri = Addressable::URI.parse("?one.two.three=four&one.two.five=six")
@@ -2540,7 +2676,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'?one[two][three][]=four&one[two][three][]=five'" do
   before do
     @uri = Addressable::URI.parse(
@@ -2548,7 +2684,7 @@ describe Addressable::URI, " when parsed from " +
     )
   end
 
-  it "should have the correct dot notation query values" do
+  it "should have the correct subscript notation query values" do
     @uri.query_values(:notation => :subscript).should == {
       "one" => {"two" => {"three" => ["four", "five"]}}
     }
@@ -2561,7 +2697,22 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][0]=four&one[two][three][1]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][0]=four&one[two][three][1]=five"
+    )
+  end
+
+  it "should have the correct subscript notation query values" do
+    @uri.query_values(:notation => :subscript).should == {
+      "one" => {"two" => {"three" => ["four", "five"]}}
+    }
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
     "'http://www.詹姆斯.com/'" do
   before do
     @uri = Addressable::URI.parse("http://www.詹姆斯.com/")
@@ -2578,7 +2729,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://www.詹姆斯.com/ some spaces /'" do
   before do
     @uri = Addressable::URI.parse("http://www.詹姆斯.com/ some spaces /")
@@ -2597,7 +2748,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://www.xn--8ws00zhy3a.com/'" do
   before do
     @uri = Addressable::URI.parse("http://www.xn--8ws00zhy3a.com/")
@@ -2606,9 +2757,17 @@ describe Addressable::URI, " when parsed from " +
   it "should be displayed as http://www.詹姆斯.com/" do
     @uri.display_uri.to_s.should == "http://www.詹姆斯.com/"
   end
+
+  it "should properly force the encoding" do
+    display_string = @uri.display_uri.to_str
+    display_string.should == "http://www.詹姆斯.com/"
+    if display_string.respond_to?(:encoding)
+      display_string.encoding.to_s.should == Encoding::UTF_8.to_s
+    end
+  end
 end
 
-describe Addressable::URI, " when parsed from " +
+describe Addressable::URI, "when parsed from " +
     "'http://www.詹姆斯.com/atomtests/iri/詹.html'" do
   before do
     @uri = Addressable::URI.parse("http://www.詹姆斯.com/atomtests/iri/詹.html")
@@ -2623,7 +2782,7 @@ describe Addressable::URI, " when parsed from " +
   end
 end
 
-describe Addressable::URI, " when parsed from a percent-encoded IRI" do
+describe Addressable::URI, "when parsed from a percent-encoded IRI" do
   before do
     @uri = Addressable::URI.parse(
       "http://www.%E3%81%BB%E3%82%93%E3%81%A8%E3%81%86%E3%81%AB%E3%81%AA" +
@@ -2936,47 +3095,6 @@ describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
   end
 end
 
-describe Addressable::URI, "when extracting from an arbitrary text" do
-  before do
-    @text = File.open(File.expand_path(
-      File.dirname(__FILE__) + "/../data/rfc3986.txt")) { |file| file.read }
-  end
-
-  it "should have all obvious URIs extractable from it" do
-    @uris = Addressable::URI.extract(@text)
-    @uris.should include("http://www.w3.org/People/Berners-Lee/")
-    @uris.should include("http://roy.gbiv.com/")
-    @uris.should include("http://larry.masinter.net/")
-    @uris = Addressable::URI.extract(@text,
-      :base => "http://example.com/", :parse => true)
-    @uris.should include(
-      Addressable::URI.parse("http://www.w3.org/People/Berners-Lee/"))
-    @uris.should include(
-      Addressable::URI.parse("http://roy.gbiv.com/"))
-    @uris.should include(
-      Addressable::URI.parse("http://larry.masinter.net/"))
-  end
-end
-
-describe Addressable::URI, "when extracting from an arbitrary text " +
-    "containing invalid URIs" do
-  before do
-    @text = <<-TEXT
-      This is an invalid URI:
-        http://example.com:bogus/path/to/something/
-      This is a valid URI:
-        http://example.com:80/path/to/something/
-    TEXT
-  end
-
-  it "should ignore invalid URIs when extracting" do
-    @uris = Addressable::URI.extract(@text)
-    @uris.should include("http://example.com:80/path/to/something/")
-    @uris.should_not include("http://example.com:bogus/path/to/something/")
-    @uris.size.should == 1
-  end
-end
-
 describe Addressable::URI, "when converting the path " +
     "'relative/path/to/something'" do
   before do
@@ -2986,13 +3104,13 @@ describe Addressable::URI, "when converting the path " +
   it "should convert to " +
       "\'relative/path/to/something\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "relative/path/to/something"
+    @uri.to_str.should == "relative/path/to/something"
   end
 
   it "should join with an absolute file path correctly" do
     @base = Addressable::URI.convert_path("/absolute/path/")
     @uri = Addressable::URI.convert_path(@path)
-    (@base + @uri).to_s.should ==
+    (@base + @uri).to_str.should ==
       "file:///absolute/path/relative/path/to/something"
   end
 end
@@ -3017,12 +3135,12 @@ describe Addressable::URI, "when given the root directory" do
   if RUBY_PLATFORM =~ /mswin/
     it "should convert to \'file:///c:/\'" do
       @uri = Addressable::URI.convert_path(@path)
-      @uri.to_s.should == "file:///c:/"
+      @uri.to_str.should == "file:///c:/"
     end
   else
     it "should convert to \'file:///\'" do
       @uri = Addressable::URI.convert_path(@path)
-      @uri.to_s.should == "file:///"
+      @uri.to_str.should == "file:///"
     end
   end
 end
@@ -3035,11 +3153,11 @@ describe Addressable::URI, "when given the path '/home/user/'" do
   it "should convert to " +
       "\'file:///home/user/\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///home/user/"
+    @uri.to_str.should == "file:///home/user/"
   end
 end
 
-describe Addressable::URI, " when given the path " +
+describe Addressable::URI, "when given the path " +
     "'c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
     @path = "c:\\windows\\My Documents 100%20\\foo.txt"
@@ -3048,11 +3166,11 @@ describe Addressable::URI, " when given the path " +
   it "should convert to " +
       "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
 end
 
-describe Addressable::URI, " when given the path " +
+describe Addressable::URI, "when given the path " +
     "'file://c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
     @path = "file://c:\\windows\\My Documents 100%20\\foo.txt"
@@ -3061,11 +3179,11 @@ describe Addressable::URI, " when given the path " +
   it "should convert to " +
       "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
 end
 
-describe Addressable::URI, " when given the path " +
+describe Addressable::URI, "when given the path " +
     "'file:c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
     @path = "file:c:\\windows\\My Documents 100%20\\foo.txt"
@@ -3074,11 +3192,11 @@ describe Addressable::URI, " when given the path " +
   it "should convert to " +
       "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
 end
 
-describe Addressable::URI, " when given the path " +
+describe Addressable::URI, "when given the path " +
     "'file:/c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
     @path = "file:/c:\\windows\\My Documents 100%20\\foo.txt"
@@ -3087,11 +3205,11 @@ describe Addressable::URI, " when given the path " +
   it "should convert to " +
       "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
 end
 
-describe Addressable::URI, " when given the path " +
+describe Addressable::URI, "when given the path " +
     "'file:///c|/windows/My%20Documents%20100%20/foo.txt'" do
   before do
     @path = "file:///c|/windows/My%20Documents%20100%20/foo.txt"
@@ -3100,7 +3218,7 @@ describe Addressable::URI, " when given the path " +
   it "should convert to " +
       "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
 end
 
@@ -3111,480 +3229,7 @@ describe Addressable::URI, "when given an http protocol URI" do
 
   it "should not do any conversion at all" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_s.should == "http://example.com/"
-  end
-end
-
-describe Addressable::URI, " when given the template pattern " +
-    "'http://example.com/search/{query}/' " +
-    "to be processed with the ExampleProcessor" do
-  before do
-    @pattern = "http://example.com/search/{query}/"
-  end
-
-  it "should expand to " +
-      "'http://example.com/search/an+example+search+query/' " +
-      "with a mapping of {\"query\" => \"an example search query\"} " do
-    Addressable::URI.expand_template(
-      "http://example.com/search/{query}/",
-      {"query" => "an example search query"},
-      ExampleProcessor).to_s.should ==
-        "http://example.com/search/an+example+search+query/"
-  end
-
-  it "should raise an error " +
-      "with a mapping of {\"query\" => \"invalid!\"}" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/search/{query}/",
-        {"query" => "invalid!"},
-        ExampleProcessor).to_s
-    end).should raise_error
-  end
-end
-
-# Section 3.3.1 of the URI Template draft v 01
-describe Addressable::URI, " when given the mapping supplied in " +
-    "Section 3.3.1 of the URI Template draft v 01" do
-  before do
-    @mapping = {
-      "a" => "fred",
-      "b" => "barney",
-      "c" => "cheeseburger",
-      "d" => "one two three",
-      "e" => "20% tricky",
-      "f" => "",
-      "20" => "this-is-spinal-tap",
-      "scheme" => "https",
-      "p" => "quote=to+be+or+not+to+be",
-      "q" => "hullo#world"
-    }
-  end
-
-  it "should result in 'http://example.org/page1#fred' " +
-      "when used to expand 'http://example.org/page1\#{a}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/page1\#{a}",
-      @mapping
-    ).to_s.should == "http://example.org/page1#fred"
-  end
-
-  it "should result in 'http://example.org/fred/barney/' " +
-      "when used to expand 'http://example.org/{a}/{b}/'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{a}/{b}/",
-      @mapping
-    ).to_s.should == "http://example.org/fred/barney/"
-  end
-
-  it "should result in 'http://example.org/fredbarney/' " +
-      "when used to expand 'http://example.org/{a}{b}/'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{a}{b}/",
-      @mapping
-    ).to_s.should == "http://example.org/fredbarney/"
-  end
-
-  it "should result in " +
-      "'http://example.com/order/cheeseburger/cheeseburger/cheeseburger/' " +
-      "when used to expand 'http://example.com/order/{c}/{c}/{c}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/order/{c}/{c}/{c}/",
-      @mapping
-    ).to_s.should ==
-        "http://example.com/order/cheeseburger/cheeseburger/cheeseburger/"
-  end
-
-  it "should result in 'http://example.org/one%20two%20three' " +
-      "when used to expand 'http://example.org/{d}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{d}",
-      @mapping
-    ).to_s.should == "http://example.org/one%20two%20three"
-  end
-
-  it "should result in 'http://example.org/20%25%20tricky' " +
-      "when used to expand 'http://example.org/{e}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{e}",
-      @mapping
-    ).to_s.should == "http://example.org/20%25%20tricky"
-  end
-
-  it "should result in 'http://example.com//' " +
-      "when used to expand 'http://example.com/{f}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{f}/",
-      @mapping
-    ).to_s.should == "http://example.com//"
-  end
-
-  it "should result in " +
-      "'https://this-is-spinal-tap.example.org?date=&option=fred' " +
-      "when used to expand " +
-      "'{scheme}://{20}.example.org?date={wilma}&option={a}'" do
-    Addressable::URI.expand_template(
-      "{scheme}://{20}.example.org?date={wilma}&option={a}",
-      @mapping
-    ).to_s.should ==
-        "https://this-is-spinal-tap.example.org?date=&option=fred"
-  end
-
-  # The v 01 draft conflicts with the v 03 draft here.
-  # The Addressable implementation uses v 03.
-  it "should result in " +
-      "'http://example.org?quote%3Dto%2Bbe%2Bor%2Bnot%2Bto%2Bbe' " +
-      "when used to expand 'http://example.org?{p}'" do
-    Addressable::URI.expand_template(
-      "http://example.org?{p}",
-      @mapping
-    ).to_s.should == "http://example.org?quote%3Dto%2Bbe%2Bor%2Bnot%2Bto%2Bbe"
-  end
-
-  # The v 01 draft conflicts with the v 03 draft here.
-  # The Addressable implementation uses v 03.
-  it "should result in 'http://example.com/hullo%23world' " +
-      "when used to expand 'http://example.com/{q}'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{q}",
-      @mapping
-    ).to_s.should == "http://example.com/hullo%23world"
-  end
-end
-
-# Section 4.5 of the URI Template draft v 03
-describe Addressable::URI, " when given the mapping supplied in " +
-    "Section 4.5 of the URI Template draft v 03" do
-  before do
-    @mapping = {
-      "foo" => "ϓ",
-      "bar" => "fred",
-      "baz" => "10,20,30",
-      "qux" => ["10","20","30"],
-      "corge" => [],
-      "grault" => "",
-      "garply" => "a/b/c",
-      "waldo" => "ben & jerrys",
-      "fred" => ["fred", "", "wilma"],
-      "plugh" => ["ẛ", "ṡ"],
-      "1-a_b.c" => "200"
-    }
-  end
-
-  it "should result in 'http://example.org/?q=fred' " +
-      "when used to expand 'http://example.org/?q={bar}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/?q={bar}",
-      @mapping
-    ).to_s.should == "http://example.org/?q=fred"
-  end
-
-  it "should result in '/' " +
-      "when used to expand '/{xyzzy}'" do
-    Addressable::URI.expand_template(
-      "/{xyzzy}",
-      @mapping
-    ).to_s.should == "/"
-  end
-
-  it "should result in " +
-      "'http://example.org/?foo=%CE%8E&bar=fred&baz=10%2C20%2C30' " +
-      "when used to expand " +
-      "'http://example.org/?{-join|&|foo,bar,xyzzy,baz}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/?{-join|&|foo,bar,xyzzy,baz}",
-      @mapping
-    ).to_s.should ==
-      "http://example.org/?foo=%CE%8E&bar=fred&baz=10%2C20%2C30"
-  end
-
-  it "should result in 'http://example.org/?d=10,20,30' " +
-      "when used to expand 'http://example.org/?d={-list|,|qux}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/?d={-list|,|qux}",
-      @mapping
-    ).to_s.should == "http://example.org/?d=10,20,30"
-  end
-
-  it "should result in 'http://example.org/?d=10&d=20&d=30' " +
-      "when used to expand 'http://example.org/?d={-list|&d=|qux}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/?d={-list|&d=|qux}",
-      @mapping
-    ).to_s.should == "http://example.org/?d=10&d=20&d=30"
-  end
-
-  it "should result in 'http://example.org/fredfred/a%2Fb%2Fc' " +
-      "when used to expand 'http://example.org/{bar}{bar}/{garply}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{bar}{bar}/{garply}",
-      @mapping
-    ).to_s.should == "http://example.org/fredfred/a%2Fb%2Fc"
-  end
-
-  it "should result in 'http://example.org/fred/fred//wilma' " +
-      "when used to expand 'http://example.org/{bar}{-prefix|/|fred}'" do
-    Addressable::URI.expand_template(
-      "http://example.org/{bar}{-prefix|/|fred}",
-      @mapping
-    ).to_s.should == "http://example.org/fred/fred//wilma"
-  end
-
-  it "should result in ':%E1%B9%A1:%E1%B9%A1:' " +
-      "when used to expand '{-neg|:|corge}{-suffix|:|plugh}'" do
-    Addressable::URI.expand_template(
-      "{-neg|:|corge}{-suffix|:|plugh}",
-      @mapping
-    ).to_s.should == ":%E1%B9%A1:%E1%B9%A1:"
-  end
-
-  it "should result in '../ben%20%26%20jerrys/' " +
-      "when used to expand '../{waldo}/'" do
-    Addressable::URI.expand_template(
-      "../{waldo}/",
-      @mapping
-    ).to_s.should == "../ben%20%26%20jerrys/"
-  end
-
-  it "should result in 'telnet:192.0.2.16:80' " +
-      "when used to expand 'telnet:192.0.2.16{-opt|:80|grault}'" do
-    Addressable::URI.expand_template(
-      "telnet:192.0.2.16{-opt|:80|grault}",
-      @mapping
-    ).to_s.should == "telnet:192.0.2.16:80"
-  end
-
-  it "should result in ':200:' " +
-      "when used to expand ':{1-a_b.c}:'" do
-    Addressable::URI.expand_template(
-      ":{1-a_b.c}:",
-      @mapping
-    ).to_s.should == ":200:"
-  end
-end
-
-describe Addressable::URI, "when given a mapping that contains a " +
-  "template-var within a value" do
-  before do
-    @mapping = {
-      "a" => "{b}",
-      "b" => "barney",
-    }
-  end
-
-  it "should result in 'http://example.com/%7Bb%7D/barney/' " +
-      "when used to expand 'http://example.com/{a}/{b}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{a}/{b}/",
-      @mapping).to_s.should == "http://example.com/%7Bb%7D/barney/"
-  end
-
-  it "should result in 'http://example.com//%7Bb%7D/' " +
-      "when used to expand 'http://example.com/{-opt|foo|foo}/{a}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{-opt|foo|foo}/{a}/",
-      @mapping).to_s.should == "http://example.com//%7Bb%7D/"
-  end
-
-  it "should result in 'http://example.com//%7Bb%7D/' " +
-      "when used to expand 'http://example.com/{-neg|foo|b}/{a}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{-neg|foo|b}/{a}/",
-      @mapping).to_s.should == "http://example.com//%7Bb%7D/"
-  end
-
-  it "should result in 'http://example.com//barney/%7Bb%7D/' " +
-      "when used to expand 'http://example.com/{-prefix|/|b}/{a}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{-prefix|/|b}/{a}/",
-      @mapping).to_s.should == "http://example.com//barney/%7Bb%7D/"
-  end
-
-  it "should result in 'http://example.com/barney//%7Bb%7D/' " +
-      "when used to expand 'http://example.com/{-suffix|/|b}/{a}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{-suffix|/|b}/{a}/",
-      @mapping).to_s.should == "http://example.com/barney//%7Bb%7D/"
-  end
-
-  it "should result in 'http://example.com/%7Bb%7D/?b=barney&c=42' " +
-      "when used to expand 'http://example.com/{a}/?{-join|&|b,c=42}'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{a}/?{-join|&|b,c=42}",
-      @mapping).to_s.should == "http://example.com/%7Bb%7D/?b=barney&c=42"
-  end
-
-  it "should result in 'http://example.com/42/?b=barney' " +
-      "when used to expand 'http://example.com/{c=42}/?{-join|&|b}'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{c=42}/?{-join|&|b}",
-      @mapping).to_s.should == "http://example.com/42/?b=barney"
-  end
-end
-
-describe Addressable::URI, "when given a single variable mapping" do
-  before do
-    @mapping = {
-      "foo" => "fred"
-    }
-  end
-
-  it "should result in 'fred' when used to expand '{foo}'" do
-    Addressable::URI.expand_template(
-      "{foo}",
-      @mapping
-    ).to_s.should == "fred"
-  end
-
-  it "should result in 'wilma' when used to expand '{bar=wilma}'" do
-    Addressable::URI.expand_template(
-      "{bar=wilma}",
-      @mapping
-    ).to_s.should == "wilma"
-  end
-
-  it "should result in '' when used to expand '{baz}'" do
-    Addressable::URI.expand_template(
-      "{baz}",
-      @mapping
-    ).to_s.should == ""
-  end
-end
-
-describe Addressable::URI, "when given a simple mapping" do
-  before do
-    @mapping = {
-      "foo" => "fred",
-      "bar" => "barney",
-      "baz" => ""
-    }
-  end
-
-  it "should result in 'foo=fred&bar=barney&baz=' when used to expand " +
-      "'{-join|&|foo,bar,baz,qux}'" do
-    Addressable::URI.expand_template(
-      "{-join|&|foo,bar,baz,qux}",
-      @mapping
-    ).to_s.should == "foo=fred&bar=barney&baz="
-  end
-
-  it "should result in 'bar=barney' when used to expand " +
-      "'{-join|&|bar}'" do
-    Addressable::URI.expand_template(
-      "{-join|&|bar}",
-      @mapping
-    ).to_s.should == "bar=barney"
-  end
-
-  it "should result in '' when used to expand " +
-      "'{-join|&|qux}'" do
-    Addressable::URI.expand_template(
-      "{-join|&|qux}",
-      @mapping
-    ).to_s.should == ""
-  end
-end
-
-describe Addressable::URI, "when given a mapping containing values " +
-    "that are already percent-encoded" do
-  before do
-    @mapping = {
-      "a" => "%7Bb%7D"
-    }
-  end
-
-  it "should result in 'http://example.com/%257Bb%257D/' " +
-      "when used to expand 'http://example.com/{a}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/{a}/",
-      @mapping).to_s.should == "http://example.com/%257Bb%257D/"
-  end
-end
-
-describe Addressable::URI, "when given a mapping containing bogus values" do
-  it "should raise a TypeError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{bogus}/", {
-          "bogus" => 42
-        }
-      )
-    end).should raise_error(TypeError)
-  end
-end
-
-describe Addressable::URI, "when given a pattern with bogus operators" do
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{-bogus|/|a,b,c}/", {
-          "a" => "a", "b" => "b", "c" => "c"
-        }
-      )
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{-prefix|/|a,b,c}/", {
-          "a" => "a", "b" => "b", "c" => "c"
-        }
-      )
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{-suffix|/|a,b,c}/", {
-          "a" => "a", "b" => "b", "c" => "c"
-        }
-      )
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{-join|/|a,b,c}/", {
-          "a" => ["a"], "b" => ["b"], "c" => "c"
-        }
-      )
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      Addressable::URI.expand_template(
-        "http://example.com/{-list|/|a,b,c}/", {
-          "a" => ["a"], "b" => ["b"], "c" => "c"
-        }
-      )
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-end
-
-describe Addressable::URI, "when given a mapping that contains an Array" do
-  before do
-    @mapping = {"query" => "an example search query".split(" ")}
-  end
-
-  it "should result in 'http://example.com/search/an+example+search+query/'" +
-      " when used to expand 'http://example.com/search/{-list|+|query}/'" do
-    Addressable::URI.expand_template(
-      "http://example.com/search/{-list|+|query}/",
-      @mapping).to_s.should ==
-        "http://example.com/search/an+example+search+query/"
-  end
-
-  it "should result in 'http://example.com/search/an+example+search+query/'" +
-      " when used to expand 'http://example.com/search/{-list|+|query}/'" +
-      " with a NoOpProcessor" do
-    Addressable::URI.expand_template(
-      "http://example.com/search/{-list|+|query}/",
-      @mapping, NoOpProcessor).to_s.should ==
-        "http://example.com/search/an+example+search+query/"
+    @uri.to_str.should == "http://example.com/"
   end
 end
 
@@ -3598,7 +3243,7 @@ class SuperString
   end
 end
 
-describe Addressable::URI, " when parsing a non-String object" do
+describe Addressable::URI, "when parsing a non-String object" do
   it "should correctly parse anything with a 'to_str' method" do
     Addressable::URI.parse(SuperString.new(42))
   end
@@ -3606,7 +3251,7 @@ describe Addressable::URI, " when parsing a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     (lambda do
       Addressable::URI.parse(42)
-    end).should raise_error(TypeError)
+    end).should raise_error(TypeError, "Can't convert Fixnum into String.")
   end
 
   it "should correctly parse heuristically anything with a 'to_str' method" do
@@ -3616,7 +3261,7 @@ describe Addressable::URI, " when parsing a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     (lambda do
       Addressable::URI.heuristic_parse(42)
-    end).should raise_error(TypeError)
+    end).should raise_error(TypeError, "Can't convert Fixnum into String.")
   end
 end
 
@@ -3698,514 +3343,50 @@ describe Addressable::URI, "when encoding a bogus object" do
   end
 end
 
-describe Addressable::URI, " when parsed from " +
-    "'/'" do
-  before do
-    @uri = Addressable::URI.parse("/")
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern '/'" do
-    @uri.extract_mapping("/").should == {}
-  end
-end
-
-describe Addressable::URI, " when parsed from '/one/'" do
-  before do
-    @uri = Addressable::URI.parse("/one/")
-  end
-
-  it "should not match the pattern '/two/'" do
-    @uri.extract_mapping("/two/").should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern '/{number}/'" do
-    @uri.extract_mapping("/{number}/").should == {"number" => "one"}
-  end
-end
-
-describe Addressable::URI, " when parsed from '/one/two/'" do
-  before do
-    @uri = Addressable::URI.parse("/one/two/")
-  end
-
-  it "should not match the pattern '/{number}/' " +
-      "with the SlashlessProcessor" do
-    @uri.extract_mapping("/{number}/", SlashlessProcessor).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern '/{number}/' without a processor" do
-    @uri.extract_mapping("/{number}/").should == {
-      "number" => "one/two"
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern '/{first}/{second}/' with the SlashlessProcessor" do
-    @uri.extract_mapping("/{first}/{second}/", SlashlessProcessor).should == {
-      "first" => "one",
-      "second" => "two"
-    }
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/search/an+example+search+query/'" do
-  before do
-    @uri = Addressable::URI.parse(
-      "http://example.com/search/an+example+search+query/")
-  end
-
-  it "should have the correct mapping when extracting values using " +
-      "the pattern 'http://example.com/search/{query}/' with the " +
-      "ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/search/{query}/", ExampleProcessor
-    ).should == {
-      "query" => "an example search query"
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/search/{-list|+|query}/'" do
-    @uri.extract_mapping(
-      "http://example.com/search/{-list|+|query}/"
-    ).should == {
-      "query" => ["an", "example", "search", "query"]
-    }
-  end
-
-  it "should return nil when extracting values using " +
-      "a non-matching pattern" do
-    @uri.extract_mapping(
-      "http://bogus.com/{thingy}/"
-    ).should == nil
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/a/b/c/'" do
-  before do
-    @uri = Addressable::URI.parse(
-      "http://example.com/a/b/c/")
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/{second}/' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/{second}/", ExampleProcessor
-    ).should == {
-      "first" => "a",
-      "second" => "b/c"
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/{-list|/|second}/'" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/{-list|/|second}/"
-    ).should == {
-      "first" => "a",
-      "second" => ["b", "c"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/{-list|/|rot13}/' " +
-      "with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/{-list|/|rot13}/",
-      ExampleProcessor
-    ).should == {
-      "first" => "a",
-      "rot13" => ["o", "p"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{-list|/|rot13}/' " +
-      "with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{-list|/|rot13}/",
-      ExampleProcessor
-    ).should == {
-      "rot13" => ["n", "o", "p"]
-    }
-  end
-
-  it "should not map to anything when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{-list|/|rot13}/'" do
-    @uri.extract_mapping("http://example.com/{-join|/|a,b,c}/").should == nil
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/?a=one&b=two&c=three'" do
-  before do
-    @uri = Addressable::URI.parse("http://example.com/?a=one&b=two&c=three")
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/?{-join|&|a,b,c}'" do
-    @uri.extract_mapping(
-      "http://example.com/?{-join|&|a,b,c}"
-    ).should == {
-      "a" => "one",
-      "b" => "two",
-      "c" => "three"
-    }
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/?rot13=frperg'" do
-  before do
-    @uri = Addressable::URI.parse("http://example.com/?rot13=frperg")
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/?{-join|&|rot13}' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/?{-join|&|rot13}",
-      ExampleProcessor
-    ).should == {
-      "rot13" => "secret"
-    }
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/one/spacer/two/'" do
-  before do
-    @uri = Addressable::URI.parse("http://example.com/one/spacer/two/")
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/spacer/{second}/'" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/spacer/{second}/"
-    ).should == {
-      "first" => "one",
-      "second" => "two"
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com{-prefix|/|stuff}/'" do
-    @uri.extract_mapping(
-      "http://example.com{-prefix|/|stuff}/"
-    ).should == {
-      "stuff" => ["one", "spacer", "two"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/o{-prefix|/|stuff}/'" do
-    @uri.extract_mapping(
-      "http://example.com/o{-prefix|/|stuff}/"
-    ).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/spacer{-prefix|/|stuff}/'" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/spacer{-prefix|/|stuff}/"
-    ).should == {
-      "first" => "one",
-      "stuff" => ["two"]
-    }
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect suffix pattern " +
-      "'http://example.com/{-prefix|/|stuff}/'" do
-    @uri.extract_mapping(
-      "http://example.com/{-prefix|/|stuff}/"
-    ).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com{-prefix|/|rot13}/' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com{-prefix|/|rot13}/",
-      ExampleProcessor
-    ).should == {
-      "rot13" => ["bar", "fcnpre", "gjb"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com{-prefix|/|rot13}' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com{-prefix|/|rot13}",
-      ExampleProcessor
-    ).should == {
-      "rot13" => ["bar", "fcnpre", "gjb", ""]
-    }
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect suffix pattern " +
-      "'http://example.com/{-prefix|/|rot13}' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{-prefix|/|rot13}",
-      ExampleProcessor
-    ).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{-suffix|/|stuff}'" do
-    @uri.extract_mapping(
-      "http://example.com/{-suffix|/|stuff}"
-    ).should == {
-      "stuff" => ["one", "spacer", "two"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{-suffix|/|stuff}o'" do
-    @uri.extract_mapping(
-      "http://example.com/{-suffix|/|stuff}o"
-    ).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/o{-suffix|/|stuff}'" do
-    @uri.extract_mapping(
-      "http://example.com/o{-suffix|/|stuff}"
-    ).should == {"stuff"=>["ne", "spacer", "two"]}
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{first}/spacer/{-suffix|/|stuff}'" do
-    @uri.extract_mapping(
-      "http://example.com/{first}/spacer/{-suffix|/|stuff}"
-    ).should == {
-      "first" => "one",
-      "stuff" => ["two"]
-    }
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect suffix pattern " +
-      "'http://example.com/{-suffix|/|stuff}/'" do
-    @uri.extract_mapping(
-      "http://example.com/{-suffix|/|stuff}/"
-    ).should == nil
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com/{-suffix|/|rot13}' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{-suffix|/|rot13}",
-      ExampleProcessor
-    ).should == {
-      "rot13" => ["bar", "fcnpre", "gjb"]
-    }
-  end
-
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://example.com{-suffix|/|rot13}' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com{-suffix|/|rot13}",
-      ExampleProcessor
-    ).should == {
-      "rot13" => ["", "bar", "fcnpre", "gjb"]
-    }
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect suffix pattern " +
-      "'http://example.com/{-suffix|/|rot13}/' with the ExampleProcessor" do
-    @uri.extract_mapping(
-      "http://example.com/{-suffix|/|rot13}/",
-      ExampleProcessor
-    ).should == nil
-  end
-end
-
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/?email=bob@sporkmonger.com'" do
+describe Addressable::URI, "when given the input " +
+    "'http://example.com/'" do
   before do
-    @uri = Addressable::URI.parse(
-      "http://example.com/?email=bob@sporkmonger.com"
-    )
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect opt pattern " +
-      "'http://example.com/?email={-opt|bogus@bogus.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-opt|bogus@bogus.com|test}"
-    ).should == nil
-  end
-
-  it "should not match anything when extracting values " +
-      "using the incorrect neg pattern " +
-      "'http://example.com/?email={-neg|bogus@bogus.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-neg|bogus@bogus.com|test}"
-    ).should == nil
-  end
-
-  it "should indicate a match when extracting values " +
-      "using the opt pattern " +
-      "'http://example.com/?email={-opt|bob@sporkmonger.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-opt|bob@sporkmonger.com|test}"
-    ).should == {}
+    @input = "http://example.com/"
   end
 
-  it "should indicate a match when extracting values " +
-      "using the neg pattern " +
-      "'http://example.com/?email={-neg|bob@sporkmonger.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-neg|bob@sporkmonger.com|test}"
-    ).should == {}
+  it "should heuristically parse to 'http://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com/"
   end
 end
 
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/?email='" do
-  before do
-    @uri = Addressable::URI.parse(
-      "http://example.com/?email="
-    )
-  end
-
-  it "should indicate a match when extracting values " +
-      "using the opt pattern " +
-      "'http://example.com/?email={-opt|bob@sporkmonger.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-opt|bob@sporkmonger.com|test}"
-    ).should == {}
-  end
-
-  it "should indicate a match when extracting values " +
-      "using the neg pattern " +
-      "'http://example.com/?email={-neg|bob@sporkmonger.com|test}'" do
-    @uri.extract_mapping(
-      "http://example.com/?email={-neg|bob@sporkmonger.com|test}"
-    ).should == {}
-  end
-end
 
-describe Addressable::URI, " when parsed from " +
-    "'http://example.com/a/b/c/?one=1&two=2#foo'" do
+describe Addressable::URI, "when given the input " +
+    "'http:example.com/'" do
   before do
-    @uri = Addressable::URI.parse(
-      "http://example.com/a/b/c/?one=1&two=2#foo"
-    )
+    @input = "http:example.com/"
   end
 
-  it "should have the correct mapping when extracting values " +
-      "using the pattern " +
-      "'http://{host}/{-suffix|/|segments}?{-join|&|one,two}\#{fragment}'" do
-    @uri.extract_mapping(
-      "http://{host}/{-suffix|/|segments}?{-join|&|one,two}\#{fragment}"
-    ).should == {
-      "host" => "example.com",
-      "segments" => ["a", "b", "c"],
-      "one" => "1",
-      "two" => "2",
-      "fragment" => "foo"
-    }
+  it "should heuristically parse to 'http://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com/"
   end
 
-  it "should not match when extracting values " +
-      "using the pattern " +
-      "'http://{host}/{-suffix|/|segments}?{-join|&|one}\#{fragment}'" do
-    @uri.extract_mapping(
-      "http://{host}/{-suffix|/|segments}?{-join|&|one}\#{fragment}"
-    ).should == nil
-  end
-
-  it "should not match when extracting values " +
-      "using the pattern " +
-      "'http://{host}/{-suffix|/|segments}?{-join|&|bogus}\#{fragment}'" do
-    @uri.extract_mapping(
-      "http://{host}/{-suffix|/|segments}?{-join|&|bogus}\#{fragment}"
-    ).should == nil
-  end
-
-  it "should not match when extracting values " +
-      "using the pattern " +
-      "'http://{host}/{-suffix|/|segments}?" +
-      "{-join|&|one,bogus}\#{fragment}'" do
-    @uri.extract_mapping(
-      "http://{host}/{-suffix|/|segments}?{-join|&|one,bogus}\#{fragment}"
-    ).should == nil
-  end
-
-  it "should not match when extracting values " +
-      "using the pattern " +
-      "'http://{host}/{-suffix|/|segments}?" +
-      "{-join|&|one,two,bogus}\#{fragment}'" do
-    @uri.extract_mapping(
-      "http://{host}/{-suffix|/|segments}?{-join|&|one,two,bogus}\#{fragment}"
-    ).should == {
-      "host" => "example.com",
-      "segments" => ["a", "b", "c"],
-      "one" => "1",
-      "two" => "2",
-      "fragment" => "foo"
-    }
+  it "should heuristically parse to 'http://example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    @uri.to_s.should == "http://example.com/"
   end
 end
 
-describe Addressable::URI, "when given a pattern with bogus operators" do
+describe Addressable::URI, "when given the input " +
+    "'http://example.com/example.com/'" do
   before do
-    @uri = Addressable::URI.parse("http://example.com/a/b/c/")
+    @input = "http://example.com/example.com/"
   end
 
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      @uri.extract_mapping("http://example.com/{-bogus|/|a,b,c}/")
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      @uri.extract_mapping("http://example.com/{-prefix|/|a,b,c}/")
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      @uri.extract_mapping("http://example.com/{-suffix|/|a,b,c}/")
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
-  end
-
-  it "should raise an InvalidTemplateOperatorError" do
-    (lambda do
-      @uri.extract_mapping("http://example.com/{-list|/|a,b,c}/")
-    end).should raise_error(Addressable::URI::InvalidTemplateOperatorError)
+  it "should heuristically parse to 'http://example.com/example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com/example.com/"
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'/path/to/resource'" do
   before do
     @input = "/path/to/resource"
@@ -4217,7 +3398,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'relative/path/to/resource'" do
   before do
     @input = "relative/path/to/resource"
@@ -4229,7 +3410,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'example.com'" do
   before do
     @input = "example.com"
@@ -4241,7 +3422,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'example.com' and a scheme hint of 'ftp'" do
   before do
     @input = "example.com"
@@ -4254,7 +3435,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'example.com:21' and a scheme hint of 'ftp'" do
   before do
     @input = "example.com:21"
@@ -4267,7 +3448,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'example.com/path/to/resource'" do
   before do
     @input = "example.com/path/to/resource"
@@ -4279,7 +3460,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'http:///example.com'" do
   before do
     @input = "http:///example.com"
@@ -4291,7 +3472,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'feed:///example.com'" do
   before do
     @input = "feed:///example.com"
@@ -4303,7 +3484,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'file://path/to/resource/'" do
   before do
     @input = "file://path/to/resource/"
@@ -4315,7 +3496,7 @@ describe Addressable::URI, " when given the input " +
   end
 end
 
-describe Addressable::URI, " when given the input " +
+describe Addressable::URI, "when given the input " +
     "'feed://http://example.com'" do
   before do
     @input = "feed://http://example.com"
@@ -4326,3 +3507,46 @@ describe Addressable::URI, " when given the input " +
     @uri.to_s.should == "feed:http://example.com"
   end
 end
+
+describe Addressable::URI, "when assigning query values" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  it "should correctly assign {:a => 'a', :b => ['c', 'd', 'e']}" do
+    @uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    @uri.query.should == "a=a&b[0]=c&b[1]=d&b[2]=e"
+  end
+
+  it "should correctly assign " +
+      "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, {:e => 'e', :f => 'f'}]}" do
+    @uri.query_values = {
+      :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
+    }
+    @uri.query.should == "a=a&b[0][c]=c&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+  end
+
+  it "should correctly assign " +
+      "{:a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]}" do
+    @uri.query_values = {
+      :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
+    }
+    @uri.query.should == "a=a&b[0][c]&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+  end
+
+  it "should correctly assign " +
+      "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
+    @uri.query_values = {
+      :a => 'a', :b => {:c => true, :d => 'd'}
+    }
+    @uri.query.should == "a=a&b[c]&b[d]=d"
+  end
+
+  it "should correctly assign " +
+      "{:a => 'a', :b => {:c => true, :d => 'd'}, :e => []}" do
+    @uri.query_values = {
+      :a => 'a', :b => {:c => true, :d => 'd'}
+    }
+    @uri.query.should == "a=a&b[c]&b[d]=d"
+  end
+end