Package org.apache.wicket.request

Source Code of org.apache.wicket.request.UrlTest

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.wicket.request;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.apache.wicket.request.Url.QueryParameter;
import org.apache.wicket.request.Url.StringMode;
import org.junit.Assert;
import org.junit.Test;

/**
* @author Matej Knopp
* @author Igor Vaynberg
*/
public class UrlTest extends Assert
{
  private void checkSegments(Url url, String... segments)
  {
    assertEquals(Arrays.asList(segments), url.getSegments());
  }

  private void checkQueryParams(Url url, String... params)
  {
    List<QueryParameter> list = new ArrayList<>();
    for (int i = 0; i < params.length; i += 2)
    {
      QueryParameter p = new QueryParameter(params[i], params[i + 1]);
      list.add(p);
    }

    assertEquals(list, url.getQueryParameters());
  }

  /**
   *
   */
  @Test
  public void parse1()
  {
    String s = "foo/bar/baz?a=4&b=5";
    Url url = Url.parse(s);
    checkSegments(url, "foo", "bar", "baz");
    checkQueryParams(url, "a", "4", "b", "5");
  }

  /**
   *
   */
  @Test
  public void parse2()
  {
    String s = "foo/bar//baz?=4&6";
    Url url = Url.parse(s);
    checkSegments(url, "foo", "bar", "", "baz");
    checkQueryParams(url, "", "4", "6", "");
  }

  /**
   *
   */
  @Test
  public void parse3()
  {
    String s = "//foo/bar/";
    Url url = Url.parse(s);
    assertNull(url.getProtocol());
    assertEquals("foo", url.getHost());
    assertNull(url.getPort());
    checkSegments(url, "", "bar", "");
    checkQueryParams(url);
  }

