Exemplo n.º 1
1
  @Test
  public void testPOJO() throws Exception {
    log.info("*** testPOJO ***");

    for (int i = 0; i < 10; i++) {
      Person person = makePerson();
      person.setLastName("smith" + i);
      registrar.createPerson(person);
    }
    // the objects returned will be fully loaded, but...
    Collection<Person> people = registrar.getPeopleByNameHydrated("joe", "%");
    assertEquals("unexpected number of managed people", 10, people.size());

    // the collection class requires hibernate to be in the path
    Class<?> clazz = people.iterator().next().getAddresses().getClass();
    log.debug("collection class=" + clazz);
    assertTrue("unexpected collection class", clazz.getPackage().getName().contains("hibernate"));

    // now get a graph of objects that contain pure POJO classes. The
    // server will create fresh POJOs for DTOs and pass information from
    // the business object POJO to the data transfer object POJO.
    people = registrar.getPeopleByNameCleaned("joe", "%");
    assertEquals("unexpected number of clean people", 10, people.size());
    for (Person p : people) {
      p.getAddresses().iterator().next().getZip();
    }

    // the POJOs are cleansed of their hibernate types
    clazz = people.iterator().next().getAddresses().getClass();
    log.debug("collection class=" + clazz);
    assertFalse("unexpected collection class", clazz.getPackage().getName().contains("hibernate"));
  }
Exemplo n.º 2
1
 private Bench runBenchmark(Class<? extends Lookup> cls, int count) throws Exception {
   System.err.println("* Running " + count + " iterations for " + cls.getSimpleName() + " ...");
   System.err.println("  - warm-up 10 iterations...");
   for (int i = 0; i < 10; i++) {
     System.runFinalization();
     System.gc();
     Lookup lookup = cls.newInstance();
     _benchmark(lookup, null, false, null);
     lookup = null;
   }
   Bench b = new Bench();
   System.err.print("  - main iterations:");
   System.err.flush();
   for (int i = 0; i < count; i++) {
     System.runFinalization();
     System.gc();
     Lookup lookup = cls.newInstance();
     _benchmark(lookup, null, false, b);
     lookup = null;
     if (i > 0 && (i % 10 == 0)) {
       System.err.print(" " + i);
       System.err.flush();
     }
   }
   System.err.println();
   return b;
 }
Exemplo n.º 3
1
 public <T extends AbstractTask> T createTask(Class<T> type, Project project, String name) {
   Task task =
       TASK_FACTORY.createTask(
           (ProjectInternal) project, GUtil.map(Task.TASK_TYPE, type, Task.TASK_NAME, name));
   assertTrue(type.isAssignableFrom(task.getClass()));
   return type.cast(task);
 }
Exemplo n.º 4
0
  @Test
  public void selfRefUsedInAPropertyIsReadSuccessfully() throws NoSuchMethodException {

    Class<?> aClass = selfRefsClass.getMethod("getChildOfSelf").getReturnType();

    assertThat(aClass.getName(), is("com.example.SelfRefs"));
  }
  private final void validateTwoAnnotations(final PackageInfoModifier.Modification mod)
      throws Exception {
    assertNotNull(mod);
    final byte[] newClass = mod.toByteArray();
    assertNotNull(newClass);
    assertTrue(newClass.length > 0);

    final Class<?> c = new ClassDefiner().define(mod.getPackageName(), newClass);
    assertNotNull(c);

    final Annotation[] annotations = c.getAnnotations();
    assertNotNull(annotations);
    assertTrue(annotations.length == 2);

    Annotation a = annotations[0];
    assertNotNull(a);
    if (a instanceof Deprecated) {
      a = annotations[1];
      assertNotNull(a);
    }
    assertTrue(a instanceof XmlJavaTypeAdapters);
    final XmlJavaTypeAdapters adaptersAnnotation = (XmlJavaTypeAdapters) a;
    final XmlJavaTypeAdapter[] adapters = adaptersAnnotation.value();
    assertNotNull(adapters);
    assertEquals(1, adapters.length);
    final XmlJavaTypeAdapter adapter = adapters[0];
    assertNotNull(adapter);
    assertEquals(Person.class, adapter.type());
    assertEquals(AnyTypeAdapter.class, adapter.value());
  }
  @Test
  public void refToFragmentOfAnotherSchemaIsReadSuccessfully() throws NoSuchMethodException {

    Class<?> aClass = fragmentRefsClass.getMethod("getFragmentOfA").getReturnType();

    assertThat(aClass.getName(), is("com.example.AdditionalPropertyValue"));
  }
  @Test
  public void testLoadFromJar() throws Exception {
    File jar = Files.createTempFile("battlecode-test", ".jar").toFile();

    jar.deleteOnExit();

    ZipOutputStream z = new ZipOutputStream(new FileOutputStream(jar));

    ZipEntry classEntry = new ZipEntry("instrumentertest/Nothing.class");

    z.putNextEntry(classEntry);

    IOUtils.copy(
        getClass().getClassLoader().getResourceAsStream("instrumentertest/Nothing.class"), z);

    z.closeEntry();
    z.close();

    IndividualClassLoader jarLoader =
        new IndividualClassLoader(
            "instrumentertest", new IndividualClassLoader.Cache(jar.toURI().toURL()));

    Class<?> jarClass = jarLoader.loadClass("instrumentertest.Nothing");

    URL jarClassLocation = jarClass.getResource("Nothing.class");

    // EXTREMELY scientific

    assertTrue(jarClassLocation.toString().startsWith("jar:"));
    assertTrue(jarClassLocation.toString().contains(jar.toURI().toURL().toString()));
  }
