@Test
  public void testPseudoContains() {
    Document doc =
        Jsoup.parse(
            "<div><p>The Rain.</p> <p class=light>The <i>rain</i>.</p> <p>Rain, the.</p></div>");

    Elements ps1 = doc.select("p:contains(Rain)");
    assertEquals(3, ps1.size());

    Elements ps2 = doc.select("p:contains(the rain)");
    assertEquals(2, ps2.size());
    assertEquals("The Rain.", ps2.first().html());
    assertEquals("The <i>rain</i>.", ps2.last().html());

    Elements ps3 = doc.select("p:contains(the Rain):has(i)");
    assertEquals(1, ps3.size());
    assertEquals("light", ps3.first().className());

    Elements ps4 = doc.select(".light:contains(rain)");
    assertEquals(1, ps4.size());
    assertEquals("light", ps3.first().className());

    Elements ps5 = doc.select(":contains(rain)");
    assertEquals(8, ps5.size()); // html, body, div,...
  }
  @Test
  public void testPseudoHas() {
    Document doc =
        Jsoup.parse(
            "<div id=0><p><span>Hello</span></p></div> <div id=1><span class=foo>There</span></div> <div id=2><p>Not</p></div>");

    Elements divs1 = doc.select("div:has(span)");
    assertEquals(2, divs1.size());
    assertEquals("0", divs1.get(0).id());
    assertEquals("1", divs1.get(1).id());

    Elements divs2 = doc.select("div:has([class]");
    assertEquals(1, divs2.size());
    assertEquals("1", divs2.get(0).id());

    Elements divs3 = doc.select("div:has(span, p)");
    assertEquals(3, divs3.size());
    assertEquals("0", divs3.get(0).id());
    assertEquals("1", divs3.get(1).id());
    assertEquals("2", divs3.get(2).id());

    Elements els1 = doc.body().select(":has(p)");
    assertEquals(3, els1.size()); // body, div, dib
    assertEquals("body", els1.first().tagName());
    assertEquals("0", els1.get(1).id());
    assertEquals("2", els1.get(2).id());
  }
 @Test
 public void testAllElements() {
   String h = "<div><p>Hello</p><p><b>there</b></p></div>";
   Document doc = Jsoup.parse(h);
   Elements allDoc = doc.select("*");
   Elements allUnderDiv = doc.select("div *");
   assertEquals(8, allDoc.size());
   assertEquals(3, allUnderDiv.size());
   assertEquals("p", allUnderDiv.first().tagName());
 }
  @Test
  public void testById() {
    Elements els =
        Jsoup.parse("<div><p id=foo>Hello</p><p id=foo>Foo two!</p></div>").select("#foo");
    assertEquals(2, els.size());
    assertEquals("Hello", els.get(0).text());
    assertEquals("Foo two!", els.get(1).text());

    Elements none = Jsoup.parse("<div id=1></div>").select("#foo");
    assertEquals(0, none.size());
  }
  @Test
  public void selectSameElements() {
    final String html = "<div>one</div><div>one</div>";

    Document doc = Jsoup.parse(html);
    Elements els = doc.select("div");
    assertEquals(2, els.size());

    Elements subSelect = els.select(":contains(one)");
    assertEquals(2, subSelect.size());
  }
  @Test
  public void testPsuedoContainsWithParentheses() {
    Document doc = Jsoup.parse("<div><p id=1>This (is good)</p><p id=2>This is bad)</p>");

    Elements ps1 = doc.select("p:contains(this (is good))");
    assertEquals(1, ps1.size());
    assertEquals("1", ps1.first().id());

    Elements ps2 = doc.select("p:contains(this is bad\\))");
    assertEquals(1, ps2.size());
    assertEquals("2", ps2.first().id());
  }
  @Test
  public void testRelaxedTags() {
    Document doc = Jsoup.parse("<abc_def id=1>Hello</abc_def> <abc-def id=2>There</abc-def>");

    Elements el1 = doc.select("abc_def");
    assertEquals(1, el1.size());
    assertEquals("1", el1.first().id());

    Elements el2 = doc.select("abc-def");
    assertEquals(1, el2.size());
    assertEquals("2", el2.first().id());
  }
