• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 package org.jsoup.select;
2 
3 import org.jsoup.Jsoup;
4 import org.jsoup.TextUtil;
5 import org.jsoup.nodes.Comment;
6 import org.jsoup.nodes.DataNode;
7 import org.jsoup.nodes.Document;
8 import org.jsoup.nodes.Element;
9 import org.jsoup.nodes.FormElement;
10 import org.jsoup.nodes.Node;
11 import org.jsoup.nodes.TextNode;
12 import org.junit.jupiter.api.Test;
13 
14 import java.util.Iterator;
15 import java.util.List;
16 
17 import static org.junit.jupiter.api.Assertions.*;
18 import static org.junit.jupiter.api.Assertions.assertFalse;
19 
20 /**
21  Tests for ElementList.
22 
23  @author Jonathan Hedley, jonathan@hedley.net */
24 public class ElementsTest {
filter()25     @Test public void filter() {
26         String h = "<p>Excl</p><div class=headline><p>Hello</p><p>There</p></div><div class=headline><h1>Headline</h1></div>";
27         Document doc = Jsoup.parse(h);
28         Elements els = doc.select(".headline").select("p");
29         assertEquals(2, els.size());
30         assertEquals("Hello", els.get(0).text());
31         assertEquals("There", els.get(1).text());
32     }
33 
attributes()34     @Test public void attributes() {
35         String h = "<p title=foo><p title=bar><p class=foo><p class=bar>";
36         Document doc = Jsoup.parse(h);
37         Elements withTitle = doc.select("p[title]");
38         assertEquals(2, withTitle.size());
39         assertTrue(withTitle.hasAttr("title"));
40         assertFalse(withTitle.hasAttr("class"));
41         assertEquals("foo", withTitle.attr("title"));
42 
43         withTitle.removeAttr("title");
44         assertEquals(2, withTitle.size()); // existing Elements are not reevaluated
45         assertEquals(0, doc.select("p[title]").size());
46 
47         Elements ps = doc.select("p").attr("style", "classy");
48         assertEquals(4, ps.size());
49         assertEquals("classy", ps.last().attr("style"));
50         assertEquals("bar", ps.last().attr("class"));
51     }
52 
hasAttr()53     @Test public void hasAttr() {
54         Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>");
55         Elements ps = doc.select("p");
56         assertTrue(ps.hasAttr("class"));
57         assertFalse(ps.hasAttr("style"));
58     }
59 
hasAbsAttr()60     @Test public void hasAbsAttr() {
61         Document doc = Jsoup.parse("<a id=1 href='/foo'>One</a> <a id=2 href='https://jsoup.org'>Two</a>");
62         Elements one = doc.select("#1");
63         Elements two = doc.select("#2");
64         Elements both = doc.select("a");
65         assertFalse(one.hasAttr("abs:href"));
66         assertTrue(two.hasAttr("abs:href"));
67         assertTrue(both.hasAttr("abs:href")); // hits on #2
68     }
69 
attr()70     @Test public void attr() {
71         Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>");
72         String classVal = doc.select("p").attr("class");
73         assertEquals("foo", classVal);
74     }
75 
absAttr()76     @Test public void absAttr() {
77         Document doc = Jsoup.parse("<a id=1 href='/foo'>One</a> <a id=2 href='https://jsoup.org'>Two</a>");
78         Elements one = doc.select("#1");
79         Elements two = doc.select("#2");
80         Elements both = doc.select("a");
81 
82         assertEquals("", one.attr("abs:href"));
83         assertEquals("https://jsoup.org", two.attr("abs:href"));
84         assertEquals("https://jsoup.org", both.attr("abs:href"));
85     }
86 
classes()87     @Test public void classes() {
88         Document doc = Jsoup.parse("<div><p class='mellow yellow'></p><p class='red green'></p>");
89 
90         Elements els = doc.select("p");
91         assertTrue(els.hasClass("red"));
92         assertFalse(els.hasClass("blue"));
93         els.addClass("blue");
94         els.removeClass("yellow");
95         els.toggleClass("mellow");
96 
97         assertEquals("blue", els.get(0).className());
98         assertEquals("red green blue mellow", els.get(1).className());
99     }
100 
hasClassCaseInsensitive()101     @Test public void hasClassCaseInsensitive() {
102         Elements els = Jsoup.parse("<p Class=One>One <p class=Two>Two <p CLASS=THREE>THREE").select("p");
103         Element one = els.get(0);
104         Element two = els.get(1);
105         Element thr = els.get(2);
106 
107         assertTrue(one.hasClass("One"));
108         assertTrue(one.hasClass("ONE"));
109 
110         assertTrue(two.hasClass("TWO"));
111         assertTrue(two.hasClass("Two"));
112 
113         assertTrue(thr.hasClass("ThreE"));
114         assertTrue(thr.hasClass("three"));
115     }
116 
text()117     @Test public void text() {
118         String h = "<div><p>Hello<p>there<p>world</div>";
119         Document doc = Jsoup.parse(h);
120         assertEquals("Hello there world", doc.select("div > *").text());
121     }
122 
hasText()123     @Test public void hasText() {
124         Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p></p></div>");
125         Elements divs = doc.select("div");
126         assertTrue(divs.hasText());
127         assertFalse(doc.select("div + div").hasText());
128     }
129 
html()130     @Test public void html() {
131         Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p>There</p></div>");
132         Elements divs = doc.select("div");
133         assertEquals("<p>Hello</p>\n<p>There</p>", divs.html());
134     }
135 
outerHtml()136     @Test public void outerHtml() {
137         Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p>There</p></div>");
138         Elements divs = doc.select("div");
139         assertEquals("<div><p>Hello</p></div><div><p>There</p></div>", TextUtil.stripNewlines(divs.outerHtml()));
140     }
141 
setHtml()142     @Test public void setHtml() {
143         Document doc = Jsoup.parse("<p>One</p><p>Two</p><p>Three</p>");
144         Elements ps = doc.select("p");
145 
146         ps.prepend("<b>Bold</b>").append("<i>Ital</i>");
147         assertEquals("<p><b>Bold</b>Two<i>Ital</i></p>", TextUtil.stripNewlines(ps.get(1).outerHtml()));
148 
149         ps.html("<span>Gone</span>");
150         assertEquals("<p><span>Gone</span></p>", TextUtil.stripNewlines(ps.get(1).outerHtml()));
151     }
152 
val()153     @Test public void val() {
154         Document doc = Jsoup.parse("<input value='one' /><textarea>two</textarea>");
155         Elements els = doc.select("input, textarea");
156         assertEquals(2, els.size());
157         assertEquals("one", els.val());
158         assertEquals("two", els.last().val());
159 
160         els.val("three");
161         assertEquals("three", els.first().val());
162         assertEquals("three", els.last().val());
163         assertEquals("<textarea>three</textarea>", els.last().outerHtml());
164     }
165 
before()166     @Test public void before() {
167         Document doc = Jsoup.parse("<p>This <a>is</a> <a>jsoup</a>.</p>");
168         doc.select("a").before("<span>foo</span>");
169         assertEquals("<p>This <span>foo</span><a>is</a> <span>foo</span><a>jsoup</a>.</p>", TextUtil.stripNewlines(doc.body().html()));
170     }
171 
after()172     @Test public void after() {
173         Document doc = Jsoup.parse("<p>This <a>is</a> <a>jsoup</a>.</p>");
174         doc.select("a").after("<span>foo</span>");
175         assertEquals("<p>This <a>is</a><span>foo</span> <a>jsoup</a><span>foo</span>.</p>", TextUtil.stripNewlines(doc.body().html()));
176     }
177 
wrap()178     @Test public void wrap() {
179         String h = "<p><b>This</b> is <b>jsoup</b></p>";
180         Document doc = Jsoup.parse(h);
181         doc.select("b").wrap("<i></i>");
182         assertEquals("<p><i><b>This</b></i> is <i><b>jsoup</b></i></p>", doc.body().html());
183     }
184 
wrapDiv()185     @Test public void wrapDiv() {
186         String h = "<p><b>This</b> is <b>jsoup</b>.</p> <p>How do you like it?</p>";
187         Document doc = Jsoup.parse(h);
188         doc.select("p").wrap("<div></div>");
189         assertEquals(
190             "<div>\n <p><b>This</b> is <b>jsoup</b>.</p>\n</div>\n<div>\n <p>How do you like it?</p>\n</div>",
191             doc.body().html());
192     }
193 
unwrap()194     @Test public void unwrap() {
195         String h = "<div><font>One</font> <font><a href=\"/\">Two</a></font></div";
196         Document doc = Jsoup.parse(h);
197         doc.select("font").unwrap();
198         assertEquals("<div>\n" +
199             " One <a href=\"/\">Two</a>\n" +
200             "</div>", doc.body().html());
201     }
202 
unwrapP()203     @Test public void unwrapP() {
204         String h = "<p><a>One</a> Two</p> Three <i>Four</i> <p>Fix <i>Six</i></p>";
205         Document doc = Jsoup.parse(h);
206         doc.select("p").unwrap();
207         assertEquals("<a>One</a> Two Three <i>Four</i> Fix <i>Six</i>", TextUtil.stripNewlines(doc.body().html()));
208     }
209 
unwrapKeepsSpace()210     @Test public void unwrapKeepsSpace() {
211         String h = "<p>One <span>two</span> <span>three</span> four</p>";
212         Document doc = Jsoup.parse(h);
213         doc.select("span").unwrap();
214         assertEquals("<p>One two three four</p>", doc.body().html());
215     }
216 
empty()217     @Test public void empty() {
218         Document doc = Jsoup.parse("<div><p>Hello <b>there</b></p> <p>now!</p></div>");
219         doc.outputSettings().prettyPrint(false);
220 
221         doc.select("p").empty();
222         assertEquals("<div><p></p> <p></p></div>", doc.body().html());
223     }
224 
remove()225     @Test public void remove() {
226         Document doc = Jsoup.parse("<div><p>Hello <b>there</b></p> jsoup <p>now!</p></div>");
227         doc.outputSettings().prettyPrint(false);
228 
229         doc.select("p").remove();
230         assertEquals("<div> jsoup </div>", doc.body().html());
231     }
232 
eq()233     @Test public void eq() {
234         String h = "<p>Hello<p>there<p>world";
235         Document doc = Jsoup.parse(h);
236         assertEquals("there", doc.select("p").eq(1).text());
237         assertEquals("there", doc.select("p").get(1).text());
238     }
239 
is()240     @Test public void is() {
241         String h = "<p>Hello<p title=foo>there<p>world";
242         Document doc = Jsoup.parse(h);
243         Elements ps = doc.select("p");
244         assertTrue(ps.is("[title=foo]"));
245         assertFalse(ps.is("[title=bar]"));
246     }
247 
parents()248     @Test public void parents() {
249         Document doc = Jsoup.parse("<div><p>Hello</p></div><p>There</p>");
250         Elements parents = doc.select("p").parents();
251 
252         assertEquals(3, parents.size());
253         assertEquals("div", parents.get(0).tagName());
254         assertEquals("body", parents.get(1).tagName());
255         assertEquals("html", parents.get(2).tagName());
256     }
257 
not()258     @Test public void not() {
259         Document doc = Jsoup.parse("<div id=1><p>One</p></div> <div id=2><p><span>Two</span></p></div>");
260 
261         Elements div1 = doc.select("div").not(":has(p > span)");
262         assertEquals(1, div1.size());
263         assertEquals("1", div1.first().id());
264 
265         Elements div2 = doc.select("div").not("#1");
266         assertEquals(1, div2.size());
267         assertEquals("2", div2.first().id());
268     }
269 
tagNameSet()270     @Test public void tagNameSet() {
271         Document doc = Jsoup.parse("<p>Hello <i>there</i> <i>now</i></p>");
272         doc.select("i").tagName("em");
273 
274         assertEquals("<p>Hello <em>there</em> <em>now</em></p>", doc.body().html());
275     }
276 
traverse()277     @Test public void traverse() {
278         Document doc = Jsoup.parse("<div><p>Hello</p></div><div>There</div>");
279         final StringBuilder accum = new StringBuilder();
280         doc.select("div").traverse(new NodeVisitor() {
281             @Override
282             public void head(Node node, int depth) {
283                 accum.append("<").append(node.nodeName()).append(">");
284             }
285 
286             @Override
287             public void tail(Node node, int depth) {
288                 accum.append("</").append(node.nodeName()).append(">");
289             }
290         });
291         assertEquals("<div><p><#text></#text></p></div><div><#text></#text></div>", accum.toString());
292     }
293 
forms()294     @Test public void forms() {
295         Document doc = Jsoup.parse("<form id=1><input name=q></form><div /><form id=2><input name=f></form>");
296         Elements els = doc.select("form, div");
297         assertEquals(3, els.size());
298 
299         List<FormElement> forms = els.forms();
300         assertEquals(2, forms.size());
301         assertNotNull(forms.get(0));
302         assertNotNull(forms.get(1));
303         assertEquals("1", forms.get(0).id());
304         assertEquals("2", forms.get(1).id());
305     }
306 
comments()307     @Test public void comments() {
308         Document doc = Jsoup.parse("<!-- comment1 --><p><!-- comment2 --><p class=two><!-- comment3 -->");
309         List<Comment> comments = doc.select("p").comments();
310         assertEquals(2, comments.size());
311         assertEquals(" comment2 ", comments.get(0).getData());
312         assertEquals(" comment3 ", comments.get(1).getData());
313 
314         List<Comment> comments1 = doc.select("p.two").comments();
315         assertEquals(1, comments1.size());
316         assertEquals(" comment3 ", comments1.get(0).getData());
317     }
318 
textNodes()319     @Test public void textNodes() {
320         Document doc = Jsoup.parse("One<p>Two<a>Three</a><p>Four</p>Five");
321         List<TextNode> textNodes = doc.select("p").textNodes();
322         assertEquals(2, textNodes.size());
323         assertEquals("Two", textNodes.get(0).text());
324         assertEquals("Four", textNodes.get(1).text());
325     }
326 
dataNodes()327     @Test public void dataNodes() {
328         Document doc = Jsoup.parse("<p>One</p><script>Two</script><style>Three</style>");
329         List<DataNode> dataNodes = doc.select("p, script, style").dataNodes();
330         assertEquals(2, dataNodes.size());
331         assertEquals("Two", dataNodes.get(0).getWholeData());
332         assertEquals("Three", dataNodes.get(1).getWholeData());
333 
334         doc = Jsoup.parse("<head><script type=application/json><crux></script><script src=foo>Blah</script>");
335         Elements script = doc.select("script[type=application/json]");
336         List<DataNode> scriptNode = script.dataNodes();
337         assertEquals(1, scriptNode.size());
338         DataNode dataNode = scriptNode.get(0);
339         assertEquals("<crux>", dataNode.getWholeData());
340 
341         // check if they're live
342         dataNode.setWholeData("<cromulent>");
343         assertEquals("<script type=\"application/json\"><cromulent></script>", script.outerHtml());
344     }
345 
nodesEmpty()346     @Test public void nodesEmpty() {
347         Document doc = Jsoup.parse("<p>");
348         assertEquals(0, doc.select("form").textNodes().size());
349     }
350 
classWithHyphen()351     @Test public void classWithHyphen() {
352         Document doc = Jsoup.parse("<p class='tab-nav'>Check</p>");
353         Elements els = doc.getElementsByClass("tab-nav");
354         assertEquals(1, els.size());
355         assertEquals("Check", els.text());
356     }
357 
siblings()358     @Test public void siblings() {
359         Document doc = Jsoup.parse("<div><p>1<p>2<p>3<p>4<p>5<p>6</div><div><p>7<p>8<p>9<p>10<p>11<p>12</div>");
360 
361         Elements els = doc.select("p:eq(3)"); // gets p4 and p10
362         assertEquals(2, els.size());
363 
364         Elements next = els.next();
365         assertEquals(2, next.size());
366         assertEquals("5", next.first().text());
367         assertEquals("11", next.last().text());
368 
369         assertEquals(0, els.next("p:contains(6)").size());
370         final Elements nextF = els.next("p:contains(5)");
371         assertEquals(1, nextF.size());
372         assertEquals("5", nextF.first().text());
373 
374         Elements nextA = els.nextAll();
375         assertEquals(4, nextA.size());
376         assertEquals("5", nextA.first().text());
377         assertEquals("12", nextA.last().text());
378 
379         Elements nextAF = els.nextAll("p:contains(6)");
380         assertEquals(1, nextAF.size());
381         assertEquals("6", nextAF.first().text());
382 
383         Elements prev = els.prev();
384         assertEquals(2, prev.size());
385         assertEquals("3", prev.first().text());
386         assertEquals("9", prev.last().text());
387 
388         assertEquals(0, els.prev("p:contains(1)").size());
389         final Elements prevF = els.prev("p:contains(3)");
390         assertEquals(1, prevF.size());
391         assertEquals("3", prevF.first().text());
392 
393         Elements prevA = els.prevAll();
394         assertEquals(6, prevA.size());
395         assertEquals("3", prevA.first().text());
396         assertEquals("7", prevA.last().text());
397 
398         Elements prevAF = els.prevAll("p:contains(1)");
399         assertEquals(1, prevAF.size());
400         assertEquals("1", prevAF.first().text());
401     }
402 
eachText()403     @Test public void eachText() {
404         Document doc = Jsoup.parse("<div><p>1<p>2<p>3<p>4<p>5<p>6</div><div><p>7<p>8<p>9<p>10<p>11<p>12<p></p></div>");
405         List<String> divText = doc.select("div").eachText();
406         assertEquals(2, divText.size());
407         assertEquals("1 2 3 4 5 6", divText.get(0));
408         assertEquals("7 8 9 10 11 12", divText.get(1));
409 
410         List<String> pText = doc.select("p").eachText();
411         Elements ps = doc.select("p");
412         assertEquals(13, ps.size());
413         assertEquals(12, pText.size()); // not 13, as last doesn't have text
414         assertEquals("1", pText.get(0));
415         assertEquals("2", pText.get(1));
416         assertEquals("5", pText.get(4));
417         assertEquals("7", pText.get(6));
418         assertEquals("12", pText.get(11));
419     }
420 
eachAttr()421     @Test public void eachAttr() {
422         Document doc = Jsoup.parse(
423             "<div><a href='/foo'>1</a><a href='http://example.com/bar'>2</a><a href=''>3</a><a>4</a>",
424             "http://example.com");
425 
426         List<String> hrefAttrs = doc.select("a").eachAttr("href");
427         assertEquals(3, hrefAttrs.size());
428         assertEquals("/foo", hrefAttrs.get(0));
429         assertEquals("http://example.com/bar", hrefAttrs.get(1));
430         assertEquals("", hrefAttrs.get(2));
431         assertEquals(4, doc.select("a").size());
432 
433         List<String> absAttrs = doc.select("a").eachAttr("abs:href");
434         assertEquals(3, absAttrs.size());
435         assertEquals(3, absAttrs.size());
436         assertEquals("http://example.com/foo", absAttrs.get(0));
437         assertEquals("http://example.com/bar", absAttrs.get(1));
438         assertEquals("http://example.com", absAttrs.get(2));
439     }
440 
setElementByIndex()441     @Test public void setElementByIndex() {
442         Document doc = Jsoup.parse("<p>One<p>Two<p>Three");
443         Element newP = doc.createElement("p").text("New").attr("id", "new");
444 
445         Elements ps = doc.select("p");
446         Element two = ps.get(1);
447         Element old = ps.set(1, newP);
448         assertSame(old, two);
449         assertSame(newP, ps.get(1)); // replaced in list
450         assertEquals("<p>One</p>\n<p id=\"new\">New</p>\n<p>Three</p>", doc.body().html()); // replaced in dom
451     }
452 
removeElementByIndex()453     @Test public void removeElementByIndex() {
454         Document doc = Jsoup.parse("<p>One<p>Two<p>Three");
455 
456         Elements ps = doc.select("p");
457         Element two = ps.get(1);
458         assertTrue(ps.contains(two));
459         Element old = ps.remove(1);
460         assertSame(old, two);
461 
462         assertEquals(2, ps.size()); // removed from list
463         assertFalse(ps.contains(old));
464         assertEquals("<p>One</p>\n<p>Three</p>", doc.body().html()); // removed from dom
465     }
466 
removeElementByObject()467     @Test public void removeElementByObject() {
468         Document doc = Jsoup.parse("<p>One<p>Two<p>Three");
469 
470         Elements ps = doc.select("p");
471         Element two = ps.get(1);
472         assertTrue(ps.contains(two));
473         boolean removed = ps.remove(two);
474         assertTrue(removed);
475 
476         assertEquals(2, ps.size()); // removed from list
477         assertFalse(ps.contains(two));
478         assertEquals("<p>One</p>\n<p>Three</p>", doc.body().html()); // removed from dom
479     }
480 
removeElementObjectNoops()481     @Test public void removeElementObjectNoops() {
482         Document doc = Jsoup.parse("<p>One<p>Two<p>Three");
483         String origHtml = doc.html();
484         Element newP = doc.createElement("p").text("New");
485 
486         Elements ps = doc.select("p");
487         int size = ps.size();
488         assertFalse(ps.remove(newP));
489         assertFalse(ps.remove(newP.childNodes()));
490         assertEquals(origHtml, doc.html());
491         assertEquals(size, ps.size());
492     }
493 
clear()494     @Test public void clear() {
495         Document doc = Jsoup.parse("<p>One</p><p>Two</p><div>Three</div>");
496         Elements ps = doc.select("p");
497         assertEquals(2, ps.size());
498         ps.clear();
499         assertEquals(0, ps.size());
500 
501         assertEquals(0, doc.select("p").size());
502     }
503 
removeAll()504     @Test public void removeAll() {
505         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four</p><div>Div");
506         Elements ps = doc.select("p");
507         assertEquals(4, ps.size());
508         Elements midPs = doc.select("p:gt(0):lt(3)"); //Two and Three
509         assertEquals(2, midPs.size());
510 
511         boolean removed = ps.removeAll(midPs);
512         assertEquals(2, ps.size());
513         assertTrue(removed);
514         assertEquals(2, midPs.size());
515 
516         Elements divs = doc.select("div");
517         assertEquals(1, divs.size());
518         assertFalse(ps.removeAll(divs));
519         assertEquals(2, ps.size());
520 
521         assertEquals("<p>One</p>\n<p>Four</p>\n<div>\n Div\n</div>", doc.body().html());
522     }
523 
retainAll()524     @Test public void retainAll() {
525         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four</p><div>Div");
526         Elements ps = doc.select("p");
527         assertEquals(4, ps.size());
528         Elements midPs = doc.select("p:gt(0):lt(3)"); //Two and Three
529         assertEquals(2, midPs.size());
530 
531         boolean removed = ps.retainAll(midPs);
532         assertEquals(2, ps.size());
533         assertTrue(removed);
534         assertEquals(2, midPs.size());
535 
536         assertEquals("<p>Two</p>\n<p>Three</p>\n<div>\n Div\n</div>", doc.body().html());
537 
538         Elements psAgain = doc.select("p");
539         assertFalse(midPs.retainAll(psAgain));
540 
541         assertEquals("<p>Two</p>\n<p>Three</p>\n<div>\n Div\n</div>", doc.body().html());
542     }
543 
iteratorRemovesFromDom()544     @Test public void iteratorRemovesFromDom() {
545         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four");
546         Elements ps = doc.select("p");
547 
548         assertEquals(4, ps.size());
549         for (Iterator<Element> it = ps.iterator(); it.hasNext(); ) {
550             Element el = it.next();
551             if (el.text().contains("Two"))
552                 it.remove();
553         }
554         assertEquals(3, ps.size());
555         assertEquals("<p>One</p>\n<p>Three</p>\n<p>Four</p>", doc.body().html());
556     }
557 
removeIf()558     @Test public void removeIf() {
559         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four");
560         Elements ps = doc.select("p");
561 
562         assertEquals(4, ps.size());
563         boolean removed = ps.removeIf(el -> el.text().contains("Two"));
564         assertTrue(removed);
565         assertEquals(3, ps.size());
566         assertEquals("<p>One</p>\n<p>Three</p>\n<p>Four</p>", doc.body().html());
567 
568         assertFalse(ps.removeIf(el -> el.text().contains("Five")));
569         assertEquals("<p>One</p>\n<p>Three</p>\n<p>Four</p>", doc.body().html());
570     }
571 
removeIfSupportsConcurrentRead()572     @Test public void removeIfSupportsConcurrentRead() {
573         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four");
574         Elements ps = doc.select("p");
575         assertEquals(4, ps.size());
576 
577         boolean removed = ps.removeIf(el -> ps.contains(el));
578         assertTrue(removed);
579         assertEquals(0, ps.size());
580         assertEquals("", doc.body().html());
581     }
582 
replaceAll()583     @Test public void replaceAll() {
584         Document doc = Jsoup.parse("<p>One<p>Two<p>Three<p>Four");
585         Elements ps = doc.select("p");
586         assertEquals(4, ps.size());
587 
588         ps.replaceAll(el -> {
589             Element div = doc.createElement("div");
590             div.text(el.text());
591             return div;
592         });
593 
594         // Check Elements
595         for (Element p : ps) {
596             assertEquals("div", p.tagName());
597         }
598 
599         // check dom
600         assertEquals("<div> One</div><div> Two</div><div> Three</div><div> Four</div>", TextUtil.normalizeSpaces(doc.body().html()));
601     }
602 }
603