Exemple #1
0
 public void testSuperInterface() throws Exception {
   CtClass cc = sloader.makeClass("test2.SuperInterface3");
   CtClass cc2 = sloader.get("test2.SuperInterface2");
   cc.addInterface(cc2);
   cc.addField(new CtField(cc2, "inner", cc));
   CtMethod m = CtNewMethod.make("public int getAge() { return inner.getAge(); }", cc);
   cc.addMethod(m);
   cc.writeFile();
 }
Exemple #2
0
  public void testStaticArrays() throws Exception {
    CtClass cc = sloader.makeClass("StaticArrays");
    CtField f = new CtField(sloader.get("test2.StaticArraysMem[]"), "myStaticField", cc);

    f.setModifiers(Modifier.STATIC);
    cc.addField(f);
    CtConstructor init = cc.makeClassInitializer();
    String body = "{\n";
    body += ("myStaticField = new test2.StaticArraysMem[2];\n");
    body += ("\n}");
    init.setBody(body);
  }
Exemple #3
0
  public void testStaticFinal() throws Exception {
    CtClass cc = sloader.makeClass("test2.StaticFinal");
    CtField f = new CtField(CtClass.intType, "sff1", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "5");
    assertEquals(new Integer(5), f.getConstantValue());

    f = new CtField(CtClass.longType, "sff2", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "6");
    assertEquals(new Long(6), f.getConstantValue());

    f = new CtField(CtClass.floatType, "sff3", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "7");
    assertEquals(new Float(7.0F), f.getConstantValue());

    f = new CtField(CtClass.floatType, "sff4", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "8.0");
    assertEquals(new Float(8.0F), f.getConstantValue());

    f = new CtField(CtClass.doubleType, "sff5", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "9");
    assertEquals(new Double(9.0), f.getConstantValue());

    f = new CtField(CtClass.doubleType, "sff6", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "10.0");
    assertEquals(new Double(10.0), f.getConstantValue());

    f = new CtField(sloader.get("java.lang.String"), "sff7", cc);
    f.setModifiers(Modifier.STATIC | Modifier.FINAL);
    cc.addField(f, "\"test\"");
    assertEquals("test", f.getConstantValue());

    f = new CtField(sloader.get("java.lang.String"), "sff8", cc);
    f.setModifiers(Modifier.STATIC);
    cc.addField(f, "\"static\"");
    assertEquals(null, f.getConstantValue());

    cc.addMethod(CtNewMethod.make("public int foo(){ return sff1 + sff7.length(); }", cc));
    cc.writeFile();
    Object obj = make(cc.getName());
    assertEquals(9, invoke(obj, "foo"));
  }
Exemple #4
0
  public void testPrune() throws Exception {
    CtClass cc = sloader.get("test2.Prune");
    cc.stopPruning(false);
    System.out.println(cc);
    cc.addField(new CtField(CtClass.intType, "f", cc));
    cc.toBytecode();
    try {
      cc.defrost();
      fail("can call defrost()");
    } catch (RuntimeException e) {
      assertTrue(e.getMessage().indexOf("prune") >= 0);
    }

    System.out.println(cc);
  }
Exemple #5
0
 public void testAddMethod() throws Exception {
   CtClass cc = sloader.get("test2.AddMethod");
   CtMethod m = CtNewMethod.make("public void f() { return 1; }", cc);
   try {
     cc.addMethod(m);
     fail();
   } catch (CannotCompileException e) {
   }
   CtMethod m2 = CtNewMethod.make("public void f(int i, int j) { return 1; }", cc);
   cc.addMethod(m2);
   try {
     cc.addField(new CtField(CtClass.longType, "f", cc));
     fail();
   } catch (CannotCompileException e) {
   }
 }
Exemple #6
0
  public void testSwitch() throws Exception {
    CtClass cc = sloader.makeClass("test2.Switch");

    cc.addMethod(
        CtNewMethod.make(
            "public int test1() {"
                + "  int i = 1;"
                + "  int j;"
                + "  switch (i) {"
                + "  case 0: j = i; break;"
                + "  case 1: j = -i; break;"
                + "  default: j = 0; break;"
                + "  }"
                + "  return j; }",
            cc));

    cc.addMethod(
        CtNewMethod.make(
            "public int test2() {"
                + "  int i = 2;"
                + "  int j = 7;"
                + "  switch (i) {"
                + "  case 0: j = i; break;"
                + "  case 1: j = -i; break;"
                + "  }"
                + "  return j; }",
            cc));

    cc.addMethod(
        CtNewMethod.make(
            "public int test3() {"
                + "  int i = Byte.MAX_VALUE;"
                + "  int j;"
                + "  switch (i) {"
                + "  case Byte.MAX_VALUE: j = i; break;"
                + "  case Byte.MIN_VALUE: j = -i; break;"
                + "  default: j = 0; break;"
                + "  }"
                + "  return j; }",
            cc));

    try {
      cc.addMethod(
          CtNewMethod.make(
              "public int test4() {"
                  + "  int i = Byte.MAX_VALUE;"
                  + "  int j;"
                  + "  switch (i) {"
                  + "  case Byte.MAX_VALUE: j = i; return j;"
                  + "  case Byte.MIN_VALUE: j = -i; return j;"
                  + "  default: j = 0;"
                  + "  }"
                  + "}",
              cc));
      fail("does not report an error (no return)");
    } catch (CannotCompileException e) {
      System.out.println(e);
    }

    try {
      cc.addMethod(
          CtNewMethod.make(
              "public int test5() {"
                  + "  int i = Byte.MAX_VALUE;"
                  + "  int j;"
                  + "  switch (i) {"
                  + "  case Byte.MAX_VALUE: j = i; return j;"
                  + "  case Byte.MIN_VALUE: j = -i; return j;"
                  + "  }"
                  + "}",
              cc));
      fail("does not report an error (not default)");
    } catch (CannotCompileException e) {
      System.out.println(e);
    }

    try {
      cc.addMethod(
          CtNewMethod.make(
              "public int test6() {"
                  + "  int i = Byte.MAX_VALUE;"
                  + "  int j;"
                  + "  switch (i) {"
                  + "  case Byte.MAX_VALUE: j = i; break;"
                  + "  default: j = -i; return j;"
                  + "  }"
                  + "  }",
              cc));
      fail("does not report an error (break)");
    } catch (CannotCompileException e) {
      System.out.println(e);
    }

    cc.addField(CtField.make("public static int k;", cc));

    cc.addMethod(
        CtNewMethod.make(
            "public void foo() {"
                + "  int i = 0;"
                + "  k = 3;"
                + "  switch (i) {"
                + "  case Byte.MAX_VALUE: k = 1;"
                + "  case Byte.MIN_VALUE: k = 2;"
                + "  }"
                + "}",
            cc));

    cc.addMethod(
        CtNewMethod.make(
            "public int test7() {"
                + "  int i = Byte.MAX_VALUE;"
                + "  int j = 3; foo();"
                + "  System.out.println(k);"
                + "  switch (i) {"
                + "  case Byte.MAX_VALUE: return k;"
                + "  case Byte.MIN_VALUE: return j;"
                + "  default: return 0;"
                + "  }"
                + "}",
            cc));

    cc.writeFile();
    Object obj = make(cc.getName());
    assertEquals(-1, invoke(obj, "test1"));
    assertEquals(7, invoke(obj, "test2"));
    assertEquals(Byte.MAX_VALUE, invoke(obj, "test3"));
    assertEquals(3, invoke(obj, "test7"));
  }