diff --git a/src/tests/template_modifiers_unittest.cc b/src/tests/template_modifiers_unittest.cc old mode 100644 new mode 100755 index 781d3d3..3defb03 --- a/src/tests/template_modifiers_unittest.cc +++ b/src/tests/template_modifiers_unittest.cc @@ -53,20 +53,20 @@ using std::vector; // Rather than put all these tests in the ctemplate namespace, or use // using-declarations, for this test I've decided to manually prepend -// GOOGLE_NAMESPACE:: everywhere it's needed. This test can serve as an +// ctemplate:: everywhere it's needed. This test can serve as an // example of how that approach looks. TEST(TemplateModifiers, HtmlEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestHtmlEscape", NULL); + ctemplate::TemplateDictionary dict("TestHtmlEscape", NULL); dict.SetEscapedValue("easy HTML", "foo", - GOOGLE_NAMESPACE::html_escape); + ctemplate::html_escape); dict.SetEscapedValue("harder HTML", "foo & bar", - GOOGLE_NAMESPACE::html_escape); + ctemplate::html_escape); dict.SetEscapedValue("hardest HTML", "", - GOOGLE_NAMESPACE::html_escape); + ctemplate::html_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts // TODO(csilvers): change this (and all other expect_*'s in all files // in this directory) to take the expected value first, not second. EXPECT_STREQ(peer.GetSectionValue("easy HTML"), "foo"); @@ -77,101 +77,101 @@ TEST(TemplateModifiers, HtmlEscape) { } TEST(TemplateModifiers, SnippetEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestSnippetEscape", NULL); + ctemplate::TemplateDictionary dict("TestSnippetEscape", NULL); dict.SetEscapedValue("easy snippet", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("valid snippet", "foo
& b­ar", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("invalid snippet", "", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("snippet with italics", "foo
& b­ar", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unclosed snippet", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("snippet with interleaving", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unclosed interleaving", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unclosed", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unterminated 1", "foo<", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unterminated 2", "foofoofoo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("close i b", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("em", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("nested em", "This is foo...", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unclosed em", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("wrongly closed em", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("misnested em", "foo", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span ltr", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span rtl", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span garbage dir attr", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span no dir", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span bad attribute", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("span quotes", "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("nested span", "This is bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("doubly-nested span", "This is " "bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("two spans", "This is text that is " "bidi.", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); dict.SetEscapedValue("unclosed span", "This is bidi text", - GOOGLE_NAMESPACE::snippet_escape); + ctemplate::snippet_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy snippet"), "foo"); EXPECT_STREQ(peer.GetSectionValue("valid snippet"), "foo
& b­ar"); @@ -226,16 +226,16 @@ TEST(TemplateModifiers, SnippetEscape) { } TEST(TemplateModifiers, PreEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestPreEscape", NULL); + ctemplate::TemplateDictionary dict("TestPreEscape", NULL); dict.SetEscapedValue("easy PRE", "foo", - GOOGLE_NAMESPACE::pre_escape); + ctemplate::pre_escape); dict.SetEscapedValue("harder PRE", "foo & bar", - GOOGLE_NAMESPACE::pre_escape); + ctemplate::pre_escape); dict.SetEscapedValue("hardest PRE", " \"--\v--\f--\n--\t--&--<-->--'--\"", - GOOGLE_NAMESPACE::pre_escape); + ctemplate::pre_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy PRE"), "foo"); EXPECT_STREQ(peer.GetSectionValue("harder PRE"), "foo & bar"); EXPECT_STREQ(peer.GetSectionValue("hardest PRE"), @@ -243,27 +243,27 @@ TEST(TemplateModifiers, PreEscape) { } TEST(TemplateModifiers, XmlEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestXmlEscape", NULL); + ctemplate::TemplateDictionary dict("TestXmlEscape", NULL); dict.SetEscapedValue("no XML", "", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); dict.SetEscapedValue("easy XML", "xoo", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); dict.SetEscapedValue("harder XML-1", "<>&'\"", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); dict.SetEscapedValue("harder XML-2", "Hello", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); dict.SetEscapedValue("hardest XML", "<>&!''\"\"foo", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); // Characters 0x00-0x1F (except \t, \r and \n) are not valid for XML and // compliant parsers are allowed to die when they encounter them. They // should be replaced with spaces. dict.SetEscapedValue("Spacey XML", " \r\n\f", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); dict.SetEscapedValue("XML with control chars", "\x01\x02\x03\x09\x0A\x0B\x0D\x15\x16\x1F", - GOOGLE_NAMESPACE::xml_escape); + ctemplate::xml_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("no XML"), ""); EXPECT_STREQ(peer.GetSectionValue("easy XML"), "xoo"); EXPECT_STREQ(peer.GetSectionValue("harder XML-1"), @@ -279,37 +279,37 @@ TEST(TemplateModifiers, XmlEscape) { } TEST(TemplateModifiers, ValidateUrlHtmlEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateUrlHtmlEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateUrlHtmlEscape", NULL); dict.SetEscapedValue("easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("easy javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("harder javascript URL", "javascript:alert(10/5)", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("easy relative URL", "foobar.html", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("harder relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); dict.SetEscapedValue("ftp URL", "ftp://ftp.example.org/pub/file.txt", - GOOGLE_NAMESPACE::validate_url_and_html_escape); + ctemplate::validate_url_and_html_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), "https://www.google.com/search?q=f&hl=en"); EXPECT_STREQ(peer.GetSectionValue("easy javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("harder javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("easy relative URL"), "foobar.html"); EXPECT_STREQ(peer.GetSectionValue("harder relative URL"), @@ -319,37 +319,37 @@ TEST(TemplateModifiers, ValidateUrlHtmlEscape) { } TEST(TemplateModifiers, ValidateImgSrcUrlHtmlEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateImgSrcUrlHtmlEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateImgSrcUrlHtmlEscape", NULL); dict.SetEscapedValue("easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("easy javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("harder javascript URL", "javascript:alert(10/5)", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("easy relative URL", "foobar.html", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("harder relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); dict.SetEscapedValue("ftp URL", "ftp://ftp.example.org/pub/file.txt", - GOOGLE_NAMESPACE::validate_img_src_url_and_html_escape); + ctemplate::validate_img_src_url_and_html_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), "https://www.google.com/search?q=f&hl=en"); EXPECT_STREQ(peer.GetSectionValue("easy javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("harder javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("easy relative URL"), "foobar.html"); EXPECT_STREQ(peer.GetSectionValue("harder relative URL"), @@ -359,48 +359,48 @@ TEST(TemplateModifiers, ValidateImgSrcUrlHtmlEscape) { } TEST(TemplateModifiers, ValidateUrlJavascriptEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateUrlJavascriptEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateUrlJavascriptEscape", NULL); dict.SetEscapedValue( "easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "mangled http URL", "HTTP://www.google.com", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "easy javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "harder javascript URL", "javascript:alert(10/5)", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "easy relative URL", "foobar.html", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "harder relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "data URL", "data: text/html", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "mangled javascript URL", "javaSCRIPT:alert(5)", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); dict.SetEscapedValue( "harder mangled javascript URL", "java\nSCRIPT:alert(5)", - GOOGLE_NAMESPACE::validate_url_and_javascript_escape); + ctemplate::validate_url_and_javascript_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), @@ -409,62 +409,62 @@ TEST(TemplateModifiers, ValidateUrlJavascriptEscape) { "HTTP://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("easy javascript URL"), "#"); EXPECT_STREQ(peer.GetSectionValue("harder javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("easy relative URL"), "foobar.html"); EXPECT_STREQ(peer.GetSectionValue("harder relative URL"), "/search?q\\x3dgreen flowers\\x26hl\\x3den"); EXPECT_STREQ(peer.GetSectionValue("data URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("mangled javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("harder mangled javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); } TEST(TemplateModifiers, ValidateImgSrcUrlJavascriptEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateImgSrcUrlJavascriptEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateImgSrcUrlJavascriptEscape", NULL); dict.SetEscapedValue( "easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "mangled http URL", "HTTP://www.google.com", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "easy javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "harder javascript URL", "javascript:alert(10/5)", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "easy relative URL", "foobar.html", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "harder relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "data URL", "data: text/html", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "mangled javascript URL", "javaSCRIPT:alert(5)", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); dict.SetEscapedValue( "harder mangled javascript URL", "java\nSCRIPT:alert(5)", - GOOGLE_NAMESPACE::validate_img_src_url_and_javascript_escape); + ctemplate::validate_img_src_url_and_javascript_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), @@ -472,9 +472,9 @@ TEST(TemplateModifiers, ValidateImgSrcUrlJavascriptEscape) { EXPECT_STREQ(peer.GetSectionValue("mangled http URL"), "HTTP://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("easy javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("harder javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("easy relative URL"), "foobar.html"); EXPECT_STREQ(peer.GetSectionValue("harder relative URL"), @@ -482,34 +482,34 @@ TEST(TemplateModifiers, ValidateImgSrcUrlJavascriptEscape) { EXPECT_STREQ(peer.GetSectionValue("data URL"), "/images/cleardot.gif"); EXPECT_STREQ(peer.GetSectionValue("mangled javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("harder mangled javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); } TEST(TemplateModifiers, ValidateUrlCssEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateUrlCssEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateUrlCssEscape", NULL); dict.SetEscapedValue("easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_url_and_css_escape); + ctemplate::validate_url_and_css_escape); dict.SetEscapedValue("harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_url_and_css_escape); + ctemplate::validate_url_and_css_escape); dict.SetEscapedValue("javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_url_and_css_escape); + ctemplate::validate_url_and_css_escape); dict.SetEscapedValue("relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_url_and_css_escape); + ctemplate::validate_url_and_css_escape); dict.SetEscapedValue("hardest URL", "http://www.google.com/s?q='bla'" "&a=\"\"&b=()&c=*\r\n\\\\bla", - GOOGLE_NAMESPACE::validate_url_and_css_escape); + ctemplate::validate_url_and_css_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), "https://www.google.com/search?q=f&hl=en"); EXPECT_STREQ(peer.GetSectionValue("javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeUrlReplacement); + ctemplate::ValidateUrl::kUnsafeUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("relative URL"), "/search?q=green flowers&hl=en"); EXPECT_STREQ(peer.GetSectionValue("hardest URL"), @@ -518,28 +518,28 @@ TEST(TemplateModifiers, ValidateUrlCssEscape) { } TEST(TemplateModifiers, ValidateImgSrcUrlCssEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestValidateImgSrcUrlCssEscape", NULL); + ctemplate::TemplateDictionary dict("TestValidateImgSrcUrlCssEscape", NULL); dict.SetEscapedValue("easy http URL", "http://www.google.com", - GOOGLE_NAMESPACE::validate_img_src_url_and_css_escape); + ctemplate::validate_img_src_url_and_css_escape); dict.SetEscapedValue("harder https URL", "https://www.google.com/search?q=f&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_css_escape); + ctemplate::validate_img_src_url_and_css_escape); dict.SetEscapedValue("javascript URL", "javascript:alert(document.cookie)", - GOOGLE_NAMESPACE::validate_img_src_url_and_css_escape); + ctemplate::validate_img_src_url_and_css_escape); dict.SetEscapedValue("relative URL", "/search?q=green flowers&hl=en", - GOOGLE_NAMESPACE::validate_img_src_url_and_css_escape); + ctemplate::validate_img_src_url_and_css_escape); dict.SetEscapedValue("hardest URL", "http://www.google.com/s?q='bla'" "&a=\"\"&b=()&c=*\r\n\\\\bla", - GOOGLE_NAMESPACE::validate_img_src_url_and_css_escape); + ctemplate::validate_img_src_url_and_css_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy http URL"), "http://www.google.com"); EXPECT_STREQ(peer.GetSectionValue("harder https URL"), "https://www.google.com/search?q=f&hl=en"); EXPECT_STREQ(peer.GetSectionValue("javascript URL"), - GOOGLE_NAMESPACE::ValidateUrl::kUnsafeImgSrcUrlReplacement); + ctemplate::ValidateUrl::kUnsafeImgSrcUrlReplacement); EXPECT_STREQ(peer.GetSectionValue("relative URL"), "/search?q=green flowers&hl=en"); EXPECT_STREQ(peer.GetSectionValue("hardest URL"), @@ -548,26 +548,26 @@ TEST(TemplateModifiers, ValidateImgSrcUrlCssEscape) { } TEST(TemplateModifiers, CleanseAttribute) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestCleanseAttribute", NULL); + ctemplate::TemplateDictionary dict("TestCleanseAttribute", NULL); dict.SetEscapedValue("easy attribute", "top", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("harder attribute", "foo & bar", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("hardest attribute", "top onclick='alert(document.cookie)'", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("equal in middle", "foo = bar", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("leading equal", "=foo", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("trailing equal", "foo=", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("all equals", "===foo===bar===", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); dict.SetEscapedValue("just equals", "===", - GOOGLE_NAMESPACE::cleanse_attribute); + ctemplate::cleanse_attribute); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy attribute"), "top"); EXPECT_STREQ(peer.GetSectionValue("harder attribute"), "foo___bar"); EXPECT_STREQ(peer.GetSectionValue("hardest attribute"), @@ -581,16 +581,16 @@ TEST(TemplateModifiers, CleanseAttribute) { } TEST(TemplateModifiers, CleanseCss) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestCleanseCss", NULL); + ctemplate::TemplateDictionary dict("TestCleanseCss", NULL); dict.SetEscapedValue("easy css", "top", - GOOGLE_NAMESPACE::cleanse_css); + ctemplate::cleanse_css); dict.SetEscapedValue("harder css", "foo & bar", - GOOGLE_NAMESPACE::cleanse_css); + ctemplate::cleanse_css); dict.SetEscapedValue("hardest css", ";width:expression(document.cookie)", - GOOGLE_NAMESPACE::cleanse_css); + ctemplate::cleanse_css); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy css"), "top"); EXPECT_STREQ(peer.GetSectionValue("harder css"), @@ -600,26 +600,26 @@ TEST(TemplateModifiers, CleanseCss) { } TEST(TemplateModifiers, JavascriptEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestJavascriptEscape", NULL); + ctemplate::TemplateDictionary dict("TestJavascriptEscape", NULL); dict.SetEscapedValue("easy JS", "joo", - GOOGLE_NAMESPACE::javascript_escape); + ctemplate::javascript_escape); dict.SetEscapedValue("harder JS", "f = 'joo';", - GOOGLE_NAMESPACE::javascript_escape); + ctemplate::javascript_escape); dict.SetEscapedValue("hardest JS", ("f = 'foo\f';\r\n\tprint \"\\&foo = \b\", \"foo\""), - GOOGLE_NAMESPACE::javascript_escape); + ctemplate::javascript_escape); dict.SetEscapedValue("close script JS", "//-->", - GOOGLE_NAMESPACE::javascript_escape); + ctemplate::javascript_escape); dict.SetEscapedValue("unicode codepoints", ("line1" "\xe2\x80\xa8" "line2" "\xe2\x80\xa9" "line3" /* \u2027 */ "\xe2\x80\xa7" /* \u202A */ "\xe2\x80\xaa" /* malformed */ "\xe2" "\xe2\x80\xa8" /* truncated */ "\xe2\x80"), - GOOGLE_NAMESPACE::javascript_escape); + ctemplate::javascript_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy JS"), "joo"); EXPECT_STREQ(peer.GetSectionValue("harder JS"), "f \\x3d \\x27joo\\x27;"); EXPECT_STREQ(peer.GetSectionValue("hardest JS"), @@ -637,59 +637,59 @@ TEST(TemplateModifiers, JavascriptEscape) { } TEST(TemplateModifiers, JavascriptNumber) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestJavascriptNumber", NULL); + ctemplate::TemplateDictionary dict("TestJavascriptNumber", NULL); dict.SetEscapedValue("empty string", "", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("boolean true", "true", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("boolean false", "false", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad boolean 1", "tfalse", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad boolean 2", "tru", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad boolean 3", "truee", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad boolean 4", "invalid", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); // Check that our string comparisons for booleans do not // assume input is null terminated. - dict.SetEscapedValue("good boolean 5", GOOGLE_NAMESPACE::TemplateString("truee", 4), - GOOGLE_NAMESPACE::javascript_number); - dict.SetEscapedValue("bad boolean 6", GOOGLE_NAMESPACE::TemplateString("true", 3), - GOOGLE_NAMESPACE::javascript_number); + dict.SetEscapedValue("good boolean 5", ctemplate::TemplateString("truee", 4), + ctemplate::javascript_number); + dict.SetEscapedValue("bad boolean 6", ctemplate::TemplateString("true", 3), + ctemplate::javascript_number); dict.SetEscapedValue("hex number 1", "0x123456789ABCDEF", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("hex number 2", "0X123456789ABCDEF", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad hex number 1", "0x123GAC", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("bad hex number 2", "0x", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("number zero", "0", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("invalid number", "A9", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("decimal zero", "0.0", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("octal number", "01234567", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("decimal number", "799.123", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("negative number", "-244", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("positive number", "+244", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("valid float 1", ".55", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("valid float 2", "8.55e-12", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); dict.SetEscapedValue("invalid float", "8.55ABC", - GOOGLE_NAMESPACE::javascript_number); + ctemplate::javascript_number); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("empty string"), ""); EXPECT_STREQ(peer.GetSectionValue("boolean true"), "true"); EXPECT_STREQ(peer.GetSectionValue("boolean false"), "false"); @@ -716,18 +716,18 @@ TEST(TemplateModifiers, JavascriptNumber) { } TEST(TemplateModifiers, JsonEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestJsonEscape", NULL); + ctemplate::TemplateDictionary dict("TestJsonEscape", NULL); dict.SetEscapedValue("easy JSON", "joo", - GOOGLE_NAMESPACE::json_escape); + ctemplate::json_escape); dict.SetEscapedValue("harder JSON", "f = \"joo\"; e = 'joo';", - GOOGLE_NAMESPACE::json_escape); + ctemplate::json_escape); dict.SetEscapedValue("hardest JSON", "f = 'foo<>';\r\n\t\fprint \"\\&foo = /\b\", \"foo\"", - GOOGLE_NAMESPACE::json_escape); + ctemplate::json_escape); dict.SetEscapedValue("html in JSON", " ", - GOOGLE_NAMESPACE::json_escape); + ctemplate::json_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("easy JSON"), "joo"); EXPECT_STREQ(peer.GetSectionValue("harder JSON"), "f = \\\"joo\\\"; " "e = 'joo';"); @@ -743,26 +743,26 @@ TEST(TemplateModifiers, JsonEscape) { } TEST(TemplateModifiers, UrlQueryEscape) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestUrlQueryEscape", NULL); + ctemplate::TemplateDictionary dict("TestUrlQueryEscape", NULL); // The first three tests do not need escaping. dict.SetEscapedValue("query escape 0", "", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 1", "noop", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 2", "0123456789abcdefghjijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ.-_*/~!(),", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 3", " ?a=b;c#d ", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 4", "#$%&+<=>?@[\\]^`{|}", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 5", "\xDE\xAD\xCA\xFE", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); dict.SetEscapedValue("query escape 6", "\"':", - GOOGLE_NAMESPACE::url_query_escape); + ctemplate::url_query_escape); - GOOGLE_NAMESPACE::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts + ctemplate::TemplateDictionaryPeer peer(&dict); // peer can look inside dicts EXPECT_STREQ(peer.GetSectionValue("query escape 0"), ""); EXPECT_STREQ(peer.GetSectionValue("query escape 1"), "noop"); EXPECT_STREQ(peer.GetSectionValue("query escape 2"), @@ -776,189 +776,189 @@ TEST(TemplateModifiers, UrlQueryEscape) { } TEST(TemplateModifiers, PrefixLine) { - GOOGLE_NAMESPACE::TemplateDictionary dict("TestPrefixLine", NULL); + ctemplate::TemplateDictionary dict("TestPrefixLine", NULL); // These don't escape: we don't put the prefix before the first line - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1", " ").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1", " ").c_str(), "pt 1"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1", "::").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1", "::").c_str(), "pt 1"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\npt 2", ":").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\npt 2", ":").c_str(), "pt 1\n:pt 2"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\npt 2", " ").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\npt 2", " ").c_str(), "pt 1\n pt 2"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\npt 2", "\n").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\npt 2", "\n").c_str(), "pt 1\n\npt 2"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\npt 2\n", " ").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\npt 2\n", " ").c_str(), "pt 1\n pt 2\n "); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\rpt 2\n", ":").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\rpt 2\n", ":").c_str(), "pt 1\r:pt 2\n:"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\npt 2\r", ":").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\npt 2\r", ":").c_str(), "pt 1\n:pt 2\r:"); - EXPECT_STREQ(GOOGLE_NAMESPACE::prefix_line("pt 1\r\npt 2\r", ":").c_str(), + EXPECT_STREQ(ctemplate::prefix_line("pt 1\r\npt 2\r", ":").c_str(), "pt 1\r\n:pt 2\r:"); } TEST(TemplateModifiers, FindModifier) { - const GOOGLE_NAMESPACE::ModifierInfo* info; - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("html_escape", 11, "", 0))); - EXPECT_EQ(info->modifier, &GOOGLE_NAMESPACE::html_escape); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("h", 1, "", 0))); - EXPECT_EQ(info->modifier, &GOOGLE_NAMESPACE::html_escape); + const ctemplate::ModifierInfo* info; + EXPECT_TRUE((info = ctemplate::FindModifier("html_escape", 11, "", 0))); + EXPECT_EQ(info->modifier, &ctemplate::html_escape); + EXPECT_TRUE((info = ctemplate::FindModifier("h", 1, "", 0))); + EXPECT_EQ(info->modifier, &ctemplate::html_escape); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("html_escape_with_arg", 20, + EXPECT_TRUE((info = ctemplate::FindModifier("html_escape_with_arg", 20, "=pre", 4))); - EXPECT_EQ(info->modifier, &GOOGLE_NAMESPACE::pre_escape); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("H", 1, "=pre", 4))); - EXPECT_EQ(info->modifier, &GOOGLE_NAMESPACE::pre_escape); + EXPECT_EQ(info->modifier, &ctemplate::pre_escape); + EXPECT_TRUE((info = ctemplate::FindModifier("H", 1, "=pre", 4))); + EXPECT_EQ(info->modifier, &ctemplate::pre_escape); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("javascript_escape_with_arg", + EXPECT_TRUE((info = ctemplate::FindModifier("javascript_escape_with_arg", 26, "=number", 7))); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("J", 1, "=number", 7))); - EXPECT_EQ(info->modifier, &GOOGLE_NAMESPACE::javascript_number); + EXPECT_TRUE((info = ctemplate::FindModifier("J", 1, "=number", 7))); + EXPECT_EQ(info->modifier, &ctemplate::javascript_number); // html_escape_with_arg doesn't have a default value, so these should fail. - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("H", 1, "=pre", 2)); // "=p" - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("H", 1, "=pree", 5)); - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("H", 1, "=notpresent", 11)); + EXPECT_FALSE(ctemplate::FindModifier("H", 1, "=pre", 2)); // "=p" + EXPECT_FALSE(ctemplate::FindModifier("H", 1, "=pree", 5)); + EXPECT_FALSE(ctemplate::FindModifier("H", 1, "=notpresent", 11)); // If we don't have a modifier-value when we ought, we should fail. - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("html_escape", 11, "=p", 2)); - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("h", 1, "=p", 2)); + EXPECT_FALSE(ctemplate::FindModifier("html_escape", 11, "=p", 2)); + EXPECT_FALSE(ctemplate::FindModifier("h", 1, "=p", 2)); - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("html_escape_with_arg", 20, + EXPECT_FALSE(ctemplate::FindModifier("html_escape_with_arg", 20, "", 0)); - EXPECT_FALSE(GOOGLE_NAMESPACE::FindModifier("H", 1, "", 0)); + EXPECT_FALSE(ctemplate::FindModifier("H", 1, "", 0)); // Test with added modifiers as well. - GOOGLE_NAMESPACE::NullModifier foo_modifier1; - GOOGLE_NAMESPACE::NullModifier foo_modifier2; - GOOGLE_NAMESPACE::NullModifier foo_modifier3; - GOOGLE_NAMESPACE::NullModifier foo_modifier4; - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-test", &foo_modifier1)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-test-arg=", &foo_modifier2)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-test-arg=h", &foo_modifier3)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-test-arg=json", &foo_modifier4)); + ctemplate::NullModifier foo_modifier1; + ctemplate::NullModifier foo_modifier2; + ctemplate::NullModifier foo_modifier3; + ctemplate::NullModifier foo_modifier4; + EXPECT_TRUE(ctemplate::AddModifier("x-test", &foo_modifier1)); + EXPECT_TRUE(ctemplate::AddModifier("x-test-arg=", &foo_modifier2)); + EXPECT_TRUE(ctemplate::AddModifier("x-test-arg=h", &foo_modifier3)); + EXPECT_TRUE(ctemplate::AddModifier("x-test-arg=json", &foo_modifier4)); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test", 6, "", 0))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test", 6, "", 0))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier1); - EXPECT_EQ(info->xss_class, GOOGLE_NAMESPACE::XSS_UNIQUE); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test", 6, "=h", 2))); + EXPECT_EQ(info->xss_class, ctemplate::XSS_UNIQUE); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test", 6, "=h", 2))); EXPECT_FALSE(info->is_registered); // This tests default values - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, "=p", 2))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=p", 2))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier2); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, "=h", 2))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=h", 2))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier3); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, "=html", 5))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=html", 5))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier2); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, "=json", 5))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=json", 5))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier4); // The value is required to start with an '=' to match the // specialization. If it doesn't, it will match the default. - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, "json", 4))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "json", 4))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier2); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=jsonnabbe", 5))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier4); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=jsonnabbe", 6))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier2); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-test-arg", 10, + EXPECT_TRUE((info = ctemplate::FindModifier("x-test-arg", 10, "=jsonnabbe", 4))); EXPECT_TRUE(info->is_registered); EXPECT_EQ(info->modifier, &foo_modifier2); // If we try to find an x- modifier that wasn't added, we should get // a legit but "unknown" modifier back. - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-foo", 5, "", 0))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-foo", 5, "", 0))); EXPECT_FALSE(info->is_registered); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-bar", 5, "=p", 2))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-bar", 5, "=p", 2))); EXPECT_FALSE(info->is_registered); // Basic test with added XssSafe modifier. - GOOGLE_NAMESPACE::NullModifier foo_modifier5; - EXPECT_TRUE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-safetest", + ctemplate::NullModifier foo_modifier5; + EXPECT_TRUE(ctemplate::AddXssSafeModifier("x-safetest", &foo_modifier5)); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-safetest", 10, "", 0))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-safetest", 10, "", 0))); EXPECT_TRUE(info->is_registered); - EXPECT_EQ(info->xss_class, GOOGLE_NAMESPACE::XSS_SAFE); + EXPECT_EQ(info->xss_class, ctemplate::XSS_SAFE); EXPECT_EQ(info->modifier, &foo_modifier5); } TEST(TemplateModifiers, AddModifier) { - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=h", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=html", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=json", &GOOGLE_NAMESPACE::json_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=j", &GOOGLE_NAMESPACE::json_escape)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=J", &GOOGLE_NAMESPACE::json_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest", &ctemplate::html_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=", &ctemplate::html_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=h", &ctemplate::html_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=html", &ctemplate::html_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=json", &ctemplate::json_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=j", &ctemplate::json_escape)); + EXPECT_TRUE(ctemplate::AddModifier("x-atest-arg=J", &ctemplate::json_escape)); // Make sure AddModifier fails with an invalid name. - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("test", &GOOGLE_NAMESPACE::html_escape)); + EXPECT_FALSE(ctemplate::AddModifier("test", &ctemplate::html_escape)); // Make sure AddModifier fails with a duplicate name. - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-atest", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=h", &GOOGLE_NAMESPACE::html_escape)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-atest-arg=html", &GOOGLE_NAMESPACE::html_escape)); + EXPECT_FALSE(ctemplate::AddModifier("x-atest", &ctemplate::html_escape)); + EXPECT_FALSE(ctemplate::AddModifier("x-atest-arg=", &ctemplate::html_escape)); + EXPECT_FALSE(ctemplate::AddModifier("x-atest-arg=h", &ctemplate::html_escape)); + EXPECT_FALSE(ctemplate::AddModifier("x-atest-arg=html", &ctemplate::html_escape)); - const GOOGLE_NAMESPACE::ModifierInfo* info; - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-atest", 7, "", 0))); + const ctemplate::ModifierInfo* info; + EXPECT_TRUE((info = ctemplate::FindModifier("x-atest", 7, "", 0))); EXPECT_FALSE(info->modval_required); // Make sure we can still add a modifier after having already // searched for it. - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-foo", 5, "", 0))); + EXPECT_TRUE((info = ctemplate::FindModifier("x-foo", 5, "", 0))); EXPECT_FALSE(info->is_registered); - GOOGLE_NAMESPACE::NullModifier foo_modifier; - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-foo", &foo_modifier)); - EXPECT_TRUE((info = GOOGLE_NAMESPACE::FindModifier("x-foo", 5, "", 0))); + ctemplate::NullModifier foo_modifier; + EXPECT_TRUE(ctemplate::AddModifier("x-foo", &foo_modifier)); + EXPECT_TRUE((info = ctemplate::FindModifier("x-foo", 5, "", 0))); EXPECT_EQ(info->modifier, &foo_modifier); } TEST(TemplateModifiers, AddXssSafeModifier) { // For shorter lines. - const GOOGLE_NAMESPACE::TemplateModifier* esc_fn = - &GOOGLE_NAMESPACE::html_escape; + const ctemplate::TemplateModifier* esc_fn = + &ctemplate::html_escape; - EXPECT_TRUE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest", esc_fn)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest-arg=", esc_fn)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest-arg=h", esc_fn)); + EXPECT_TRUE(ctemplate::AddXssSafeModifier("x-asafetest", esc_fn)); + EXPECT_TRUE(ctemplate::AddXssSafeModifier("x-asafetest-arg=", esc_fn)); + EXPECT_TRUE(ctemplate::AddXssSafeModifier("x-asafetest-arg=h", esc_fn)); // Make sure AddXssSafeModifier fails with an invalid name. - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("test", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("test", esc_fn)); // Make sure AddXssSafeModifier fails with a duplicate name. - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest-arg=", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-asafetest-arg=h", + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-asafetest", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-asafetest-arg=", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-asafetest-arg=h", esc_fn)); // Make sure AddXssSafeModifier fails if the same modifier was // previously added via AddModifier. - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-safetest2", esc_fn)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-safetest2-arg=", esc_fn)); - EXPECT_TRUE(GOOGLE_NAMESPACE::AddModifier("x-safetest2-arg=h", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-safetest2", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-safetest2-arg=", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddXssSafeModifier("x-safetest2-arg=h", esc_fn)); + EXPECT_TRUE(ctemplate::AddModifier("x-safetest2", esc_fn)); + EXPECT_TRUE(ctemplate::AddModifier("x-safetest2-arg=", esc_fn)); + EXPECT_TRUE(ctemplate::AddModifier("x-safetest2-arg=h", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-safetest2", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-safetest2-arg=", esc_fn)); + EXPECT_FALSE(ctemplate::AddXssSafeModifier("x-safetest2-arg=h", esc_fn)); // and vice versa. - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-asafetest", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-asafetest-arg=", esc_fn)); - EXPECT_FALSE(GOOGLE_NAMESPACE::AddModifier("x-asafetest-arg=h", esc_fn)); + EXPECT_FALSE(ctemplate::AddModifier("x-asafetest", esc_fn)); + EXPECT_FALSE(ctemplate::AddModifier("x-asafetest-arg=", esc_fn)); + EXPECT_FALSE(ctemplate::AddModifier("x-asafetest-arg=h", esc_fn)); } // Helper function. Determines whether the Modifier specified by @@ -967,10 +967,10 @@ TEST(TemplateModifiers, AddXssSafeModifier) { static bool CheckXSSAlternative(const string& modname, const string& modval, const string& alt_modname, const string& alt_modval) { - const GOOGLE_NAMESPACE::ModifierInfo *mod, *alt_mod; - mod = GOOGLE_NAMESPACE::FindModifier(modname.c_str(), modname.length(), + const ctemplate::ModifierInfo *mod, *alt_mod; + mod = ctemplate::FindModifier(modname.c_str(), modname.length(), modval.c_str(), modval.length()); - alt_mod = GOOGLE_NAMESPACE::FindModifier(alt_modname.c_str(), + alt_mod = ctemplate::FindModifier(alt_modname.c_str(), alt_modname.length(), alt_modval.c_str(), alt_modval.length()); @@ -1039,48 +1039,48 @@ TEST(TemplateModifiers, XSSAlternatives) { // This is a basic sanity check for the GetDefaultModifierForXXX() functions. // More testing happens in AutoEscaper code which uses them. TEST(TemplateModifiers, DefaultModifiersForContext) { - const GOOGLE_NAMESPACE::ModifierAndValue* modval; + const ctemplate::ModifierAndValue* modval; string print_mods; - const vector modvals_html = - GOOGLE_NAMESPACE::GetDefaultModifierForHtml(); + const vector modvals_html = + ctemplate::GetDefaultModifierForHtml(); EXPECT_EQ(1, modvals_html.size()); - print_mods = GOOGLE_NAMESPACE::PrettyPrintModifiers(modvals_html, ";"); + print_mods = ctemplate::PrettyPrintModifiers(modvals_html, ";"); EXPECT_STREQ(":h", print_mods.c_str()); modval = modvals_html.front(); - EXPECT_EQ(modval->modifier_info->modifier, &GOOGLE_NAMESPACE::html_escape); + EXPECT_EQ(modval->modifier_info->modifier, &ctemplate::html_escape); - const vector modvals_js = - GOOGLE_NAMESPACE::GetDefaultModifierForJs(); + const vector modvals_js = + ctemplate::GetDefaultModifierForJs(); EXPECT_EQ(1, modvals_js.size()); - print_mods = GOOGLE_NAMESPACE::PrettyPrintModifiers(modvals_js, ";"); + print_mods = ctemplate::PrettyPrintModifiers(modvals_js, ";"); EXPECT_STREQ(":j", print_mods.c_str()); modval = modvals_js.front(); - EXPECT_EQ(modval->modifier_info->modifier, &GOOGLE_NAMESPACE::javascript_escape); + EXPECT_EQ(modval->modifier_info->modifier, &ctemplate::javascript_escape); - const vector modvals_xml = - GOOGLE_NAMESPACE::GetDefaultModifierForXml(); + const vector modvals_xml = + ctemplate::GetDefaultModifierForXml(); EXPECT_EQ(1, modvals_xml.size()); - print_mods = GOOGLE_NAMESPACE::PrettyPrintModifiers(modvals_xml, ";"); + print_mods = ctemplate::PrettyPrintModifiers(modvals_xml, ";"); EXPECT_STREQ(":xml_escape", print_mods.c_str()); modval = modvals_xml.front(); - EXPECT_EQ(modval->modifier_info->modifier, &GOOGLE_NAMESPACE::xml_escape); + EXPECT_EQ(modval->modifier_info->modifier, &ctemplate::xml_escape); - const vector modvals_json = - GOOGLE_NAMESPACE::GetDefaultModifierForJson(); + const vector modvals_json = + ctemplate::GetDefaultModifierForJson(); EXPECT_EQ(1, modvals_json.size()); - print_mods = GOOGLE_NAMESPACE::PrettyPrintModifiers(modvals_json, ";"); + print_mods = ctemplate::PrettyPrintModifiers(modvals_json, ";"); EXPECT_STREQ(":j", print_mods.c_str()); modval = modvals_json.front(); - EXPECT_EQ(modval->modifier_info->modifier, &GOOGLE_NAMESPACE::javascript_escape); + EXPECT_EQ(modval->modifier_info->modifier, &ctemplate::javascript_escape); } // This tests for a bug we had where we were returning a pointer into // a vector that became invalid after the vector was resized. TEST(TemplateModifiers, ManyUnknownModifiers) { string tpl_str1 = "{{from_name:x-test=4}} sent you a message"; - const GOOGLE_NAMESPACE::Template* tpl1 = GOOGLE_NAMESPACE::Template::StringToTemplate( - tpl_str1, GOOGLE_NAMESPACE::DO_NOT_STRIP); + const ctemplate::Template* tpl1 = ctemplate::Template::StringToTemplate( + tpl_str1, ctemplate::DO_NOT_STRIP); string tpl_str2 = "{{from_name:x-test=4}} sent you a message:"; string expected_out = "me sent you a message:"; @@ -1090,12 +1090,12 @@ TEST(TemplateModifiers, ManyUnknownModifiers) { tpl_str2.append("{{from_name:x-" + string(i, 't') + "=4}}"); expected_out.append("me"); } - const GOOGLE_NAMESPACE::Template* tpl2 = GOOGLE_NAMESPACE::Template::StringToTemplate( - tpl_str2, GOOGLE_NAMESPACE::DO_NOT_STRIP); + const ctemplate::Template* tpl2 = ctemplate::Template::StringToTemplate( + tpl_str2, ctemplate::DO_NOT_STRIP); // Even after the resizing, the references to the unknown // modifiers in tpl1 and tpl2 should still be valid. - GOOGLE_NAMESPACE::TemplateDictionary dict("test"); + ctemplate::TemplateDictionary dict("test"); dict.SetValue("from_name", "me"); string out;