@@ -15,353 +15,353 @@
 
 #include "config.h"
 
 #import "TestsAppDelegate.h"
 
-static OFString *const module = @"OFURI";
-static OFString *URIString = @"ht+tp://us%3Aer:p%40w@ho%3Ast:1234/"
+static OFString *const module = @"OFIRI";
+static OFString *IRIString = @"ht+tp://us%3Aer:p%40w@ho%3Ast:1234/"
     @"pa%3Fth?que%23ry=1&f%26oo=b%3dar#frag%23ment";
 
-@implementation TestsAppDelegate (OFURITests)
-- (void)URITests
+@implementation TestsAppDelegate (OFIRITests)
+- (void)IRITests
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFURI *URI1, *URI2, *URI3, *URI4, *URI5, *URI6, *URI7, *URI8, *URI9;
-	OFURI *URI10, *URI11;
-	OFMutableURI *mutableURI;
-
-	TEST(@"+[URIWithString:]",
-	    R(URI1 = [OFURI URIWithString: URIString]) &&
-	    R(URI2 = [OFURI URIWithString: @"http://foo:80"]) &&
-	    R(URI3 = [OFURI URIWithString: @"http://bar/"]) &&
-	    R(URI4 = [OFURI URIWithString: @"file:///etc/passwd"]) &&
-	    R(URI5 = [OFURI URIWithString: @"http://foo/bar/qux/foo%2fbar"]) &&
-	    R(URI6 = [OFURI URIWithString: @"https://[12:34::56:abcd]/"]) &&
-	    R(URI7 = [OFURI URIWithString: @"https://[12:34::56:abcd]:234/"]) &&
-	    R(URI8 = [OFURI URIWithString: @"urn:qux:foo"]) &&
-	    R(URI9 = [OFURI URIWithString: @"file:/foo?query#frag"]) &&
-	    R(URI10 = [OFURI URIWithString: @"file:foo@bar/qux?query#frag"]) &&
-	    R(URI11 = [OFURI URIWithString: @"http://ä/ö?ü"]))
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #1",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"ht,tp://foo"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #2",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"http://f`oo"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #3",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"http://foo/`"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #4",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"http://foo/foo?`"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #5",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"http://foo/foo?foo#`"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #6",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"https://[g]/"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #7",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"https://[f]:/"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #8",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"https://[f]:f/"])
-
-	EXPECT_EXCEPTION(@"+[URIWithString:] fails with invalid characters #9",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"foo:"])
-
-	TEST(@"+[URIWithString:relativeToURI:]",
-	    [[[OFURI URIWithString: @"/foo" relativeToURI: URI1] string]
+	OFIRI *IRI1, *IRI2, *IRI3, *IRI4, *IRI5, *IRI6, *IRI7, *IRI8, *IRI9;
+	OFIRI *IRI10, *IRI11;
+	OFMutableIRI *mutableIRI;
+
+	TEST(@"+[IRIWithString:]",
+	    R(IRI1 = [OFIRI IRIWithString: IRIString]) &&
+	    R(IRI2 = [OFIRI IRIWithString: @"http://foo:80"]) &&
+	    R(IRI3 = [OFIRI IRIWithString: @"http://bar/"]) &&
+	    R(IRI4 = [OFIRI IRIWithString: @"file:///etc/passwd"]) &&
+	    R(IRI5 = [OFIRI IRIWithString: @"http://foo/bar/qux/foo%2fbar"]) &&
+	    R(IRI6 = [OFIRI IRIWithString: @"https://[12:34::56:abcd]/"]) &&
+	    R(IRI7 = [OFIRI IRIWithString: @"https://[12:34::56:abcd]:234/"]) &&
+	    R(IRI8 = [OFIRI IRIWithString: @"urn:qux:foo"]) &&
+	    R(IRI9 = [OFIRI IRIWithString: @"file:/foo?query#frag"]) &&
+	    R(IRI10 = [OFIRI IRIWithString: @"file:foo@bar/qux?query#frag"]) &&
+	    R(IRI11 = [OFIRI IRIWithString: @"http://ä/ö?ü"]))
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #1",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"ht,tp://foo"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #2",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"http://f`oo"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #3",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"http://foo/`"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #4",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"http://foo/foo?`"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #5",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"http://foo/foo?foo#`"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #6",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"https://[g]/"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #7",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"https://[f]:/"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #8",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"https://[f]:f/"])
+
+	EXPECT_EXCEPTION(@"+[IRIWithString:] fails with invalid characters #9",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"foo:"])
+
+	TEST(@"+[IRIWithString:relativeToIRI:]",
+	    [[[OFIRI IRIWithString: @"/foo" relativeToIRI: IRI1] string]
 	    isEqual: @"ht+tp://us%3Aer:p%40w@ho%3Ast:1234/foo"] &&
-	    [[[OFURI URIWithString: @"foo/bar?q"
-		     relativeToURI: [OFURI URIWithString: @"http://h/qux/quux"]]
+	    [[[OFIRI IRIWithString: @"foo/bar?q"
+		     relativeToIRI: [OFIRI IRIWithString: @"http://h/qux/quux"]]
 	    string] isEqual: @"http://h/qux/foo/bar?q"] &&
-	    [[[OFURI URIWithString: @"foo/bar"
-		     relativeToURI: [OFURI URIWithString: @"http://h/qux/?x"]]
+	    [[[OFIRI IRIWithString: @"foo/bar"
+		     relativeToIRI: [OFIRI IRIWithString: @"http://h/qux/?x"]]
 	    string] isEqual: @"http://h/qux/foo/bar"] &&
-	    [[[OFURI URIWithString: @"http://foo/?q"
-		     relativeToURI: URI1] string] isEqual: @"http://foo/?q"] &&
-	    [[[OFURI URIWithString: @"foo"
-		     relativeToURI: [OFURI URIWithString: @"http://foo/bar"]]
+	    [[[OFIRI IRIWithString: @"http://foo/?q"
+		     relativeToIRI: IRI1] string] isEqual: @"http://foo/?q"] &&
+	    [[[OFIRI IRIWithString: @"foo"
+		     relativeToIRI: [OFIRI IRIWithString: @"http://foo/bar"]]
 	    string] isEqual: @"http://foo/foo"] &&
-	    [[[OFURI URIWithString: @"foo"
-		     relativeToURI: [OFURI URIWithString: @"http://foo"]]
+	    [[[OFIRI IRIWithString: @"foo"
+		     relativeToIRI: [OFIRI IRIWithString: @"http://foo"]]
 	    string] isEqual: @"http://foo/foo"])
 
 	EXPECT_EXCEPTION(
-	    @"+[URIWithString:relativeToURI:] fails with invalid characters #1",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"`" relativeToURI: URI1])
-
-	EXPECT_EXCEPTION(
-	    @"+[URIWithString:relativeToURI:] fails with invalid characters #2",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"/`" relativeToURI: URI1])
-
-	EXPECT_EXCEPTION(
-	    @"+[URIWithString:relativeToURI:] fails with invalid characters #3",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"?`" relativeToURI: URI1])
-
-	EXPECT_EXCEPTION(
-	    @"+[URIWithString:relativeToURI:] fails with invalid characters #4",
-	    OFInvalidFormatException,
-	    [OFURI URIWithString: @"#`" relativeToURI: URI1])
+	    @"+[IRIWithString:relativeToIRI:] fails with invalid characters #1",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"`" relativeToIRI: IRI1])
+
+	EXPECT_EXCEPTION(
+	    @"+[IRIWithString:relativeToIRI:] fails with invalid characters #2",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"/`" relativeToIRI: IRI1])
+
+	EXPECT_EXCEPTION(
+	    @"+[IRIWithString:relativeToIRI:] fails with invalid characters #3",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"?`" relativeToIRI: IRI1])
+
+	EXPECT_EXCEPTION(
+	    @"+[IRIWithString:relativeToIRI:] fails with invalid characters #4",
+	    OFInvalidFormatException,
+	    [OFIRI IRIWithString: @"#`" relativeToIRI: IRI1])
 
 #ifdef OF_HAVE_FILES
-	TEST(@"+[fileURIWithPath:]",
-	    [[[OFURI fileURIWithPath: @"testfile.txt"] fileSystemRepresentation]
+	TEST(@"+[fileIRIWithPath:]",
+	    [[[OFIRI fileIRIWithPath: @"testfile.txt"] fileSystemRepresentation]
 	    isEqual: [[OFFileManager defaultManager].currentDirectoryPath
 	    stringByAppendingPathComponent: @"testfile.txt"]])
 
 # if defined(OF_WINDOWS) || defined(OF_MSDOS)
-	OFURI *tmp;
-	TEST(@"+[fileURIWithPath:] for c:\\",
-	    (tmp = [OFURI fileURIWithPath: @"c:\\"]) &&
+	OFIRI *tmp;
+	TEST(@"+[fileIRIWithPath:] for c:\\",
+	    (tmp = [OFIRI fileIRIWithPath: @"c:\\"]) &&
 	    [tmp.string isEqual: @"file:/c:/"] &&
 	    [tmp.fileSystemRepresentation isEqual: @"c:\\"])
 # endif
 
 # ifdef OF_WINDOWS
-	TEST(@"+[fileURIWithPath:] with UNC",
-	    (tmp = [OFURI fileURIWithPath: @"\\\\foo\\bar"
+	TEST(@"+[fileIRIWithPath:] with UNC",
+	    (tmp = [OFIRI fileIRIWithPath: @"\\\\foo\\bar"
 			      isDirectory: false]) &&
 	    [tmp.host isEqual: @"foo"] && [tmp.path isEqual: @"/bar"] &&
 	    [tmp.string isEqual: @"file://foo/bar"] &&
 	    [tmp.fileSystemRepresentation isEqual: @"\\\\foo\\bar"] &&
-	    (tmp = [OFURI fileURIWithPath: @"\\\\test" isDirectory: true]) &&
+	    (tmp = [OFIRI fileIRIWithPath: @"\\\\test" isDirectory: true]) &&
 	    [tmp.host isEqual: @"test"] && [tmp.path isEqual: @"/"] &&
 	    [tmp.string isEqual: @"file://test/"] &&
 	    [tmp.fileSystemRepresentation isEqual: @"\\\\test"])
 # endif
 #endif
 
 	TEST(@"-[string]",
-	    [URI1.string isEqual: URIString] &&
-	    [URI2.string isEqual: @"http://foo:80"] &&
-	    [URI3.string isEqual: @"http://bar/"] &&
-	    [URI4.string isEqual: @"file:///etc/passwd"] &&
-	    [URI5.string isEqual: @"http://foo/bar/qux/foo%2fbar"] &&
-	    [URI6.string isEqual: @"https://[12:34::56:abcd]/"] &&
-	    [URI7.string isEqual: @"https://[12:34::56:abcd]:234/"] &&
-	    [URI8.string isEqual: @"urn:qux:foo"] &&
-	    [URI9.string isEqual: @"file:/foo?query#frag"] &&
-	    [URI10.string isEqual: @"file:foo@bar/qux?query#frag"] &&
-	    [URI11.string isEqual: @"http://ä/ö?ü"])
+	    [IRI1.string isEqual: IRIString] &&
+	    [IRI2.string isEqual: @"http://foo:80"] &&
+	    [IRI3.string isEqual: @"http://bar/"] &&
+	    [IRI4.string isEqual: @"file:///etc/passwd"] &&
+	    [IRI5.string isEqual: @"http://foo/bar/qux/foo%2fbar"] &&
+	    [IRI6.string isEqual: @"https://[12:34::56:abcd]/"] &&
+	    [IRI7.string isEqual: @"https://[12:34::56:abcd]:234/"] &&
+	    [IRI8.string isEqual: @"urn:qux:foo"] &&
+	    [IRI9.string isEqual: @"file:/foo?query#frag"] &&
+	    [IRI10.string isEqual: @"file:foo@bar/qux?query#frag"] &&
+	    [IRI11.string isEqual: @"http://ä/ö?ü"])
 
 	TEST(@"-[scheme]",
-	    [URI1.scheme isEqual: @"ht+tp"] && [URI4.scheme isEqual: @"file"] &&
-	    [URI9.scheme isEqual: @"file"] && [URI10.scheme isEqual: @"file"] &&
-	    [URI11.scheme isEqual: @"http"])
+	    [IRI1.scheme isEqual: @"ht+tp"] && [IRI4.scheme isEqual: @"file"] &&
+	    [IRI9.scheme isEqual: @"file"] && [IRI10.scheme isEqual: @"file"] &&
+	    [IRI11.scheme isEqual: @"http"])
 
-	TEST(@"-[user]", [URI1.user isEqual: @"us:er"] && URI4.user == nil &&
-	    URI10.user == nil && URI11.user == nil)
+	TEST(@"-[user]", [IRI1.user isEqual: @"us:er"] && IRI4.user == nil &&
+	    IRI10.user == nil && IRI11.user == nil)
 	TEST(@"-[password]",
-	    [URI1.password isEqual: @"p@w"] && URI4.password == nil &&
-	    URI10.password == nil && URI11.password == nil)
-	TEST(@"-[host]", [URI1.host isEqual: @"ho:st"] &&
-	    [URI6.host isEqual: @"12:34::56:abcd"] &&
-	    [URI7.host isEqual: @"12:34::56:abcd"] &&
-	    URI8.host == nil && URI9.host == nil && URI10.host == nil &&
-	    [URI11.host isEqual: @"ä"])
-	TEST(@"-[port]", URI1.port.unsignedShortValue == 1234 &&
-	    [URI4 port] == nil && URI7.port.unsignedShortValue == 234 &&
-	    URI8.port == nil && URI9.port == nil && URI10.port == nil &&
-	    URI11.port == nil)
+	    [IRI1.password isEqual: @"p@w"] && IRI4.password == nil &&
+	    IRI10.password == nil && IRI11.password == nil)
+	TEST(@"-[host]", [IRI1.host isEqual: @"ho:st"] &&
+	    [IRI6.host isEqual: @"12:34::56:abcd"] &&
+	    [IRI7.host isEqual: @"12:34::56:abcd"] &&
+	    IRI8.host == nil && IRI9.host == nil && IRI10.host == nil &&
+	    [IRI11.host isEqual: @"ä"])
+	TEST(@"-[port]", IRI1.port.unsignedShortValue == 1234 &&
+	    [IRI4 port] == nil && IRI7.port.unsignedShortValue == 234 &&
+	    IRI8.port == nil && IRI9.port == nil && IRI10.port == nil &&
+	    IRI11.port == nil)
 	TEST(@"-[path]",
-	    [URI1.path isEqual: @"/pa?th"] &&
-	    [URI4.path isEqual: @"/etc/passwd"] &&
-	    [URI8.path isEqual: @"qux:foo"] &&
-	    [URI9.path isEqual: @"/foo"] &&
-	    [URI10.path isEqual: @"foo@bar/qux"] &&
-	    [URI11.path isEqual: @"/ö"])
+	    [IRI1.path isEqual: @"/pa?th"] &&
+	    [IRI4.path isEqual: @"/etc/passwd"] &&
+	    [IRI8.path isEqual: @"qux:foo"] &&
+	    [IRI9.path isEqual: @"/foo"] &&
+	    [IRI10.path isEqual: @"foo@bar/qux"] &&
+	    [IRI11.path isEqual: @"/ö"])
 	TEST(@"-[pathComponents]",
-	    [URI1.pathComponents isEqual:
+	    [IRI1.pathComponents isEqual:
 	    [OFArray arrayWithObjects: @"/", @"pa?th", nil]] &&
-	    [URI4.pathComponents isEqual:
+	    [IRI4.pathComponents isEqual:
 	    [OFArray arrayWithObjects: @"/", @"etc", @"passwd", nil]] &&
-	    [URI5.pathComponents isEqual:
+	    [IRI5.pathComponents isEqual:
 	    [OFArray arrayWithObjects: @"/", @"bar", @"qux", @"foo/bar", nil]])
 	TEST(@"-[lastPathComponent]",
-	    [[[OFURI URIWithString: @"http://host/foo//bar/baz"]
+	    [[[OFIRI IRIWithString: @"http://host/foo//bar/baz"]
 	    lastPathComponent] isEqual: @"baz"] &&
-	    [[[OFURI URIWithString: @"http://host/foo//bar/baz/"]
+	    [[[OFIRI IRIWithString: @"http://host/foo//bar/baz/"]
 	    lastPathComponent] isEqual: @"baz"] &&
-	    [[[OFURI URIWithString: @"http://host/foo/"]
+	    [[[OFIRI IRIWithString: @"http://host/foo/"]
 	    lastPathComponent] isEqual: @"foo"] &&
-	    [[[OFURI URIWithString: @"http://host/"]
+	    [[[OFIRI IRIWithString: @"http://host/"]
 	    lastPathComponent] isEqual: @"/"] &&
-	    [URI5.lastPathComponent isEqual: @"foo/bar"])
+	    [IRI5.lastPathComponent isEqual: @"foo/bar"])
 	TEST(@"-[query]",
-	    [URI1.query isEqual: @"que#ry=1&f&oo=b=ar"] && URI4.query == nil &&
-	    [URI9.query isEqual: @"query"] && [URI10.query isEqual: @"query"] &&
-	    [URI11.query isEqual: @"ü"])
+	    [IRI1.query isEqual: @"que#ry=1&f&oo=b=ar"] && IRI4.query == nil &&
+	    [IRI9.query isEqual: @"query"] && [IRI10.query isEqual: @"query"] &&
+	    [IRI11.query isEqual: @"ü"])
 	TEST(@"-[queryItems]",
-	    [URI1.queryItems isEqual: [OFArray arrayWithObjects:
+	    [IRI1.queryItems isEqual: [OFArray arrayWithObjects:
 	    [OFPair pairWithFirstObject: @"que#ry" secondObject: @"1"],
 	    [OFPair pairWithFirstObject: @"f&oo" secondObject: @"b=ar"], nil]]);
 	TEST(@"-[fragment]",
-	    [URI1.fragment isEqual: @"frag#ment"] && URI4.fragment == nil &&
-	    [URI9.fragment isEqual: @"frag"] &&
-	    [URI10.fragment isEqual: @"frag"])
-
-	TEST(@"-[copy]", R(URI4 = [[URI1 copy] autorelease]))
-
-	TEST(@"-[isEqual:]", [URI1 isEqual: URI4] && ![URI2 isEqual: URI3] &&
-	    [[OFURI URIWithString: @"HTTP://bar/"] isEqual: URI3])
-
-	TEST(@"-[hash:]", URI1.hash == URI4.hash && URI2.hash != URI3.hash)
+	    [IRI1.fragment isEqual: @"frag#ment"] && IRI4.fragment == nil &&
+	    [IRI9.fragment isEqual: @"frag"] &&
+	    [IRI10.fragment isEqual: @"frag"])
+
+	TEST(@"-[copy]", R(IRI4 = [[IRI1 copy] autorelease]))
+
+	TEST(@"-[isEqual:]", [IRI1 isEqual: IRI4] && ![IRI2 isEqual: IRI3] &&
+	    [[OFIRI IRIWithString: @"HTTP://bar/"] isEqual: IRI3])
+
+	TEST(@"-[hash:]", IRI1.hash == IRI4.hash && IRI2.hash != IRI3.hash)
 
 	EXPECT_EXCEPTION(@"Detection of invalid format",
-	    OFInvalidFormatException, [OFURI URIWithString: @"http"])
+	    OFInvalidFormatException, [OFIRI IRIWithString: @"http"])
 
-	mutableURI = [OFMutableURI URIWithScheme: @"dummy"];
+	mutableIRI = [OFMutableIRI IRIWithScheme: @"dummy"];
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedScheme:] with invalid characters fails",
-	    OFInvalidFormatException, mutableURI.scheme = @"%20")
+	    OFInvalidFormatException, mutableIRI.scheme = @"%20")
 
 	TEST(@"-[setHost:]",
-	    (mutableURI.host = @"ho:st") &&
-	    [mutableURI.percentEncodedHost isEqual: @"ho%3Ast"] &&
-	    (mutableURI.host = @"12:34:ab") &&
-	    [mutableURI.percentEncodedHost isEqual: @"[12:34:ab]"] &&
-	    (mutableURI.host = @"12:34:aB") &&
-	    [mutableURI.percentEncodedHost isEqual: @"[12:34:aB]"] &&
-	    (mutableURI.host = @"12:34:g") &&
-	    [mutableURI.percentEncodedHost isEqual: @"12%3A34%3Ag"])
+	    (mutableIRI.host = @"ho:st") &&
+	    [mutableIRI.percentEncodedHost isEqual: @"ho%3Ast"] &&
+	    (mutableIRI.host = @"12:34:ab") &&
+	    [mutableIRI.percentEncodedHost isEqual: @"[12:34:ab]"] &&
+	    (mutableIRI.host = @"12:34:aB") &&
+	    [mutableIRI.percentEncodedHost isEqual: @"[12:34:aB]"] &&
+	    (mutableIRI.host = @"12:34:g") &&
+	    [mutableIRI.percentEncodedHost isEqual: @"12%3A34%3Ag"])
 
 	TEST(@"-[setPercentEncodedHost:]",
-	    (mutableURI.percentEncodedHost = @"ho%3Ast") &&
-	    [mutableURI.host isEqual: @"ho:st"] &&
-	    (mutableURI.percentEncodedHost = @"[12:34]") &&
-	    [mutableURI.host isEqual: @"12:34"] &&
-	    (mutableURI.percentEncodedHost = @"[12::ab]") &&
-	    [mutableURI.host isEqual: @"12::ab"])
+	    (mutableIRI.percentEncodedHost = @"ho%3Ast") &&
+	    [mutableIRI.host isEqual: @"ho:st"] &&
+	    (mutableIRI.percentEncodedHost = @"[12:34]") &&
+	    [mutableIRI.host isEqual: @"12:34"] &&
+	    (mutableIRI.percentEncodedHost = @"[12::ab]") &&
+	    [mutableIRI.host isEqual: @"12::ab"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedHost:] with invalid characters fails #1",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedHost = @"/")
+	    mutableIRI.percentEncodedHost = @"/")
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedHost:] with invalid characters fails #2",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedHost = @"[12:34")
+	    mutableIRI.percentEncodedHost = @"[12:34")
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedHost:] with invalid characters fails #3",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedHost = @"[a::g]")
+	    mutableIRI.percentEncodedHost = @"[a::g]")
 
 	TEST(@"-[setUser:]",
-	    (mutableURI.user = @"us:er") &&
-	    [mutableURI.percentEncodedUser isEqual: @"us%3Aer"])
+	    (mutableIRI.user = @"us:er") &&
+	    [mutableIRI.percentEncodedUser isEqual: @"us%3Aer"])
 
 	TEST(@"-[setPercentEncodedUser:]",
-	    (mutableURI.percentEncodedUser = @"us%3Aer") &&
-	    [mutableURI.user isEqual: @"us:er"])
+	    (mutableIRI.percentEncodedUser = @"us%3Aer") &&
+	    [mutableIRI.user isEqual: @"us:er"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedUser:] with invalid characters fails",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedHost = @"/")
+	    mutableIRI.percentEncodedHost = @"/")
 
 	TEST(@"-[setPassword:]",
-	    (mutableURI.password = @"pass:word") &&
-	    [mutableURI.percentEncodedPassword isEqual: @"pass%3Aword"])
+	    (mutableIRI.password = @"pass:word") &&
+	    [mutableIRI.percentEncodedPassword isEqual: @"pass%3Aword"])
 
 	TEST(@"-[setPercentEncodedPassword:]",
-	    (mutableURI.percentEncodedPassword = @"pass%3Aword") &&
-	    [mutableURI.password isEqual: @"pass:word"])
+	    (mutableIRI.percentEncodedPassword = @"pass%3Aword") &&
+	    [mutableIRI.password isEqual: @"pass:word"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedPassword:] with invalid characters fails",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedPassword = @"/")
+	    mutableIRI.percentEncodedPassword = @"/")
 
 	TEST(@"-[setPath:]",
-	    (mutableURI.path = @"pa/th@?") &&
-	    [mutableURI.percentEncodedPath isEqual: @"pa/th@%3F"])
+	    (mutableIRI.path = @"pa/th@?") &&
+	    [mutableIRI.percentEncodedPath isEqual: @"pa/th@%3F"])
 
 	TEST(@"-[setPercentEncodedPath:]",
-	    (mutableURI.percentEncodedPath = @"pa/th@%3F") &&
-	    [mutableURI.path isEqual: @"pa/th@?"])
+	    (mutableIRI.percentEncodedPath = @"pa/th@%3F") &&
+	    [mutableIRI.path isEqual: @"pa/th@?"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedPath:] with invalid characters fails",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedPath = @"?")
+	    mutableIRI.percentEncodedPath = @"?")
 
 	TEST(@"-[setQuery:]",
-	    (mutableURI.query = @"que/ry?#") &&
-	    [mutableURI.percentEncodedQuery isEqual: @"que/ry?%23"])
+	    (mutableIRI.query = @"que/ry?#") &&
+	    [mutableIRI.percentEncodedQuery isEqual: @"que/ry?%23"])
 
 	TEST(@"-[setPercentEncodedQuery:]",
-	    (mutableURI.percentEncodedQuery = @"que/ry?%23") &&
-	    [mutableURI.query isEqual: @"que/ry?#"])
+	    (mutableIRI.percentEncodedQuery = @"que/ry?%23") &&
+	    [mutableIRI.query isEqual: @"que/ry?#"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedQuery:] with invalid characters fails",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedQuery = @"`")
+	    mutableIRI.percentEncodedQuery = @"`")
 
 	TEST(@"-[setQueryItems:]",
-	    (mutableURI.queryItems = [OFArray arrayWithObjects:
+	    (mutableIRI.queryItems = [OFArray arrayWithObjects:
 	    [OFPair pairWithFirstObject: @"foo&bar" secondObject: @"baz=qux"],
 	    [OFPair pairWithFirstObject: @"f=oobar" secondObject: @"b&azqux"],
-	    nil]) && [mutableURI.percentEncodedQuery isEqual:
+	    nil]) && [mutableIRI.percentEncodedQuery isEqual:
 	    @"foo%26bar=baz%3Dqux&f%3Doobar=b%26azqux"])
 
 	TEST(@"-[setFragment:]",
-	    (mutableURI.fragment = @"frag/ment?#") &&
-	    [mutableURI.percentEncodedFragment isEqual: @"frag/ment?%23"])
+	    (mutableIRI.fragment = @"frag/ment?#") &&
+	    [mutableIRI.percentEncodedFragment isEqual: @"frag/ment?%23"])
 
 	TEST(@"-[setPercentEncodedFragment:]",
-	    (mutableURI.percentEncodedFragment = @"frag/ment?%23") &&
-	    [mutableURI.fragment isEqual: @"frag/ment?#"])
+	    (mutableIRI.percentEncodedFragment = @"frag/ment?%23") &&
+	    [mutableIRI.fragment isEqual: @"frag/ment?#"])
 
 	EXPECT_EXCEPTION(
 	    @"-[setPercentEncodedFragment:] with invalid characters fails",
 	    OFInvalidFormatException,
-	    mutableURI.percentEncodedFragment = @"`")
-
-	TEST(@"-[URIByAppendingPathComponent:isDirectory:]",
-	    [[[OFURI URIWithString: @"file:///foo/bar"]
-	    URIByAppendingPathComponent: @"qux" isDirectory: false] isEqual:
-	    [OFURI URIWithString: @"file:///foo/bar/qux"]] &&
-	    [[[OFURI URIWithString: @"file:///foo/bar/"]
-	    URIByAppendingPathComponent: @"qux" isDirectory: false] isEqual:
-	    [OFURI URIWithString: @"file:///foo/bar/qux"]] &&
-	    [[[OFURI URIWithString: @"file:///foo/bar/"]
-	    URIByAppendingPathComponent: @"qu?x" isDirectory: false] isEqual:
-	    [OFURI URIWithString: @"file:///foo/bar/qu%3Fx"]] &&
-	    [[[OFURI URIWithString: @"file:///foo/bar/"]
-	    URIByAppendingPathComponent: @"qu?x" isDirectory: true] isEqual:
-	    [OFURI URIWithString: @"file:///foo/bar/qu%3Fx/"]])
-
-	TEST(@"-[URIByStandardizingPath]",
-	    [[[OFURI URIWithString: @"http://foo/bar/.."]
-	    URIByStandardizingPath] isEqual:
-	    [OFURI URIWithString: @"http://foo/"]] &&
-	    [[[OFURI URIWithString: @"http://foo/bar/%2E%2E/../qux/"]
-	    URIByStandardizingPath] isEqual:
-	    [OFURI URIWithString: @"http://foo/bar/qux/"]] &&
-	    [[[OFURI URIWithString: @"http://foo/bar/./././qux/./"]
-	    URIByStandardizingPath] isEqual:
-	    [OFURI URIWithString: @"http://foo/bar/qux/"]] &&
-	    [[[OFURI URIWithString: @"http://foo/bar/../../qux"]
-	    URIByStandardizingPath] isEqual:
-	    [OFURI URIWithString: @"http://foo/../qux"]])
+	    mutableIRI.percentEncodedFragment = @"`")
+
+	TEST(@"-[IRIByAppendingPathComponent:isDirectory:]",
+	    [[[OFIRI IRIWithString: @"file:///foo/bar"]
+	    IRIByAppendingPathComponent: @"qux" isDirectory: false] isEqual:
+	    [OFIRI IRIWithString: @"file:///foo/bar/qux"]] &&
+	    [[[OFIRI IRIWithString: @"file:///foo/bar/"]
+	    IRIByAppendingPathComponent: @"qux" isDirectory: false] isEqual:
+	    [OFIRI IRIWithString: @"file:///foo/bar/qux"]] &&
+	    [[[OFIRI IRIWithString: @"file:///foo/bar/"]
+	    IRIByAppendingPathComponent: @"qu?x" isDirectory: false] isEqual:
+	    [OFIRI IRIWithString: @"file:///foo/bar/qu%3Fx"]] &&
+	    [[[OFIRI IRIWithString: @"file:///foo/bar/"]
+	    IRIByAppendingPathComponent: @"qu?x" isDirectory: true] isEqual:
+	    [OFIRI IRIWithString: @"file:///foo/bar/qu%3Fx/"]])
+
+	TEST(@"-[IRIByStandardizingPath]",
+	    [[[OFIRI IRIWithString: @"http://foo/bar/.."]
+	    IRIByStandardizingPath] isEqual:
+	    [OFIRI IRIWithString: @"http://foo/"]] &&
+	    [[[OFIRI IRIWithString: @"http://foo/bar/%2E%2E/../qux/"]
+	    IRIByStandardizingPath] isEqual:
+	    [OFIRI IRIWithString: @"http://foo/bar/qux/"]] &&
+	    [[[OFIRI IRIWithString: @"http://foo/bar/./././qux/./"]
+	    IRIByStandardizingPath] isEqual:
+	    [OFIRI IRIWithString: @"http://foo/bar/qux/"]] &&
+	    [[[OFIRI IRIWithString: @"http://foo/bar/../../qux"]
+	    IRIByStandardizingPath] isEqual:
+	    [OFIRI IRIWithString: @"http://foo/../qux"]])
 
 	objc_autoreleasePoolPop(pool);
 }
 @end