generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-03-24 17:49:45 +01:00
Code Issues Projects Releases Wiki Activity

java: write test program for TemplatePrecompiler

Browse Source
This commit is contained in:
Muga Nishizawa 2011-04-23 19:19:05 +09:00
parent eb8a338a0e
commit 0408738b48
7 changed files with 1513 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
java/.settings/org.eclipse.jdt.core.prefs
View File

@ -1,6 +1,13 @@
#Mon Sep 27 07:43:48 JST 2010
#Tue Apr 12 19:14:17 JST 2011
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.6
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
org.eclipse.jdt.core.compiler.source=1.6

2
java/src/main/java/org/msgpack/template/builder/BeansBuildContext.java
View File

@ -280,6 +280,6 @@ public class BeansBuildContext extends BuildContextBase<BeansFieldEntry> {
@Override
public Template loadTemplate(Class<?> targetClass, BeansFieldEntry[] entries, Template[] templates) {
throw new UnsupportedOperationException(targetClass.getName());
return null;
}
}

21
java/src/main/java/org/msgpack/template/builder/BuilderSelectorRegistry.java
View File

@ -54,14 +54,9 @@ public class BuilderSelectorRegistry {
*/
private static void initForJava(){
instance.append(new ArrayTemplateBuilderSelector());
if(isSupportJavassist()){
instance.append(
new AnnotationTemplateBuilderSelector(
new JavassistTemplateBuilder()));
instance.append(new AnnotationTemplateBuilderSelector(new JavassistTemplateBuilder()));
instance.forceBuilder = new JavassistTemplateBuilder();
//Java beans
instance.append(new BeansTemplateBuilderSelector(
new JavassistTemplateBuilder(
new BeansFieldEntryReader(),
@ -73,22 +68,17 @@ public class BuilderSelectorRegistry {
}
)));
}else{
instance.append(
new AnnotationTemplateBuilderSelector(
new ReflectionTemplateBuilder()));
instance.append(new AnnotationTemplateBuilderSelector(new ReflectionTemplateBuilder()));
instance.forceBuilder = new ReflectionTemplateBuilder();
//Java beans
instance.append(new BeansTemplateBuilderSelector(
new BeansTemplateBuilder()));
instance.append(new BeansTemplateBuilderSelector(new BeansTemplateBuilder()));
}
instance.append(new OrdinalEnumTemplateBuilderSelector());
instance.append(new EnumTemplateBuilderSelector());
}
public static boolean isSupportJavassist(){
try {
return System.getProperty("java.vm.name").equals("Dalvik");
return !System.getProperty("java.vm.name").equals("Dalvik");
} catch (Exception e) {
return true;
}
@ -112,7 +102,6 @@ public class BuilderSelectorRegistry {
* @param builderSelector
*/
public void append(BuilderSelector builderSelector){
if(contains(builderSelector.getName())){
throw new RuntimeException("Duplicate BuilderSelector name:" + builderSelector.getName());
}

2
java/src/main/java/org/msgpack/template/builder/JavassistTemplateBuilder.java
View File

@ -112,7 +112,7 @@ public class JavassistTemplateBuilder extends CustomTemplateBuilder {
* @param reader
* @param buildContextFactory
*/
public JavassistTemplateBuilder(IFieldEntryReader reader,BuildContextFactory buildContextFactory ){
public JavassistTemplateBuilder(IFieldEntryReader reader, BuildContextFactory buildContextFactory ){
this();
this.reader = reader;
this.buildContextFactory = buildContextFactory;

85
java/src/main/java/org/msgpack/util/TemplatePrecompiler.java
View File

@ -19,43 +19,92 @@ package org.msgpack.util;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import org.msgpack.template.builder.BuilderSelectorRegistry;
import org.msgpack.template.builder.JavassistTemplateBuilder;
import org.msgpack.template.builder.TemplateBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TemplatePrecompiler {
private static final Logger LOG = LoggerFactory.getLogger(TemplatePrecompiler.class);
//public static final String SRC = "msgpack.template.srcdir";
public static final String DEST = "msgpack.template.destdir";
public static final String DIST = "msgpack.template.distdir";
public static final String DEFAULT_DEST = ".";
//public static final String DEFAULT_SRC = ".";
public static final String DEFAULT_DIST = ".";
private static TemplatePrecompiler INSTANCE = null;
private TemplatePrecompiler() {
public static void saveTemplates(final String[] classNames) throws IOException, ClassNotFoundException {
List<String> ret = new ArrayList<String>();
for (String className : classNames) {
matchClassNames(ret, className);
}
List<Class<?>> ret0 = toClass(ret);
for (Class<?> c : ret0) {
saveTemplateClass(c);
}
}
public static void saveTemplates(final String[] classFileNames) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");// TODO
@SuppressWarnings("serial")
private static void matchClassNames(List<String> ret, final String className) throws IOException {
String packageName = className.substring(0, className.lastIndexOf('.'));
String relativedName = className.substring(className.lastIndexOf('.') + 1, className.length());
String patName = relativedName.replace("*", "(\\w+)");
Pattern pat = Pattern.compile(patName);
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
JavaFileManager fm = compiler.getStandardFileManager(
new DiagnosticCollector<JavaFileObject>(), null, null);
HashSet<JavaFileObject.Kind> kind = new HashSet<JavaFileObject.Kind>(){{
add(JavaFileObject.Kind.CLASS);
}};
for (JavaFileObject f : fm.list(StandardLocation.PLATFORM_CLASS_PATH, packageName, kind, false)) {
String relatived0 = f.getName();
String name0 = relatived0.substring(0, relatived0.length() - ".class".length());
Matcher m = pat.matcher(name0);
if (m.matches()) {
String name = packageName + '.' + name0;
if (!ret.contains(name)) {
ret.add(name);
}
}
}
}
private static List<Class<?>> toClass(List<String> classNames) throws ClassNotFoundException {
List<Class<?>> ret = new ArrayList<Class<?>>(classNames.size());
ClassLoader cl = TemplatePrecompiler.class.getClassLoader();
for (String className : classNames) {
Class<?> c = cl.loadClass(className);
ret.add(c);
}
return ret;
}
public static void saveTemplateClasses(Class<?>[] targetClasses) throws IOException {
for (Class<?> c : targetClasses) {
saveTemplateClass(c);
}
}
public static void saveTemplateClass(Class<?> targetClass) throws IOException {
if (INSTANCE != null) {
INSTANCE = new TemplatePrecompiler();
}
LOG.info("Saving template of " + targetClass.getName() + "...");
Properties props = System.getProperties();
String distDirName = getDirName(props, DIST, DEFAULT_DIST);
String distDirName = getDirName(props, DEST, DEFAULT_DEST);
if (targetClass.isEnum()) {
throw new UnsupportedOperationException("Enum not supported yet: " + targetClass.getName());
throw new UnsupportedOperationException("Not supported enum type yet: " + targetClass.getName());
} else {
new JavassistTemplateBuilder().writeTemplate(targetClass, distDirName);
}

110
java/src/test/java/org/msgpack/util/TestTemplatePrecompiler.java
View File

@ -1,110 +0,0 @@
package org.msgpack.util;
import org.junit.Test;
import static org.junit.Assert.*;
import org.msgpack.MessagePack;
import org.msgpack.MessageTypeException;
import org.msgpack.template.TemplateRegistry;
public class TestTemplatePrecompiler {
@Test
public void testPrimitiveTypeFields00() throws Exception {
System.getProperties().setProperty(TemplatePrecompiler.DIST, "./target/test-classes");
Class<?> c = PrimitiveTypeFieldsClass.class;
TemplatePrecompiler.saveTemplateClass(PrimitiveTypeFieldsClass.class);
PrimitiveTypeFieldsClass src = new PrimitiveTypeFieldsClass();
src.f0 = (byte) 0;
src.f1 = 1;
src.f2 = 2;
src.f3 = 3;
src.f4 = 4;
src.f5 = 5;
src.f6 = false;
try {
MessagePack.pack(src);
fail();
} catch (Exception e) {
assertTrue(e instanceof MessageTypeException);
assertTrue(TemplateRegistry.unregister(c));
}
try {
TemplateRegistry.lookup(c, true, true);
byte[] raw = MessagePack.pack(src);
PrimitiveTypeFieldsClass dst = MessagePack.unpack(raw, PrimitiveTypeFieldsClass.class);
assertEquals(src.f0, dst.f0);
assertEquals(src.f1, dst.f1);
assertEquals(src.f2, dst.f2);
assertEquals(src.f3, dst.f3);
//assertEquals(src.f4, dst.f4);
//assertEquals(src.f5, dst.f5);
assertEquals(src.f6, dst.f6);
} finally {
TemplateRegistry.unregister(c);
}
}
@Test
public void testPrimitiveTypeFields01() throws Exception {
System.getProperties().setProperty(TemplatePrecompiler.DIST, "./target/test-classes");
Class<?> c = PrimitiveTypeFieldsClass.class;
TemplatePrecompiler.saveTemplateClass(PrimitiveTypeFieldsClass.class);
PrimitiveTypeFieldsClass src = new PrimitiveTypeFieldsClass();
try {
MessagePack.pack(src);
fail();
} catch (Exception e) {
assertTrue(e instanceof MessageTypeException);
assertTrue(TemplateRegistry.unregister(c));
}
try {
TemplateRegistry.lookup(c, true, true);
byte[] raw = MessagePack.pack(src);
PrimitiveTypeFieldsClass dst = MessagePack.unpack(raw, PrimitiveTypeFieldsClass.class);
assertEquals(src.f0, dst.f0);
assertEquals(src.f1, dst.f1);
assertEquals(src.f2, dst.f2);
assertEquals(src.f3, dst.f3);
//assertEquals(src.f4, dst.f4);
//assertEquals(src.f5, dst.f5);
assertEquals(src.f6, dst.f6);
} finally {
TemplateRegistry.unregister(c);
}
}
@Test
public void testPrimitiveTypeFields02() throws Exception {
System.getProperties().setProperty(TemplatePrecompiler.DIST, "./target/test-classes");
Class<?> c = PrimitiveTypeFieldsClass.class;
TemplatePrecompiler.saveTemplateClass(PrimitiveTypeFieldsClass.class);
PrimitiveTypeFieldsClass src = null;
MessagePack.pack(src);
try {
TemplateRegistry.lookup(c, true, true);
byte[] raw = MessagePack.pack(src);
PrimitiveTypeFieldsClass dst = MessagePack.unpack(raw, PrimitiveTypeFieldsClass.class);
assertEquals(src, dst);
} finally {
TemplateRegistry.unregister(c);
}
}
public static class PrimitiveTypeFieldsClass {
public byte f0;
public short f1;
public int f2;
public long f3;
public float f4;
public double f5;
public boolean f6;
public PrimitiveTypeFieldsClass() {
}
}
}

1431
java/src/test/java/org/msgpack/util/TestTemplatePrecompilerPackUnpack.java Normal file
View File

File diff suppressed because it is too large Load Diff