Google Git
Sign in
apache / incubator-pagespeed-debian / 16b49815e99b996f06e51fb4c4930437e6ccfc4c / . / src / pagespeed / kernel / html / html_parse_test.cc
blob: fe357ed35cb5e2de0df909218256eeae31bbe698 [file] [log] [blame]
/*
* Copyright 2010 Google Inc.
*
* Licensed 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.
*/
// Author: jmarantz@google.com (Joshua Marantz)
// Unit-test the html reader/writer to ensure that a few tricky
// constructs come through without corruption.
#include <vector>
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/gtest.h"
#include "pagespeed/kernel/base/gmock.h"
#include "pagespeed/kernel/base/message_handler.h"
#include "pagespeed/kernel/base/mock_message_handler.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/string_writer.h"
#include "pagespeed/kernel/html/disable_test_filter.h"
#include "pagespeed/kernel/html/empty_html_filter.h"
#include "pagespeed/kernel/html/explicit_close_tag.h"
#include "pagespeed/kernel/html/html_element.h"
#include "pagespeed/kernel/html/html_event.h"
#include "pagespeed/kernel/html/html_filter.h"
#include "pagespeed/kernel/html/html_name.h"
#include "pagespeed/kernel/html/html_node.h"
#include "pagespeed/kernel/html/html_parse.h"
#include "pagespeed/kernel/html/html_parse_test_base.h"
#include "pagespeed/kernel/html/html_testing_peer.h"
#include "pagespeed/kernel/html/html_writer_filter.h"
using testing::UnorderedElementsAre;
namespace net_instaweb {
class HtmlParseTest : public HtmlParseTestBase {
protected:
// Returns the contents wrapped in a Div.
GoogleString Div(const StringPiece& text) {
return StrCat("<div>", text, "</div>");
}
// For tag-pairs that auto-close, we expect the appearance
// of tag2 to automatically close tag1.
void ExpectAutoClose(const char* tag1, const char* tag2) {
GoogleString test_case = StrCat("auto_close_", tag1, "_", tag2);
ValidateExpected(
test_case,
Div(StrCat("<", tag1, ">x<", tag2, ">y")),
Div(StrCat("<", tag1, ">x</", tag1, "><",
StrCat(tag2, ">y</", tag2, ">"))));
}
// For 2 tags that do not have a specified auto-close relationship,
// we expect the appearance of tag2 to nest inside tag1.
void ExpectNoAutoClose(const char* tag1, const char* tag2) {
GoogleString test_case = StrCat("no_auto_close_", tag1, "_", tag2);
ValidateExpected(
test_case,
Div(StrCat("<", tag1, ">x<", tag2, ">y")),
Div(StrCat("<", tag1, ">x<", tag2, ">y</",
StrCat(tag2, "></", tag1, ">"))));
}
virtual bool AddBody() const { return true; }
// Sends the input through the HtmlParse filter chain, flushing
// at flush_index. Leaves resulting output in output_buffer_.
void ParseWithFlush(StringPiece input, int flush_index) {
GoogleString this_id = StringPrintf("http://test.com/%d", flush_index);
output_buffer_.clear();
html_parse_.StartParse(this_id);
html_parse_.ParseText(input.substr(0, flush_index));
html_parse_.Flush();
html_parse_.ParseText(input.substr(flush_index));
html_parse_.FinishParse();
}
};
class HtmlParseTestNoBody : public HtmlParseTestBase {
virtual bool AddBody() const { return false; }
};
TEST_F(HtmlParseTest, AvoidFalseXmlComment) {
ValidateNoChanges("avoid_false_xml_comment",
"<script type=\"text/javascript\">\n"
"// <!-- this looks like a comment but is not\n"
"</script>");
}
TEST_F(HtmlParseTest, RetainBogusEndTag) {
ValidateNoChanges("bogus_end_tag",
"<script language=\"JavaScript\" type=\"text/javascript\">\n"
"<!--\n"
"var s = \"</retain_bogus_end_tag>\";\n"
"// -->\n"
"</script>");
}
TEST_F(HtmlParseTest, AmpersandInHref) {
// Note that we will escape the "&" in the href.
ValidateNoChanges("ampersand_in_href",
"<a href=\"http://myhost.com/path?arg1=val1&arg2=val2\">Hello</a>");
}
TEST_F(HtmlParseTest, BooleanSpaceCloseInTag) {
ValidateExpected("bool_space_close", "<a b >foo</a>", "<a b>foo</a>");
ValidateNoChanges("bool_close", "<a b>foo</a>");
ValidateExpected("space_close_sq", "<a b='c' >foo</a>", "<a b='c'>foo</a>");
ValidateExpected("space_close_dq",
"<a b=\"c\" >foo</a>", "<a b=\"c\">foo</a>");
ValidateExpected("space_close_nq", "<a b=c >foo</a>", "<a b=c>foo</a>");
// Distilled from http://www.gougou.com/
// Unclear exactly what we should do here, maybe leave it as it was without
// the space?
ValidateExpected("allow_semicolon",
"<a onclick='return m(this)'; >foo</a>",
"<a onclick='return m(this)' ;>foo</a>");
}
TEST_F(HtmlParseTest, EmbeddedNuls) {
const char kHtml[] = "<script att\0r></script>";
// Note: STATIC_STRLEN won't stop at embedded null.
ValidateNoChanges("inner_mess", GoogleString(kHtml, STATIC_STRLEN(kHtml)));
const char kHtml2[] = "<script\0y></script>";
// Note: STATIC_STRLEN won't stop at embedded null.
ValidateNoChanges("inner_mess2",
GoogleString(kHtml2, STATIC_STRLEN(kHtml2)));
}
class AttrValuesSaverFilter : public EmptyHtmlFilter {
public:
AttrValuesSaverFilter() { }
virtual void StartElement(HtmlElement* element) {
const HtmlElement::AttributeList& attrs = element->attributes();
for (HtmlElement::AttributeConstIterator i(attrs.begin());
i != attrs.end(); ++i) {
const char* value = i->DecodedValueOrNull();
if (i->decoding_error()) {
value_ += "<ERROR>";
} else if (value == NULL) {
value_ += "(null)";
} else {
value_ += value;
}
}
}
const GoogleString& value() { return value_; }
virtual const char* Name() const { return "attr_saver"; }
private:
GoogleString value_;
DISALLOW_COPY_AND_ASSIGN(AttrValuesSaverFilter);
};
TEST_F(HtmlParseTest, EscapedSingleQuote) {
AttrValuesSaverFilter attr_saver;
html_parse_.AddFilter(&attr_saver);
Parse("escaped_single_quote",
"<img src='my&#39;single_quoted_image.jpg'/>");
EXPECT_EQ("my'single_quoted_image.jpg", attr_saver.value());
}
TEST_F(HtmlParseTest, AttrDecodeError) {
AttrValuesSaverFilter attr_saver;
html_parse_.AddFilter(&attr_saver);
Parse("attr_not_decodable", "<img src='muñecos'/>");
EXPECT_EQ("<ERROR>", attr_saver.value());
}
TEST_F(HtmlParseTest, UnclosedQuote) {
// In this test, the system automatically closes the 'a' tag, which
// didn't really get closed in the input text. The exact syntax
// of the expected results not critical, as long as the parser recovers
// and does not crash.
//
// TODO(jmarantz): test error reporting.
ValidateNoChanges("unclosed_quote",
"<div>\n"
" <a href=\"http://myhost.com/path?arg1=val1&arg2=val2>Hello</a>\n"
"</div>\n"
"<p>next token</p>"
"</body></html>\n"
"\"></a></div>");
}
TEST_F(HtmlParseTest, NestedDivInBr) {
ValidateNoChanges("nested_div_in_br",
"<br><div>hello</div></br>");
}
// bug 2465145 - Sequential defaulted attribute tags lost
TEST_F(HtmlParseTest, SequentialDefaultedTagsLost) {
// This test cannot work with libxml, but since we use our own
// parser we can make it work. See
// https://bugzilla.gnome.org/show_bug.cgi?id=611655
ValidateNoChanges("sequential_defaulted_attribute_tags_lost",
"<select>\n"
" <option value=\"&amp;cat=244\">Other option</option>\n"
" <option value selected style=\"color: #ccc;\">Default option"
"</option>\n"
"</select>");
// Illegal attribute "http://www.yahoo.com", per HTML5, is two attributes:
// http: and "yahoo.com", with the slashes going into the ether.
// (This is also how Chrome and Firefox parse it.)
ValidateExpected(
"yahoo",
"<a href=\"#\" http://www.yahoo.com class=\"a b\">yahoo</a>",
"<a href=\"#\" http: www.yahoo.com class=\"a b\">yahoo</a>");
// Here's another interesting thing from the bug testcase.
// Specifying a literal "&" without a recognized sequence
// following it gets parsed correctly by libxml2, and then
// re-encoded by our writer as &amp;. That's fine; let's
// make sure that doesn't change.
ValidateNoChanges("amp_cat",
"<option value=\"&cat=244\">other</option>");
}
// bug 2465201 : some html constructs do not need ';' termination.
// Fixed by providing own lexer.
TEST_F(HtmlParseTest, UnterminatedTokens) {
// the termination semicolons should be added in the output.
ValidateNoChanges("unterminated_tokens",
"<p>Look at the non breaking space: \"&nbsp\"</p>");
}
// bug 2467040 : keep ampersands and quotes encoded
TEST_F(HtmlParseTest, EncodeAmpersandsAndQuotes) {
ValidateNoChanges("ampersands_in_text",
"<p>This should be a string '&amp;amp;' not a single ampersand.</p>");
ValidateNoChanges("ampersands_in_values",
"<img alt=\"This should be a string '&amp;amp;' "
"not a single ampersand.\"/>");
ValidateNoChanges("quotes",
"<p>Clicking <a href=\"javascript: alert(&quot;Alert works!&quot;);\">"
"here</a> should pop up an alert box.</p>");
}
// bug 2508334 : encoding unicode in general
TEST_F(HtmlParseTest, EncodeUnicode) {
ValidateNoChanges("unicode_in_text",
"<p>Non-breaking space: '&nbsp;'</p>\n"
"<p>Alpha: '&alpha;'</p>\n"
"<p>Unicode #54321: '&#54321;'</p>\n");
}
TEST_F(HtmlParseTest, ImplicitExplicitClose) {
// The lexer/printer preserves the input syntax, making it easier
// to diff inputs & outputs.
//
// TODO(jmarantz): But we can have a rewrite pass that eliminates
// the superfluous "/>".
ValidateNoChanges("one_brief_one_implicit_input",
"<input type=\"text\" name=\"username\">"
"<input type=\"password\" name=\"password\"/>");
}
TEST_F(HtmlParseTest, OpenBracketAfterQuote) {
// Note: even though it looks like two input elements, in practice
// it's parsed as one.
const char input[] =
"<input type=\"text\" name=\"username\""
"<input type=\"password\" name=\"password\"/>";
const char expected[] =
"<input type=\"text\" name=\"username\""
" <input type=\"password\" name=\"password\"/>";
// Extra space 'between' attributes'
ValidateExpected("open_bracket_after_quote", input, expected);
}
TEST_F(HtmlParseTest, OpenBracketUnquoted) {
// '<' after unquoted attr value.
// This is just a malformed attribute name, not a start of a new tag.
const char input[] =
"<input type=\"text\" name=username"
"<input type=\"password\" name=\"password\"/>";
ValidateNoChanges("open_bracket_unquoted", input);
}
TEST_F(HtmlParseTest, OpenBracketAfterEquals) {
// '<' after equals sign. This is actually an attribute value,
// not a start of a new tag.
const char input[] =
"<input type=\"text\" name="
"<input type=\"password\" name=\"password\"/>";
ValidateNoChanges("open_brack_after_equals", input);
}
TEST_F(HtmlParseTest, OpenBracketAfterName) {
// '<' after after attr name.
const char input[] =
"<input type=\"text\" name"
"<input type=\"password\" name=\"password\"/>";
ValidateNoChanges("open_brack_after_name", input);
}
class HtmlParseTestNoBodyNoHtml : public HtmlParseTestNoBody {
protected:
virtual bool AddHtmlTags() const { return false; }
void CheckOutput(int start_index, int end_index,
const GoogleString& input,
const GoogleString& expected_output) {
for (int i = start_index; i < end_index; ++i) {
SetupWriter();
html_parse()->set_size_limit(i);
html_parse()->StartParse("http://test.com/in.html");
// Flush after every character.
for (int j = 0; j < input.size(); ++j) {
GoogleString x;
x.push_back(input[j]);
html_parse()->ParseText(StringPiece(x));
html_parse()->Flush();
}
html_parse()->FinishParse();
EXPECT_EQ(expected_output, output_buffer_);
}
}
};
TEST_F(HtmlParseTestNoBodyNoHtml, SizeLimit) {
static const char input[] =
"<html>" // 6 chars
"<input type=\"text\"/>" // 20 chars
"<script type=\"text/javascript\">alert('123');</script>" // 53 chars
"<!--[if IE]>...<![endif]-->" // 27 chars
"<table><tr><td>blah</td></tr></table>" // 37 chars
"</html>"; // 7 chars
ValidateNoChanges("no_limit", input);
static const char output_when_break_in_html[] =
"<html></html>";
for (int i = 1; i < 150; ++i) {
// With no flushes, the output is just <html></html>
html_parse_.set_size_limit(i);
ValidateExpected("break_in_input", input,
output_when_break_in_html);
}
// Now test with flushes injected.
CheckOutput(1, 6, input, output_when_break_in_html);
static const char output_when_break_in_input[] =
"<html><input type=\"text\"/></html>";
CheckOutput(6, 26, input, output_when_break_in_input);
static const char output_with_break_in_script_tag[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\"></script>"
"</html>";
CheckOutput(26, 57, input, output_with_break_in_script_tag);
static const char output_with_break_in_script_text_or_later[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\">alert('123');</script>"
"</html>";
CheckOutput(57, 79, input, output_with_break_in_script_text_or_later);
static const char output_with_break_in_comment[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\">alert('123');</script>"
"<!--[if IE]>...<![endif]-->"
"<table></table>"
"</html>";
CheckOutput(79, 113, input, output_with_break_in_comment);
static const char output_with_break_in_tr[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\">alert('123');</script>"
"<!--[if IE]>...<![endif]-->"
"<table><tr></tr></table>"
"</html>";
CheckOutput(113, 117, input, output_with_break_in_tr);
static const char output_with_break_in_td[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\">alert('123');</script>"
"<!--[if IE]>...<![endif]-->"
"<table><tr><td></td></tr></table>"
"</html>";
CheckOutput(117, 121, input, output_with_break_in_td);
static const char output_with_break_in_td_text[] =
"<html><input type=\"text\"/>"
"<script type=\"text/javascript\">alert('123');</script>"
"<!--[if IE]>...<![endif]-->"
"<table><tr><td>blah</td></tr></table>"
"</html>";
CheckOutput(121, 160, input, output_with_break_in_td_text);
}
TEST_F(HtmlParseTest, OpenBracketAfterSpace) {
// '<' after after unquoted attr value. Here name<input is an attribute
// name.
const char input[] =
"<input type=\"text\" "
"<input type=\"password\" name=\"password\"/>";
ValidateNoChanges("open_brack_after_name", input);
}
TEST_F(HtmlParseTest, AutoClose) {
ExplicitCloseTag close_tags;
html_parse_.AddFilter(&close_tags);
// Cover the simple cases. E.g. dd is closed by tr, but not dd.
ExpectNoAutoClose("dd", "tr");
ExpectAutoClose("dd", "dd");
ExpectAutoClose("dt", "dd");
ExpectAutoClose("dt", "dt");
ExpectNoAutoClose("dt", "rp");
ExpectAutoClose("li", "li");
ExpectNoAutoClose("li", "dt");
ExpectAutoClose("optgroup", "optgroup");
ExpectNoAutoClose("optgroup", "rp");
ExpectAutoClose("option", "optgroup");
ExpectAutoClose("option", "option");
ExpectNoAutoClose("option", "rp");
// <p> has an outrageous number of tags that auto-close it.
ExpectNoAutoClose("p", "tr"); // tr is not listed in the auto-closers for p.
ExpectAutoClose("p", "address"); // first closer of 28.
ExpectAutoClose("p", "h2"); // middle closer of 28.
ExpectAutoClose("p", "ul"); // last closer of 28.
// Cover the remainder of the cases.
ExpectAutoClose("rp", "rt");
ExpectAutoClose("rp", "rp");
ExpectNoAutoClose("rp", "dd");
ExpectAutoClose("rt", "rt");
ExpectAutoClose("rt", "rp");
ExpectNoAutoClose("rt", "dd");
ExpectAutoClose("tbody", "tbody");
ExpectAutoClose("tbody", "tfoot");
ExpectNoAutoClose("tbody", "dd");
ExpectAutoClose("td", "td");
ExpectAutoClose("td", "th");
ExpectNoAutoClose("td", "rt");
ExpectAutoClose("tfoot", "tbody");
ExpectNoAutoClose("tfoot", "dd");
ExpectAutoClose("th", "td");
ExpectAutoClose("th", "th");
ExpectNoAutoClose("th", "rt");
ExpectAutoClose("thead", "tbody");
ExpectAutoClose("thead", "tfoot");
ExpectNoAutoClose("thead", "dd");
ExpectAutoClose("tr", "tr");
ExpectNoAutoClose("tr", "td");
// http://www.w3.org/TR/html5/the-end.html#misnested-tags:-b-i-b-i
// TODO(jmarantz): add more tests related to formatting keywords.
}
TEST_F(HtmlParseTest, BogusComment) {
ValidateNoChanges("what_php",
"<?php include('includes/_pagebottom.tpl.php'); ?>");
ValidateNoChanges("bad break", "</\na>");
}
namespace {
class AnnotatingHtmlFilter : public EmptyHtmlFilter {
public:
AnnotatingHtmlFilter() : annotate_flush_(false) {}
virtual ~AnnotatingHtmlFilter() {}
virtual void StartElement(HtmlElement* element) {
StrAppend(&buffer_, (buffer_.empty() ? "+" : " +"), element->name_str());
bool first = true;
const HtmlElement::AttributeList& attrs = element->attributes();
for (HtmlElement::AttributeConstIterator i(attrs.begin());
i != attrs.end(); ++i) {
const HtmlElement::Attribute& attr = *i;
StrAppend(&buffer_, (first ? ":" : ","), attr.name_str());
const char* value = attr.DecodedValueOrNull();
if (attr.decoding_error()) {
StrAppend(&buffer_, "=<ERROR>");
} else if (value != NULL) {
StrAppend(&buffer_, "=", attr.quote_str(), value, attr.quote_str());
}
first = false;
}
}
virtual void EndElement(HtmlElement* element) {
StrAppend(&buffer_, " -", element->name_str());
switch (element->style()) {
case HtmlElement::AUTO_CLOSE: buffer_ += "(a)"; break;
case HtmlElement::IMPLICIT_CLOSE: buffer_ += "(i)"; break;
case HtmlElement::EXPLICIT_CLOSE: buffer_ += "(e)"; break;
case HtmlElement::BRIEF_CLOSE: buffer_ += "(b)"; break;
case HtmlElement::UNCLOSED: buffer_ += "(u)"; break;
case HtmlElement::INVISIBLE: buffer_ += "(I)"; break;
}
}
virtual void Characters(HtmlCharactersNode* characters) {
StrAppend(&buffer_, (buffer_.empty() ? "'" : " '"), characters->contents(),
"'");
}
virtual const char* Name() const { return "AnnotatingHtmlFilter"; }
const GoogleString& buffer() const { return buffer_; }
void Clear() { buffer_.clear(); }
virtual void Flush() {
if (annotate_flush_) {
buffer_ += "[F]";
}
}
void set_annotate_flush(bool x) { annotate_flush_ = x; }
private:
bool annotate_flush_;
GoogleString buffer_;
};
} // namespace
class HtmlAnnotationTest : public HtmlParseTestNoBody {
protected:
virtual void SetUp() {
HtmlParseTestNoBody::SetUp();
html_parse_.AddFilter(&annotation_);
}
const GoogleString& annotation() { return annotation_.buffer(); }
void ResetAnnotation() { annotation_.Clear(); }
virtual bool AddHtmlTags() const { return false; }
protected:
AnnotatingHtmlFilter annotation_;
};
TEST_F(HtmlAnnotationTest, CorrectTaggify) {
// Under HTML5 rules (and recent Chrome and FF practice), something like
// <foo</bar> makes an element named foo<, with attribute named bar.
// (See 12.2.4.10 Tag name state).
//
// However, we have to be careful not to turn just anything following <
// into an element name, since sometimes there are <'s which are
// meant to just be less than signs.
//
ValidateNoChanges("no_taggify_digit", "<p>1<2</p>");
EXPECT_EQ("+p '1<2' -p(e)", annotation());
ResetAnnotation();
ValidateNoChanges("no_taggify_unicode", "<p>☃<☕</p>");
EXPECT_EQ("+p '☃<☕' -p(e)", annotation());
ResetAnnotation();
ValidateExpected("letter",
"<p>x<y</p>", "<p>x<y< p>"); // lost the / since 'p' is attr.
EXPECT_EQ("+p 'x' +y<:p -y<(u) -p(u)", annotation());
ResetAnnotation();
ValidateExpected("taggify_letter+digit",
"<p>x1<y2</p>", "<p>x1<y2< p>");
EXPECT_EQ("+p 'x1' +y2<:p -y2<(u) -p(u)", annotation());
ResetAnnotation();
ValidateExpected("taggify_letter+unicode", "<p>x☃<y☕</p>",
"<p>x☃<y☕< p>"); // no / since p is attr on a y☕< element.
EXPECT_EQ("+p 'x☃' +y☕<:p -y☕<(u) -p(u)", annotation());
ResetAnnotation();
ValidateNoChanges("no_taggify_digit+letter", "<p>1x<2y</p>");
EXPECT_EQ("+p '1x<2y' -p(e)", annotation());
ResetAnnotation();
ValidateNoChanges("no_taggify_unicode+letter", "<p>☃x<☕y</p>");
EXPECT_EQ("+p '☃x<☕y' -p(e)", annotation());
ResetAnnotation();
// Found on http://www.taobao.com/
// Don't turn <1... -> <1...>
ValidateNoChanges("taobao", "<a>1+1<1母婴全场加1元超值购</a>");
EXPECT_EQ("+a '1+1<1母婴全场加1元超值购' -a(e)", annotation());
ResetAnnotation();
}
TEST_F(HtmlAnnotationTest, WeirdAttributes) {
// Just about everything can be an attribute
ValidateNoChanges("weird_attr", "<a ,=\"foo\">");
EXPECT_EQ("+a:,=\"foo\" -a(u)", annotation());
ResetAnnotation();
// ... even an equal sign
ValidateNoChanges("weird_attr_equal", "<a ==\"foo\">");
EXPECT_EQ("+a:==\"foo\" -a(u)", annotation());
ResetAnnotation();
}
TEST_F(HtmlAnnotationTest, WeirdCloseCase) {
// </> is nothing useful, but we preserve it as a literal.
ValidateNoChanges("close_nothing", "</><foo>");
EXPECT_EQ("'</>' +foo -foo(u)", annotation());
ResetAnnotation();
// <foo / > isn't an attempt at self-close, it just has a stray /
// we can't represent.
ValidateExpected("not_self_close", "<foo / >", "<foo>");
EXPECT_EQ("+foo -foo(u)", annotation());
ResetAnnotation();
// <foo /> is a self-close.
ValidateExpected("self_close", "<foo />", "<foo/>");
EXPECT_EQ("+foo -foo(b)", annotation());
ResetAnnotation();
}
TEST_F(HtmlAnnotationTest, UnbalancedMarkup) {
// The second 'tr' closes the first one, and our HtmlWriter will not
// implicitly close 'tr' because IsImplicitlyClosedTag is false, so
// the markup is changed to add the missing tr.
ValidateNoChanges("unbalanced_markup",
"<font><tr><i><font></i></font><tr></font>");
// We use this (hopefully) self-explanatory annotation format to indicate
// what's going on in the parse.
EXPECT_EQ("+font -font(a) +tr +i +font -font(u) -i(e) '</font>' -tr(a) +tr "
"'</font>' -tr(u)",
annotation());
}
TEST_F(HtmlAnnotationTest, StrayCloseTr) {
ValidateNoChanges("stray_tr",
"<table><tr><table></tr></table></tr></table>");
// We use this (hopefully) self-explanatory annotation format to indicate
// what's going on in the parse.
EXPECT_EQ("+table +tr +table '</tr>' -table(e) -tr(e) -table(e)",
annotation());
}
TEST_F(HtmlAnnotationTest, IClosedByOpenTr) {
ValidateNoChanges("unclosed_i_tag", "<tr><i>a<tr>b");
EXPECT_EQ("+tr +i 'a' -i(a) -tr(a) +tr 'b' -tr(u)", annotation());
// TODO(jmarantz): morlovich points out that this is nowhere near
// how a browser will handle this stuff... For a nighmarish testcase, try:
// data:text/html,<table><tr><td><i>a<tr>b
//
// The 'a' gets rendered in italics *after* the b.
//
// See also:
// http://www.whatwg.org/specs/web-apps/current-work/multipage/
// the-end.html#unexpected-markup-in-tables
//
// But note that these 2 are the same and do what I expect:
//
// data:text/html,<table><tr><td><i>a</td></tr></table>b
// data:text/html,<table><tr><td><i>a</table>b
//
// the 'a' is italicized but the 'b' is not. If I omit the 'td'
// then the 'b' gets italicized. This implies I suppose that 'i' is
// closed by td but is not closed by tr or table. And it is indeed
// closed by the *implicit* closing of td.
// http://www.w3.org/TR/html5/the-end.html#misnested-tags:-b-i-b-i
}
TEST_F(HtmlAnnotationTest, INotClosedByOpenTableExplicit) {
ValidateNoChanges("explicit_close_tr", "<i>a<table><tr></tr></table>b");
EXPECT_EQ("+i 'a' +table +tr -tr(e) -table(e) 'b' -i(u)", annotation());
}
TEST_F(HtmlAnnotationTest, INotClosedByOpenTableImplicit) {
ValidateNoChanges("implicit_close_tr", "<i>a<table><tr></table>b");
EXPECT_EQ("+i 'a' +table +tr -tr(u) -table(e) 'b' -i(u)", annotation());
}
TEST_F(HtmlAnnotationTest, AClosedByBInLi) {
ValidateNoChanges("a_closed_by_b", "<li><a href='x'></b>");
EXPECT_EQ("+li +a:href='x' '</b>' -a(u) -li(u)", annotation());
}
TEST_F(HtmlAnnotationTest, BClosedByTd) {
ValidateNoChanges("b_closed_by_td", "<table><tr><td><b>1</table></b>");
// The <b> gets closed by the </td>, which is automatically closed by
// the td, which is automatically closed by the tr, which is automatically
// closed by the tbody, which is automatically closed by the "</table>".
// The actual "</b>" that appears here doesn't close any open tags, so
// its rendered as literal characters.
//
// TODO(jmarantz): consider adding a new event-type to represent bogus
// tags rather than using Characters.
EXPECT_EQ("+table +tr +td +b '1' -b(u) -td(u) -tr(u) -table(e) '</b>'",
annotation());
}
TEST_F(HtmlAnnotationTest, BNotClosedByTable) {
ValidateNoChanges(
"a_closed_by_b",
"<table><tbody><tr><b><td>hello</tr></tbody></table>World</b>");
// We do not create the same annotation Chrome does in this case. Opening up
// the inspector on
// data:text/html,<table><tbody><tr><b><td>hello</tr></tbody></table>World</b>
// shows us (ignoring html, head, and body tags for brevity):
// <b></b>
// <table>
// <tbody>
// <tr>
// <td>hello</td>
// </td>
// </tbody>
// </table>
// <b>World</b>
// For us to replicate this structure, we'd have to move the 'b' tag ahead of
// the <table> opening tag. To do this we would need to buffer tables until
// they reached the end-table tag. This does not appear to be a good
// tradeoff as tables might be large and buffering them would impact
// the UX for all sites, as a defense against bad markup and filters that
// care deeply about the structure of formatting elements in illegal DOM
// positions.
//
// But note that this malformed markup will in fact pass through
// parsing & serialization with byte accuracy.
}
TEST_F(HtmlAnnotationTest, StrayCloseTrInTable) {
ValidateNoChanges("stray_close_tr",
"<div><table><tbody><td>1</td></tr></tbody></table></div>");
EXPECT_EQ("+div +table +tbody +td '1' -td(e) '</tr>' -tbody(e) -table(e) "
"-div(e)", annotation());
}
TEST_F(HtmlAnnotationTest, StrayCloseTrInTableWithUnclosedTd) {
ValidateNoChanges("stray_close_tr_unclosed_td",
"<tr><table><td>1</tr></table>");
EXPECT_EQ("+tr +table +td '1</tr>' -td(u) -table(e) -tr(u)", annotation());
// TODO(jmarantz): the above is not quite DOM-accurate. A 'tr' will
// actually be synthesized around the <td>. To solve this and
// maintain byte accuracy we must synthesize an HtmlElement whose
// opening-tag is invisible, and create a map that requires <td>
// elements to be enclosed in <tr> etc. See, in Chrome,
// data:text/html,<tr><table><td>1</tr></table>
}
TEST_F(HtmlAnnotationTest, OverlappingStyleTags) {
ValidateNoChanges("overlapping_style_tags", "n<b>b<i>bi</b>i</i>n");
// TODO(jmarantz): The behavior of this sequence is well-specified, but
// is not currently implemented by PSA. We should have
// EXPECT_EQ("'n' +b 'b' +i 'bi' -i(u) -b(e) +i* 'i' -i(e) 'n'",
// annotation());
// Note that we will need to render a synthetic <i> that shows up in our
// DOM tree but does not get serialized. We have no current representation
// for that, but we could easily add a bool to HtmlElement to suppress the
// serialization of the open tag. Above that's represented by "+i*".
//
// But we actually get this, which does not have the 'i' in italics.
EXPECT_EQ("'n' +b 'b' +i 'bi' -i(u) -b(e) 'i</i>n'", annotation());
// There is no real drawback to implementing this; but at the moment
// no filters are likely to care.
}
TEST_F(HtmlAnnotationTest, AClosedByP) {
ValidateNoChanges("a_closed_by_p", "<P>This is a <A>link<P>More");
// According to Chrome("data:text/html,<P>This is a <A>link<P>More") the
// structure should be something like this:
// "+p 'This is a' +a link -a -p +p +a more -a -p"
// In this fashion a&p overlap together in a fashion similar to bold and
// italic.
//
// But we actually product this markup:
EXPECT_EQ("+P 'This is a ' +A 'link' +P 'More' -P(u) -A(u) -P(u)",
annotation());
}
TEST_F(HtmlAnnotationTest, PFont) {
ValidateNoChanges("p_font", "<P><FONT>a<P>b</FONT>");
// TODO(jmarantz): The second <P> should force the close of
// the first one, despite the intervening <font>. In other words
// we need to keep track of which formatting elements are active:
// <p> does not nest but I suppose <font> likely does.
//
// Chrome("data:text/html,<P><FONT>a<P>b</FONT>") yields
// "<p><font>a</font</p><p><font><b></font></p>"
EXPECT_EQ("+P +FONT 'a' +P 'b' -P(u) -FONT(e) -P(u)", annotation());
}
TEST_F(HtmlAnnotationTest, HtmlTbodyCol) {
// The spaces before the tag names are invalid. Chrome parses these as
// literals; our behavior is consistent.
ValidateNoChanges("html_tbody_col", "< HTML> < TBODY> < COL SPAN=999999999>");
EXPECT_EQ("'< HTML> < TBODY> < COL SPAN=999999999>'", annotation());
}
TEST_F(HtmlAnnotationTest, WeirdAttrQuotes) {
// Note that in the expected results, a space was inserted before
// 'position:absolute' and before 'Windings'. I think this is correct.
//
// TODO(jmarantz): check in Chrome.
ValidateExpected("weird_attr_quotes",
"<DIV STYLE=\"top:214px; left:139px;\""
"position:absolute; font-size:26px;\">"
"<NOBR><SPAN STYLE=\"font-family:\"Wingdings 2\";\">"
"</SPAN></NOBR></DIV>",
"<DIV STYLE=\"top:214px; left:139px;\" "
"position:absolute; font-size:26px;\">"
"<NOBR><SPAN STYLE=\"font-family:\" Wingdings 2\";\">"
"</SPAN></NOBR></DIV>");
EXPECT_EQ("+DIV:STYLE=\"top:214px; left:139px;\",position:absolute;,"
"font-size:26px;\" +NOBR "
"+SPAN:STYLE=\"font-family:\",Wingdings,2\";\" "
"-SPAN(e) -NOBR(e) -DIV(e)", annotation());
}
TEST_F(HtmlAnnotationTest, Misc) {
//
// 1. This is <B>bold, <I>bold italic, </b>italic, </i>normal text
// 2. <P>This is a <A>link<P>More
// 3. <P><FONT>a<P>b</FONT>
// 7. <img title=="><script>alert('foo')</script>">
// 8. < HTML> < TBODY> < COL SPAN=999999999>
// 9. <DIV STYLE="top:214px; left:139px; position:absolute; font-size:26px;">
// <NOBR><SPAN STYLE="font-family:"Wingdings 2";"></SPAN></NOBR></DIV>
// 10. <a href="http://www.cnn.com/"' title="cnn.com">cnn</a>
// 11. do <![if !supportLists]>not<![endif]> lose this text
// 12. <table><tr><td>row1<tr><td>row2</td>
// 13. <table><tr><td>foo<td>bar<tr><td>baz<td>boo</table>
// 14. <p>The quick <strong>brown fox</strong></p>\njumped over the\n
// <p>lazy</strong> dog.</p>
// 15. <p> paragraph <h1> heading </h1>
// 16. <a href="h">1<a>2</a></a>
ValidateNoChanges("quote_balance", "<img title=\"><script>alert('foo')"
"</script>\">");
EXPECT_EQ("+img:title=\"><script>alert('foo')</script>\" -img(i)",
annotation());
}
TEST_F(HtmlAnnotationTest, DoubleEquals) {
// Note that the attr-value is not in fact a quoted string. The second
// "=" begins the attr-value and its terminated by the ">". The script
// is not in the quote. The closing quote and > are stray and rendered
// as characters in our DOM. We are byte accurate. This behavior
// was hand-confirmed as consistent with Chrome by typing
// data:text/html,<img title=="><script>alert('foo')</script>">
// into the URL bar on 12/13/2011. The "alert" popped up which is
// consistent with the dom annotation below.
ValidateNoChanges("double_equals",
"<img title==\"><script>alert('foo')</script>\">");
EXPECT_EQ("+img:title==\" -img(i) +script 'alert('foo')' -script(e) '\">'",
annotation());
}
TEST_F(HtmlAnnotationTest, AttrEqStartWithSlash) {
// Note the "/>" here does *not* briefly end the 'body'; it's part of the
// attribute. Verified with chrome using
// data:text/html,<body title=/>hello</body>
ValidateNoChanges("attr_eq_starts_with_slash", "<body title=/>1</body>");
EXPECT_EQ("+body:title=/ '1' -body(e)", annotation());
}
TEST_F(HtmlAnnotationTest, AttrEqEndsWithSlash) {
// Note again the "/>" here does *not* briefly end the 'body'; it's part of
// the attribute. Verified with chrome using
// data:text/html,<body title=x/>hello</body>
ValidateNoChanges("attr_eq_ends_with_slash", "<body title=x/></body>");
EXPECT_EQ("+body:title=x/ -body(e)", annotation());
}
TEST_F(HtmlAnnotationTest, TableForm) {
ValidateNoChanges("table_form", "<table><form><input></table><input></form>");
EXPECT_EQ("+table +form +input -input(i) -form(u) -table(e)"
" +input -input(i) '</form>'",
annotation());
}
TEST_F(HtmlAnnotationTest, ComplexQuotedAttribute) {
ValidateNoChanges("complex_quoted_attr",
"<div x='\\'><img onload=alert(42)"
"src=http://json.org/img/json160.gif>'></div>");
EXPECT_EQ("+div:x='\\' "
"+img:onload=alert(42)src=http://json.org/img/json160.gif "
"-img(i) ''>' -div(e)", annotation());
}
TEST_F(HtmlAnnotationTest, DivNbsp) {
ValidateNoChanges("div_nbsp",
"<div&nbsp &nbsp style=\\-\\mo\\z\\-b\\i\\nd\\in\\g:\\url("
"//business\\i\\nfo.co.uk\\/labs\\/xbl\\/xbl\\.xml\\#xss)"
">");
EXPECT_EQ("'<div&nbsp &nbsp style=\\-\\mo\\z\\-b\\i\\nd\\in\\g:\\"
"url(//business\\i\\nfo.co.uk\\/labs\\/xbl\\/xbl\\.xml\\#xss)>'",
annotation());
}
TEST_F(HtmlAnnotationTest, ExtraQuote) {
ValidateExpected(
"extra_quote",
"<a href=\"http://www.cnn.com/\"' title=\"cnn.com\">cnn</a>",
"<a href=\"http://www.cnn.com/\" ' title=\"cnn.com\">cnn</a>");
}
TEST_F(HtmlAnnotationTest, TrNesting) {
ValidateNoChanges("nesting", "<tr><td><tr a=b><td c=d></td></tr>");
EXPECT_EQ("+tr +td -td(a) -tr(a) +tr:a=b +td:c=d -td(e) -tr(e)",
annotation());
}
TEST_F(HtmlAnnotationTest, AttrEndingWithOpenAngle) {
ValidateNoChanges("weird_attr", "<script src=foo<bar>Content");
EXPECT_EQ("+script:src=foo<bar 'Content' -script(u)", annotation());
}
TEST_F(HtmlAnnotationTest, ScriptQuirkBasic) {
ValidateNoChanges("script_quirk_1",
"<script><!--<script></script>a</script>b");
EXPECT_EQ("+script '<!--<script></script>a' -script(e) 'b'", annotation());
ResetAnnotation();
ValidateNoChanges("script_quirk_2",
"<script><!--</script>a</script>b");
EXPECT_EQ("+script '<!--' -script(e) 'a</script>b'", annotation());
ResetAnnotation();
ValidateNoChanges("script_quirk_3",
"<script><script></script>a</script>b");
EXPECT_EQ("+script '<script>' -script(e) 'a</script>b'", annotation());
ResetAnnotation();
ValidateNoChanges("script_quirk_4",
"<script><!--<script>--></script>a</script>b");
EXPECT_EQ("+script '<!--<script>-->' -script(e) 'a</script>b'", annotation());
}
TEST_F(HtmlAnnotationTest, ScriptQuirkCloseAttr) {
// HTML5 script parsing is weird in that </script> actually gets attribute
// parsing.
ValidateExpected("script_quirk_close",
"<script></script a=\"foo>\">Bar",
"<script></script>Bar");
EXPECT_EQ("+script -script(e) 'Bar'", annotation());
ResetAnnotation();
ValidateExpected("script_quirk_close2",
"<script></script a=\"foo>\" bar=\'>' bax>Bar",
"<script></script>Bar");
EXPECT_EQ("+script -script(e) 'Bar'", annotation());
ResetAnnotation();
ValidateExpected("script_quirk_close_slash",
"<script></script a=\"foo>\"/>Bar",
"<script></script>Bar");
EXPECT_EQ("+script -script(e) 'Bar'", annotation());
}
TEST_F(HtmlAnnotationTest, ScriptQuirkBriefClose) {
// HTML5 script parsing --- closing </style />
ValidateExpected("script_quirk_close_brief",
"<script></script/>Bar",
"<script></script>Bar");
EXPECT_EQ("+script -script(e) 'Bar'", annotation());
ResetAnnotation();
ValidateExpected("script_quirk_close_brief",
"<script></script /foo>Bar",
"<script></script>Bar");
EXPECT_EQ("+script -script(e) 'Bar'", annotation());
}
// TODO(jmarantz): fix this case; we lose the stray "=".
// TEST_F(HtmlAnnotationTest, StrayEq) {
// ValidateNoChanges("stray_eq", "<a href='foo.html'=>b</a>");
// EXPECT_EQ("+a:href=foo.html -a(e)", annotation());
// }
TEST_F(HtmlAnnotationTest, FlushDoesNotBreakCharacterBlock) {
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<div></div>"); // will get flushed.
html_parse_.ParseText("bytes:"); // will not get flushed till the end.
html_parse_.Flush();
html_parse_.ParseText(":more:");
html_parse_.Flush();
html_parse_.ParseText(":still more:");
html_parse_.Flush();
html_parse_.ParseText(":final bytes:");
html_parse_.FinishParse();
EXPECT_STREQ(
"+div -div(e)[F][F][F] 'bytes::more::still more::final bytes:'[F]",
annotation());
}
TEST_F(HtmlAnnotationTest, FlushDoesNotBreakScriptTag) {
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<script>");
html_parse_.Flush();
html_parse_.ParseText("a=b;");
html_parse_.Flush();
html_parse_.ParseText("c=d;");
html_parse_.Flush();
html_parse_.ParseText("</scr");
html_parse_.Flush();
html_parse_.ParseText("ipt><script>");
html_parse_.Flush();
html_parse_.ParseText("e=f;");
html_parse_.Flush();
html_parse_.ParseText("g=h;");
// No explicit </script> but the lexer will help us close it.
html_parse_.FinishParse();
EXPECT_STREQ("[F][F][F][F] +script 'a=b;c=d;' -script(e)[F][F]"
" +script 'e=f;g=h;' -script(u)[F]", // "(u)" for unclosed.
annotation());
}
TEST_F(HtmlAnnotationTest, FlushDoesNotBreakScriptTagWithComment) {
SetupWriter();
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<script>");
html_parse_.InsertComment("c1");
html_parse_.Flush();
html_parse_.ParseText("a=b;");
html_parse_.Flush();
html_parse_.ParseText("</script><script>");
html_parse_.InsertComment("c2");
html_parse_.Flush();
html_parse_.ParseText("</script>");
html_parse_.FinishParse();
EXPECT_STREQ("[F][F] +script 'a=b;' -script(e)[F] +script -script(e)[F]",
annotation());
EXPECT_STREQ("<!--c1--><script>a=b;</script><!--c2--><script></script>",
output_buffer_);
}
TEST_F(HtmlAnnotationTest, FlushDoesNotBreakStyleTag) {
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<style>");
html_parse_.Flush();
html_parse_.ParseText(".blue {color: ");
html_parse_.Flush();
html_parse_.ParseText("blue;}");
html_parse_.Flush();
html_parse_.ParseText("</style>");
html_parse_.FinishParse();
EXPECT_STREQ("[F][F][F] +style '.blue {color: blue;}' -style(e)[F]",
annotation());
}
TEST_F(HtmlAnnotationTest, UnclosedScriptOnly) {
SetupWriter();
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<script>");
html_parse_.FinishParse();
// Note that we will get an EndElement callback. See -script(u) in annotation.
// However we will not insert a </script> in the output, since there was none
// in the input.
EXPECT_STREQ("+script -script(u)[F]", annotation());
EXPECT_STREQ("<script>", output_buffer_);
}
TEST_F(HtmlAnnotationTest, UnclosedScriptOnlyWithFlush) {
SetupWriter();
annotation_.set_annotate_flush(true);
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<script>");
html_parse_.Flush();
html_parse_.FinishParse();
// Note that we will get an EndElement callback. See -script(u) in annotation.
// However we will not insert a </script> in the output, since there was none
// in the input.
EXPECT_STREQ("[F] +script -script(u)[F]", annotation());
EXPECT_STREQ("<script>", output_buffer_);
}
TEST_F(HtmlAnnotationTest, NulInAttrName) {
// Tests that we don't crash with an embedded NUL in an attribute name.
SetupWriter();
html_parse_.StartParse("http://test.com/nul_in_attr.html");
html_parse_.ParseText("<img src");
html_parse_.ParseText(StringPiece("\0", 1));
html_parse_.ParseText("file:-1675375991 />");
html_parse_.FinishParse();
}
TEST_F(HtmlParseTest, MakeName) {
EXPECT_EQ(0, HtmlTestingPeer::symbol_table_size(&html_parse_));
// Empty names are a corner case that we hope does not crash. Note
// that empty-string atoms are special-cased in the symbol table
// and require no new allocated bytes.
{
HtmlName empty = html_parse_.MakeName("");
EXPECT_EQ(0, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kNotAKeyword, empty.keyword());
EXPECT_EQ("", empty.value());
}
// When we make a name using its enum, there should be no symbol table growth.
HtmlName body_symbol = html_parse_.MakeName(HtmlName::kBody);
EXPECT_EQ(0, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kBody, body_symbol.keyword());
// When we make a name using the canonical form (all-lower-case) there
// should still be no symbol table growth.
HtmlName body_canonical = html_parse_.MakeName("body");
EXPECT_EQ(0, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kBody, body_canonical.keyword());
// But when we introduce a new capitalization, we want to retain the
// case, even though we do html keyword matching. We will have to
// store the new form in the symbol table so we'll be allocating
// some bytes, including the nul terminator.
HtmlName body_new_capitalization = html_parse_.MakeName("Body");
EXPECT_EQ(4, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kBody, body_new_capitalization.keyword());
// Make a name out of something that is not a keyword.
// This should also increase the symbol-table size.
HtmlName non_keyword = html_parse_.MakeName("hiybbprqag");
EXPECT_EQ(14, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kNotAKeyword, non_keyword.keyword());
// Empty names are a corner case that we hope does not crash. Note
// that empty-string atoms are special-cased in the symbol table
// and require no new allocated bytes.
{
HtmlName empty = html_parse_.MakeName("");
EXPECT_EQ(14, HtmlTestingPeer::symbol_table_size(&html_parse_));
EXPECT_EQ(HtmlName::kNotAKeyword, empty.keyword());
EXPECT_EQ("", empty.value());
}
}
// bug 2508140 : <noscript> in <head>
TEST_F(HtmlParseTestNoBody, NoscriptInHead) {
// Some real websites (ex: google.com) have <noscript> in the <head> even
// though this is technically illegal according to the HTML4 spec.
// We should support the case in use.
ValidateNoChanges("noscript_in_head",
"<head><noscript><title>You don't have JS enabled :(</title>"
"</noscript></head>");
}
TEST_F(HtmlParseTestNoBody, NoCaseFold) {
// Case folding is off by default. However, we don't keep the
// closing-tag separate in the IR so we will always make that
// match.
ValidateExpected("no_case_fold",
"<DiV><Other xY='AbC' Href='dEf'>Hello</OTHER></diV>",
"<DiV><Other xY='AbC' Href='dEf'>Hello</Other></DiV>");
// Despite the fact that we retain case, in our IR, and the cases did not
// match between opening and closing tags, there should be no messages
// warning about unmatched tags.
EXPECT_EQ(0, message_handler_.TotalMessages());
}
TEST_F(HtmlParseTestNoBody, CaseFold) {
SetupWriter();
html_writer_filter_->set_case_fold(true);
ValidateExpected("case_fold",
"<DiV><Other xY='AbC' Href='dEf'>Hello</OTHER></diV>",
"<div><other xy='AbC' href='dEf'>Hello</other></div>");
}
// Bool that is auto-initialized to false
class Bool {
public:
Bool() : value_(false) {}
Bool(bool value) : value_(value) {} // Copy constructor // NOLINT
const bool Test() const { return value_; }
private:
bool value_;
};
// Class simply keeps track of which handlers have been called.
class HandlerCalledFilter : public HtmlFilter {
public:
HandlerCalledFilter() : enabled_value_(true) {}
virtual void StartDocument() { called_start_document_ = true; }
virtual void EndDocument() { called_end_document_ = true;}
virtual void StartElement(HtmlElement* element) {
called_start_element_ = true;
}
virtual void EndElement(HtmlElement* element) {
called_end_element_ = true;
}
virtual void Cdata(HtmlCdataNode* cdata) { called_cdata_ = true; }
virtual void Comment(HtmlCommentNode* comment) { called_comment_ = true; }
virtual void IEDirective(HtmlIEDirectiveNode* directive) {
called_ie_directive_ = true;
}
virtual void Characters(HtmlCharactersNode* characters) {
called_characters_ = true;
}
virtual void Directive(HtmlDirectiveNode* directive) {
called_directive_ = true;
}
virtual void Flush() { called_flush_ = true; }
virtual void DetermineEnabled(GoogleString* disabled_reason) {
set_is_enabled(enabled_value_);
}
virtual bool CanModifyUrls() { return false; }
void SetEnabled(bool enabled_value) {
enabled_value_ = enabled_value;
}
virtual const char* Name() const { return "HandlerCalled"; }
Bool called_start_document_;
Bool called_end_document_;
Bool called_start_element_;
Bool called_end_element_;
Bool called_cdata_;
Bool called_comment_;
Bool called_ie_directive_;
Bool called_characters_;
Bool called_directive_;
Bool called_flush_;
private:
bool enabled_value_;
DISALLOW_COPY_AND_ASSIGN(HandlerCalledFilter);
};
class HandlerCalledTest : public HtmlParseTest {
protected:
HandlerCalledTest() {
html_parse_.AddFilter(&handler_called_filter_);
first_event_listener_ = new HandlerCalledFilter();
second_event_listener_ = new HandlerCalledFilter();
html_parse_.add_event_listener(first_event_listener_);
html_parse_.add_event_listener(second_event_listener_);
}
HandlerCalledFilter handler_called_filter_;
HandlerCalledFilter* first_event_listener_;
HandlerCalledFilter* second_event_listener_;
private:
DISALLOW_COPY_AND_ASSIGN(HandlerCalledTest);
};
// Check that StartDocument and EndDocument were called for filters.
TEST_F(HandlerCalledTest, StartEndDocumentCalled) {
Parse("start_end_document_called", "");
EXPECT_TRUE(handler_called_filter_.called_start_document_.Test());
EXPECT_TRUE(handler_called_filter_.called_end_document_.Test());
EXPECT_TRUE(first_event_listener_->called_start_document_.Test());
EXPECT_TRUE(first_event_listener_->called_end_document_.Test());
EXPECT_TRUE(second_event_listener_->called_start_document_.Test());
EXPECT_TRUE(second_event_listener_->called_end_document_.Test());
}
// Check that StartDocument and EndDocument were called for filters.
TEST_F(HandlerCalledTest, StartEndDocumentWithFilterDisabled) {
handler_called_filter_.SetEnabled(false);
Parse("start_end_document_called", "");
EXPECT_FALSE(handler_called_filter_.called_start_document_.Test());
EXPECT_FALSE(handler_called_filter_.called_end_document_.Test());
EXPECT_TRUE(first_event_listener_->called_start_document_.Test());
EXPECT_TRUE(first_event_listener_->called_end_document_.Test());
EXPECT_TRUE(second_event_listener_->called_start_document_.Test());
EXPECT_TRUE(second_event_listener_->called_end_document_.Test());
handler_called_filter_.SetEnabled(true);
Parse("start_end_document_called", "");
EXPECT_TRUE(handler_called_filter_.called_start_document_.Test());
EXPECT_TRUE(handler_called_filter_.called_end_document_.Test());
EXPECT_TRUE(first_event_listener_->called_start_document_.Test());
EXPECT_TRUE(first_event_listener_->called_end_document_.Test());
EXPECT_TRUE(second_event_listener_->called_start_document_.Test());
EXPECT_TRUE(second_event_listener_->called_end_document_.Test());
}
TEST_F(HandlerCalledTest, StartEndElementCalled) {
Parse("start_end_element_called", "<p>...</p>");
EXPECT_TRUE(handler_called_filter_.called_start_element_.Test());
EXPECT_TRUE(handler_called_filter_.called_end_element_.Test());
EXPECT_TRUE(first_event_listener_->called_start_element_.Test());
EXPECT_TRUE(first_event_listener_->called_end_element_.Test());
EXPECT_TRUE(second_event_listener_->called_start_element_.Test());
EXPECT_TRUE(second_event_listener_->called_end_element_.Test());
}
TEST_F(HandlerCalledTest, CdataCalled) {
Parse("cdata_called", "<![CDATA[...]]>");
// Looks like a directive, but isn't.
EXPECT_FALSE(handler_called_filter_.called_directive_.Test());
EXPECT_TRUE(handler_called_filter_.called_cdata_.Test());
EXPECT_FALSE(first_event_listener_->called_directive_.Test());
EXPECT_TRUE(first_event_listener_->called_cdata_.Test());
EXPECT_FALSE(second_event_listener_->called_directive_.Test());
EXPECT_TRUE(second_event_listener_->called_cdata_.Test());
}
TEST_F(HandlerCalledTest, CommentCalled) {
Parse("comment_called", "<!--...-->");
EXPECT_TRUE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_comment_.Test());
}
TEST_F(HandlerCalledTest, IEDirectiveCalled1) {
Parse("ie_directive_called", "<!--[if IE]>...<![endif]-->");
// Looks like a comment, but isn't.
EXPECT_FALSE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(handler_called_filter_.called_ie_directive_.Test());
EXPECT_FALSE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_ie_directive_.Test());
EXPECT_FALSE(second_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_ie_directive_.Test());
}
TEST_F(HandlerCalledTest, IEDirectiveCalled2) {
// See http://code.google.com/p/modpagespeed/issues/detail?id=136 and
// http://msdn.microsoft.com/en-us/library/ms537512(VS.85).aspx#dlrevealed
Parse("ie_directive_called", "<!--[if lte IE 8]>...<![endif]-->");
EXPECT_FALSE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(handler_called_filter_.called_ie_directive_.Test());
EXPECT_FALSE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_ie_directive_.Test());
EXPECT_FALSE(second_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_ie_directive_.Test());
}
TEST_F(HandlerCalledTest, IEDirectiveCalled3) {
Parse("ie_directive_called", "<!--[if false]>...<![endif]-->");
EXPECT_FALSE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(handler_called_filter_.called_ie_directive_.Test());
EXPECT_FALSE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_ie_directive_.Test());
EXPECT_FALSE(second_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_ie_directive_.Test());
}
// Downlevel-revealed commments normally look like <![if foo]>...<![endif]>.
// However, although most (non-IE) browsers will ignore those, they're
// technically not valid, so some sites use the below trick (which is valid
// HTML, and still works for IE). For an explanation, see
// http://en.wikipedia.org/wiki/Conditional_comment#
// Downlevel-revealed_conditional_comment
TEST_F(HandlerCalledTest, IEDirectiveCalledRevealedOpen) {
Parse("ie_directive_called", "<!--[if !IE]><!-->");
EXPECT_FALSE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(handler_called_filter_.called_ie_directive_.Test());
EXPECT_FALSE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_ie_directive_.Test());
EXPECT_FALSE(second_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_ie_directive_.Test());
}
TEST_F(HandlerCalledTest, IEDirectiveCalledRevealedClose) {
Parse("ie_directive_called", "<!--<![endif]-->");
EXPECT_FALSE(handler_called_filter_.called_comment_.Test());
EXPECT_TRUE(handler_called_filter_.called_ie_directive_.Test());
EXPECT_FALSE(first_event_listener_->called_comment_.Test());
EXPECT_TRUE(first_event_listener_->called_ie_directive_.Test());
EXPECT_FALSE(second_event_listener_->called_comment_.Test());
EXPECT_TRUE(second_event_listener_->called_ie_directive_.Test());
}
// Unit tests for event-list manipulation. In these tests, we do not parse
// HTML input text, but instead create two 'Characters' nodes and use the
// event-list manipulation methods and make sure they render as expected.
class EventListManipulationTest : public HtmlParseTest {
protected:
EventListManipulationTest() { }
virtual void SetUp() {
HtmlParseTest::SetUp();
static const char kUrl[] = "http://html.parse.test/event_list_test.html";
ASSERT_TRUE(html_parse_.StartParse(kUrl));
node1_ = html_parse_.NewCharactersNode(NULL, "1");
HtmlTestingPeer::AddEvent(&html_parse_,
new HtmlCharactersEvent(node1_, -1));
node2_ = html_parse_.NewCharactersNode(NULL, "2");
node3_ = html_parse_.NewCharactersNode(NULL, "3");
// Note: the last 2 are not added in SetUp.
}
virtual void TearDown() {
html_parse_.FinishParse();
HtmlParseTest::TearDown();
}
void CheckExpected(const GoogleString& expected) {
SetupWriter();
html_parse()->ApplyFilter(html_writer_filter_.get());
EXPECT_EQ(expected, output_buffer_);
}
HtmlCharactersNode* node1_;
HtmlCharactersNode* node2_;
HtmlCharactersNode* node3_;
private:
DISALLOW_COPY_AND_ASSIGN(EventListManipulationTest);
};
TEST_F(EventListManipulationTest, TestReplace) {
EXPECT_TRUE(html_parse_.ReplaceNode(node1_, node2_));
CheckExpected("2");
}
TEST_F(EventListManipulationTest, TestInsertNodeBeforeNode) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
html_parse_.InsertNodeBeforeNode(node1_, node2_);
CheckExpected("21");
html_parse_.InsertNodeBeforeNode(node1_, node3_);
CheckExpected("231");
}
TEST_F(EventListManipulationTest, TestInsertNodeAfterNode) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
html_parse_.InsertNodeAfterNode(node1_, node2_);
CheckExpected("12");
html_parse_.InsertNodeAfterNode(node1_, node3_);
CheckExpected("132");
}
TEST_F(EventListManipulationTest, TestInsertNodeBeforeCurrent) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
html_parse_.InsertNodeBeforeCurrent(node2_);
// Current is left at queue_.end() after the AddEvent.
CheckExpected("12");
HtmlTestingPeer::SetCurrent(&html_parse_, node1_);
html_parse_.InsertNodeBeforeCurrent(node3_);
CheckExpected("312");
}
TEST_F(EventListManipulationTest, TestInsertNodeAfterCurrent) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::SetCurrent(&html_parse_, node1_);
html_parse_.InsertNodeAfterCurrent(node2_);
// Note that if we call CheckExpected here it will mutate current_.
html_parse_.InsertNodeAfterCurrent(node3_);
CheckExpected("123");
}
TEST_F(EventListManipulationTest, TestDeleteOnly) {
html_parse_.DeleteNode(node1_);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestDeleteFirst) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
html_parse_.DeleteNode(node1_);
CheckExpected("23");
html_parse_.DeleteNode(node2_);
CheckExpected("3");
html_parse_.DeleteNode(node3_);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestDeleteLast) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
html_parse_.DeleteNode(node3_);
CheckExpected("12");
html_parse_.DeleteNode(node2_);
CheckExpected("1");
html_parse_.DeleteNode(node1_);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestDeleteMiddle) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
html_parse_.DeleteNode(node2_);
CheckExpected("13");
}
// Note that an unconditionally sanity check runs after every
// filter, verifying that all the parent-pointers are correct.
// CheckExpected applies the HtmlWriterFilter, so it runs the
// parent-pointer check.
TEST_F(EventListManipulationTest, TestAddParentToSequence) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node3_, div));
CheckExpected("<div>123</div>");
// Now interpose a span between the div and the Characters nodes.
HtmlElement* span = html_parse_.NewElement(div, HtmlName::kSpan);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node2_, span));
CheckExpected("<div><span>12</span>3</div>");
// Next, add an HTML block above the div. Note that we pass 'div' in as
// both 'first' and 'last'.
HtmlElement* html = html_parse_.NewElement(NULL, HtmlName::kHtml);
EXPECT_TRUE(html_parse_.AddParentToSequence(div, div, html));
CheckExpected("<html><div><span>12</span>3</div></html>");
}
TEST_F(EventListManipulationTest, TestPrependChild) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.InsertNodeBeforeCurrent(div);
CheckExpected("1<div></div>");
html_parse_.PrependChild(div, node2_);
CheckExpected("1<div>2</div>");
html_parse_.PrependChild(div, node3_);
CheckExpected("1<div>32</div>");
// TODO(sligocki): Test with elements that don't explicitly end like image.
}
TEST_F(EventListManipulationTest, TestAppendChild) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.InsertNodeBeforeCurrent(div);
CheckExpected("1<div></div>");
html_parse_.AppendChild(div, node2_);
CheckExpected("1<div>2</div>");
html_parse_.AppendChild(div, node3_);
CheckExpected("1<div>23</div>");
// TODO(sligocki): Test with elements that don't explicitly end like image.
}
TEST_F(EventListManipulationTest, TestAddParentToSequenceDifferentParents) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node2_, div));
CheckExpected("<div>12</div>");
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
CheckExpected("<div>12</div>3");
EXPECT_FALSE(html_parse_.AddParentToSequence(node2_, node3_, div));
}
TEST_F(EventListManipulationTest, TestDeleteGroup) {
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node2_, div));
CheckExpected("<div>12</div>");
html_parse_.DeleteNode(div);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestMoveElementIntoParent1) {
HtmlElement* head = html_parse_.NewElement(NULL, HtmlName::kHead);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node1_, head));
CheckExpected("<head>1</head>");
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node2_, node2_, div));
CheckExpected("<head>1</head><div>2</div>");
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
CheckExpected("<head>1</head><div>2</div>3");
HtmlTestingPeer::SetCurrent(&html_parse_, div);
EXPECT_TRUE(html_parse_.MoveCurrentInto(head));
CheckExpected("<head>1<div>2</div></head>3");
}
TEST_F(EventListManipulationTest, TestMoveElementIntoParent2) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlElement* head = html_parse_.NewElement(NULL, HtmlName::kHead);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node1_, head));
CheckExpected("<head>1</head>");
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
CheckExpected("<head>1</head>23");
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node3_, node3_, div));
CheckExpected("<head>1</head>2<div>3</div>");
HtmlTestingPeer::SetCurrent(&html_parse_, div);
EXPECT_TRUE(html_parse_.MoveCurrentInto(head));
CheckExpected("<head>1<div>3</div></head>2");
EXPECT_TRUE(html_parse_.DeleteSavingChildren(div));
CheckExpected("<head>13</head>2");
EXPECT_TRUE(html_parse_.DeleteSavingChildren(head));
CheckExpected("132");
}
TEST_F(EventListManipulationTest, TestDeleteSavingChildrenEnd) {
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node1_, div));
CheckExpected("<div>1</div>");
EXPECT_TRUE(html_parse_.DeleteSavingChildren(div));
CheckExpected("1");
}
TEST_F(EventListManipulationTest, TestMoveCurrentBefore) {
// Setup events.
HtmlTestingPeer::set_coalesce_characters(&html_parse_, false);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
EXPECT_TRUE(html_parse_.AddParentToSequence(node1_, node2_, div));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
CheckExpected("<div>12</div>3");
HtmlTestingPeer::SetCurrent(&html_parse_, node3_);
// Test MoveCurrentBefore().
EXPECT_TRUE(html_parse_.MoveCurrentBefore(node2_));
CheckExpected("<div>132</div>");
#ifdef NDEBUG
// Test that current_ pointing to end() does not crash in non-debug build.
// In debug build, there is a LOG(DFATAL), so we cannot run this.
// NOTE: We do not expect this case ever to happen in normal code.
EXPECT_FALSE(html_parse_.MoveCurrentBefore(node2_));
CheckExpected("<div>132</div>");
#endif
// Test that current_ pointing to a containing object will not work.
HtmlElement* span = html_parse_.NewElement(NULL, HtmlName::kSpan);
EXPECT_TRUE(html_parse_.AddParentToSequence(div, div, span));
CheckExpected("<span><div>132</div></span>");
HtmlTestingPeer::SetCurrent(&html_parse_, span);
EXPECT_FALSE(html_parse_.MoveCurrentBefore(node2_));
CheckExpected("<span><div>132</div></span>");
}
TEST_F(EventListManipulationTest, TestCoalesceOnAdd) {
CheckExpected("1");
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
CheckExpected("12");
// this will coalesce node1 and node2 togethers. So there is only
// one node1_="12", and node2_ is gone. Deleting node1_ will now
// leave us empty
html_parse_.DeleteNode(node1_);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestCoalesceOnDelete) {
CheckExpected("1");
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div, -1);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer testing_peer;
testing_peer.SetNodeParent(node2_, div);
html_parse_.CloseElement(div, HtmlElement::EXPLICIT_CLOSE, -1);
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node3_, -1));
CheckExpected("1<div>2</div>3");
// Removing the div, leaving the children intact...
EXPECT_TRUE(html_parse_.DeleteSavingChildren(div));
CheckExpected("123");
// At this point, node1, node2, and node3 are automatically coalesced.
// This means when we remove node1, all the content will disappear.
html_parse_.DeleteNode(node1_);
CheckExpected("");
}
TEST_F(EventListManipulationTest, TestHasChildren) {
CheckExpected("1");
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div, -1);
EXPECT_FALSE(html_parse_.HasChildrenInFlushWindow(div));
HtmlTestingPeer::AddEvent(&html_parse_, new HtmlCharactersEvent(node2_, -1));
HtmlTestingPeer testing_peer;
testing_peer.SetNodeParent(node2_, div);
// Despite having added a new element into the stream, the div is not
// closed yet, so it's not recognized as a child.
EXPECT_FALSE(html_parse_.HasChildrenInFlushWindow(div));
html_parse_.CloseElement(div, HtmlElement::EXPLICIT_CLOSE, -1);
EXPECT_TRUE(html_parse_.HasChildrenInFlushWindow(div));
EXPECT_TRUE(html_parse_.DeleteNode(node2_));
EXPECT_FALSE(html_parse_.HasChildrenInFlushWindow(div));
}
TEST_F(EventListManipulationTest, AppendComment) {
html_parse_.InsertComment("hello");
CheckExpected("1<!--hello-->");
}
TEST_F(EventListManipulationTest, AppendCommentWithEscaping) {
html_parse_.InsertComment("<i>hello</i> <!--world-->");
CheckExpected("1<!--&lt;i&gt;hello&lt;/i&gt; &lt;!--world--&gt;-->");
}
TEST_F(EventListManipulationTest, CommentBeforeDiv1) {
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div, -1);
html_parse_.InsertComment("hello");
html_parse_.CloseElement(div, HtmlElement::EXPLICIT_CLOSE, -1);
CheckExpected("1<!--hello--><div></div>");
}
TEST_F(EventListManipulationTest, CommentBeforeDiv2) {
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.InsertComment("hello");
html_parse_.AddElement(div, -1);
html_parse_.CloseElement(div, HtmlElement::EXPLICIT_CLOSE, -1);
CheckExpected("1<!--hello--><div></div>");
}
TEST_F(EventListManipulationTest, CommentAfterDiv) {
HtmlElement* div = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div, -1);
html_parse_.CloseElement(div, HtmlElement::EXPLICIT_CLOSE, -1);
html_parse_.InsertComment("hello");
CheckExpected("1<div></div><!--hello-->");
}
TEST_F(EventListManipulationTest, CommentAfterFirstDiv) {
HtmlElement* div1 = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div1, -1);
html_parse_.CloseElement(div1, HtmlElement::EXPLICIT_CLOSE, -1);
HtmlElement* div2 = html_parse_.NewElement(NULL, HtmlName::kDiv);
html_parse_.AddElement(div2, -1);
html_parse_.CloseElement(div2, HtmlElement::EXPLICIT_CLOSE, -1);
HtmlTestingPeer::SetCurrent(&html_parse_, div1);
html_parse_.InsertComment("hello");
CheckExpected("1<div></div><!--hello--><div></div>");
}
class InsertCommentOnFirstDivFilter : public EmptyHtmlFilter {
public:
InsertCommentOnFirstDivFilter(bool at_start, HtmlParse* parse)
: html_parse_(parse),
at_start_(at_start),
first_(true) {
}
virtual void StartDocument() { first_ = true; }
virtual void StartElement(HtmlElement* element) { Insert(true, element); }
virtual void EndElement(HtmlElement* element) { Insert(false, element); }
virtual const char* Name() const { return "InsertCommentOnFirstDivFilter"; }
private:
void Insert(bool at_start, HtmlElement* element) {
if (first_ && (at_start == at_start_) &&
(element->keyword() == HtmlName::kDiv)) {
html_parse_->InsertComment("hello");
first_ = false;
}
}
private:
HtmlParse* html_parse_;
bool at_start_;
bool first_;
DISALLOW_COPY_AND_ASSIGN(InsertCommentOnFirstDivFilter);
};
TEST_F(HtmlParseTestNoBody, CommentInsideFirstDiv) {
InsertCommentOnFirstDivFilter insert_at_first_div(true, &html_parse_);
html_parse_.AddFilter(&insert_at_first_div);
SetupWriter();
ValidateExpected("comment_inside_first_div",
"1<div>2</div>3<div>4</div>5",
"1<!--hello--><div>2</div>3<div>4</div>5");
}
TEST_F(HtmlParseTestNoBody, CommentAfterFirstDiv) {
InsertCommentOnFirstDivFilter insert_at_first_div(false, &html_parse_);
html_parse_.AddFilter(&insert_at_first_div);
SetupWriter();
ValidateExpected("comment_inside_first_div",
"1<div>2</div>3<div>4</div>5",
"1<div>2</div><!--hello-->3<div>4</div>5");
}
TEST_F(HtmlParseTestNoBody, InsertCommentFromEmpty) {
html_parse_.InsertComment("hello");
SetupWriter();
html_parse()->ApplyFilter(html_writer_filter_.get());
EXPECT_EQ("<!--hello-->", output_buffer_);
}
TEST_F(HtmlParseTestNoBody, InsertCommentFromFlushInLargeCharactersBlock) {
SetupWriter();
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<style>bytes:");
// This should be inserted before <style>.
EXPECT_TRUE(html_parse_.InsertComment("FLUSH1"));
html_parse_.Flush();
html_parse_.ParseText(":more:");
html_parse_.Flush();
html_parse_.ParseText(":still more:");
// We are inside a literal block, so it's not safe to insert a comment here.
// This should not show up in output_buffer_.
EXPECT_FALSE(html_parse_.InsertComment("FLUSH2"));
html_parse_.Flush();
html_parse_.ParseText(":final bytes:</style>");
EXPECT_TRUE(html_parse_.InsertComment("FLUSH3"));
html_parse_.FinishParse();
EXPECT_EQ("<!--FLUSH1--><style>bytes::more::still more::final bytes:</style>"
"<!--FLUSH3-->",
output_buffer_);
}
TEST_F(HtmlParseTestNoBody, InsertCommentFromFlushInEmptyCharactersBlock) {
SetupWriter();
html_parse_.StartParse("http://test.com/blank_flush.html");
html_parse_.ParseText("<style>");
// This should be inserted before <style>.
EXPECT_TRUE(html_parse_.InsertComment("FLUSH1"));
EXPECT_TRUE(html_parse_.InsertComment("FLUSH2"));
html_parse_.Flush();
html_parse_.ParseText("</style>");
EXPECT_TRUE(html_parse_.InsertComment("FLUSH3"));
html_parse_.FinishParse();
EXPECT_EQ("<!--FLUSH1--><!--FLUSH2--><style></style><!--FLUSH3-->",
output_buffer_);
}
// Unit tests for attribute manipulation.
// Goal is to make sure we don't (eg) read deallocated storage
// while manipulating attribute values.
class AttributeManipulationTest : public HtmlParseTest {
protected:
AttributeManipulationTest() { }
virtual void SetUp() {
HtmlParseTest::SetUp();
static const char kUrl[] =
"http://html.parse.test/attribute_manipulation_test.html";
ASSERT_TRUE(html_parse_.StartParse(kUrl));
node_ = html_parse_.NewElement(NULL, HtmlName::kA);
html_parse_.AddElement(node_, 0);
html_parse_.AddAttribute(node_, HtmlName::kHref, "http://www.google.com/");
node_->AddAttribute(html_parse_.MakeName(HtmlName::kId), "37",
HtmlElement::NO_QUOTE);
node_->AddAttribute(html_parse_.MakeName(HtmlName::kClass), "search!",
HtmlElement::SINGLE_QUOTE);
// Add a binary attribute (one without value).
node_->AddAttribute(html_parse_.MakeName(HtmlName::kSelected), NULL,
HtmlElement::NO_QUOTE);
html_parse_.CloseElement(node_, HtmlElement::BRIEF_CLOSE, 0);
}
virtual void TearDown() {
html_parse_.FinishParse();
HtmlParseTest::TearDown();
}
void CheckExpected(const GoogleString& expected) {
SetupWriter();
html_parse_.ApplyFilter(html_writer_filter_.get());
EXPECT_EQ(expected, output_buffer_);
}
int NumAttributes(HtmlElement* element) {
int size = 0;
const HtmlElement::AttributeList& attrs = element->attributes();
for (HtmlElement::AttributeConstIterator i(attrs.begin());
i != attrs.end(); ++i) {
++size;
}
return size;
}
HtmlElement::Attribute* AttributeAt(HtmlElement* element, int index) {
int pos = 0;
HtmlElement::AttributeList* attrs = element->mutable_attributes();
for (HtmlElement::AttributeIterator i(attrs->begin());
i != attrs->end(); ++i) {
if (pos == index) {
return i.Get();
}
++pos;
}
return NULL;
}
HtmlElement* node_;
private:
DISALLOW_COPY_AND_ASSIGN(AttributeManipulationTest);
};
TEST_F(AttributeManipulationTest, PropertiesAndDeserialize) {
StringPiece google("http://www.google.com/");
StringPiece number37("37");
StringPiece search("search!");
EXPECT_EQ(4, NumAttributes(node_));
EXPECT_EQ(google, node_->AttributeValue(HtmlName::kHref));
EXPECT_EQ(number37, node_->AttributeValue(HtmlName::kId));
EXPECT_EQ(search, node_->AttributeValue(HtmlName::kClass));
// Returns NULL for attributes that do not exist ...
EXPECT_TRUE(NULL == node_->AttributeValue(HtmlName::kNotAKeyword));
// ... and for attributes which have no value.
EXPECT_TRUE(NULL == node_->AttributeValue(HtmlName::kSelected));
// Returns NULL for attributes that do not exist.
EXPECT_TRUE(NULL == node_->FindAttribute(HtmlName::kNotAKeyword));
// Returns an attribute reference for attributes without values.
HtmlElement::Attribute* selected = node_->FindAttribute(HtmlName::kSelected);
EXPECT_TRUE(NULL != selected);
EXPECT_TRUE(NULL == selected->DecodedValueOrNull());
EXPECT_EQ(google, node_->AttributeValue(HtmlName::kHref));
EXPECT_EQ(number37, node_->AttributeValue(HtmlName::kId));
EXPECT_EQ(search, node_->AttributeValue(HtmlName::kClass));
EXPECT_EQ(google, node_->FindAttribute(HtmlName::kHref)->escaped_value());
EXPECT_EQ(number37, node_->FindAttribute(HtmlName::kId)->escaped_value());
EXPECT_EQ(search, node_->FindAttribute(HtmlName::kClass)->escaped_value());
CheckExpected("<a href=\"http://www.google.com/\" id=37 class='search!'"
" selected />");
}
TEST_F(AttributeManipulationTest, AddAttribute) {
html_parse_.AddAttribute(node_, HtmlName::kLang, "ENG-US");
CheckExpected("<a href=\"http://www.google.com/\" id=37 class='search!'"
" selected lang=\"ENG-US\"/>");
}
TEST_F(AttributeManipulationTest, DeleteAttribute) {
node_->DeleteAttribute(HtmlName::kId);
CheckExpected("<a href=\"http://www.google.com/\" class='search!'"
" selected />");
node_->DeleteAttribute(HtmlName::kSelected);
CheckExpected("<a href=\"http://www.google.com/\" class='search!'/>");
}
TEST_F(AttributeManipulationTest, ModifyAttribute) {
HtmlElement::Attribute* href =
node_->FindAttribute(HtmlName::kHref);
EXPECT_TRUE(href != NULL);
href->SetValue("google");
href->set_quote_style(HtmlElement::SINGLE_QUOTE);
html_parse_.SetAttributeName(href, HtmlName::kSrc);
CheckExpected("<a src='google' id=37 class='search!' selected />");
}
TEST_F(AttributeManipulationTest, ModifyKeepAttribute) {
HtmlElement::Attribute* href =
node_->FindAttribute(HtmlName::kHref);
EXPECT_TRUE(href != NULL);
// This apparently do-nothing call to SetValue exposed an allocation bug.
href->SetValue(href->DecodedValueOrNull());
href->set_quote_style(href->quote_style());
href->set_name(href->name());
CheckExpected("<a href=\"http://www.google.com/\" id=37 class='search!'"
" selected />");
}
TEST_F(AttributeManipulationTest, BadUrl) {
EXPECT_FALSE(html_parse_.StartParse(")(*&)(*&(*"));
// To avoid having the TearDown crash, restart the parse.
html_parse_.StartParse("http://www.example.com");
}
TEST_F(AttributeManipulationTest, CloneElement) {
HtmlElement* clone = html_parse_.CloneElement(node_);
// The clone is identical (but not the same object).
EXPECT_NE(clone, node_);
EXPECT_EQ(HtmlName::kA, clone->keyword());
EXPECT_EQ(node_->style(), clone->style());
EXPECT_EQ(4, NumAttributes(clone));
EXPECT_EQ(HtmlName::kHref, AttributeAt(clone, 0)->keyword());
EXPECT_STREQ("http://www.google.com/",
AttributeAt(clone, 0)->DecodedValueOrNull());
EXPECT_EQ(HtmlName::kId, AttributeAt(clone, 1)->keyword());
EXPECT_STREQ("37", AttributeAt(clone, 1)->DecodedValueOrNull());
EXPECT_EQ(HtmlName::kClass, AttributeAt(clone, 2)->keyword());
EXPECT_STREQ("search!", AttributeAt(clone, 2)->DecodedValueOrNull());
EXPECT_EQ(HtmlName::kSelected, AttributeAt(clone, 3)->keyword());
EXPECT_EQ(NULL, AttributeAt(clone, 3)->DecodedValueOrNull());
HtmlElement::Attribute* id = clone->FindAttribute(HtmlName::kId);
ASSERT_TRUE(id != NULL);
id->SetValue("38");
// Clone is not added initially, and the original is not touched.
CheckExpected("<a href=\"http://www.google.com/\" id=37 class='search!'"
" selected />");
// Looks sane when added.
html_parse_.InsertNodeBeforeNode(node_, clone);
CheckExpected("<a href=\"http://www.google.com/\" id=38 class='search!'"
" selected />"
"<a href=\"http://www.google.com/\" id=37 class='search!'"
" selected />");
}
TEST_F(HtmlParseTest, NoDisabledFilter) {
std::vector<GoogleString> disabled_filters;
ASSERT_TRUE(disabled_filters.empty());
html_parse_.SetDynamicallyDisabledFilterList(&disabled_filters);
DisableTestFilter filter("not_disabled_filter", true, "Ignored reason");
html_parse_.AddFilter(&filter);
Parse("not_disabled_filter", "<!-- Empty body -->");
EXPECT_TRUE(disabled_filters.empty());
}
TEST_F(HtmlParseTest, DisabledFilters) {
std::vector<GoogleString> disabled_filters;
ASSERT_TRUE(disabled_filters.empty());
html_parse_.SetDynamicallyDisabledFilterList(&disabled_filters);
DisableTestFilter filter1("not_disabled_filter1", true, "Ignored reason");
html_parse_.AddFilter(&filter1);
DisableTestFilter disabled_filter1("disabled_filter1", false, "");
html_parse_.AddFilter(&disabled_filter1);
DisableTestFilter filter2("not_disabled_filter2", true, "Ignored reason");
html_parse_.AddFilter(&filter2);
DisableTestFilter disabled_filter2("disabled_filter2", false, "");
html_parse_.AddFilter(&disabled_filter2);
DisableTestFilter filter3("not_disabled_filter3", true, "Ignored reason");
html_parse_.AddFilter(&filter3);
Parse("disabled_filter", "<!-- Empty body -->");
EXPECT_THAT(disabled_filters,
UnorderedElementsAre(disabled_filter1.ExpectedDisabledMessage(),
disabled_filter2.ExpectedDisabledMessage()));
}
TEST_F(HtmlParseTest, DisabledFilterWithReason) {
std::vector<GoogleString> disabled_filters;
ASSERT_TRUE(disabled_filters.empty());
html_parse_.SetDynamicallyDisabledFilterList(&disabled_filters);
const GoogleString disabled_reason("Some reason");
DisableTestFilter filter("disabled_filter_with_reason", false,
disabled_reason);
html_parse_.AddFilter(&filter);
Parse("disabled_filter_with_reason", "<!-- Empty body -->");
EXPECT_THAT(disabled_filters,
UnorderedElementsAre(filter.ExpectedDisabledMessage()));
}
class CountingCallbacksFilter : public EmptyHtmlFilter {
public:
CountingCallbacksFilter()
: num_start_elements_(0),
num_end_elements_(0),
num_char_elements_(0) {
}
int num_start_elements() const { return num_start_elements_; }
int num_end_elements() const { return num_end_elements_; }
int num_char_elements() const { return num_char_elements_; }
protected:
virtual void StartDocument() {
num_start_elements_ = 0;
num_end_elements_ = 0;
num_char_elements_ = 0;
}
virtual void StartElement(HtmlElement* element) {
++num_start_elements_;
}
virtual void EndElement(HtmlElement* element) {
++num_end_elements_;
}
virtual void Characters(HtmlCharactersNode* characters) {
++num_char_elements_;
}
virtual const char* Name() const { return "CountingCallbacksFilter"; }
private:
int num_start_elements_;
int num_end_elements_;
int num_char_elements_;
DISALLOW_COPY_AND_ASSIGN(CountingCallbacksFilter);
};
// Checks that deleting nodes does not change the expected order of
// HTML parse events. We delete any node of del_node_type_, but we
// only delete it when we see a tag of type del_from_type_ (and
// del_from_start_tag indicates whether we do it when we see the start
// tag or the end tag of del_from_type). Can be configured to remove
// nodes using DeleteSavingChildren, DeleteNode, or
// MakeElementInvisible.
class DeleteNodesFilter : public CountingCallbacksFilter {
public:
explicit DeleteNodesFilter(HtmlParse* html_parse)
: html_parse_(html_parse),
delete_node_type_(HtmlName::kNotAKeyword),
delete_from_type_(HtmlName::kNotAKeyword),
delete_on_open_tag_(false),
save_children_(true),
make_invisible_(false),
num_deleted_elements_(0),
flushes_preventing_delete_(0) {
}
void set_delete_node_type(HtmlName::Keyword keyword) {
delete_node_type_ = keyword;
}
void set_save_children(bool x) { save_children_ = x; }
void set_make_invisible(bool x) { make_invisible_ = x; }
void set_delete_from_type(HtmlName::Keyword keyword) {
delete_from_type_ = keyword;
}
void set_delete_on_open_tag(bool del_from_start) {
delete_on_open_tag_ = del_from_start;
}
int num_deleted_elements() const { return num_deleted_elements_; }
int flushes_preventing_delete() const { return flushes_preventing_delete_; }
protected:
virtual void StartDocument() {
pending_deletes_.clear();
num_deleted_elements_ = 0;
flushes_preventing_delete_ = 0;
// Note: we do not clear save_children_ or make_invisible_ here because
// we re-use these settings when repeating tests with different flush
// windows.
}
virtual void StartElement(HtmlElement* element) {
CountingCallbacksFilter::StartElement(element);
if (element->keyword() == delete_node_type_) {
pending_deletes_.push_back(element);
}
if (delete_on_open_tag_ && element->keyword() == delete_from_type_) {
DeleteElements();
}
}
virtual void EndElement(HtmlElement* element) {
CountingCallbacksFilter::EndElement(element);
if (!delete_on_open_tag_ && element->keyword() == delete_from_type_) {
DeleteElements();
}
}
virtual void Flush() {
// We can't delete an element that has been flushed.
for (int i = 0, n = pending_deletes_.size(); i < n; ++i) {
++flushes_preventing_delete_;
}
pending_deletes_.clear();
}
virtual const char* Name() const { return "DeleteNodesFilter"; }
private:
void DeleteElements() {
for (int i = 0, n = pending_deletes_.size(); i < n; ++i) {
HtmlElement* element = pending_deletes_[i];
bool success = make_invisible_
? html_parse_->MakeElementInvisible(element)
: (save_children_
? html_parse_->DeleteSavingChildren(element)
: html_parse_->DeleteNode(element));
if (success) {
++num_deleted_elements_;
}
}
pending_deletes_.clear();
}
HtmlParse* html_parse_;
std::vector<HtmlElement*> pending_deletes_;
HtmlName::Keyword delete_node_type_;
HtmlName::Keyword delete_from_type_;
bool delete_on_open_tag_;
bool save_children_;
bool make_invisible_;
int num_deleted_elements_;
int flushes_preventing_delete_;
DISALLOW_COPY_AND_ASSIGN(DeleteNodesFilter);
};
class HtmlParseDeleteTest : public HtmlParseTest {
protected:
HtmlParseDeleteTest()
: delete_filter_(html_parse()),
total_successes_(0),
total_failures_(0) {
html_parse()->AddFilter(&delete_filter_);
SetupWriter();
}
void DeleteTest(StringPiece input,
StringPiece expected_output_if_deletes_worked) {
for (int i = 0, n = input.size(); i < n; ++i) {
ParseWithFlush(input, i);
if (delete_filter_.num_deleted_elements() != 0) {
EXPECT_STREQ(expected_output_if_deletes_worked,
output_buffer_) << " flush " << i;
++total_successes_;
} else {
EXPECT_STREQ(input, output_buffer_) << " flush " << i;
++total_failures_;
}
output_buffer_.clear();
}
}
DeleteNodesFilter delete_filter_;
int total_successes_;
int total_failures_;
};
TEST_F(HtmlParseDeleteTest, DeleteAtStartAcrossFlush) {
delete_filter_.set_delete_on_open_tag(true);
delete_filter_.set_save_children(false);
delete_filter_.set_delete_node_type(HtmlName::kDiv);
delete_filter_.set_delete_from_type(HtmlName::kDiv);
const StringPiece kInput("1<div id=a>hello</div>2");
DeleteTest(kInput, "12");
// We can utilize the infrastructure in DeferCurrentNode to make it
// possible to delete nodes from their StartElement even if their
// EndElement is not in the flush window
EXPECT_EQ(0, total_failures_);
// If the both the StartElement and EndElement are visible, then
// we should successfully eliminate the div and its contents. That
// will happen every time.
EXPECT_EQ(kInput.size(), total_successes_);
}
TEST_F(HtmlParseDeleteTest, DeleteAtEndAcrossFlush) {
delete_filter_.set_delete_on_open_tag(false);
delete_filter_.set_save_children(false);
delete_filter_.set_delete_node_type(HtmlName::kDiv);
delete_filter_.set_delete_from_type(HtmlName::kDiv);
DeleteTest("1<div id=a>hello</div>2", "12");
// If the flush happened in the middle of the div, then we will
// fail. That will happen at least sometimes.
EXPECT_LT(0, total_failures_);
// If the both the StartElement and EndElement are visible, then
// we should successfully eliminate the div and its contents. That
// will happen at least sometimes.
EXPECT_LT(0, total_successes_);
}
TEST_F(HtmlParseDeleteTest, InvisibleAtStart) {
delete_filter_.set_delete_on_open_tag(true);
delete_filter_.set_make_invisible(true);
delete_filter_.set_delete_node_type(HtmlName::kDiv);
delete_filter_.set_delete_from_type(HtmlName::kDiv);
const StringPiece kInput("1<div id=a>hello</div>2");
DeleteTest(kInput, "1hello2");
// It is always possible to make nodes invisible as long as their
// StartElement has not been flushed.
EXPECT_EQ(0, total_failures_);
EXPECT_EQ(kInput.size(), total_successes_);
}
TEST_F(HtmlParseDeleteTest, InvisibleAtEnd) {
delete_filter_.set_delete_on_open_tag(false);
delete_filter_.set_make_invisible(true);
delete_filter_.set_delete_node_type(HtmlName::kDiv);
delete_filter_.set_delete_from_type(HtmlName::kDiv);
DeleteTest("1<div id=a>hello</div>2", "1hello2");
// If the flush happened in the middle of the div, then we will
// fail. That will happen at least sometimes.
EXPECT_LT(0, total_failures_);
// If the both the StartElement and EndElement are visible, then
// we should successfully eliminate the div and its contents. That
// will happen at least sometimes.
EXPECT_LT(0, total_successes_);
}
class EventListOrderTest : public HtmlParseTest {
protected:
EventListOrderTest()
: delete_nodes_filter_(&html_parse_) {
html_parse_.AddFilter(&delete_nodes_filter_);
}
virtual bool AddBody() const { return false; }
virtual bool AddHtmlTags() const { return false; }
DeleteNodesFilter delete_nodes_filter_;
private:
DISALLOW_COPY_AND_ASSIGN(EventListOrderTest);
};
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledOnOpen) {
delete_nodes_filter_.set_delete_on_open_tag(true);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kDiv);
ValidateExpected("delete_saving_children_open",
"<div><p>1</p></div><span>2</span>",
"<p>1</p><span>2</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledOnClose) {
delete_nodes_filter_.set_delete_on_open_tag(false);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kDiv);
ValidateExpected("delete_saving_children_close",
"<div><p>1</p></div><span>2</span>",
"<p>1</p><span>2</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledInner) {
delete_nodes_filter_.set_delete_on_open_tag(true);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kP);
ValidateExpected("delete_saving_children_inner",
"<div><p>1</p></div><span>2</span>",
"<p>1</p><span>2</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledOuter) {
delete_nodes_filter_.set_delete_on_open_tag(true);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kSpan);
ValidateExpected("delete_saving_children_outer",
"<div><p>1</p></div><span>2</span>",
"<p>1</p><span>2</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledInnerMiddle) {
delete_nodes_filter_.set_delete_on_open_tag(false);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kP);
ValidateExpected("delete_saving_children_inner_middle",
"<div><p>1</p>2<span>3</span></div><span>4</span>",
"<p>1</p>2<span>3</span><span>4</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledInnerEnd) {
delete_nodes_filter_.set_delete_on_open_tag(false);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kP);
ValidateExpected("delete_saving_children_inner_end",
"<div><p>1</p></div><span>2</span>",
"<p>1</p><span>2</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 2);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledInnerDeep) {
delete_nodes_filter_.set_delete_on_open_tag(false);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kP);
ValidateExpected("delete_saving_children_inner_deep",
"<div><a><p>1</p>2<span>3</span></a></div><span>4</span>",
"<a><p>1</p>2<span>3</span></a><span>4</span>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 5);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
TEST_F(EventListOrderTest, DeleteSavingChildrenCalledOuterDistant) {
delete_nodes_filter_.set_delete_on_open_tag(false);
delete_nodes_filter_.set_delete_node_type(HtmlName::kDiv);
delete_nodes_filter_.set_delete_from_type(HtmlName::kA);
ValidateExpected("delete_saving_children_outer_distant",
"<div><p>1</p></div><span>2</span><a>3</a>",
"<p>1</p><span>2</span><a>3</a>");
EXPECT_EQ(delete_nodes_filter_.num_start_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_end_elements(), 4);
EXPECT_EQ(delete_nodes_filter_.num_char_elements(), 3);
EXPECT_EQ(delete_nodes_filter_.num_deleted_elements(), 1);
}
// Filter to remove nodes during parsing and restore them sometime later.
class RestoreNodesFilter : public CountingCallbacksFilter {
public:
explicit RestoreNodesFilter(HtmlParse* html_parse)
: html_parse_(html_parse),
outstanding_deferred_elements_(0),
num_deletes_(0),
restore_on_open_(false) {
}
// Establishes the ID or text of an element to defer, and the ID of an
// element to move after.
void MoveOnStart(const char* id_or_text, const char* restore_point) {
remove_map_[id_or_text] = restore_point;
}
void DeleteOnStart(const char* id_or_text) {
delete_set_.insert(id_or_text);
}
void set_restore_on_open(bool restore) {
restore_on_open_ = restore;
}
// Returns the number of nodes that have been deferred, but not yet restored.
bool AllRestored() const { return restore_map_.empty(); }
int outstanding_deferred_elements() const {
return outstanding_deferred_elements_;
}
int num_deletes() const { return num_deletes_; }
protected:
virtual void StartDocument() {
CountingCallbacksFilter::StartDocument();
restore_map_.clear();
outstanding_deferred_elements_ = 0;
num_deletes_ = 0;
}
virtual void Characters(HtmlCharactersNode* node) {
CountingCallbacksFilter::Characters(node);
const GoogleString& text = node->contents();
if (!MaybeRemoveNode(text, node) &&
!MaybeDeleteNode(text, node)) {
MaybeRestoreNode(text);
}
}
virtual void StartElement(HtmlElement* element) {
CountingCallbacksFilter::StartElement(element);
const char* id = FindId(element);
if (id != NULL) {
if (!MaybeRemoveNode(id, element)) {
MaybeDeleteNode(id, element);
}
if (restore_on_open_) {
MaybeRestoreNode(id);
}
}
}
virtual void EndElement(HtmlElement* element) {
CountingCallbacksFilter::EndElement(element);
const char* id = FindId(element);
if (id != NULL && !restore_on_open_) {
MaybeRestoreNode(id);
}
}
virtual const char* Name() const { return "RestoreNodesFilter"; }
private:
typedef std::map<GoogleString, HtmlNode*> RestoreMap;
const char* FindId(HtmlElement* element) {
const HtmlElement::Attribute* attr = element->FindAttribute("id");
if (attr == NULL) {
return NULL;
}
return attr->DecodedValueOrNull();
}
bool MaybeRemoveNode(const GoogleString& id, HtmlNode* node) {
StringStringMap::iterator p = remove_map_.find(id);
if (p != remove_map_.end()) {
const GoogleString& restore_id = p->second;
EXPECT_TRUE(restore_map_[restore_id] == NULL);
restore_map_[restore_id] = node;
html_parse_->DeferCurrentNode();
if (dynamic_cast<HtmlElement*>(node) != NULL) {
++outstanding_deferred_elements_;
}
return true;
}
return false;
}
bool MaybeDeleteNode(const GoogleString& id, HtmlNode* node) {
if (delete_set_.find(id) != delete_set_.end() &&
html_parse_->DeleteNode(node)) {
++num_deletes_;
return true;
}
return false;
}
void MaybeRestoreNode(const GoogleString& id) {
RestoreMap::iterator p = restore_map_.find(id);
if (p != restore_map_.end()) {
HtmlNode* restore_node = p->second;
html_parse_->RestoreDeferredNode(restore_node);
restore_map_.erase(p);
if (dynamic_cast<HtmlElement*>(restore_node) != NULL) {
--outstanding_deferred_elements_;
}
}
}
HtmlParse* html_parse_;
StringStringMap remove_map_;
StringSet delete_set_;
RestoreMap restore_map_;
int outstanding_deferred_elements_;
int num_deletes_;
bool restore_on_open_;
DISALLOW_COPY_AND_ASSIGN(RestoreNodesFilter);
};
class HtmlRestoreTest : public HtmlParseTest {
protected:
HtmlRestoreTest()
: upstream_writer_filter_(&html_parse_),
upstream_writer_(&upstream_buffer_),
restore_nodes_filter_(&html_parse_),
expect_restored_(true) {
// We are interested in the effect on deferring nodes on (a) the
// filter that does the deferring, (b) upstream filters and (c)
// downstream filters. Downstream is covered by the normal
// HtmlWriterFilter filter that gets installed by SetupWriter.
// But Upstream is interesting too, especially when a FLUSH occurs
// while a deferred node is open. Sowe simply install another
// writer filter before the RestoreNodesFilter, which should see
// the input unmodified.
html_parse_.AddFilter(&upstream_writer_filter_);
html_parse_.AddFilter(&pre_counts_filter_);
upstream_writer_filter_.set_writer(&upstream_writer_);
html_parse_.AddFilter(&restore_nodes_filter_);
html_parse_.AddFilter(&post_counts_filter_);
}
virtual bool AddBody() const { return false; }
virtual bool AddHtmlTags() const { return false; }
// Runs a test like ValidateExpected, but puts one or two Flush
// calls at aribtrary points in the text, covering all n^2 places
// to put the two flushes.
//
// Don't call this with an especially large 'before', otherwise the
// time taken will grow quadratically. Calling this with 70 byte
// inputs appears to be OK, taking <300ms to run even in a debug build.
void RunTestsWithManyFlushWindows(StringPiece before,
StringPiece expected) {
SetupWriter();
int before_size = before.size();
for (int flush1 = 0; flush1 < before_size; ++flush1) {
for (int flush2 = flush1; flush2 < before_size; ++flush2) {
GoogleString this_id =
StringPrintf("http://test.com/%d_%d", flush1, flush2);
html_parse_.StartParse(this_id);
if (flush1 != 0) {
html_parse_.ParseText(before.substr(0, flush1));
}
if (flush2 != flush1) {
html_parse_.Flush();
html_parse_.ParseText(before.substr(flush1, flush2 - flush1));
}
if (flush2 != before_size) {
html_parse_.Flush();
html_parse_.ParseText(before.substr(flush2));
}
html_parse_.FinishParse();
ASSERT_STREQ(expected, output_buffer_) << this_id;
output_buffer_.clear();
ASSERT_STREQ(before, upstream_buffer_) << this_id;
upstream_buffer_.clear();
// If we expect that everything that was removed was restored, then the
// start/end/char-counts should all match before and during
// the RestoreNodes filter.
if (expect_restored_) {
EXPECT_TRUE(restore_nodes_filter_.AllRestored()) << this_id;
if (restore_nodes_filter_.num_deletes() == 0) {
ASSERT_EQ(pre_counts_filter_.num_start_elements(),
restore_nodes_filter_.num_start_elements()) << this_id;
ASSERT_EQ(pre_counts_filter_.num_end_elements(),
restore_nodes_filter_.num_end_elements()) << this_id;
ASSERT_EQ(pre_counts_filter_.num_start_elements(),
post_counts_filter_.num_start_elements()) << this_id;
ASSERT_EQ(pre_counts_filter_.num_end_elements(),
post_counts_filter_.num_end_elements()) << this_id;
}
ASSERT_EQ(pre_counts_filter_.num_char_elements(),
restore_nodes_filter_.num_char_elements()) << this_id;
// We use ASSERT_GE here because some of the tests will result in
// characters being coalesced on the defer or on the restore.
ASSERT_GE(pre_counts_filter_.num_char_elements(),
post_counts_filter_.num_char_elements()) << this_id;
// Of course, start and end element count must be balanced,
// as long as all deferred nodes were restored.
ASSERT_EQ(restore_nodes_filter_.num_start_elements(),
(restore_nodes_filter_.num_end_elements() +
restore_nodes_filter_.num_deletes())) << this_id;
} else {
// Otherwise there will be an extra Start tag for every
// unrestored element.
EXPECT_FALSE(restore_nodes_filter_.AllRestored()) << this_id;
ASSERT_EQ(
restore_nodes_filter_.num_start_elements(),
(restore_nodes_filter_.num_end_elements() +
restore_nodes_filter_.outstanding_deferred_elements()))
<< this_id;
}
// Note that only the restore_nodes_filter itself can have mismatched
// start/end callback-counts. Filters running before or after that one
// see a balanced set of callbacks.
ASSERT_EQ(pre_counts_filter_.num_start_elements(),
pre_counts_filter_.num_end_elements()) << this_id;
ASSERT_EQ(post_counts_filter_.num_start_elements(),
post_counts_filter_.num_end_elements()) << this_id;
}
}
}
void TestTwoFilters(const char* src1, const char* dest1,
const char* src2, const char* dest2,
const char* node_to_delete,
StringPiece input,
StringPiece expected) {
RestoreNodesFilter restore_nodes_filter2(&html_parse_);
html_parse_.AddFilter(&restore_nodes_filter2);
SetupWriter();
restore_nodes_filter_.MoveOnStart(src1, dest1);
if (node_to_delete != NULL) {
restore_nodes_filter_.DeleteOnStart(node_to_delete);
}
restore_nodes_filter2.MoveOnStart(src2, dest2);
RunTestsWithManyFlushWindows(input, expected);
}
HtmlWriterFilter upstream_writer_filter_;
CountingCallbacksFilter pre_counts_filter_;
StringWriter upstream_writer_;
GoogleString upstream_buffer_;
RestoreNodesFilter restore_nodes_filter_;
CountingCallbacksFilter post_counts_filter_;
bool expect_restored_;
private:
DISALLOW_COPY_AND_ASSIGN(HtmlRestoreTest);
};
TEST_F(HtmlRestoreTest, MoveAAfterB) {
restore_nodes_filter_.MoveOnStart("a", "b"); // moves div 'a' after div 'b'
RunTestsWithManyFlushWindows(
("0<div id=a>1<span>2</span>3</div>"
"4<div id=b>5<span>6</span></div>7"),
("04<div id=b>5<span>6</span></div>"
"<div id=a>1<span>2</span>3</div>7"));
}
TEST_F(HtmlRestoreTest, MoveAAfterBUnclosed) {
restore_nodes_filter_.MoveOnStart("a", "b"); // moves div 'a' after div 'b'
RunTestsWithManyFlushWindows(
("0<div id=a>1<span>2</span>3</div>"
"4<div id=b>5<span>6</span>7"), // b unclosed, but lexer auto-closes it.
("04<div id=b>5<span>6</span>7"
"<div id=a>1<span>2</span>3</div>"));
}
TEST_F(HtmlRestoreTest, MoveAAfterNestedB) {
restore_nodes_filter_.MoveOnStart("a", "b"); // moves div 'a' after div 'b'
RunTestsWithManyFlushWindows(
("0<div id=a>1<span>2</span>3</div>"
"4<div><div id=b>5<span>6</span></div>7</div>"),
("04<div><div id=b>5<span>6</span></div>"
"<div id=a>1<span>2</span>3</div>7</div>"));
}
TEST_F(HtmlRestoreTest, MoveABAfterC) {
restore_nodes_filter_.MoveOnStart("a", "c");
restore_nodes_filter_.MoveOnStart("b", "a");
RunTestsWithManyFlushWindows(
"0<img id=a />1<img id=b />2<img id=c />3",
"012<img id=c /><img id=a /><img id=b />3");
}
TEST_F(HtmlRestoreTest, MoveTextAfterDiv) {
restore_nodes_filter_.MoveOnStart("start", "a");
RunTestsWithManyFlushWindows(
"start<div id=a></div>",
"<div id=a></div>start");
}
TEST_F(HtmlRestoreTest, MoveDivAfterText) {
restore_nodes_filter_.MoveOnStart("a", "hello");
RunTestsWithManyFlushWindows(
"<div id=a></div>hello",
"hello<div id=a></div>");
}
TEST_F(HtmlRestoreTest, MoveTextfterText) {
restore_nodes_filter_.MoveOnStart("one", "two");
RunTestsWithManyFlushWindows("one<p>two", "<p>twoone");
}
TEST_F(HtmlRestoreTest, MoveStartWithEndNotVisibleAUnclosed) {
message_handler_.AddPatternToSkipPrinting(
"*Removed node <div id=a> (unclosed)*");
SetupWriter();
restore_nodes_filter_.MoveOnStart("a", "b");
expect_restored_ = false;
RunTestsWithManyFlushWindows("<div id=a>1<div id=b>2</div>", "");
EXPECT_LT(0, message_handler_.MessagesOfType(kWarning));
}
TEST_F(HtmlRestoreTest, MoveDivWithMissingDestination) {
message_handler_.AddPatternToSkipPrinting("*Removed node <div id=a></div>*");
SetupWriter();
restore_nodes_filter_.MoveOnStart("a", "b");
expect_restored_ = false;
RunTestsWithManyFlushWindows("<div id=a>1</div>", "");
EXPECT_LT(0, message_handler_.MessagesOfType(kWarning));
}
TEST_F(HtmlRestoreTest, MoveCharsWithMissingDestination) {
message_handler_.AddPatternToSkipPrinting(
"*Removed node Characters text never replaced*");
SetupWriter();
restore_nodes_filter_.MoveOnStart("text", "no_such_destination");
expect_restored_ = false;
RunTestsWithManyFlushWindows("text", "");
EXPECT_LT(0, message_handler_.MessagesOfType(kWarning));
}
TEST_F(HtmlRestoreTest, TwoDeleteAcrossFlush) {
SetupWriter();
restore_nodes_filter_.DeleteOnStart("a");
RunTestsWithManyFlushWindows("1<div id=a></div>2", "12");
}
TEST_F(HtmlRestoreTest, RestoreOnOpenTag) {
SetupWriter();
restore_nodes_filter_.MoveOnStart("a", "b");
restore_nodes_filter_.set_restore_on_open(true);
RunTestsWithManyFlushWindows("<div id=a>abc</div><div id=b>def</div>",
"<div id=b><div id=a>abc</div>def</div>");
}
// This tests having two filters that each do deferrals. The
// interesting case is where the second filter in the chain defers a
// node first, and then, before restoring first deferred node, another
// filter defers a different node.
TEST_F(HtmlRestoreTest, TwoDeferringFilters) {
TestTwoFilters(
"b", "c",
"a", "d",
NULL, // Node to delete
"<img id=a /><img id=b /><img id=c /><img id=d />",
"<img id=c /><img id=b /><img id=d /><img id=a />");
}
TEST_F(HtmlRestoreTest, TwoDeferringFiltersWithDelete) {
TestTwoFilters(
"b", "c", // In first filter, mov div b to after to div c.
"a", "d", // In second filter, move div a to after div d.
"a", // In first filter, delete node "a"
"<img id=a /><img id=b /><img id=c /><img id=d />",
"<img id=c /><img id=b /><img id=d />");
}
TEST_F(HtmlRestoreTest, TwoDeferringFiltersNestingOuterFirst) {
TestTwoFilters(
"a", "d",
"b", "c",
NULL, // Node to delete
"<div id=a><div id=b></div><div id=c></div></div><div id=d></div>",
"<div id=d></div><div id=a><div id=c></div><div id=b></div></div>");
}
TEST_F(HtmlRestoreTest, TwoDeferringFiltersNestingOuterFirstWithDelete) {
TestTwoFilters(
"a", "d",
"b", "c",
"b",
"<div id=a><div id=b></div><div id=c></div></div><div id=d></div>",
"<div id=d></div><div id=a><div id=c></div></div>");
}
TEST_F(HtmlRestoreTest, TwoDeferringFiltersNestingInnerFirst) {
TestTwoFilters(
"b", "c",
"a", "d",
NULL, // Node to delete
"<div id=a><div id=b></div><div id=c></div></div><div id=d></div>",
"<div id=d></div><div id=a><div id=c></div><div id=b></div></div>");
}
TEST_F(HtmlRestoreTest, TwoDeferringFiltersNestingInnerFirstWithDelete) {
TestTwoFilters(
"b", "c",
"a", "d",
"a",
"<div id=a><div id=b></div><div id=c></div></div><div id=d></div>",
"<div id=d></div>");
}
TEST_F(HtmlRestoreTest, DeferringAndDeletingFilters) {
DeleteNodesFilter delete_nodes_filter(&html_parse_);
RestoreNodesFilter restore_nodes_filter2(&html_parse_);
html_parse_.AddFilter(&delete_nodes_filter); // Upstream
html_parse_.AddFilter(&restore_nodes_filter2); // Downstream
SetupWriter();
// Don't do anything with restore_nodes_filter_
delete_nodes_filter.set_delete_node_type(HtmlName::kSpan);
delete_nodes_filter.set_delete_from_type(HtmlName::kDiv);
delete_nodes_filter.set_delete_on_open_tag(true);
restore_nodes_filter2.MoveOnStart("a", "d");
const StringPiece kInput(
"<span id=a><div id=b></div><div id=c></div></span><div id=d></div>");
ValidateExpected("defer_and_delete", kInput,
"<div id=b></div><div id=c></div><div id=d></div>");
EXPECT_EQ(1, delete_nodes_filter.num_deleted_elements());
// With the same filter setup, put a flush in the middle.
output_buffer_.clear();
html_parse_.StartParse("http://test.com/with_flush");
html_parse_.ParseText(kInput.substr(0, kInput.size() / 2));
html_parse_.Flush();
html_parse_.ParseText(kInput.substr(kInput.size() / 2));
html_parse_.FinishParse();
// Because of the flush, deleting the 'span' did not work. However,
// moving the span (and all its contents) after the 'd' did.
//
// TODO(jmarantz): consider making DeleteSavingChildren work even if
// the EndElement is not yet parsed, in which case we can switch to
// using RunTestsWithManyFlushWindows and expect the same results
// regardless of when the flush occurs.
EXPECT_STREQ(
"<div id=d></div><span id=a><div id=b></div><div id=c></div></span>",
output_buffer_);
EXPECT_EQ(0, delete_nodes_filter.num_deleted_elements());
}
TEST_F(HtmlRestoreTest, DeleteDeferredNode) {
DeleteNodesFilter delete_nodes_filter(&html_parse_);
RestoreNodesFilter restore_nodes_filter2(&html_parse_);
html_parse_.AddFilter(&delete_nodes_filter); // Upstream
html_parse_.AddFilter(&restore_nodes_filter2); // Downstream
SetupWriter();
// Don't do anything with restore_nodes_filter_
delete_nodes_filter.set_delete_node_type(HtmlName::kSpan);
delete_nodes_filter.set_delete_from_type(HtmlName::kDiv);
delete_nodes_filter.set_delete_on_open_tag(true);
restore_nodes_filter2.MoveOnStart("a", "d");
const StringPiece kInput("<span id=a></span><div id=d></div>");
ValidateExpected("delete_deferred", kInput, "<div id=d></div>");
EXPECT_EQ(1, delete_nodes_filter.num_deleted_elements());
EXPECT_EQ(0, delete_nodes_filter.flushes_preventing_delete());
// With the same filter setup, put a flush in the middle.
output_buffer_.clear();
html_parse_.StartParse("http://test.com/with_flush");
html_parse_.ParseText(kInput.substr(0, kInput.size() / 2));
html_parse_.Flush();
html_parse_.ParseText(kInput.substr(kInput.size() / 2));
html_parse_.FinishParse();
// Because of the flush, deleting the 'span' did not work. However,
// moving the span after the 'd' did.
//
// TODO(jmarantz): consider making DeleteSavingChildren work even if
// the EndElement is not yet parsed, in which case we can switch to
// using RunTestsWithManyFlushWindows and expect the same results
// regardless of when the flush occurs.
EXPECT_STREQ("<div id=d></div><span id=a></span>", output_buffer_);
EXPECT_EQ(0, delete_nodes_filter.num_deleted_elements());
EXPECT_EQ(1, delete_nodes_filter.flushes_preventing_delete());
}
TEST_F(HtmlRestoreTest, CoalesceCharsAfterRestore) {
restore_nodes_filter_.MoveOnStart("1", "a");
SetupWriter();
const StringPiece kInput("1<img id=a />2");
int num_times_chars_are_coalesced = 0;
int num_times_chars_are_not_coalesced = 0;
for (int i = 0, n = kInput.size(); i < n; ++i) {
ParseWithFlush(kInput, i);
EXPECT_STREQ("<img id=a />12", output_buffer_) << i;
// Before the deferral, we had two Characters nodes.
EXPECT_EQ(2, pre_counts_filter_.num_char_elements()) << i;
// The filter that does the deferring also sees two Characters nodes.
EXPECT_EQ(2, restore_nodes_filter_.num_char_elements()) << i;
// After the restore, the Characters nodes may be coalesced,
// depending on the flush window.
EXPECT_TRUE((post_counts_filter_.num_char_elements() == 1) ||
(post_counts_filter_.num_char_elements() == 2)) << i;
if (post_counts_filter_.num_char_elements() == 1) {
++num_times_chars_are_coalesced;
} else {
++num_times_chars_are_not_coalesced;
}
}
EXPECT_LT(0, num_times_chars_are_coalesced);
EXPECT_LT(0, num_times_chars_are_not_coalesced);
}
TEST_F(HtmlRestoreTest, CoalesceCharsOnDefer) {
restore_nodes_filter_.MoveOnStart("a", "b");
SetupWriter();
const StringPiece kInput("1<img id=a />2<p id=b />");
int num_times_chars_are_coalesced = 0;
int num_times_chars_are_not_coalesced = 0;
for (int i = 0, n = kInput.size(); i < n; ++i) {
ParseWithFlush(kInput, i);
EXPECT_STREQ(output_buffer_, "12<p id=b /><img id=a />");
// Before the deferral, we had two Characters nodes.
EXPECT_EQ(2, pre_counts_filter_.num_char_elements()) << i;
// The filter that does the deferring also sees two Characters nodes.
EXPECT_EQ(2, restore_nodes_filter_.num_char_elements()) << i;
// After the restore, the Characters nodes may be coalesced,
// depending on the flush window.
// After the deferral, the Characters nodes may be coalesced,
// depending on the flush window.
EXPECT_TRUE((post_counts_filter_.num_char_elements() == 1) ||
(post_counts_filter_.num_char_elements() == 2)) << i;
if (post_counts_filter_.num_char_elements() == 1) {
++num_times_chars_are_coalesced;
} else {
++num_times_chars_are_not_coalesced;
}
}
EXPECT_LT(0, num_times_chars_are_coalesced);
EXPECT_LT(0, num_times_chars_are_not_coalesced);
}
// This test just shows that the lexer will, in the absense of Defer or
// Delete calls, coalesce Characters nodes across Flush. It does this
// by being lazy and not emitting literals until it seems some HTML syntax.
TEST_F(HtmlRestoreTest, CoalesceCharsAcrossFlush) {
SetupWriter();
const StringPiece kInput("12");
for (int i = 0, n = kInput.size(); i < n; ++i) {
ParseWithFlush(kInput, i);
EXPECT_STREQ("12", output_buffer_) << i;
EXPECT_EQ(1, pre_counts_filter_.num_char_elements()) << i;
}
}
class InsertScriptsFilter : public EmptyHtmlFilter {
public:
explicit InsertScriptsFilter(HtmlParse* parse)
: html_parse_(parse),
at_start_(false),
before_(false),
external_(false) {
}
void set_insert_before(bool before) { before_ = before; }
void set_at_start(bool at_start) { at_start_ = at_start; }
void set_external(bool external) { external_ = external; }
protected:
virtual void StartElement(HtmlElement* element) { Insert(true, element); }
virtual void EndElement(HtmlElement* element) { Insert(false, element); }
virtual const char* Name() const { return "InsertScriptsFilter"; }
private:
void Insert(bool at_start, HtmlElement* element) {
if (element->keyword() == HtmlName::kHead) {
if (at_start == at_start_) {
if (before_) {
html_parse_->InsertScriptBeforeCurrent("inserted", external_);
} else {
html_parse_->InsertScriptAfterCurrent("inserted", external_);
}
}
}
}
private:
HtmlParse* html_parse_;
bool at_start_;
bool before_;
bool external_;
DISALLOW_COPY_AND_ASSIGN(InsertScriptsFilter);
};
TEST_F(HtmlParseTestNoBody, InsertInlineScriptAfterStartOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(false);
insert_scripts.set_at_start(true);
insert_scripts.set_external(false);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head><script>inserted</script>text</head>");
}
TEST_F(HtmlParseTestNoBody, InsertInlineScriptBeforeEndOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(true);
insert_scripts.set_at_start(false);
insert_scripts.set_external(false);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head>text<script>inserted</script></head>");
}
TEST_F(HtmlParseTestNoBody, InsertInlineScriptBeforeStartOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(true);
insert_scripts.set_at_start(true);
insert_scripts.set_external(false);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<script>inserted</script><head>text</head>");
}
TEST_F(HtmlParseTestNoBody, InsertInlineScriptAfterEndOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(false);
insert_scripts.set_at_start(false);
insert_scripts.set_external(false);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head>text</head><script>inserted</script>");
}
TEST_F(HtmlParseTestNoBody, InsertExternalScriptAfterStartOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(false);
insert_scripts.set_at_start(true);
insert_scripts.set_external(true);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head><script src=\"inserted\"></script>text</head>");
}
TEST_F(HtmlParseTestNoBody, InsertExternalScriptBeforeEndOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(true);
insert_scripts.set_at_start(false);
insert_scripts.set_external(true);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head>text<script src=\"inserted\"></script></head>");
}
TEST_F(HtmlParseTestNoBody, InsertExternalScriptBeforeStartOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(true);
insert_scripts.set_at_start(true);
insert_scripts.set_external(true);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<script src=\"inserted\"></script><head>text</head>");
}
TEST_F(HtmlParseTestNoBody, InsertExternalScriptAfterEndOfHead) {
InsertScriptsFilter insert_scripts(&html_parse_);
insert_scripts.set_insert_before(false);
insert_scripts.set_at_start(false);
insert_scripts.set_external(true);
html_parse_.AddFilter(&insert_scripts);
SetupWriter();
ValidateExpected("1",
"<head>text</head>",
"<head>text</head><script src=\"inserted\"></script>");
}
} // namespace net_instaweb