", xmlString.trim());
simpleXmlSerializer.setCreatingHtmlDom(true);
// then test when generating html
String domString = simpleXmlSerializer.getAsString(node, "UTF-8");
assertEquals("\n" +
// "
&"''<> &garbage;&
",
"
&"''<> &garbage;&
",
domString.trim());
}
/**
* make sure that the unicode character has leading 'x'.
*
*
ŠA; is converted by FF to 3 characters: Š + 'A' + ';'
*
�x138A; is converted by FF to 6? 7? characters: � 'x'+'1'+'3'+
* '8' + 'A' + ';' #0 is displayed kind of weird
*
ᎊ is a single character
*
*
* @throws Exception
*/
public void testHexConversion() throws Exception {
CleanerProperties properties = new CleanerProperties();
properties.setOmitHtmlEnvelope(true);
properties.setOmitXmlDeclaration(true);
SimpleXmlSerializer simpleXmlSerializer = new SimpleXmlSerializer(properties);
simpleXmlSerializer.setCreatingHtmlDom(false);
String xmlString = simpleXmlSerializer.getAsString( "
", xmlString);
properties.reset();
}
public void testPattern() {
for (Object[] test : new Object[][] {
new Object[] { "0x138A;", false, -1, -1, null, true, 0, 7, "x138A", true, 0, 1, "0" },
new Object[] { "x138A;", true, 0, 6, "x138A", true, 0, 6, "x138A", false, -1, -1, null },
new Object[] { "138;", false, -1, -1, null, false, -1, -1, null, true, 0, 4, "138" },
new Object[] { "139", false, -1, -1, null, false, -1, -1, null, true, 0, 3, "139" },
new Object[] { "x13A", true, 0, 4, "x13A", true, 0, 4, "x13A", false, -1, -1, null },
new Object[] { "13F", false, -1, -1, null, false, -1, -1, null, true, 0, 2, "13" },
new Object[] { "13", false, -1, -1, null, false, -1, -1, null, true, 0, 2, "13" },
new Object[] { "X13AZ", true, 0, 4, "X13A", true, 0, 4, "X13A", false, -1, -1, null } }) {
int i = 0;
String input = (String) test[i++];
boolean strict = (Boolean) test[i++];
int sstart = (Integer) test[i++];
int send = (Integer) test[i++];
String sgroup = (String) test[i++];
boolean relaxed = (Boolean) test[i++];
int rstart = (Integer) test[i++];
int rend = (Integer) test[i++];
String rgroup = (String) test[i++];
boolean decimal = (Boolean) test[i++];
int dstart = (Integer) test[i++];
int dend = (Integer) test[i++];
String dgroup = (String) test[i++];
Matcher m = Utils.HEX_STRICT.matcher(input);
boolean actual = m.find();
assertEquals(input, strict, actual);
if (actual) {
assertEquals(input + " strict start ", sstart, m.start());
assertEquals(input + " strict end ", send, m.end());
assertEquals(input + " strict group ", sgroup, m.group(1));
}
m = Utils.HEX_RELAXED.matcher(input);
actual = m.find();
assertEquals(input, relaxed, actual);
if (actual) {
assertEquals(input + " relaxed start ", rstart, m.start());
assertEquals(input + " relaxed end ", rend, m.end());
assertEquals(input + " relaxed group ", rgroup, m.group(1));
}
m = Utils.DECIMAL.matcher(input);
actual = m.find();
assertEquals(input, decimal, actual);
if (actual) {
assertEquals(input + " decimal start ", dstart, m.start());
assertEquals(input + " decimal end ", dend, m.end());
assertEquals(input + " decimal group ", dgroup, m.group(1));
}
}
}
public void testConvertUnicode() throws Exception {
CleanerProperties cleanerProperties = new CleanerProperties();
cleanerProperties.setOmitHtmlEnvelope(true);
cleanerProperties.setOmitXmlDeclaration(true);
cleanerProperties.setUseEmptyElementTags(false);
// right tick is special unicode character 8217
String output = new SimpleXmlSerializer(cleanerProperties).getAsString(
"
President’s Message
");
assertEquals("
President’s Message
", output);
}
private static final String HTML_COMMENT_OUT_BEGIN = "";
private static final String SAMPLE_JS = "var x = ['foo','bar'];";
private static final String COMMENT_START = "";
/**
* Test conversion of former ( now bad practice ) of:
*
*
* <style><!-- style info --></style>
*
*
* into <style>/(star)<![CDATA[(star)/ style info
* /(star)]]>(star)/</style>
*
* Note: disabled because it doesn't test actual behavior
* @throws IOException
*/
public void disabledTestConvertOldStyleComments() throws IOException {
// TODO: May need additional flag to handle '<' inside of scripts
// dontEscape() in xml serializer should not be triggered based on use
// cdata
// but dontEscape is used by subclasses -- need to investigate best
// solution.
// maybe o.k. to have the < > be translated. That is what original test
// does.
// but the ' should probably not be touched??
HtmlCleaner cleaner = new HtmlCleaner();
CleanerProperties properties = new CleanerProperties();
properties.setOmitXmlDeclaration(true);
properties.setUseCdataForScriptAndStyle(true);
properties.setAddNewlineToHeadAndBody(false);
// test for positive matches to old-style comment hacks
for (String[] testData : new String[][] {
// normal case - remove old-style comment out hack
new String[] {
HTML_COMMENT_OUT_BEGIN + "//" + COMMENT_START + "\n" + SAMPLE_JS + "//" + COMMENT_END + "\n"
+ HTML_COMMENT_OUT_END,
HTML_COMMENT_OUT_BEGIN + CData.SAFE_BEGIN_CDATA + "\n" + SAMPLE_JS
+ CData.SAFE_END_CDATA + "\n" + HTML_COMMENT_OUT_END },
// don't let random whitespace confuse things
new String[] {
HTML_COMMENT_OUT_BEGIN + "\n\n\n\n" + "//" + " \t" + COMMENT_START + "\n" + SAMPLE_JS
+ "\n\n\n" + "//" + COMMENT_END + "\n\n\t\n" + HTML_COMMENT_OUT_END,
HTML_COMMENT_OUT_BEGIN + "\n\n\n\n" + CData.SAFE_BEGIN_CDATA + "\n" + SAMPLE_JS
+ "\n\n\n" + "//" + CData.SAFE_END_CDATA + "\n\n\t\n" + HTML_COMMENT_OUT_END },
}) {
doTestConvertOldStyleComments(cleaner, properties, testData);
}
// test for false positives
for (String[] testData : new String[][] {
// make sure not to remove real comments
new String[] {
HTML_COMMENT_OUT_BEGIN + "//" + "an ordinary comment" + "\n" + SAMPLE_JS + "//" + "a final remark"
+ HTML_COMMENT_OUT_END,
HTML_COMMENT_OUT_BEGIN + CData.SAFE_BEGIN_CDATA + "//" + "an ordinary comment" + "\n"
+ SAMPLE_JS + "//" + "a final remark" + CData.SAFE_END_CDATA + HTML_COMMENT_OUT_END }, }) {
doTestConvertOldStyleComments(cleaner, properties, testData);
}
}
/**
* @param cleaner
* @param properties
* @param testData
*/
private void doTestConvertOldStyleComments(HtmlCleaner cleaner, CleanerProperties properties, String[] testData)
throws IOException {
TagNode node = cleaner.clean(testData[0]);
// test to make sure the no-op still works
properties.setUseCdataForScriptAndStyle(false);
String xmlString = new SimpleXmlSerializer(properties).getAsString(node);
assertEquals(testData[0], xmlString);
// now test actual
properties.setUseCdataForScriptAndStyle(true);
xmlString = new SimpleXmlSerializer(properties).getAsString(node);
assertEquals(testData[1], xmlString);
}
public void testIgnoreClosingCData() throws IOException {
String html = "\n"
+ "ASWA - Events"
+ "";
CleanerProperties properties = new CleanerProperties();
properties.setOmitXmlDeclaration(true);
properties.setUseCdataForScriptAndStyle(true);
properties.setAddNewlineToHeadAndBody(false);
properties.setIgnoreQuestAndExclam(false);
HtmlCleaner cleaner = new HtmlCleaner(properties);
TagNode node = cleaner.clean(html);
//properties.setUseCdataForScriptAndStyle(false);
String xmlString = new SimpleXmlSerializer(properties).getAsString(node);
assertEquals(html, xmlString);
}
public void testTransResCharsToNCR() throws Exception {
HtmlCleaner cleaner = new HtmlCleaner();
CleanerProperties properties = cleaner.getProperties();
String xmlString;
properties.setNamespacesAware(false);
properties.setAdvancedXmlEscape(true);
properties.setTransResCharsToNCR(true);
xmlString = getXmlString(cleaner, properties);
assertTrue(xmlString.indexOf("