Exemplo n.º 8
0
  @Test
  @SuppressWarnings("rawtypes")
  public void wordDelimitersCausesCamelCase()
      throws ClassNotFoundException, IntrospectionException, InstantiationException,
          IllegalAccessException, InvocationTargetException {

    ClassLoader resultsClassLoader =
        generateAndCompile(
            "/schema/properties/propertiesWithWordDelimiters.json",
            "com.example",
            config("usePrimitives", true, "propertyWordDelimiters", "_ -"));

    Class generatedType = resultsClassLoader.loadClass("com.example.WordDelimit");

    Object instance = generatedType.newInstance();

    new PropertyDescriptor("propertyWithUnderscores", generatedType)
        .getWriteMethod()
        .invoke(instance, "a_b_c");
    new PropertyDescriptor("propertyWithHyphens", generatedType)
        .getWriteMethod()
        .invoke(instance, "a-b-c");
    new PropertyDescriptor("propertyWithMixedDelimiters", generatedType)
        .getWriteMethod()
        .invoke(instance, "a b_c-d");

    JsonNode jsonified = mapper.valueToTree(instance);

    assertThat(jsonified.has("property_with_underscores"), is(true));
    assertThat(jsonified.has("property-with-hyphens"), is(true));
    assertThat(jsonified.has("property_with mixed-delimiters"), is(true));
  }
 private List<String> dependenciesOf(Package source) {
   List<String> result = new ArrayList<>();
   if (source.isAnnotationPresent(DependsUpon.class))
     for (Class<?> target : source.getAnnotation(DependsUpon.class).packagesOf())
       result.add(target.getPackage().getName());
   return result;
 }
 @Test
 public void acceptedCommandsCanBeSerializedTest() throws Exception {
   Field commandsField = JaxbCommandsRequest.class.getDeclaredField("commands");
   XmlElements xmlElemsAnno = (XmlElements) commandsField.getAnnotations()[0];
   XmlElement[] xmlElems = xmlElemsAnno.value();
   Set<Class> cmdSet = new HashSet<Class>(AcceptedCommands.getSet());
   assertEquals(cmdSet.size(), xmlElems.length);
   Set<String> xmlElemNameSet = new HashSet<String>();
   for (XmlElement xmlElemAnno : xmlElems) {
     Class cmdClass = xmlElemAnno.type();
     String name = xmlElemAnno.name();
     assertTrue(name + " is used twice as a name.", xmlElemNameSet.add(name));
     assertTrue(
         cmdClass.getSimpleName()
             + " is present in "
             + JaxbCommandsRequest.class.getSimpleName()
             + " but not in "
             + AcceptedCommands.class.getSimpleName(),
         cmdSet.remove(cmdClass));
   }
   for (Class cmdClass : cmdSet) {
     System.out.println("Missing: " + cmdClass.getSimpleName());
   }
   assertTrue(
       "See output for classes in "
           + AcceptedCommands.class.getSimpleName()
           + " that are not in "
           + JaxbCommandsRequest.class.getSimpleName(),
       cmdSet.size() == 0);
 }
  @Test
  public void testSetAmount2() throws Exception {
    System.out.println("setAmount2");

    /* Set up a new loan */
    Loan target = new Loan();

    /* get the setAmount method details */
    Method method = Loan.class.getDeclaredMethod("setAmount", double.class);

    /* make the field assessible */
    method.setAccessible(true);

    /* invoke the method setAmount with the value 3000.0 */
    method.invoke(target, 3000.0);

    /*access the field loanAmount and check its value is set the 3000.0*/
    Class secretClass = target.getClass();
    Field f = secretClass.getDeclaredField("loanAmount");
    f.setAccessible(true);

    double result = f.getDouble(target);

    assertEquals("The amounts should be equal", 3000.00, result, 0.0);
  }
