433 lines
18 KiB
Java
433 lines
18 KiB
Java
/*
|
|
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8008738 8065138
|
|
* @summary checks that the mapping implemented by
|
|
* com.sun.org.apache.xml.internal.serializer.Encodings
|
|
* correctly identifies valid Charset names and
|
|
* correctly maps them to their preferred mime names.
|
|
* Also checks that the Encodings.properties resource file
|
|
* is consistent.
|
|
* @modules java.xml/com.sun.org.apache.xml.internal.serializer:+open
|
|
* @compile -XDignore.symbol.file CheckEncodingPropertiesFile.java
|
|
* @run main CheckEncodingPropertiesFile
|
|
* @author Daniel Fuchs
|
|
*/
|
|
|
|
import com.sun.org.apache.xml.internal.serializer.EncodingInfo;
|
|
import com.sun.org.apache.xml.internal.serializer.Encodings;
|
|
import java.io.InputStreamReader;
|
|
import java.lang.reflect.Method;
|
|
import java.nio.charset.Charset;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Properties;
|
|
import java.util.Set;
|
|
import java.util.StringTokenizer;
|
|
|
|
public class CheckEncodingPropertiesFile {
|
|
|
|
private static final String ENCODINGS_FILE = "com/sun/org/apache/xml/internal/serializer/Encodings.properties";
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
Properties props = new Properties();
|
|
Module xmlModule = EncodingInfo.class.getModule();
|
|
try (InputStreamReader is = new InputStreamReader(xmlModule.getResourceAsStream(ENCODINGS_FILE))) {
|
|
props.load(is);
|
|
}
|
|
|
|
if (!props.containsKey("UTF8")) {
|
|
// If the test fails here - it may indicate that you stumbled on an
|
|
// issue similar to that fixed by JDK-8065138.
|
|
// Check that the content of the Encodings.properties included in
|
|
// the tested build image matches the content of the file in the source
|
|
// jaxp tree of the jdk forest.
|
|
throw new RuntimeException("UTF8 key missing in " + ENCODINGS_FILE);
|
|
}
|
|
|
|
//printAllCharsets();
|
|
|
|
test(props);
|
|
}
|
|
|
|
|
|
private static final class CheckCharsetMapping {
|
|
|
|
/**
|
|
* A map that maps Java or XML name to canonical charset names.
|
|
* key: upper cased value of Java or XML name.
|
|
* value: case-sensitive canonical name of charset.
|
|
*/
|
|
private final Map<String, String> charsetMap = new HashMap<>();
|
|
|
|
private final Map<String, String> preferredMime = new HashMap<>();
|
|
|
|
/**
|
|
* Unresolved alias names.
|
|
* For a given set of names pointing to the same unresolved charset,
|
|
* this map will contain, for each alias in the set, a mapping
|
|
* with the alias.toUpperValue() as key and the set of known aliases
|
|
* as value.
|
|
*/
|
|
private final Map<String, Collection<String>> unresolved = new HashMap<>();
|
|
|
|
public final static class ConflictingCharsetError extends Error {
|
|
ConflictingCharsetError(String a, String cs1, String cs2) {
|
|
super("Conflicting charset mapping for '"+a+"': '"+cs1+"' and '"+cs2+"'");
|
|
}
|
|
}
|
|
|
|
public final static class MissingValidCharsetNameError extends Error {
|
|
MissingValidCharsetNameError(String name, Collection<String> aliases) {
|
|
super(name+": Line "+aliases+" has no recognized charset alias");
|
|
}
|
|
}
|
|
|
|
public final static class ConflictingPreferredMimeNameError extends Error {
|
|
ConflictingPreferredMimeNameError(String a, String cs1, String cs2) {
|
|
super("Conflicting preferred mime name for '"+a+"': '"+cs1+"' and '"+cs2+"'");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For each alias in aliases, attempt to find the canonical
|
|
* charset name.
|
|
* All names in aliases are supposed to point to the same charset.
|
|
* Names in aliases can be java names or XML names, indifferently.
|
|
* @param aliases list of names (aliases) for a given charset.
|
|
* @return The canonical name of the charset, if found, null otherwise.
|
|
*/
|
|
private String findCharsetNameFor(String[] aliases) {
|
|
String cs = null;
|
|
String res = null;
|
|
for (String a : aliases) {
|
|
final String k = a.toUpperCase();
|
|
String cachedCs = charsetMap.get(k);
|
|
if (cs == null) {
|
|
cs = cachedCs;
|
|
}
|
|
if (cachedCs != null && cs != null
|
|
&& !Charset.forName(cachedCs).name().equals(Charset.forName(cs).name())) {
|
|
throw new ConflictingCharsetError(a,cs,cachedCs);
|
|
}
|
|
try {
|
|
final String rcs = Charset.forName(a).name();
|
|
if (cs != null && !Charset.forName(cs).name().equals(rcs)) {
|
|
throw new ConflictingCharsetError(a,cs,rcs);
|
|
}
|
|
if (res == null) {
|
|
if (a.equals(aliases[0])) {
|
|
res = a;
|
|
} else {
|
|
res = cs;
|
|
}
|
|
}
|
|
cs = rcs;
|
|
charsetMap.put(k, res == null ? cs : res);
|
|
} catch (Exception x) {
|
|
continue;
|
|
}
|
|
}
|
|
return res == null ? cs : res;
|
|
}
|
|
|
|
/**
|
|
* Register a canonical charset name for a given set of aliases.
|
|
*
|
|
* @param charsetName the canonical charset name.
|
|
* @param aliases a list of aliases for the given charset.
|
|
*/
|
|
private void registerCharsetNameFor(String charsetName, String[] aliases) {
|
|
if (charsetName == null) throw new NullPointerException();
|
|
|
|
for (String a : aliases) {
|
|
String k = a.toUpperCase();
|
|
String csv = charsetMap.get(k);
|
|
if (csv == null) {
|
|
charsetMap.put(k, charsetName);
|
|
csv = charsetName;
|
|
} else if (!csv.equals(charsetName)) {
|
|
throw new ConflictingCharsetError(a,charsetName,csv);
|
|
}
|
|
|
|
final Collection<String> c = unresolved.get(k);
|
|
if (c != null) {
|
|
for (String aa : c) {
|
|
k = aa.toUpperCase();
|
|
String csvv = charsetMap.get(k);
|
|
if (csvv == null) charsetMap.put(k, csv);
|
|
unresolved.remove(k);
|
|
}
|
|
throw new MissingValidCharsetNameError(charsetName,c);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a set of aliases as being unresolved.
|
|
* @param names the list of names - this should be what is returned by
|
|
* nameSet.toArray(new String[nameSet.size()])
|
|
* @param nameSet the set of unresolved aliases.
|
|
*/
|
|
private void registerUnresolvedNamesFor(String[] names, Collection<String> nameSet) {
|
|
// This is not necessarily an error: it could happen that some
|
|
// charsets are simply not supported on some OS/Arch
|
|
System.err.println("Warning: unresolved charset names: '"+ nameSet
|
|
+ "' This is not necessarily an error "
|
|
+ "- this charset may not be supported on this platform.");
|
|
for (String a : names) {
|
|
final String k = a.toUpperCase();
|
|
final Collection<String> c = unresolved.get(k);
|
|
if (c != null) {
|
|
//System.out.println("Found: "+a+" -> "+c);
|
|
//System.out.println("\t merging "+ c + " with " + nameSet);
|
|
nameSet.addAll(c);
|
|
for (String aa : c) {
|
|
unresolved.put(aa.toUpperCase(), nameSet);
|
|
}
|
|
}
|
|
unresolved.put(k, nameSet);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Add a new charset name mapping
|
|
* @param javaName the (supposedly) java name of the charset.
|
|
* @param xmlNames a list of corresponding XML names for that charset.
|
|
*/
|
|
void addMapping(String javaName, Collection<String> xmlNames) {
|
|
final LinkedHashSet<String> aliasNames = new LinkedHashSet<>();
|
|
aliasNames.add(javaName);
|
|
aliasNames.addAll(xmlNames);
|
|
final String[] aliases = aliasNames.toArray(new String[aliasNames.size()]);
|
|
final String cs = findCharsetNameFor(aliases);
|
|
if (cs != null) {
|
|
registerCharsetNameFor(cs, aliases);
|
|
if (xmlNames.size() > 0) {
|
|
String preferred = xmlNames.iterator().next();
|
|
String cachedPreferred = preferredMime.get(cs.toUpperCase());
|
|
if (cachedPreferred != null && !cachedPreferred.equals(preferred)) {
|
|
throw new ConflictingPreferredMimeNameError(cs, cachedPreferred, preferred);
|
|
}
|
|
preferredMime.put(cs.toUpperCase(), preferred);
|
|
}
|
|
} else {
|
|
registerUnresolvedNamesFor(aliases, aliasNames);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the canonical name of the charset for the given Java or XML
|
|
* alias name.
|
|
* @param alias the alias name
|
|
* @return the canonical charset name - or null if unknown.
|
|
*/
|
|
public String getCharsetNameFor(String alias) {
|
|
return charsetMap.get(alias.toUpperCase());
|
|
}
|
|
|
|
}
|
|
|
|
public static void test(Properties props) throws Exception {
|
|
|
|
// First, build a mapping from the properties read from the resource
|
|
// file.
|
|
// We're going to check the consistency of the resource file
|
|
// while building this mapping, and throw errors if the file
|
|
// does not meet our assumptions.
|
|
//
|
|
Map<String, Collection<String>> lines = new HashMap<>();
|
|
final CheckCharsetMapping mapping = new CheckCharsetMapping();
|
|
|
|
for (String key : props.stringPropertyNames()) {
|
|
Collection<String> values = getValues(props.getProperty(key));
|
|
lines.put(key, values);
|
|
mapping.addMapping(key, values);
|
|
}
|
|
|
|
// Then build maps of EncodingInfos, and print along debugging
|
|
// information that should help understand the content of the
|
|
// resource file and the mapping it defines.
|
|
//
|
|
Map<String, EncodingInfo> javaInfos = new HashMap<>(); // Map indexed by java names
|
|
Map<String, EncodingInfo> xmlMap = new HashMap<>(); // Map indexed by XML names
|
|
Map<String, String> preferred =
|
|
new HashMap<>(mapping.preferredMime); // Java Name -> Preferred Mime Name
|
|
List<EncodingInfo> all = new ArrayList<>(); // unused...
|
|
for (Entry<String, Collection<String>> e : lines.entrySet()) {
|
|
final String charsetName = mapping.getCharsetNameFor(e.getKey());
|
|
if (charsetName == null) {
|
|
System.out.println("!! No charset for: "+e.getKey()+ " "+ e.getValue());
|
|
continue;
|
|
}
|
|
Charset c = Charset.forName(charsetName);
|
|
EncodingInfo info;
|
|
final String k = e.getKey().toUpperCase();
|
|
final String kc = charsetName.toUpperCase();
|
|
StringBuilder sb = new StringBuilder();
|
|
for (String xml : e.getValue()) {
|
|
final String kx = xml.toUpperCase();
|
|
info = xmlMap.get(kx);
|
|
if (info == null) {
|
|
info = new EncodingInfo(xml, charsetName);
|
|
System.out.println("** XML: "+xml+" -> "+charsetName);
|
|
xmlMap.put(kx, info);
|
|
all.add(info);
|
|
}
|
|
if (!javaInfos.containsKey(k)) {
|
|
javaInfos.put(k, info);
|
|
if (!preferred.containsKey(k)) {
|
|
preferred.put(k, xml);
|
|
}
|
|
sb.append("** Java: ").append(k).append(" -> ")
|
|
.append(xml).append(" (charset: ")
|
|
.append(charsetName).append(")\n");
|
|
}
|
|
if (!javaInfos.containsKey(kc)) {
|
|
if (!preferred.containsKey(kc)) {
|
|
preferred.put(kc, xml);
|
|
}
|
|
javaInfos.put(kc, info);
|
|
sb.append("** Java: ").append(kc).append(" -> ")
|
|
.append(xml).append(" (charset: ")
|
|
.append(charsetName).append(")\n");
|
|
}
|
|
if (!javaInfos.containsKey(c.name().toUpperCase())) {
|
|
if (!preferred.containsKey(c.name().toUpperCase())) {
|
|
preferred.put(c.name().toUpperCase(), xml);
|
|
}
|
|
javaInfos.put(c.name().toUpperCase(), info);
|
|
sb.append("** Java: ").append(c.name().toUpperCase()).append(" -> ")
|
|
.append(xml).append(" (charset: ")
|
|
.append(charsetName).append(")\n");
|
|
}
|
|
}
|
|
if (sb.length() == 0) {
|
|
System.out.println("Nothing new for "+charsetName+": "+e.getKey()+" -> "+e.getValue());
|
|
} else {
|
|
System.out.print(sb);
|
|
}
|
|
|
|
}
|
|
|
|
// Now we're going to verify that Encodings.java has done its job
|
|
// correctly. We're going to ask Encodings to convert java names to mime
|
|
// names and mime names to java names - and verify that the returned
|
|
// java names do map to recognized charsets.
|
|
//
|
|
// We're also going to verify that Encodings has recorded the preferred
|
|
// mime name correctly.
|
|
|
|
Method m = Encodings.class.getDeclaredMethod("getMimeEncoding", String.class);
|
|
m.setAccessible(true);
|
|
|
|
Set<String> xNames = new HashSet<>();
|
|
Set<String> jNames = new HashSet<>();
|
|
for (String name: xmlMap.keySet()) {
|
|
final String javaName = checkConvertMime2Java(name);
|
|
checkPreferredMime(m, javaName, preferred);
|
|
jNames.add(javaName);
|
|
xNames.add(name);
|
|
}
|
|
|
|
|
|
for (String javaName : lines.keySet()) {
|
|
final String javaCharsetName = mapping.getCharsetNameFor(javaName.toUpperCase());
|
|
if (javaCharsetName == null) continue;
|
|
if (!jNames.contains(javaName)) {
|
|
checkPreferredMime(m, javaName, preferred);
|
|
jNames.add(javaName);
|
|
}
|
|
for (String xml : lines.get(javaName)) {
|
|
if (xNames.contains(xml)) continue;
|
|
final String jName = checkConvertMime2Java(xml);
|
|
xNames.add(xml);
|
|
if (jNames.contains(jName)) continue;
|
|
checkPreferredMime(m, jName, preferred);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static String checkConvertMime2Java(String xml) {
|
|
final String jName = Encodings.convertMime2JavaEncoding(xml);
|
|
final String jCharsetName;
|
|
try {
|
|
jCharsetName = Charset.forName(jName).name();
|
|
} catch (Exception x) {
|
|
throw new Error("Unrecognized charset returned by Encodings.convertMime2JavaEncoding(\""+xml+"\")", x);
|
|
}
|
|
System.out.println("Encodings.convertMime2JavaEncoding(\""+xml+"\") = \""+jName+"\" ("+jCharsetName+")");
|
|
return jName;
|
|
}
|
|
|
|
private static void checkPreferredMime(Method m, String javaName, Map<String,String> preferred)
|
|
throws Exception {
|
|
final String mime = (String) m.invoke(null, javaName);
|
|
final String expected = preferred.get(javaName.toUpperCase());
|
|
if (Arrays.deepEquals(new String[] {mime}, new String[] {expected})) {
|
|
System.out.println("Encodings.getMimeEncoding(\""+javaName+"\") = \""+mime+"\"");
|
|
} else {
|
|
throw new Error("Bad preferred mime type for: '"+javaName+"': expected '"+
|
|
expected+"' but got '"+mime+"'");
|
|
}
|
|
}
|
|
|
|
private static Collection<String> getValues(String val) {
|
|
int pos = val.indexOf(' ');
|
|
if (pos < 0) {
|
|
return Collections.singletonList(val);
|
|
}
|
|
//lastPrintable =
|
|
// Integer.decode(val.substring(pos).trim()).intValue();
|
|
StringTokenizer st =
|
|
new StringTokenizer(val.substring(0, pos), ",");
|
|
final List<String> values = new ArrayList<>(st.countTokens());
|
|
while (st.hasMoreTokens()) {
|
|
values.add(st.nextToken());
|
|
}
|
|
return values;
|
|
}
|
|
|
|
// can be called in main() to help debugging.
|
|
// Prints out all available charsets and their recognized aliases
|
|
// as returned by the Charset API.
|
|
private static void printAllCharsets() {
|
|
Map<String, Charset> all = Charset.availableCharsets();
|
|
System.out.println("\n=========================================\n");
|
|
for (String can : all.keySet()) {
|
|
System.out.println(can + ": " + all.get(can).aliases());
|
|
}
|
|
}
|
|
}
|