/*
* Copyright 2006-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
import java.beans.PropertyEditor;
import java.beans.PropertyEditorManager;
import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject.Kind;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;
final class TestEditor {
private final PropertyEditor editor;
TestEditor(Class type) {
System.out.println("Property class: " + type);
this.editor = PropertyEditorManager.findEditor(type);
if (this.editor == null)
throw new Error("could not find editor for " + type);
System.out.println("PropertyEditor class: " + this.editor.getClass());
validate(null, null);
}
void testJava(Object value) {
this.editor.setValue(value);
MemoryFileManager manager = new MemoryFileManager();
Object object = manager.invoke(this.editor.getJavaInitializationString());
System.out.println("Property value before: " + value);
System.out.println("Property value after: " + object);
if (!areEqual(value, object))
throw new Error("values are not equal");
}
void testValue(Object value, String text) {
this.editor.setValue(value);
validate(value, text);
}
void testText(String text, Object value) {
this.editor.setAsText(text);
validate(value, text);
}
private void validate(Object value, String text) {
if (!areEqual(value, this.editor.getValue()))
throw new Error("value should be " + value);
// getAsText don't return null
if (text == null) {
text = "null";
}
if (!areEqual(text, this.editor.getAsText()))
throw new Error("text should be " + text);
}
private static boolean areEqual(Object object1, Object object2) {
return (object1 == null)
? object2 == null
: object1.equals(object2);
}
private static final class MemoryFileManager extends ForwardingJavaFileManager {
private static final String CLASS = "Executor";
private static final String METHOD = "execute";
private static final JavaCompiler COMPILER = ToolProvider.getSystemJavaCompiler();
private final Map<String, MemoryClass> map = new HashMap<String, MemoryClass>();
private final MemoryClassLoader loader = new MemoryClassLoader();
MemoryFileManager() {
super(COMPILER.getStandardFileManager(null, null, null));
}
public Object invoke(String expression) {
MemorySource file = new MemorySource(CLASS, METHOD, expression);
if (!COMPILER.getTask(null, this, null, null, null, Arrays.asList(file)).call())
throw new Error("compilation failed");
MemoryClass mc = this.map.get(CLASS);
if (mc == null)
throw new Error("class not found: " + CLASS);
Class c = this.loader.loadClass(CLASS, mc.toByteArray());
try {
return c.getMethod(METHOD).invoke(null);
}
catch (Exception exception) {
throw new Error(exception);
}
}
public MemoryClass getJavaFileForOutput(Location location, String name, Kind kind, FileObject source) {
MemoryClass type = this.map.get(name);
if (type == null) {
type = new MemoryClass(name);
this.map.put(name, type);
}
return type;
}
}
private static final class MemoryClassLoader extends ClassLoader {
public Class<?> loadClass(String name, byte[] array) {
return defineClass(name, array, 0, array.length);
}
}
private static class MemoryObject extends SimpleJavaFileObject {
protected MemoryObject(String name, Kind kind) {
super(toURI(name, kind.extension), kind);
}
private static URI toURI(String name, String extension) {
try {
return new URI("mfm:///" + name.replace('.', '/') + extension);
}
catch (URISyntaxException exception) {
throw new Error(exception);
}
}
}
private static final class MemoryClass extends MemoryObject {
private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
MemoryClass(String className) {
super(className, Kind.CLASS);
}
public ByteArrayOutputStream openOutputStream() {
this.baos.reset();
return this.baos;
}
public byte[] toByteArray() {
return this.baos.toByteArray();
}
}
private static final class MemorySource extends MemoryObject {
private final String value;
MemorySource(String className, String methodName, String expression) {
super(className, Kind.SOURCE);
this.value
= "public class " + className + " {\n"
+ " public static Object " + methodName + "() throws Exception {\n"
+ " return " + expression + ";\n"
+ " }\n"
+ "}\n";
}
public CharSequence getCharContent(boolean ignore) {
return this.value;
}
}
}