@Test
  public void pathSegments() throws URISyntaxException {
    UriComponentsBuilder builder = UriComponentsBuilder.newInstance();
    UriComponents result = builder.pathSegment("foo").pathSegment("bar").build();

    assertEquals("/foo/bar", result.getPath());
    assertEquals(Arrays.asList("foo", "bar"), result.getPathSegments());
  }
 @Test // SPR-10779
 public void fromHttpUrlStringCaseInsesitiveScheme() {
   assertEquals(
       "http", UriComponentsBuilder.fromHttpUrl("HTTP://www.google.com").build().getScheme());
   assertEquals(
       "https", UriComponentsBuilder.fromHttpUrl("HTTPS://www.google.com").build().getScheme());
 }
 @Test
 public void emptySegments() throws Exception {
   assertThat(
       UriComponentsBuilder.fromUriString("http://example.com/abc/")
           .path("/x/y/z")
           .build()
           .toString(),
       equalTo("http://example.com/abc/x/y/z"));
   assertThat(
       UriComponentsBuilder.fromUriString("http://example.com/abc/")
           .pathSegment("x", "y", "z")
           .build()
           .toString(),
       equalTo("http://example.com/abc/x/y/z"));
   assertThat(
       UriComponentsBuilder.fromUriString("http://example.com/abc/")
           .path("/x/")
           .path("/y/z")
           .build()
           .toString(),
       equalTo("http://example.com/abc/x/y/z"));
   assertThat(
       UriComponentsBuilder.fromUriString("http://example.com/abc/")
           .pathSegment("x")
           .path("y")
           .build()
           .toString(),
       equalTo("http://example.com/abc/x/y"));
 }
  @Test
  public void pathThenPathSegments() {
    UriComponentsBuilder builder = UriComponentsBuilder.fromPath("/foo/bar").pathSegment("ba/z");
    UriComponents result = builder.build().encode();

    assertEquals("/foo/bar/ba%2Fz", result.getPath());
    assertEquals(Arrays.asList("foo", "bar", "ba%2Fz"), result.getPathSegments());
  }
  @Test
  public void pathSegmentsThenPath() {
    UriComponentsBuilder builder = UriComponentsBuilder.newInstance().pathSegment("foo").path("/");
    UriComponents result = builder.build();

    assertEquals("/foo/", result.getPath());
    assertEquals(Collections.singletonList("foo"), result.getPathSegments());
  }
  @Test
  public void pathSegmentsSomeEmpty() {
    UriComponentsBuilder builder =
        UriComponentsBuilder.newInstance().pathSegment("", "foo", "", "bar");
    UriComponents result = builder.build();

    assertEquals("/foo/bar", result.getPath());
    assertEquals(Arrays.asList("foo", "bar"), result.getPathSegments());
  }
 @Test
 public void copyToUriComponentsBuilder() {
   UriComponents source = UriComponentsBuilder.fromPath("/foo/bar").pathSegment("ba/z").build();
   UriComponentsBuilder targetBuilder = UriComponentsBuilder.newInstance();
   source.copyToUriComponentsBuilder(targetBuilder);
   UriComponents result = targetBuilder.build().encode();
   assertEquals("/foo/bar/ba%2Fz", result.getPath());
   assertEquals(Arrays.asList("foo", "bar", "ba%2Fz"), result.getPathSegments());
 }
  @Test
  public void emptyQueryParam() throws URISyntaxException {
    UriComponentsBuilder builder = UriComponentsBuilder.newInstance();
    UriComponents result = builder.queryParam("baz").build();

    assertEquals("baz", result.getQuery());
    MultiValueMap<String, String> expectedQueryParams = new LinkedMultiValueMap<>(2);
    expectedQueryParams.add("baz", null);
    assertEquals(expectedQueryParams, result.getQueryParams());
  }
  @Test
  public void buildAndExpandHierarchical() {
    UriComponents result = UriComponentsBuilder.fromPath("/{foo}").buildAndExpand("fooValue");
    assertEquals("/fooValue", result.toUriString());

    Map<String, String> values = new HashMap<>();
    values.put("foo", "fooValue");
    values.put("bar", "barValue");
    result = UriComponentsBuilder.fromPath("/{foo}/{bar}").buildAndExpand(values);
    assertEquals("/fooValue/barValue", result.toUriString());
  }
 @Test
 public void equalsOpaqueUriComponents() throws Exception {
   UriComponents uriComponents1 =
       UriComponentsBuilder.fromUriString("http:example.com/foo/bar").build();
   UriComponents uriComponents2 =
       UriComponentsBuilder.fromUriString("http:example.com/foo/bar").build();
   UriComponents uriComponents3 =
       UriComponentsBuilder.fromUriString("http:example.com/foo/bin").build();
   assertThat(uriComponents1, instanceOf(OpaqueUriComponents.class));
   assertThat(uriComponents1, equalTo(uriComponents1));
   assertThat(uriComponents1, equalTo(uriComponents2));
   assertThat(uriComponents1, not(equalTo(uriComponents3)));
 }
  @Test
  public void buildAndExpandOpaque() {
    UriComponents result =
        UriComponentsBuilder.fromUriString("mailto:{user}@{domain}")
            .buildAndExpand("foo", "example.com");
    assertEquals("mailto:[email protected]", result.toUriString());

    Map<String, String> values = new HashMap<>();
    values.put("user", "foo");
    values.put("domain", "example.com");
    UriComponentsBuilder.fromUriString("mailto:{user}@{domain}").buildAndExpand(values);
    assertEquals("mailto:[email protected]", result.toUriString());
  }
  @Test // SPR-9317
  public void fromUriEncodedQuery() throws URISyntaxException {
    URI uri = new URI("http://www.example.org/?param=aGVsbG9Xb3JsZA%3D%3D");
    String fromUri = UriComponentsBuilder.fromUri(uri).build().getQueryParams().get("param").get(0);
    String fromUriString =
        UriComponentsBuilder.fromUriString(uri.toString())
            .build()
            .getQueryParams()
            .get("param")
            .get(0);

    assertEquals(fromUri, fromUriString);
  }
  @Test
  public void testClone() throws URISyntaxException {
    UriComponentsBuilder builder1 = UriComponentsBuilder.newInstance();
    builder1
        .scheme("http")
        .host("e1.com")
        .path("/p1")
        .pathSegment("ps1")
        .queryParam("q1")
        .fragment("f1");

    UriComponentsBuilder builder2 = (UriComponentsBuilder) builder1.clone();
    builder2
        .scheme("https")
        .host("e2.com")
        .path("p2")
        .pathSegment("ps2")
        .queryParam("q2")
        .fragment("f2");

    UriComponents result1 = builder1.build();
    assertEquals("http", result1.getScheme());
    assertEquals("e1.com", result1.getHost());
    assertEquals("/p1/ps1", result1.getPath());
    assertEquals("q1", result1.getQuery());
    assertEquals("f1", result1.getFragment());

    UriComponents result2 = builder2.build();
    assertEquals("https", result2.getScheme());
    assertEquals("e2.com", result2.getHost());
    assertEquals("/p1/ps1/p2/ps2", result2.getPath());
    assertEquals("q1&q2", result2.getQuery());
    assertEquals("f2", result2.getFragment());
  }
 @Test
 public void toUriEncoded() throws URISyntaxException {
   UriComponents uriComponents =
       UriComponentsBuilder.fromUriString("http://example.com/hotel list/Z\u00fcrich").build();
   assertEquals(
       new URI("http://example.com/hotel%20list/Z%C3%BCrich"), uriComponents.encode().toUri());
 }
 @Test
 public void queryParamWithoutValueWithEquals() throws Exception {
   UriComponents uriComponents =
       UriComponentsBuilder.fromUriString("http://example.com/foo?bar=").build();
   assertThat(uriComponents.toUriString(), equalTo("http://example.com/foo?bar="));
   assertThat(uriComponents.getQueryParams().get("bar").get(0), equalTo(""));
 }
  @Test
  public void fromUriString() {
    UriComponents result =
        UriComponentsBuilder.fromUriString("http://www.ietf.org/rfc/rfc3986.txt").build();
    assertEquals("http", result.getScheme());
    assertNull(result.getUserInfo());
    assertEquals("www.ietf.org", result.getHost());
    assertEquals(-1, result.getPort());
    assertEquals("/rfc/rfc3986.txt", result.getPath());
    assertEquals(Arrays.asList("rfc", "rfc3986.txt"), result.getPathSegments());
    assertNull(result.getQuery());
    assertNull(result.getFragment());

    result =
        UriComponentsBuilder.fromUriString(
                "http://*****:*****@java.sun.com:80/javase/6/docs/api/java/util/BitSet.html?foo=bar#and(java.util.BitSet)")
            .build();
    assertEquals("http", result.getScheme());
    assertEquals("arjen:foobar", result.getUserInfo());
    assertEquals("java.sun.com", result.getHost());
    assertEquals(80, result.getPort());
    assertEquals("/javase/6/docs/api/java/util/BitSet.html", result.getPath());
    assertEquals("foo=bar", result.getQuery());
    MultiValueMap<String, String> expectedQueryParams = new LinkedMultiValueMap<>(1);
    expectedQueryParams.add("foo", "bar");
    assertEquals(expectedQueryParams, result.getQueryParams());
    assertEquals("and(java.util.BitSet)", result.getFragment());

    result = UriComponentsBuilder.fromUriString("mailto:[email protected]#baz").build();
    assertEquals("mailto", result.getScheme());
    assertNull(result.getUserInfo());
    assertNull(result.getHost());
    assertEquals(-1, result.getPort());
    assertEquals("*****@*****.**", result.getSchemeSpecificPart());
    assertNull(result.getPath());
    assertNull(result.getQuery());
    assertEquals("baz", result.getFragment());

    result = UriComponentsBuilder.fromUriString("docs/guide/collections/designfaq.html#28").build();
    assertNull(result.getScheme());
    assertNull(result.getUserInfo());
    assertNull(result.getHost());
    assertEquals(-1, result.getPort());
    assertEquals("docs/guide/collections/designfaq.html", result.getPath());
    assertNull(result.getQuery());
    assertEquals("28", result.getFragment());
  }
  @Test // SPR-9832
  public void fromUriStringQueryParamWithReservedCharInValue() throws URISyntaxException {
    String uri = "http://www.google.com/ig/calculator?q=1USD=?EUR";
    UriComponents result = UriComponentsBuilder.fromUriString(uri).build();

    assertEquals("q=1USD=?EUR", result.getQuery());
    assertEquals("1USD=?EUR", result.getQueryParams().getFirst("q"));
  }
 @Test
 public void expand() {
   UriComponents uriComponents =
       UriComponentsBuilder.fromUriString("http://example.com").path("/{foo} {bar}").build();
   uriComponents = uriComponents.expand("1 2", "3 4");
   assertEquals("/1 2 3 4", uriComponents.getPath());
   assertEquals("http://example.com/1 2 3 4", uriComponents.toUriString());
 }
 @Test // SPR-11970
 public void fromUriStringNoPathWithReservedCharInQuery() {
   UriComponents result =
       UriComponentsBuilder.fromUriString("http://[email protected]").build();
   assertTrue(StringUtils.isEmpty(result.getUserInfo()));
   assertEquals("example.com", result.getHost());
   assertTrue(result.getQueryParams().containsKey("foo"));
   assertEquals("[email protected]", result.getQueryParams().getFirst("foo"));
 }
  @Test // SPR-10539
  public void fromUriStringIPv6Host() throws URISyntaxException {
    UriComponents result =
        UriComponentsBuilder.fromUriString("http://[1abc:2abc:3abc::5ABC:6abc]:8080/resource")
            .build()
            .encode();
    assertEquals("[1abc:2abc:3abc::5ABC:6abc]", result.getHost());

    UriComponents resultWithScopeId =
        UriComponentsBuilder.fromUriString("http://[1abc:2abc:3abc::5ABC:6abc%eth0]:8080/resource")
            .build()
            .encode();
    assertEquals("[1abc:2abc:3abc::5ABC:6abc%25eth0]", resultWithScopeId.getHost());

    UriComponents resultIPv4compatible =
        UriComponentsBuilder.fromUriString("http://[::192.168.1.1]:8080/resource").build().encode();
    assertEquals("[::192.168.1.1]", resultIPv4compatible.getHost());
  }
  @Test
  public void fromOpaqueUri() throws URISyntaxException {
    URI uri = new URI("mailto:[email protected]#baz");
    UriComponents result = UriComponentsBuilder.fromUri(uri).build();
    assertEquals("mailto", result.getScheme());
    assertEquals("*****@*****.**", result.getSchemeSpecificPart());
    assertEquals("baz", result.getFragment());

    assertEquals("Invalid result URI", uri, result.toUri());
  }
 /**
  * Configure a base URL to prepend URI templates with. The base URL must have a scheme and host
  * but may optionally contain a port and a path. The base URL must be fully expanded and encoded
  * which can be done via {@link UriComponentsBuilder}.
  *
  * @param baseUrl the base URL.
  */
 public void setBaseUrl(String baseUrl) {
   if (baseUrl != null) {
     UriComponents uriComponents = UriComponentsBuilder.fromUriString(baseUrl).build();
     Assert.hasText(uriComponents.getScheme(), "'baseUrl' must have a scheme");
     Assert.hasText(uriComponents.getHost(), "'baseUrl' must have a host");
     Assert.isNull(uriComponents.getQuery(), "'baseUrl' cannot have a query");
     Assert.isNull(uriComponents.getFragment(), "'baseUrl' cannot have a fragment");
   }
   this.baseUrl = baseUrl;
 }
  @Test
  public void fromPath() throws URISyntaxException {
    UriComponents result =
        UriComponentsBuilder.fromPath("foo").queryParam("bar").fragment("baz").build();
    assertEquals("foo", result.getPath());
    assertEquals("bar", result.getQuery());
    assertEquals("baz", result.getFragment());

    assertEquals("Invalid result URI String", "foo?bar#baz", result.toUriString());

    URI expected = new URI("foo?bar#baz");
    assertEquals("Invalid result URI", expected, result.toUri());

    result = UriComponentsBuilder.fromPath("/foo").build();
    assertEquals("/foo", result.getPath());

    expected = new URI("/foo");
    assertEquals("Invalid result URI", expected, result.toUri());
  }
 @Test
 public void toUriWithIpv6HostAlreadyEncoded() throws URISyntaxException {
   UriComponents uriComponents =
       UriComponentsBuilder.fromUriString(
               "http://[1abc:2abc:3abc::5ABC:6abc]:8080/hotel%20list/Z%C3%BCrich")
           .build(true);
   UriComponents encoded = uriComponents.encode();
   assertEquals(
       new URI("http://[1abc:2abc:3abc::5ABC:6abc]:8080/hotel%20list/Z%C3%BCrich"),
       encoded.toUri());
 }
  @Test
  public void plain() throws URISyntaxException {
    UriComponentsBuilder builder = UriComponentsBuilder.newInstance();
    UriComponents result =
        builder
            .scheme("http")
            .host("example.com")
            .path("foo")
            .queryParam("bar")
            .fragment("baz")
            .build();
    assertEquals("http", result.getScheme());
    assertEquals("example.com", result.getHost());
    assertEquals("foo", result.getPath());
    assertEquals("bar", result.getQuery());
    assertEquals("baz", result.getFragment());

    URI expected = new URI("http://example.com/foo?bar#baz");
    assertEquals("Invalid result URI", expected, result.toUri());
  }
  @Test
  public void fromHierarchicalUri() throws URISyntaxException {
    URI uri = new URI("http://example.com/foo?bar#baz");
    UriComponents result = UriComponentsBuilder.fromUri(uri).build();
    assertEquals("http", result.getScheme());
    assertEquals("example.com", result.getHost());
    assertEquals("/foo", result.getPath());
    assertEquals("bar", result.getQuery());
    assertEquals("baz", result.getFragment());

    assertEquals("Invalid result URI", uri, result.toUri());
  }
  @Test
  public void multipleFromSameBuilder() throws URISyntaxException {
    UriComponentsBuilder builder =
        UriComponentsBuilder.newInstance().scheme("http").host("example.com").pathSegment("foo");
    UriComponents result1 = builder.build();
    builder = builder.pathSegment("foo2").queryParam("bar").fragment("baz");
    UriComponents result2 = builder.build();

    assertEquals("http", result1.getScheme());
    assertEquals("example.com", result1.getHost());
    assertEquals("/foo", result1.getPath());
    URI expected = new URI("http://example.com/foo");
    assertEquals("Invalid result URI", expected, result1.toUri());

    assertEquals("http", result2.getScheme());
    assertEquals("example.com", result2.getHost());
    assertEquals("/foo/foo2", result2.getPath());
    assertEquals("bar", result2.getQuery());
    assertEquals("baz", result2.getFragment());
    expected = new URI("http://example.com/foo/foo2?bar#baz");
    assertEquals("Invalid result URI", expected, result2.toUri());
  }
 @Test
 public void equalsHierarchicalUriComponents() throws Exception {
   UriComponents uriComponents1 =
       UriComponentsBuilder.fromUriString("http://example.com")
           .path("/{foo}")
           .query("bar={baz}")
           .build();
   UriComponents uriComponents2 =
       UriComponentsBuilder.fromUriString("http://example.com")
           .path("/{foo}")
           .query("bar={baz}")
           .build();
   UriComponents uriComponents3 =
       UriComponentsBuilder.fromUriString("http://example.com")
           .path("/{foo}")
           .query("bin={baz}")
           .build();
   assertThat(uriComponents1, instanceOf(HierarchicalUriComponents.class));
   assertThat(uriComponents1, equalTo(uriComponents1));
   assertThat(uriComponents1, equalTo(uriComponents2));
   assertThat(uriComponents1, not(equalTo(uriComponents3)));
 }
  @Test // SPR-11872
  public void fromHttpRequestWithForwardedHostWithDefaultPort() {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setScheme("http");
    request.setServerName("localhost");
    request.setServerPort(10080);
    request.addHeader("X-Forwarded-Host", "example.org");

    HttpRequest httpRequest = new ServletServerHttpRequest(request);
    UriComponents result = UriComponentsBuilder.fromHttpRequest(httpRequest).build();

    assertEquals("example.org", result.getHost());
    assertEquals(-1, result.getPort());
  }
  @Test
  public void fromHttpRequestWithForwardedHost() {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setScheme("http");
    request.setServerName("localhost");
    request.setServerPort(-1);
    request.setRequestURI("/mvc-showcase");
    request.addHeader("X-Forwarded-Host", "anotherHost");

    HttpRequest httpRequest = new ServletServerHttpRequest(request);
    UriComponents result = UriComponentsBuilder.fromHttpRequest(httpRequest).build();

    assertEquals("http://anotherHost/mvc-showcase", result.toString());
  }