Exemple #8
0
  @Test
  public void not() {
    Document doc =
        Jsoup.parse("<div id=1><p>One</p></div> <div id=2><p><span>Two</span></p></div>");

    Elements div1 = doc.select("div").not(":has(p > span)");
    assertEquals(1, div1.size());
    assertEquals("1", div1.first().id());

    Elements div2 = doc.select("div").not("#1");
    assertEquals(1, div2.size());
    assertEquals("2", div2.first().id());
  }
  @Test
  public void testPseudoEquals() {
    Document doc = Jsoup.parse("<div><p>One</p><p>Two</p><p>Three</>p></div><div><p>Four</p>");
    Elements ps = doc.select("div p:eq(0)");
    assertEquals(2, ps.size());
    assertEquals("One", ps.get(0).text());
    assertEquals("Four", ps.get(1).text());

    Elements ps2 = doc.select("div:eq(0) p:eq(0)");
    assertEquals(1, ps2.size());
    assertEquals("One", ps2.get(0).text());
    assertEquals("p", ps2.get(0).tagName());
  }
  @Test
  public void notParas() {
    Document doc = Jsoup.parse("<p id=1>One</p> <p>Two</p> <p><span>Three</span></p>");

    Elements el1 = doc.select("p:not([id=1])");
    assertEquals(2, el1.size());
    assertEquals("Two", el1.first().text());
    assertEquals("Three", el1.last().text());

    Elements el2 = doc.select("p:not(:has(span))");
    assertEquals(2, el2.size());
    assertEquals("One", el2.first().text());
    assertEquals("Two", el2.last().text());
  }
  @Test
  public void parentChildElement() {
    String h = "<div id=1><div id=2><div id = 3></div></div></div><div id=4></div>";
    Document doc = Jsoup.parse(h);

    Elements divs = doc.select("div > div");
    assertEquals(2, divs.size());
    assertEquals("2", divs.get(0).id()); // 2 is child of 1
    assertEquals("3", divs.get(1).id()); // 3 is child of 2

    Elements div2 = doc.select("div#1 > div");
    assertEquals(1, div2.size());
    assertEquals("2", div2.get(0).id());
  }
  @Test
  public void handlesCommasInSelector() {
    Document doc =
        Jsoup.parse("<p name='1,2'>One</p><div>Two</div><ol><li>123</li><li>Text</li></ol>");

    Elements ps = doc.select("[name=1,2]");
    assertEquals(1, ps.size());

    Elements containers = doc.select("div, li:matches([0-9,]+)");
    assertEquals(2, containers.size());
    assertEquals("div", containers.get(0).tagName());
    assertEquals("li", containers.get(1).tagName());
    assertEquals("123", containers.get(1).text());
  }
  @Test
  public void testByAttributeStarting() {
    Document doc =
        Jsoup.parse(
            "<div id=1 data-name=jsoup>Hello</div><p data-val=5 id=2>There</p><p id=3>No</p>");
    Elements withData = doc.select("[^data-]");
    assertEquals(2, withData.size());
    assertEquals("1", withData.first().id());
    assertEquals("2", withData.last().id());

    withData = doc.select("p[^data-]");
    assertEquals(1, withData.size());
    assertEquals("2", withData.first().id());
  }
  @Test
  public void testByTag() {
    // should be case insensitive
    Elements els =
        Jsoup.parse("<div id=1><div id=2><p>Hello</p></div></div><DIV id=3>").select("DIV");
    assertEquals(3, els.size());
    assertEquals("1", els.get(0).id());
    assertEquals("2", els.get(1).id());
    assertEquals("3", els.get(2).id());

    Elements none =
        Jsoup.parse("<div id=1><div id=2><p>Hello</p></div></div><div id=3>").select("span");
    assertEquals(0, none.size());
  }
  @Test
  public void testByClass() {
    Elements els =
        Jsoup.parse("<p id=0 class='ONE two'><p id=1 class='one'><p id=2 class='two'>")
            .select("P.One");
    assertEquals(2, els.size());
    assertEquals("0", els.get(0).id());
    assertEquals("1", els.get(1).id());

    Elements none = Jsoup.parse("<div class='one'></div>").select(".foo");
    assertEquals(0, none.size());

    Elements els2 = Jsoup.parse("<div class='One-Two'></div>").select(".one-two");
    assertEquals(1, els2.size());
  }
  @Test
  public void deeperDescendant() {
    String h =
        "<div class=head><p><span class=first>Hello</div><div class=head><p class=first><span>Another</span><p>Again</div>";
    Document doc = Jsoup.parse(h);
    Element root = doc.getElementsByClass("head").first();

    Elements els = root.select("div p .first");
    assertEquals(1, els.size());
    assertEquals("Hello", els.first().text());
    assertEquals("span", els.first().tagName());

    Elements aboveRoot = root.select("body p .first");
    assertEquals(0, aboveRoot.size());
  }
 @Test
 public void testAllWithClass() {
   String h = "<p class=first>One<p class=first>Two<p>Three";
   Document doc = Jsoup.parse(h);
   Elements ps = doc.select("*.first");
   assertEquals(2, ps.size());
 }
 @Test
 public void testByAttributeRegexCombined() {
   Document doc = Jsoup.parse("<div><table class=x><td>Hello</td></table></div>");
   Elements els = doc.select("div table[class~=x|y]");
   assertEquals(1, els.size());
   assertEquals("Hello", els.text());
 }
 @Test
 public void testPseudoBetween() {
   Document doc = Jsoup.parse("<div><p>One</p><p>Two</p><p>Three</>p></div><div><p>Four</p>");
   Elements ps = doc.select("div p:gt(0):lt(2)");
   assertEquals(1, ps.size());
   assertEquals("Two", ps.get(0).text());
 }
 @Test
 public void notAdjacent() {
   String h = "<ol><li id=1>One<li id=2>Two<li id=3>Three</ol>";
   Document doc = Jsoup.parse(h);
   Elements sibs = doc.select("li#1 + li#3");
   assertEquals(0, sibs.size());
 }
 @Test
 public void testPseudoGreaterThan() {
   Document doc = Jsoup.parse("<div><p>One</p><p>Two</p><p>Three</p></div><div><p>Four</p>");
   Elements ps = doc.select("div p:gt(0)");
   assertEquals(2, ps.size());
   assertEquals("Two", ps.get(0).text());
   assertEquals("Three", ps.get(1).text());
 }
  @Test
  public void parentWithClassChild() {
    String h =
        "<h1 class=foo><a href=1 /></h1><h1 class=foo><a href=2 class=bar /></h1><h1><a href=3 /></h1>";
    Document doc = Jsoup.parse(h);

    Elements allAs = doc.select("h1 > a");
    assertEquals(3, allAs.size());
    assertEquals("a", allAs.first().tagName());

    Elements fooAs = doc.select("h1.foo > a");
    assertEquals(2, fooAs.size());
    assertEquals("a", fooAs.first().tagName());

    Elements barAs = doc.select("h1.foo > a.bar");
    assertEquals(1, barAs.size());
  }
 @Test
 public void testCombinedWithContains() {
   Document doc = Jsoup.parse("<p id=1>One</p><p>Two +</p><p>Three +</p>");
   Elements els = doc.select("p#1 + :contains(+)");
   assertEquals(1, els.size());
   assertEquals("Two +", els.text());
   assertEquals("p", els.first().tagName());
 }
 @Test
 public void multiChildDescent() {
   String h = "<div id=foo><h1 class=bar><a href=http://example.com/>One</a></h1></div>";
   Document doc = Jsoup.parse(h);
   Elements els = doc.select("div#foo > h1.bar > a[href*=example]");
   assertEquals(1, els.size());
   assertEquals("a", els.first().tagName());
 }
 @Test
 public void adjacentSiblingsWithId() {
   String h = "<ol><li id=1>One<li id=2>Two<li id=3>Three</ol>";
   Document doc = Jsoup.parse(h);
   Elements sibs = doc.select("li#1 + li#2");
   assertEquals(1, sibs.size());
   assertEquals("Two", sibs.get(0).text());
 }
 @Test
 public void generalSiblings() {
   String h = "<ol><li id=1>One<li id=2>Two<li id=3>Three</ol>";
   Document doc = Jsoup.parse(h);
   Elements els = doc.select("#1 ~ #3");
   assertEquals(1, els.size());
   assertEquals("Three", els.first().text());
 }
  @Test
  public void notClass() {
    Document doc = Jsoup.parse("<div class=left>One</div><div class=right id=1><p>Two</p></div>");

    Elements el1 = doc.select("div:not(.left)");
    assertEquals(1, el1.size());
    assertEquals("1", el1.first().id());
  }
 @Test
 public void testPseudoCombined() {
   Document doc =
       Jsoup.parse(
           "<div class='foo'><p>One</p><p>Two</p></div><div><p>Three</p><p>Four</p></div>");
   Elements ps = doc.select("div.foo p:gt(0)");
   assertEquals(1, ps.size());
   assertEquals("Two", ps.get(0).text());
 }
  @Test
  public void containsOwn() {
    Document doc = Jsoup.parse("<p id=1>Hello <b>there</b> now</p>");
    Elements ps = doc.select("p:containsOwn(Hello now)");
    assertEquals(1, ps.size());
    assertEquals("1", ps.first().id());

    assertEquals(0, doc.select("p:containsOwn(there)").size());
  }
  @Test
  public void notAll() {
    Document doc = Jsoup.parse("<p>Two</p> <p><span>Three</span></p>");

    Elements el1 = doc.body().select(":not(p)"); // should just be the span
    assertEquals(2, el1.size());
    assertEquals("body", el1.first().tagName());
    assertEquals("span", el1.last().tagName());
  }