Exemplo n.º 12
0
  public void assertTestsStarted(Class<?>... classes) {
    List<String> testNames = newArrayList();
    for (Class<?> each : classes) {
      testNames.add(each.getName());
    }

    assertTestsStarted(toArray(testNames, String.class));
  }
  @Test
  public void detectsFindAllWithSortParameterOnSortingRepository() throws Exception {

    Class<RepositoryWithCustomSortingFindAll> type = RepositoryWithCustomSortingFindAll.class;

    assertFindAllMethodOn(type, type.getMethod("findAll", Sort.class));
    assertSaveMethodPresent(type, false);
  }
Exemplo n.º 14
0
  @Test
  public void refToFragmentOfSelfIsReadSuccessfully() throws NoSuchMethodException {

    Class<?> aClass = fragmentRefsClass.getMethod("getFragmentOfSelf").getReturnType();

    assertThat(aClass.getName(), is("com.example.A"));
    assertThat(aClass.getMethods(), hasItemInArray(hasProperty("name", equalTo("getPropertyOfA"))));
  }
    /*
     * (non-Javadoc)
     * @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
     */
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {

      Class<?> returnType = invocation.getMethod().getReturnType();
      return returnType.equals(Boolean.class) || returnType.equals(boolean.class)
          ? true
          : DEFAULT.answer(invocation);
    }
Exemplo n.º 16
0
 @Test
 public void testConstructor() throws Exception {
   Class<HMAC> c = HMAC.class;
   assertEquals(1, c.getDeclaredConstructors().length);
   Constructor<HMAC> constructor = c.getDeclaredConstructor();
   assertTrue(Modifier.isPrivate(constructor.getModifiers()));
   constructor.setAccessible(true);
   constructor.newInstance();
 }
Exemplo n.º 17
0
  @Test
  public void selfRefUsedAsArrayItemsIsReadSuccessfully() throws NoSuchMethodException {

    Type listOfAType = selfRefsClass.getMethod("getArrayOfSelf").getGenericReturnType();
    Class<?> listEntryClass =
        (Class<?>) ((ParameterizedType) listOfAType).getActualTypeArguments()[0];

    assertThat(listEntryClass.getName(), is("com.example.SelfRefs"));
  }
 protected void invokeKey(String name) throws Exception {
   if (!needsKey) return;
   BehaviorSkinBase skin = (BehaviorSkinBase) getView().getSkin();
   BehaviorBase behavior = skin.getBehavior();
   Class<? extends BehaviorBase> behaviorClass = behavior.getClass();
   Field field = behaviorClass.getDeclaredField(name);
   field.setAccessible(true);
   field.set(behavior, true);
 }
 /**
  * Refectively invokes action method on behavior
  *
  * <p>NOTE to self: boolean.class != Boolean.class - getDeclaredMethod doesn't do any
  * primitve/Object type conversion.
  *
  * @param name method name
  * @param param boolean parameter
  * @throws NoSuchMethodException
  * @throws IllegalAccessException
  * @throws InvocationTargetException
  */
 protected void invokeBehavior(String name, boolean param)
     throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
   BehaviorSkinBase skin = (BehaviorSkinBase) getView().getSkin();
   BehaviorBase behavior = skin.getBehavior();
   Class<? extends BehaviorBase> behaviorClass = behavior.getClass();
   Method method = behaviorClass.getDeclaredMethod(name, boolean.class);
   method.setAccessible(true);
   method.invoke(behavior, param);
 }
  /** @see DATACMNS-393 */
  @Test
  public void detectsOverloadedMethodsCorrectly() throws Exception {

    Class<RepositoryWithAllCrudMethodOverloaded> type = RepositoryWithAllCrudMethodOverloaded.class;
    assertFindOneMethodOn(type, type.getDeclaredMethod("findOne", Long.class));
    assertDeleteMethodOn(type, type.getDeclaredMethod("delete", Long.class));
    assertSaveMethodOn(type, type.getDeclaredMethod("save", Domain.class));
    assertFindAllMethodOn(type, type.getDeclaredMethod("findAll"));
  }
  @Test
  public void detectsMethodsOnPagingAndSortingRepository() throws Exception {

    Class<DomainPagingAndSortingRepository> type = DomainPagingAndSortingRepository.class;

    assertFindAllMethodOn(type, type.getMethod("findAll", Pageable.class));
    assertDeleteMethodOn(type, type.getMethod("delete", Serializable.class));
    assertSaveMethodPresent(type, true);
  }
