public void testDollarClassInStaticMethod() throws Exception { CtClass cc = sloader.makeClass("test5.DollarClass"); CtMethod m = CtNewMethod.make("public static int run(){ return $class.getName().length(); }", cc); cc.addMethod(m); m = CtNewMethod.make("public int run2(){ return $class.getName().length(); }", cc); cc.addMethod(m); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(cc.getName().length(), invoke(obj, "run")); assertEquals(cc.getName().length(), invoke(obj, "run2")); }
public void testCodeGen() throws Exception { CtClass cc = sloader.get("test2.CodeGen"); CtMethod m1 = cc.getDeclaredMethod("run"); m1.insertBefore( "{ double d = true ? 1 : 0.1; " + " d = d > 0.5 ? 0.0 : - 1.0; " + " System.out.println(d); " + " String s = \"foo\"; " + " s = 1 + 2 + s + \"bar\"; " + " s += \"poi\" + 3 + seven() + seven(\":\" + ' '); " + " s += .14; " + " msg = s; " + " System.out.println(s); }"); // recursive type check is done if $proceed is used. CtMethod m2 = CtNewMethod.make( "public int test() {" + " String s = $proceed(\"int\" + (3 + 0.14)) + '.'; " + " System.out.println(s); return s.length(); }", cc, "this", "seven"); cc.addMethod(m2); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(19, invoke(obj, "run")); assertEquals(9, invoke(obj, "test")); }
public void testMethodInInner2() throws Exception { CtClass inner = sloader.get("test2.Nested3$Inner"); CtClass outer = sloader.get("test2.Nested3"); String src = "public int f() {" + " int k = 0;" + " test2.Nested3 n = new test2.Nested3(3);" + " k += n.geti();" + " n = new test2.Nested3();" + " k += n.geti();" + " n = new test2.Nested3(\"foo\");" + " k += n.geti();" + " return k; }"; outer.stopPruning(true); outer.writeFile(); try { CtMethod m = CtNewMethod.make(src, inner); fail(); } catch (RuntimeException e) { } outer.defrost(); CtMethod m = CtNewMethod.make(src, inner); inner.addMethod(m); inner.writeFile(); outer.writeFile(); Object iobj = make(inner.getName()); assertEquals(6, invoke(iobj, "f")); }
public void testCodeGen2() throws Exception { CtClass cc = sloader.makeClass("test2.CodeGen2"); CtMethod m1 = CtNewMethod.make( "public int test() {" + " int len;" + " String s = \"foo\" + \"bar\" + 3;" + " System.out.println(s); len = s.length();" + " len = -3 + len; len = len - (7 - 2 + -1);" + " int k = 3; len += ~k - ~3;" + " return len; }", cc); cc.addMethod(m1); CtMethod m2 = CtNewMethod.make( "public int test2() {" + " double d = 0.2 - -0.1;" + " d += (0.2 + 0.3) * 1.0;" + " return (int)(d * 10); }", cc); cc.addMethod(m2); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(0, invoke(obj, "test")); assertEquals(8, invoke(obj, "test2")); }
@Override protected synchronized CtClass get0(String className, boolean useCache) throws NotFoundException { if (!exclude(className)) { if (isSrg) { CtClass cachedClass = srgClasses.get(className); if (cachedClass != null) { return cachedClass; } cachedClass = super.getCached(className); if (cachedClass != null && cachedClass.isPrimitive()) { return cachedClass; } if (!Transformer.remapClassName(className).equals(className)) { Log.severe("Attempted to load obfuscated class " + className, new Throwable()); return null; } String remappedName = Transformer.unmapClassName(className); byte[] bytes = getBytes(remappedName); if (bytes != null) { bytes = Transformer.transform(bytes); try { CtClass ctClass = new CtClassType(new ByteArrayInputStream(bytes), this); if (!remappedName.equals(className)) { ctClass.freeze(); } srgClasses.put(className, ctClass); return ctClass; } catch (IOException e) { Log.severe("Failed to make " + className + " from " + remappedName, e); } return null; } } else { if (!Transformer.unmapClassName(className).equals(className)) { Log.severe( "Attempted to load SRG class " + className + " while patching a non-SRG class.", new Throwable()); return null; } } } CtClass clazz; if (useCache) { clazz = getCached(className); if (clazz != null) { return clazz; } } clazz = createCtClass(className, useCache); if (clazz != null) { // clazz.getName() != classname if classname is "[L<name>;". if (useCache) { cacheCtClass(clazz.getName(), clazz, false); } } return clazz; }
public void testInsertLocal() throws Exception { CtClass cc = sloader.get("test2.InsertLocal"); CtMethod m1 = cc.getDeclaredMethod("foo"); m1.insertBefore("{ i = s.length(); d = 0.14; }"); m1.insertAfter("{ field = i; }"); CtMethod m2 = cc.getDeclaredMethod("run2"); m2.insertAt(22, "{ s = \"12\"; k = 5; }"); CtMethod m3 = cc.getDeclaredMethod("run3"); m3.instrument( new ExprEditor() { public void edit(NewExpr n) throws CannotCompileException { n.replace("{ i++; $_ = $proceed($$); }"); } public void edit(FieldAccess f) throws CannotCompileException { f.replace("{ i++; $_ = $proceed($$); }"); } public void edit(MethodCall m) throws CannotCompileException { m.replace("{ i++; $_ = $proceed($$); }"); } }); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(317, invoke(obj, "run")); assertEquals(7, invoke(obj, "run2")); assertEquals(3, invoke(obj, "run3")); }
public void testRemoveAnnotatino() throws Exception { CtClass cc = sloader.get("test5.RemoveAnnotation"); AnnotationsAttribute aa = (AnnotationsAttribute) cc.getClassFile().getAttribute(AnnotationsAttribute.invisibleTag); assertTrue(aa.removeAnnotation("test5.RemoveAnno1")); AttributeInfo ai = cc.getClassFile().removeAttribute(AnnotationsAttribute.invisibleTag); assertEquals(ai.getName(), AnnotationsAttribute.invisibleTag); CtMethod foo = cc.getDeclaredMethod("foo"); AnnotationsAttribute aa2 = (AnnotationsAttribute) foo.getMethodInfo().getAttribute(AnnotationsAttribute.invisibleTag); assertTrue(aa2.removeAnnotation("test5.RemoveAnno1")); CtMethod bar = cc.getDeclaredMethod("bar"); AnnotationsAttribute aa3 = (AnnotationsAttribute) bar.getMethodInfo().getAttribute(AnnotationsAttribute.invisibleTag); assertFalse(aa3.removeAnnotation("test5.RemoveAnno1")); assertTrue(aa3.removeAnnotation("test5.RemoveAnno2")); AttributeInfo ai2 = bar.getMethodInfo().removeAttribute(AnnotationsAttribute.invisibleTag); assertEquals(ai2.getName(), AnnotationsAttribute.invisibleTag); CtMethod run = cc.getDeclaredMethod("run"); AttributeInfo ai3 = run.getMethodInfo().removeAttribute(AnnotationsAttribute.invisibleTag); assertNull(ai3); CtField baz = cc.getDeclaredField("baz"); AttributeInfo ai4 = baz.getFieldInfo().removeAttribute(AnnotationsAttribute.invisibleTag); assertEquals(ai4.getName(), AnnotationsAttribute.invisibleTag); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(3, invoke(obj, "run")); }
public void testJIRA256() throws Exception { // CtClass ec = sloader.get("test5.Entity"); CtClass cc = sloader.makeClass("test5.JIRA256"); ClassFile ccFile = cc.getClassFile(); ConstPool constpool = ccFile.getConstPool(); AnnotationsAttribute attr = new AnnotationsAttribute(constpool, AnnotationsAttribute.visibleTag); javassist.bytecode.annotation.Annotation entityAnno = new javassist.bytecode.annotation.Annotation("test5.Entity", constpool); // = new javassist.bytecode.annotation.Annotation(constpool, ec); entityAnno.addMemberValue( "value", new javassist.bytecode.annotation.ArrayMemberValue(constpool)); attr.addAnnotation(entityAnno); ccFile.addAttribute(attr); cc.writeFile(); Object o = make(cc.getName()); assertTrue(o.getClass().getName().equals("test5.JIRA256")); java.lang.annotation.Annotation[] annotations = o.getClass().getDeclaredAnnotations(); assertEquals(1, annotations.length); }
public void testAddCatchForConstructor() throws Exception { CtClass cc = sloader.get("test2.AddCatchForConstructor"); CtConstructor m1 = cc.getDeclaredConstructors()[0]; m1.addCatch("return;", sloader.get("java.lang.Exception")); cc.writeFile(); Object obj = make(cc.getName()); }
public void testArrayLen() throws Exception { CtClass cc = sloader.get("test2.ArrayLenTest"); cc.addMethod(CtNewMethod.make("public int foo(){ return this.length; }", cc)); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(1, invoke(obj, "foo")); }
public void testNewArray() throws Exception { ExprEditor ed = new ExprEditor() { int dim[] = {1, 2, 2, 1, 2, 2, 3}; int cdim[] = {1, 1, 2, 1, 1, 2, 2}; int counter = 0; public void edit(NewArray expr) throws CannotCompileException { try { CtClass str = sloader.get("java.lang.String"); if (counter < 3) assertEquals(str, expr.getComponentType()); else assertEquals(CtClass.intType, expr.getComponentType()); assertEquals(dim[counter], expr.getDimension()); assertEquals(cdim[counter], expr.getCreatedDimensions()); expr.replace("{ i += $1; $_ = $proceed($$); }"); ++counter; } catch (NotFoundException e) { throw new CannotCompileException(e); } } }; CtClass cc = sloader.get("test2.NewArray"); CtMethod m1 = cc.getDeclaredMethod("foo"); m1.instrument(ed); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(48, invoke(obj, "run")); }
public void onWrite(ClassPool pool, String className) throws NotFoundException, CannotCompileException { CtClass cc = pool.get(className); try { if (isPersistent(className)) { CtClass base = cc.getSuperclass(); CtConstructor cons = new CtConstructor(constructorParams, cc); if (base.subclassOf(persistent) || base == object) { cons.setBody(null); cc.addConstructor(cons); if (base == object) { cc.setSuperclass(persistent); } } else { if (!isPersistent(base.getName())) { throw new NotFoundException( "Base class " + base.getName() + " was not declared as persistent"); } cons.setBody("super($0);"); cc.addConstructor(cons); } preprocessMethods(cc, true, true); if (base == persistent || base == object) { CtMethod m = new CtMethod(isRecursive, cc, null); m.setBody("return false;"); cc.addMethod(m); addSerializeMethods(cc, false); } else if (base.subtypeOf(serializable)) { addSerializeMethods(cc, true); } if ((cc.getModifiers() & Modifier.PRIVATE) == 0) { CtClass f = pool.makeClass(className + "LoadFactory"); f.addInterface(factory); CtMethod c = new CtMethod(create, f, null); c.setBody("return new " + className + "($1);"); f.addMethod(c); CtNewConstructor.defaultConstructor(f); } } else { preprocessMethods( cc, cc.subtypeOf(persistent) && cc != persistent, !className.startsWith("org.nachodb")); } } catch (Exception x) { x.printStackTrace(); } }
public void testJIRA241() throws Exception { CtClass cc = sloader.get("test5.JIRA241"); CtMethod testMethod = cc.getDeclaredMethod("test"); testMethod.insertAfter("System.out.println(\"inserted!\");"); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(10, invoke(obj, "run")); }
public static CtClass getSuperclass(CtClass c) throws CompileError { try { CtClass sc = c.getSuperclass(); if (sc != null) return sc; } catch (NotFoundException e) { } throw new CompileError("cannot find the super class of " + c.getName()); }
public void testJIRA249() throws Exception { CtClass cc = sloader.get("test5.BoolTest"); CtMethod testMethod = cc.getDeclaredMethod("test"); testMethod.insertBefore("i = foo(true & true);"); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(1, invoke(obj, "run")); }
public void testTypeAnno() throws Exception { CtClass cc = sloader.get("test5.TypeAnno"); cc.getClassFile().compact(); cc.writeFile(); Object obj = make(cc.getName()); TypeVariable<?> t = obj.getClass().getTypeParameters()[0]; Annotation[] annos = t.getAnnotations(); assertEquals("@test5.TypeAnnoA()", annos[0].toString()); }
/* * This method is invoked by CtClassType.setName(). It removes a * CtClass object from the hash table and inserts it with the new * name. Don't delegate to the parent. */ synchronized void classNameChanged(String oldname, CtClass clazz) { CtClass c = (CtClass) getCached(oldname); if (c == clazz) // must check this equation. removeCached(oldname); // see getAndRename(). String newName = clazz.getName(); checkNotFrozen(newName); cacheCtClass(newName, clazz, false); }
public void testArrayLength() throws Exception { CtClass cc = sloader.makeClass("test2.ArrayLength"); CtMethod m2 = CtNewMethod.make( "public int f() { String[] s = new String[3]; " + "return s.length; }", cc); cc.addMethod(m2); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(3, invoke(obj, "f")); }
public void testJIRA248() throws Exception { CtClass cc = sloader.get("test5.JIRA248"); String methodBody = "public int run() { return foo() + super.foo() + super.bar() + test5.JIRA248Intf2.super.baz(); }"; CtMethod ctMethod = CtMethod.make(methodBody, cc); cc.addMethod(ctMethod); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(40271, invoke(obj, "run")); }
public void testAddLocalVar() throws Exception { CtClass cc = sloader.get("test2.AddLocalVar"); CtMethod m1 = cc.getDeclaredMethod("foo"); m1.addLocalVariable("i", CtClass.intType); m1.insertBefore("i = 3;"); m1.insertAfter("$_ = i + 1;"); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(4, invoke(obj, "foo")); }
public void testReplaceClassName() throws Exception { String oldName = "test2.ReplaceClassName2"; String newName = "test2.ReplaceClassName3"; CtClass cc = sloader.get("test2.ReplaceClassName"); cc.replaceClassName(oldName, newName); cc.writeFile(); CtClass cc2 = dloader.get(cc.getName()); CtMethod m = cc2.getDeclaredMethod("foo"); assertEquals(newName, m.getParameterTypes()[0].getName()); }
public void testLocalVar() throws Exception { CtClass cc = sloader.get("test2.LocalVar"); CtMethod m = cc.getDeclaredMethod("toString"); m.addLocalVariable("var", CtClass.booleanType); m.insertBefore("{var = true; }"); m.insertAfter("{if (var) hashCode(); }", false); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(3, invoke(obj, "foo")); }
public void testConstBody() throws Exception { CtClass cc = sloader.get("test2.ConstBody"); CtConstructor cons = new CtConstructor( new CtClass[] {sloader.get("java.lang.String"), sloader.get("java.lang.Integer")}, cc); cons.setBody("super((String)$1, (Integer)$2);"); cc.addConstructor(cons); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(1, invoke(obj, "bar")); }
public boolean subtypeOf(CtClass clazz) throws NotFoundException { if (super.subtypeOf(clazz)) return true; String cname = clazz.getName(); if (cname.equals(javaLangObject)) return true; CtClass[] intfs = getInterfaces(); for (int i = 0; i < intfs.length; i++) if (intfs[i].subtypeOf(clazz)) return true; return clazz.isArray() && getComponentType().subtypeOf(clazz.getComponentType()); }
/** * Creates a new class (or interface) from the given class file. If there already exists a class * with the same name, the new class overwrites that previous class. * * <p>This method is used for creating a <code>CtClass</code> object directly from a class file. * The qualified class name is obtained from the class file; you do not have to explicitly give * the name. * * @param classfile class file. * @param ifNotFrozen throws a RuntimeException if this parameter is true and there is a frozen * class with the same name. * @see javassist.ByteArrayClassPath */ public CtClass makeClass(InputStream classfile, boolean ifNotFrozen) throws IOException, RuntimeException { compress(); classfile = new BufferedInputStream(classfile); CtClass clazz = new CtClassType(classfile, this); clazz.checkModify(); String classname = clazz.getName(); if (ifNotFrozen) checkNotFrozen(classname); cacheCtClass(classname, clazz, true); return clazz; }
public void testSetExceptions() throws Exception { CtClass cc = sloader.get("test2.SetExceptions"); CtMethod m = cc.getDeclaredMethod("f"); CtClass ex = m.getExceptionTypes()[0]; assertEquals("java.lang.Exception", ex.getName()); m.setExceptionTypes(null); assertEquals(0, m.getExceptionTypes().length); m.setExceptionTypes(new CtClass[0]); assertEquals(0, m.getExceptionTypes().length); m.setExceptionTypes(new CtClass[] {ex}); assertEquals(ex, m.getExceptionTypes()[0]); }
public void testMethodInInner() throws Exception { CtClass inner = sloader.get("test2.Nested2$Inner"); CtClass outer = sloader.get("test2.Nested2"); String src = "public int f(test2.Nested2 n) {" + " n.i = 1; n.i++; n.i += 2; return n.i; }"; outer.writeFile(); try { CtMethod m = CtNewMethod.make(src, inner); fail(); } catch (RuntimeException e) { } outer.defrost(); CtMethod m = CtNewMethod.make(src, inner); inner.addMethod(m); src = "public int g(test2.Nested2 n) {" + " n.d = 1.0; n.d++; n.d += 2.0;" + " return n.d == 4.0 ? 7 : 8; }"; m = CtNewMethod.make(src, inner); inner.addMethod(m); src = "public int h(test2.Nested2 n) {" + " n.s = \"poi\";" + "return n.s.length() + f(n) + g(n); }"; m = CtNewMethod.make(src, inner); inner.addMethod(m); inner.writeFile(); outer.writeFile(); Object nobj = make(outer.getName()); Object iobj = make(inner.getName()); Method mth = iobj.getClass().getMethod("h", new Class[] {nobj.getClass()}); Object resobj = mth.invoke(iobj, new Object[] {nobj}); int res = ((Integer) resobj).intValue(); assertEquals(14, res); }
public void testSuperCall() throws Exception { CtClass cc = sloader.get("test2.SuperCall"); CtMethod m1 = cc.getDeclaredMethod("foo"); m1.instrument( new ExprEditor() { public void edit(MethodCall m) throws CannotCompileException { m.replace("{ $_ = $proceed($$); }"); } }); cc.writeFile(); Object obj = make(cc.getName()); invoke(obj, "bar"); }
/** @parma classname jvm class name. */ public CtClass lookupClass(int type, int dim, String classname) throws CompileError { String cname = ""; CtClass clazz; if (type == CLASS) { clazz = lookupClassByJvmName(classname); if (dim > 0) cname = clazz.getName(); else return clazz; } else cname = getTypeName(type); while (dim-- > 0) cname += "[]"; return lookupClass(cname, false); }
public void testRemoveCall() throws Exception { CtClass cc = sloader.get("test2.RemoveCall"); CtMethod m1 = cc.getDeclaredMethod("bar"); m1.instrument( new ExprEditor() { public void edit(MethodCall m) throws CannotCompileException { m.replace("{ $_ = ($r)null; }"); } }); cc.writeFile(); Object obj = make(cc.getName()); assertEquals(0, invoke(obj, "bar")); }