  /**
   *
   */
  @Test
  public void parse4()
  {
    String s = "/foo/bar//";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "foo", "bar", "", "");
    checkQueryParams(url);
  }

  /**
   *
   */
  @Test
  public void parse5()
  {
    String s = "foo/b%3Dr/b%26z/x%3F?a=b&x%3F%264=y%3Dz";
    Url url = Url.parse(s);
    checkSegments(url, "foo", "b=r", "b&z", "x?");
    checkQueryParams(url, "a", "b", "x?&4", "y=z");
  }

  /**
   * Same as #parse5() but with full url and not encoded '=' char in the query string
   * WICKET-5157
   */
  @Test
  public void parse5_1()
  {
    String s = "http://host:12345/foo/b%3Dr/b%26z/x%3F?a=b&x%3F%264=y=z";
    Url url = Url.parse(s);
    checkSegments(url, "", "foo", "b=r", "b&z", "x?");
    checkQueryParams(url, "a", "b", "x?&4", "y=z");
  }

  /**
   *
   */
  @Test
  public void parse6()
  {
    String s = "";
    Url url = Url.parse(s);
    checkSegments(url);
    checkQueryParams(url);
  }

  /**
   *
   */
  @Test
  public void parse7()
  {
    String s = "?a=b";
    Url url = Url.parse(s);
    checkSegments(url);
    checkQueryParams(url, "a", "b");
  }

  /**
   *
   */
  @Test
  public void parse8()
  {
    String s = "/";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url);
  }

  /**
   *
   */
  @Test
  public void parse9()
  {
    String s = "/?a=b";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "b");
  }

  /**
   *
   */
  @Test
  public void parse10()
  {
    String s = "/?a";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "");
  }

  /**
   *
   */
  @Test
  public void parse11()
  {
    String s = "/?a=";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "");
  }

  /**
   *
   */
  @Test
  public void parse12()
  {
    String s = "/?=b";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "", "b");
  }

  /**
   * https://issues.apache.org/jira/browse/WICKET-4398
   */
  @Test
  public void parse13()
  {
    String s = "/?a=b&";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "b");
  }

  /**
   * https://issues.apache.org/jira/browse/WICKET-4398
   */
  @Test
  public void parse14()
  {
    String s = "/?a=b&+";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "b", " ", "");
  }

  /**
   * https://issues.apache.org/jira/browse/WICKET-4877
   */
  @Test
  public void testParse15()
  {
    String s = "http://localhost:56704;jsessionid=8kxeo3reannw1qjtxgkju8yiu";
    Url url = Url.parse(s);
    assertEquals(Integer.valueOf(56704), url.getPort());
    checkSegments(url, ";jsessionid=8kxeo3reannw1qjtxgkju8yiu");
  }

  /**
   * Make it possible to use full url without protocol
   * https://issues.apache.org/jira/browse/WICKET-5065
   */
  @Test
  public void parse16()
  {
    String s = "//localhost:56704;jsessionid=8kxeo3reannw1qjtxgkju8yiu";
    Url url = Url.parse(s);
    assertNull(url.getProtocol());
    assertEquals("localhost", url.getHost());
    assertEquals(Integer.valueOf(56704), url.getPort());
    checkSegments(url, ";jsessionid=8kxeo3reannw1qjtxgkju8yiu");
  }

  /**
   * WICKET-5259
   */
  @Test
  public void parse17()
  {
    String s = "http://me:secret@localhost";
    Url url = Url.parse(s);
    assertEquals("http", url.getProtocol());
    assertEquals("me:secret@localhost", url.getHost());
  }

  /**
   * WICKET-5259
   */
  @Test
  public void parse18()
  {
    String s = "http://me:secret@localhost:8080";
    Url url = Url.parse(s);
    assertEquals("http", url.getProtocol());
    assertEquals("me:secret@localhost", url.getHost());
    assertEquals(Integer.valueOf(8080), url.getPort());
  }

  /**
   *
   */
  @Test
  public void render1()
  {
    Url url = new Url();
    url.getSegments().add("foo");
    url.getSegments().add("b=r");
    url.getSegments().add("b&z");
    url.getSegments().add("x?");
    url.setQueryParameter("a", "b");
    url.setQueryParameter("x?&4", "y=z");

    assertEquals("foo/b=r/b&z/x%3F?a=b&x%3F%264=y%3Dz", url.toString());
  }

  /**
   *
   */
  @Test
  public void render2()
  {
    String s = "/absolute/url";
    Url url = Url.parse(s);
    assertEquals(url.toString(), s);
  }

  /**
   *
   */
  @Test
  public void render3()
  {
    String s = "//absolute/url";
    Url url = Url.parse(s);
    assertEquals(url.toString(StringMode.FULL), s);
  }

  /**
   *
   */
  @Test
  public void render4()
  {
    String s = "/";
    Url url = Url.parse(s);
    assertEquals(url.toString(), s);
  }

  @Test
  public void render5()
  {
    Url url = Url.parse("https://www.domain.com/foo/bar?baz=ban");

    // local string mode
    assertEquals("/foo/bar?baz=ban", url.toString(StringMode.LOCAL));

    // full string mode
    assertEquals("https://www.domain.com/foo/bar?baz=ban", url.toString(StringMode.FULL));

    // local is the default mode
    assertEquals(url.toString(StringMode.LOCAL), url.toString());
  }


  /**
   *
   */
  @Test
  public void absolute1()
  {
    Url url = Url.parse("abc/efg");
    assertFalse(url.isFull());
    assertFalse(url.isContextAbsolute());
  }

  /**
   *
   */
  @Test
  public void absolute2()
  {
    Url url = Url.parse("");
    assertFalse(url.isFull());
    assertFalse(url.isContextAbsolute());
  }

  /**
   *
   */
  @Test
  public void absolute3()
  {
    Url url = Url.parse("/");
    assertFalse(url.isFull());
    assertTrue(url.isContextAbsolute());
  }

  /**
   *
   */
  @Test
  public void absolute4()
  {
    Url url = Url.parse("/abc/efg");
    assertFalse(url.isFull());
    assertTrue(url.isContextAbsolute());
  }

  /**
   *
   */
  @Test
  public void absolute5()
  {
    Url url = Url.parse("http://www.domain.com");
    assertTrue(url.isFull());
    assertFalse(url.isContextAbsolute());
  }


  /**
   *
   */
  @Test
  public void concat1()
  {
    Url url = Url.parse("abc/efg");
    url.concatSegments(Arrays.asList("xx", "yy"));
    assertEquals(Url.parse("abc/xx/yy"), url);
  }

  /**
   *
   */
  @Test
  public void concat2()
  {
    Url url = Url.parse("abc/efg");
    url.concatSegments(Arrays.asList(".", "..", "xx", "yy"));
    assertEquals(Url.parse("xx/yy"), url);
  }

  /**
   *
   */
  @Test
  public void concat3()
  {
    Url url = Url.parse("abc/efg");
    url.concatSegments(Arrays.asList("..", "..", "xx", "yy"));
    assertEquals(Url.parse("xx/yy"), url);
  }

  /**
   *
   */
  @Test
  public void concat4()
  {
    Url url = Url.parse("abc/efg");
    url.concatSegments(Arrays.asList("..", "..", "..", "xx", "yy"));
    assertEquals(Url.parse("../xx/yy"), url);
  }

  /**
   *
   */
  @Test
  public void concat5()
  {
    Url url = Url.parse("abc/efg/");
    url.concatSegments(Arrays.asList("xx", "yy"));
    assertEquals(Url.parse("abc/efg/xx/yy"), url);
  }

  /**
   *
   */
  @Test
  public void concat6()
  {
    Url url = Url.parse("abc/efg/");
    url.concatSegments(Arrays.asList(".."));
    assertEquals(Url.parse("abc/"), url);
  }

  /**
   *
   */
  @Test
  public void concat7()
  {
    Url url = Url.parse("abc/efg/");
    url.concatSegments(Arrays.asList("..", ".."));
    assertEquals(Url.parse(""), url);
  }

  /**
   *
   */
  @Test
  public void concat8()
  {
    Url url = Url.parse("fff/abc/efg/xxx");
    url.concatSegments(Arrays.asList(".."));
    assertEquals(Url.parse("fff/abc/"), url);
  }

  /**
   *
   */
  @Test
  public void concat9()
  {
    Url url = Url.parse("fff/abc/efg/xxx");
    url.concatSegments(Arrays.asList("..", ".."));
    assertEquals(Url.parse("fff/"), url);
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-3363">WICKET-3363</a>
   */
  @Test
  public void resolveRelative1()
  {
    Url relative = Url.parse("./a/b?p1=v1");
    Url baseUrl = Url.parse("c/d?p2=v2");
    baseUrl.resolveRelative(relative);

    assertEquals("c/a/b?p1=v1", baseUrl.toString());
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-3363">WICKET-3363</a>
   */
  @Test
  public void resolveRelative2()
  {
    Url relative = Url.parse("a/b?p1=v1");
    Url baseUrl = Url.parse("c/d?p2=v2");
    baseUrl.resolveRelative(relative);

    assertEquals("c/a/b?p1=v1", baseUrl.toString());
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-3363">WICKET-3363</a>
   */
  @Test
  public void resolveRelative3()
  {
    Url relative = Url.parse("../a/b?p1=v1");
    Url baseUrl = Url.parse("c/d");
    baseUrl.resolveRelative(relative);

    assertEquals("a/b?p1=v1", baseUrl.toString());
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-4518">WICKET-4518</a>
   */
  @Test
  public void resolveRelative4()
  {
    Url relative = Url.parse("../?p1=v1");
    Url baseUrl = Url.parse("c/d");
    baseUrl.resolveRelative(relative);

    assertEquals("?p1=v1", baseUrl.toString());
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-4789">WICKET-4789</a>
   */
  @Test
  public void resolveRelative_EmptyTrailingSegmentInBase()
  {
    Url relative = Url.parse("./?0-1.ILinkListener-link");
    Url baseUrl = Url.parse("Home/");
    baseUrl.resolveRelative(relative);

    assertEquals("Home/?0-1.ILinkListener-link", baseUrl.toString());
  }

  /**
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-4789">WICKET-4789</a>
   */
  @Test
  public void resolveRelative_EmptyTrailingSegmentInBase2()
  {
    Url relative = Url.parse("./foo/?0-1.ILinkListener-link");
    Url baseUrl = Url.parse("Home/");
    baseUrl.resolveRelative(relative);

    assertEquals("Home/foo/?0-1.ILinkListener-link", baseUrl.toString());
  }

  /**
   * Tries to resolve a relative url against a base that has no segments
   */
  @Test
  public void resolveRelative_NoSegmentsInBase()
  {
    Url relative = Url.parse("?a=b");
    Url baseUrl = Url.parse("?foo=bar");
    baseUrl.resolveRelative(relative);

    assertEquals("?a=b", baseUrl.toString());
  }

  /**
   * Tries to resolve a relative url against a base that has no segments
   */
  @Test
  public void resolveRelative_NoSegmentsInBase2()
  {
    Url relative = Url.parse("bar/baz?a=b");
    Url baseUrl = Url.parse("?foo=bar");
    baseUrl.resolveRelative(relative);

    assertEquals("bar/baz?a=b", baseUrl.toString());
  }

  /**
   * Tries to resolve a relative url that starts with dot followed by empty segment
   *
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-4518">WICKET-4518</a>
   */
  @Test
  public void resolveRelative_DotFollowedByEmptySegment1()
  {
    Url relative = Url.parse("./?a=b");
    Url baseUrl = Url.parse("bar");
    baseUrl.resolveRelative(relative);

    assertEquals("?a=b", baseUrl.toString());
    assertEquals("no empty segment", 0, baseUrl.getSegments().size());
  }

  /**
   * Tries to resolve a relative url that starts with dot followed by empty segment
   *
   * @see <a href="https://issues.apache.org/jira/browse/WICKET-4518">WICKET-4518</a>
   */
  @Test
  public void resolveRelative_DotFollowedByEmptySegment2()
  {
    Url relative = Url.parse("./?a=b");
    Url baseUrl = Url.parse("bar/baz");
    baseUrl.resolveRelative(relative);

    assertEquals("bar/?a=b", baseUrl.toString());
  }

  /**
   * Tests that the default charset is UTF-8
   */
  @Test
  public void charset1()
  {
    Url url = new Url();
    assertEquals(Charset.forName("UTF-8"), url.getCharset());
  }

  /**
   * Tests setting the charset explicitly in the constructor
   */
  @Test
  public void charset2()
  {
    Charset expected = Charset.forName("ISO-8859-2");
    Url url = new Url(expected);
    assertEquals(expected, url.getCharset());
  }

  /**
   * Tests that the charset is recovered after deserialization (from Url#charsetName)
   *
   * @throws Exception
   */
  @Test
  public void charset3() throws Exception
  {
    Charset expected = Charset.forName("ISO-8859-1");
    Url url = new Url(expected);
    Url clonedUrl = cloneObject(url);
    assertEquals(expected, clonedUrl.getCharset());
  }

  private Url cloneObject(Url url) throws Exception
  {
    final ByteArrayOutputStream out = new ByteArrayOutputStream(256);
    ObjectOutputStream oos = new ObjectOutputStream(out);
    oos.writeObject(url);
    ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
    return (Url)ois.readObject();
  }

  /**
   *
   */
  @Test
  public void parseRelativeUrl()
  {
    Url url = Url.parse("foo");
    checkUrl(url, null, null, null, "foo");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("foo/bar/baz");
    checkUrl(url, null, null, null, "foo", "bar", "baz");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("?foobar");
    checkUrl(url, null, null, null);
    assertEquals("", url.getQueryParameter("foobar").getValue());
    assertFalse(url.isContextAbsolute());

    url = Url.parse("foo?a=123");
    checkUrl(url, null, null, null, "foo");
    assertEquals("123", url.getQueryParameter("a").getValue());
    assertFalse(url.isContextAbsolute());

    url = Url.parse("/foo");
    checkUrl(url, null, null, null, "", "foo");
    assertTrue(url.isContextAbsolute());
  }

  /**
   *
   */
  @Test
  public void parseAbsoluteUrl()
  {
    Url url = Url.parse("ftp://myhost:8081");
    checkUrl(url, "ftp", "myhost", 8081, "", "");
    assertTrue(url.isFull());
    assertEquals("ftp://myhost:8081/", url.toString(StringMode.FULL));

    url = Url.parse("gopher://myhost:8081/foo");
    checkUrl(url, "gopher", "myhost", 8081, "", "foo");
    assertTrue(url.isFull());
    assertEquals("gopher://myhost:8081/foo", url.toString(StringMode.FULL));

    url = Url.parse("http://myhost:80/foo");
    checkUrl(url, "http", "myhost", 80, "", "foo");
    assertTrue(url.isFull());
    assertEquals("http://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("http://myhost:81/foo");
    checkUrl(url, "http", "myhost", 81, "", "foo");
    assertTrue(url.isFull());
    assertEquals("http://myhost:81/foo", url.toString(StringMode.FULL));

    url = Url.parse("http://myhost/foo");
    checkUrl(url, "http", "myhost", 80, "", "foo");
    assertTrue(url.isFull());
    assertEquals("http://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("https://myhost:443/foo");
    checkUrl(url, "https", "myhost", 443, "", "foo");
    assertTrue(url.isFull());
    assertEquals("https://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("HTTPS://myhost/foo:123");
    checkUrl(url, "https", "myhost", 443, "", "foo:123");
    assertTrue(url.isFull());
    assertEquals("https://myhost/foo:123", url.toString(StringMode.FULL));

    url = Url.parse("ftp://myhost/foo");
    checkUrl(url, "ftp", "myhost", 21, "", "foo");
    assertTrue(url.isFull());
    assertEquals("ftp://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("ftp://myhost:21/foo");
    checkUrl(url, "ftp", "myhost", 21, "", "foo");
    assertTrue(url.isFull());
    assertEquals("ftp://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("ftp://user:pass@myhost:21/foo");
    checkUrl(url, "ftp", "user:pass@myhost", 21, "", "foo");
    assertTrue(url.isFull());
    assertEquals("ftp://user:pass@myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("FTp://myhost/foo");
    checkUrl(url, "ftp", "myhost", 21, "", "foo");
    assertTrue(url.isFull());
    assertEquals("ftp://myhost/foo", url.toString(StringMode.FULL));

    url = Url.parse("unknown://myhost/foo");
    checkUrl(url, "unknown", "myhost", null, "", "foo");
    assertTrue(url.isFull());
    assertEquals("unknown://myhost/foo", url.toString(StringMode.FULL));
  }

  private void checkUrl(Url url, String protocol, String host, Integer port, String... segments)
  {
    assertNotNull(url);
    assertEquals(protocol, url.getProtocol());
    assertEquals(host, url.getHost());
    assertEquals(port, url.getPort());
    assertEquals(Arrays.asList(segments), url.getSegments());
  }

  @Test
  public void compact()
  {
    assertEquals("", Url.parse("").canonical().getPath());
    assertEquals("/", Url.parse("/").canonical().getPath());
    assertEquals("/a", Url.parse("/a").canonical().getPath());
    assertEquals("a/", Url.parse("a/").canonical().getPath());
    assertEquals("", Url.parse("example/..").canonical().getPath());
    assertEquals("..", Url.parse("example/../..").canonical().getPath());
    assertEquals("..", Url.parse("example/.././..").canonical().getPath());
    assertEquals("a///", Url.parse("a///").canonical().getPath());
    assertEquals("a//b/c", Url.parse("a//b/c").canonical().getPath());
    assertEquals("foo/test", Url.parse("foo/bar/../baz/../test").canonical().getPath());
    assertEquals("a/d", Url.parse("a/b/c/../../d").canonical().getPath());
    assertEquals("a/d", Url.parse("../../a/b/../c/../d").canonical().getPath());
    assertEquals("a/d", Url.parse("../../a/b/../c/../d/.").canonical().getPath());
    assertEquals("a", Url.parse("../../a/b/../c/../d/..").canonical().getPath());
    assertEquals("", Url.parse("../../a/b/../c/../d/../..").canonical().getPath());
  }

  @Test
  public void copyConstructor()
  {
    String protocol = "myProtocol";
    String host = "www.example.com";
    Integer port = 12345;
    Url url = Url.parse("segment1/segment2?name1=value1");
    url.setProtocol(protocol);
    url.setHost(host);
    url.setPort(port);
    Url copy = new Url(url);
    List<String> segments = copy.getSegments();
    assertEquals(2, segments.size());
    assertEquals("segment1", segments.get(0));
    assertEquals("segment2", segments.get(1));
    List<QueryParameter> queryParameters = copy.getQueryParameters();
    assertEquals(1, queryParameters.size());
    QueryParameter queryParameter = queryParameters.get(0);
    assertEquals("name1", queryParameter.getName());
    assertEquals("value1", queryParameter.getValue());
    assertEquals(protocol, copy.getProtocol());
    assertEquals(host, copy.getHost());
    assertEquals(port, copy.getPort());
  }

  /**
   * https://issues.apache.org/jira/browse/WICKET-4387 Parse uri with '://' in it should consider
   * it as absolute only if there are no slashes earlier in the string.
   */
  @Test
  public void parseHttpSlashSlashColon()
  {
    // relative
    String uri = "/abc/http://host:9090/";
    Url url = Url.parse(uri);
    assertEquals(uri, url.toString());
    assertNull(url.getProtocol());
    assertNull(url.getHost());
    assertNull(url.getPort());

    // absolute
    uri = "abchttp://host:9090/";
    url = Url.parse(uri);
    assertEquals(uri, url.toString(StringMode.FULL));
    assertEquals("abchttp", url.getProtocol());
    assertEquals("host", url.getHost());
    assertEquals(Integer.valueOf(9090), url.getPort());

  }

  /**
   *
   */
  @Test
  public void prependLeadingSegments1()
  {
    Url url = Url.parse("a");

    url.prependLeadingSegments(Arrays.asList("x", "y"));

    assertEquals("x/y/a", url.toString());
  }

  /**
   *
   */
  @Test
  public void prependLeadingSegments2()
  {
    Url url = Url.parse("a");

    url.prependLeadingSegments(Arrays.asList("x"));

    assertEquals("x/a", url.toString());
  }

  /**
   *
   */
  @Test
  public void prependLeadingSegments3()
  {
    Url url = Url.parse("a");

    url.prependLeadingSegments(Collections.<String> emptyList());

    assertEquals("a", url.toString());
  }

  /**
   *
   */
  @Test
  public void prependLeadingSegments4()
  {
    Url url = new Url();

    url.prependLeadingSegments(Arrays.asList("x"));

    assertEquals("x", url.toString());
  }

  /**
   *
   */
  @Test
  public void removeLeadingSegments1()
  {
    Url url = Url.parse("a/b");

    url.removeLeadingSegments(1);
    assertEquals("b", url.toString());
  }

  /**
   *
   */
  @Test
  public void removeLeadingSegments2()
  {
    Url url = Url.parse("a/b");

    url.removeLeadingSegments(2);
    assertEquals("", url.toString());
  }

  /**
   *
   */
  @Test(expected = IllegalArgumentException.class)
  public void removeLeadingSegments3()
  {
    Url url = Url.parse("a/b");

    url.removeLeadingSegments(3);
  }

  @Test
  public void wicket_5114_allowtoStringFullWhenContainingTwoDots()
  {
    Url url = Url.parse("/mountPoint/whatever.../");
    url.setHost("wicketHost");
    assertEquals("//wicketHost/mountPoint/whatever.../", url.toString(StringMode.FULL));
  }

  @Test(expected = IllegalStateException.class)
  public void wicket_5114_throwExceptionWhenToStringFullContainsRelativePathSegment()
  {
    Url url = Url.parse("/mountPoint/../whatever/");
    url.setHost("wicketHost");
    url.toString(StringMode.FULL);
  }

  @Test
  public void isContextAbsolute()
  {
    Url url = Url.parse("");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("http://www.example.com/path");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("//www.example.com/path");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("path");
    assertFalse(url.isContextAbsolute());

    url = Url.parse("/path");
    assertTrue(url.isContextAbsolute());
  }

  @Test
  public void isFull()
  {
    Url url = Url.parse("");
    assertFalse(url.isFull());

    url = Url.parse("http://www.example.com/path");
    assertTrue(url.isFull());

    url = Url.parse("//www.example.com/path");
    assertTrue(url.isFull());

    url = Url.parse("path");
    assertFalse(url.isFull());

    url = Url.parse("/path");
    assertFalse(url.isFull());
  }

  /**
   * Should accept parameter values containing equals sign(s)
   * https://issues.apache.org/jira/browse/WICKET-5157
   */
  @Test
  public void parseQueryStringWithEqualsSignInParameterValue()
  {
    String s = "/?a=b=c&d=e=f";
    Url url = Url.parse(s);
    assertTrue(url.isContextAbsolute());
    checkSegments(url, "", "");
    checkQueryParams(url, "a", "b=c", "d", "e=f");
  }

}
TOP

Related Classes of org.apache.wicket.request.UrlTest

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.