Exemplo n.º 22
0
  @Test
  public void testBeforeAddInterceptor() throws Exception {
    final TestClassLoader loader = getTestClassLoader();
    final String javassistClassName = "com.navercorp.pinpoint.profiler.interceptor.bci.TestObject";

    loader.addTransformer(
        javassistClassName,
        new TransformCallback() {

          @Override
          public byte[] doInTransform(
              Instrumentor instrumentContext,
              ClassLoader classLoader,
              String className,
              Class<?> classBeingRedefined,
              ProtectionDomain protectionDomain,
              byte[] classfileBuffer)
              throws InstrumentException {
            try {
              logger.info("modify className:{} cl:{}", className, classLoader);

              InstrumentClass aClass =
                  instrumentContext.getInstrumentClass(
                      classLoader, javassistClassName, classfileBuffer);

              String methodName = "callA";
              aClass
                  .getDeclaredMethod(methodName)
                  .addInterceptor(
                      "com.navercorp.pinpoint.profiler.interceptor.TestBeforeInterceptor");

              return aClass.toBytecode();
            } catch (InstrumentException e) {
              e.printStackTrace();
              throw new RuntimeException(e.getMessage(), e);
            }
          }
        });

    loader.initialize();

    Class<?> testObjectClazz = loader.loadClass(javassistClassName);
    final String methodName = "callA";
    logger.info("class:{}", testObjectClazz.toString());
    final Object testObject = testObjectClazz.newInstance();
    Method callA = testObjectClazz.getMethod(methodName);
    callA.invoke(testObject);
    Interceptor interceptor = getInterceptor(loader, 0);
    assertEqualsIntField(interceptor, "call", 1);
    assertEqualsObjectField(
        interceptor, "className", "com.navercorp.pinpoint.profiler.interceptor.bci.TestObject");
    assertEqualsObjectField(interceptor, "methodName", methodName);
    assertEqualsObjectField(interceptor, "args", null);

    assertEqualsObjectField(interceptor, "target", testObject);
  }
  /**
   * input/output simple records.
   *
   * @throws Exception if test was failed
   */
  @SuppressWarnings("unchecked")
  @Test
  public void simple_record() throws Exception {
    ModelLoader loader = generate();

    Class<?> type = loader.modelType("Simple");
    assertThat(type.isAnnotationPresent(ModelInputLocation.class), is(true));
    assertThat(type.isAnnotationPresent(ModelOutputLocation.class), is(true));

    ModelWrapper object = loader.newModel("Simple");
    DataOutputBuffer output = new DataOutputBuffer();
    ModelOutput<Object> modelOut =
        (ModelOutput<Object>)
            type.getAnnotation(ModelOutputLocation.class)
                .value()
                .getDeclaredConstructor(RecordEmitter.class)
                .newInstance(new TsvEmitter(new OutputStreamWriter(output, "UTF-8")));

    object.set("sid", 1L);
    object.set("value", new Text("hello"));
    modelOut.write(object.unwrap());

    object.set("sid", 2L);
    object.set("value", new Text("world"));
    modelOut.write(object.unwrap());

    object.set("sid", 3L);
    object.set("value", null);
    modelOut.write(object.unwrap());
    modelOut.close();

    DataInputBuffer input = new DataInputBuffer();
    input.reset(output.getData(), output.getLength());
    ModelInput<Object> modelIn =
        (ModelInput<Object>)
            type.getAnnotation(ModelInputLocation.class)
                .value()
                .getDeclaredConstructor(RecordParser.class)
                .newInstance(new TsvParser(new InputStreamReader(input, "UTF-8")));
    ModelWrapper copy = loader.newModel("Simple");

    modelIn.readTo(copy.unwrap());
    assertThat(copy.get("sid"), is((Object) 1L));
    assertThat(copy.get("value"), is((Object) new Text("hello")));

    modelIn.readTo(copy.unwrap());
    assertThat(copy.get("sid"), is((Object) 2L));
    assertThat(copy.get("value"), is((Object) new Text("world")));

    modelIn.readTo(copy.unwrap());
    assertThat(copy.get("sid"), is((Object) 3L));
    assertThat(copy.getOption("value").isNull(), is(true));

    assertThat(input.read(), is(-1));
    modelIn.close();
  }
  /** @see DATACMNS-393 */
  @Test
  public void selectsFindAllWithSortParameterOnRepositoryAmongUnsuitableAlternatives()
      throws Exception {

    Class<RepositoryWithInvalidPagingFallbackToSortFindAll> type =
        RepositoryWithInvalidPagingFallbackToSortFindAll.class;

    assertFindAllMethodOn(type, type.getMethod("findAll", Sort.class));
    assertSaveMethodPresent(type, false);
  }
  @Test
  public void detectsMethodsOnCustomRepository() throws Exception {

    Class<RepositoryWithCustomSortingAndPagingFindAll> type =
        RepositoryWithCustomSortingAndPagingFindAll.class;
    assertFindAllMethodOn(type, type.getMethod("findAll", Pageable.class));

    Class<RepositoryWithIterableDeleteOnly> type1 = RepositoryWithIterableDeleteOnly.class;
    assertDeleteMethodOn(type1, type1.getMethod("delete", Iterable.class));
  }
