View Javadoc

1   /*
2    * Copyright 2005 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.vafer.dependency.resources;
17  
18  import java.io.File;
19  import java.io.FileOutputStream;
20  import java.io.InputStream;
21  import java.lang.reflect.Method;
22  import java.util.HashMap;
23  import java.util.Map;
24  
25  import org.objectweb.asm.ClassAdapter;
26  import org.objectweb.asm.ClassReader;
27  import org.objectweb.asm.ClassWriter;
28  import org.objectweb.asm.util.CheckClassAdapter;
29  import org.vafer.dependency.asm.Remapper;
30  import org.vafer.dependency.resources.buildtime.BuildtimeResourceResolver;
31  import org.vafer.dependency.resources.runtime.MapperDump;
32  import org.vafer.dependency.resources.runtime.RuntimeResourceResolver;
33  import org.vafer.jar.AbstractJarTestCase;
34  import org.vafer.jar.Jar;
35  import org.vafer.jar.JarProcessor;
36  import org.vafer.jar.handler.JarHandler;
37  import org.vafer.jar.handler.OutputJarHandler;
38  import org.vafer.jar.handler.RenamingJarHandler;
39  
40  public class ResourceLookupTestCase extends AbstractJarTestCase {
41  
42  	private static final class BytecodeClassLoader extends ClassLoader {
43  
44  	    public BytecodeClassLoader() {
45  			super();
46  		}
47  
48  		public BytecodeClassLoader(ClassLoader parent) {
49  			super(parent);
50  		}
51  
52  		public Class loadClass( final byte[] bytecode ) {
53  
54  			final Class clazz = defineClass(null, bytecode, 0, bytecode.length);
55  	        
56  	        return clazz;
57  	    }
58  	}
59  
60  	public void testStaticResourceResolver() throws Exception {
61  
62  		final File jar1 = createJar(this.getClass(),
63  				new String[] { classToResource(Lookup.class.getName()) }
64  		);
65  
66  		final File output = File.createTempFile("output", "jar");
67  		
68  		final JarHandler handler = new RenamingJarHandler(
69  				new RenamingJarHandler.Mapper() {
70  					public String getNameFor(Jar jar, String name) {
71  						return "prefix/" + name;
72  					}			
73  				}, new BuildtimeResourceResolver()).chain(new OutputJarHandler(new FileOutputStream(output)));
74  		
75  		new JarProcessor().processJars(new Jar[] { new Jar(jar1) }, handler);
76  
77  		output.delete();		
78  	}
79  
80  	public void testRuntimeResourceResolver() throws Exception {
81  
82  		final File jar1 = createJar(this.getClass(),
83  				new String[] { classToResource(Lookup.class.getName()) }
84  		);
85  
86  		final File output = File.createTempFile("output", "jar");
87  		
88  		final JarHandler handler = new RenamingJarHandler(
89  				new RenamingJarHandler.Mapper() {
90  					public String getNameFor(Jar jar, String name) {
91  						return "prefix/" + name;
92  					}			
93  				}, new RuntimeResourceResolver()).chain(new OutputJarHandler(new FileOutputStream(output)));
94  		
95  		new JarProcessor().processJars(new Jar[] { new Jar(jar1) }, handler);
96  		
97  		output.delete();		
98  	}
99  	
100 	
101 	public void testRuntimeRewriting() throws Exception {
102 
103 //		{
104 //			final InputStream original = Lookup.class.getClassLoader().getResourceAsStream(classToResource(Lookup.class.getName()));
105 //			assertNotNull(original);		
106 //			new ClassReader(original).accept(new TraceClassVisitor(new PrintWriter(System.out)),0);
107 //		}
108 
109 		final InputStream original = Lookup.class.getClassLoader().getResourceAsStream(classToResource(Lookup.class.getName()));
110 		assertNotNull(original);		
111 
112 		final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
113     
114 		final Remapper remapper =
115 			new Remapper() {
116 				public String map( final String name ) {
117 					return "prefix/" + name;
118 				}
119 		};
120 
121 		ClassAdapter adapter = new CheckClassAdapter(cw);
122 
123 		adapter = new RuntimeResourceResolver().getClassAdapter(cw, remapper);
124 
125 		new ClassReader(original).accept(adapter,0);
126 		
127 		final byte[] classBytes = cw.toByteArray();
128 //		final InputStream rewritten = new ByteArrayInputStream(classBytes);
129 //		new ClassReader(rewritten).accept(new TraceClassVisitor(new PrintWriter(System.out)),0);
130 
131 		final BytecodeClassLoader cl = new BytecodeClassLoader();
132 		final Class c = cl.loadClass(classBytes);
133 		final Method m = c.getMethod("find", null);
134 		final Object r = m.invoke(c.newInstance(), new Object[] { });
135 		
136 		assertNotNull(r);
137 	}
138 	
139 	public void testResolveBehaviour() throws Exception {
140 		
141 		final Map mapping = new HashMap();
142 		mapping.put("resource", "prefix/resource");
143 		
144 		final byte[] generatedClassBytes = MapperDump.dump("org/vafer/dependency/Mapper", mapping);
145 		
146 		final BytecodeClassLoader cl = new BytecodeClassLoader();
147 		final Class c = cl.loadClass(generatedClassBytes);
148 		final Method m = c.getMethod("resolveResource", new Class[] { String.class });
149 		final Object r = m.invoke(null, new Object[] { "resource" });
150 		
151 		assertEquals("prefix/resource", r);
152 	}
153 }