Exemplo n.º 26
0
 @Test
 public void testSetClassName() throws Exception {
   Intent intent = new Intent();
   Class<? extends IntentTest> thisClass = getClass();
   intent.setClassName("package.name", thisClass.getName());
   assertSame(thisClass.getName(), intent.getComponent().getClassName());
   assertEquals("package.name", intent.getComponent().getPackageName());
   ShadowIntent si = shadowOf(intent);
   assertSame(si.getIntentClass(), thisClass);
 }
Exemplo n.º 27
0
  @Test
  public void selfRefUsedForAdditionalPropertiesIsReadSuccessfully() throws NoSuchMethodException {

    Type additionalPropertiesType =
        selfRefsClass.getMethod("getAdditionalProperties").getGenericReturnType();
    Class<?> mapEntryClass =
        (Class<?>) ((ParameterizedType) additionalPropertiesType).getActualTypeArguments()[1];

    assertThat(mapEntryClass.getName(), is("com.example.SelfRefs"));
  }
Exemplo n.º 28
0
  @Test
  public void nestedSelfRefsInStringContentWithoutParentFile()
      throws NoSuchMethodException, ClassNotFoundException, IOException {

    String schemaContents =
        IOUtils.toString(
            CodeGenerationHelper.class.getResource("/schema/ref/nestedSelfRefsReadAsString.json"));
    JCodeModel codeModel = new JCodeModel();
    new SchemaMapper().generate(codeModel, "NestedSelfRefsInString", "com.example", schemaContents);

    codeModel.build(schemaRule.getGenerateDir());

    ClassLoader classLoader = schemaRule.compile();

    Class<?> nestedSelfRefs = classLoader.loadClass("com.example.NestedSelfRefsInString");
    assertThat(
        nestedSelfRefs.getMethod("getThings").getReturnType().getSimpleName(), equalTo("List"));

    Class<?> listEntryType =
        (Class<?>)
            ((ParameterizedType) nestedSelfRefs.getMethod("getThings").getGenericReturnType())
                .getActualTypeArguments()[0];
    assertThat(listEntryType.getName(), equalTo("com.example.Thing"));

    Class<?> thingClass = classLoader.loadClass("com.example.Thing");
    assertThat(
        thingClass.getMethod("getNamespace").getReturnType().getSimpleName(), equalTo("String"));
    assertThat(thingClass.getMethod("getName").getReturnType().getSimpleName(), equalTo("String"));
    assertThat(
        thingClass.getMethod("getVersion").getReturnType().getSimpleName(), equalTo("String"));
  }
Exemplo n.º 29
0
  @Test
  public void shouldFindPathAnnotatedClassesInPackage() {
    ClassPathScanner scanner = new ClassPathScanner(PACKAGE_ORG_CAMUNDA_BPM_ENGINE_REST);
    Set<Class<?>> classes = scanner.getClassesWithAnnotation(Path.class);

    assertEquals(16, classes.size());

    for (Class<?> clazz : classes) {
      Path annotation = clazz.getAnnotation(Path.class);
      System.out.println(clazz + " path: " + annotation.value());
    }
  }
Exemplo n.º 30
0
  @Test
  public void shouldFindApplicationPathAnnotatedClassInPackage() {
    ClassPathScanner scanner = new ClassPathScanner(PACKAGE_RESTAPIDOC_TEST);
    Set<Class<?>> classes = scanner.getClassesWithAnnotation(ApplicationPath.class);

    assertEquals(1, classes.size());

    for (Class<?> clazz : classes) {
      ApplicationPath annotation = clazz.getAnnotation(ApplicationPath.class);
      System.out.println(clazz + " path: " + annotation.value());
    }
  }