public ClassName withoutPrefixChars(final int prefixLength) { final String nameWithoutPackage = this.getNameWithoutPackage().asJavaName(); return ClassName.fromString(this.getPackage().asJavaName() + "/" + nameWithoutPackage.substring(prefixLength, nameWithoutPackage.length())); }
private final String callTesteeWith(final Class<?> first, final Class<?> second) { return this.testee.getCommonSuperClass(ClassName.fromClass(first) .asInternalName(), ClassName.fromClass(second).asInternalName()); }
@Override public void visitInnerClass(final String name, final String outerName, final String innerName, final int access) { super.visitInnerClass(name, outerName, innerName, access); if ((outerName != null) && this.classInfo.id.getName().equals(ClassName.fromString(name))) { this.classInfo.outerClass = outerName; } }
private static Function<String,String> classToPackageGlob() { return a -> ClassName.fromString(a).getPackage().asJavaName() + ".*"; }
public static ClassName fromString(final String clazz) { final String name = clazz.replace('.', '/'); if (name.equals(OBJECT.asInternalName())) { return OBJECT; } if (name.equals(STRING.asInternalName())) { return STRING; } return new ClassName(name); }
public Optional<ClassName> findTestee(final String className) { final ClassName name = ClassName.fromString(className); if (name.asJavaName().endsWith("Test") && tryName(name.withoutSuffixChars(TEST_LENGTH))) { return Optional.ofNullable(name.withoutSuffixChars(TEST_LENGTH)); } if (name.getNameWithoutPackage().asJavaName().startsWith("Test") && tryName(name.withoutPrefixChars(TEST_LENGTH))) { return Optional.ofNullable(name.withoutPrefixChars(TEST_LENGTH)); } return Optional.empty(); }
@Override public int compareTo(final ClassName o) { return this.asJavaName().compareTo(o.asJavaName()); }
@Override public InputStream getData(String name) throws IOException { final Collection<String> names = classNames(); if (!names.contains(ClassName.fromString(name).asJavaName())) { return null; } return this.child.getData(name); }
@Test public void shouldWriteDisassembledOriginalBytecodeToDisk() { executeFor(VeryMutable.class); final Path shouldBeCreated = classBasePath(VeryMutable.class).resolve(ClassName.fromClass(VeryMutable.class).asJavaName() + ".txt"); assertThat(shouldBeCreated).exists(); }
@Test public void getNameWithoutPackageShouldReturnNameOnlyWhenClassIsOuterClass() { assertEquals(ClassName.fromString("String"), ClassName.fromClass(String.class).getNameWithoutPackage()); }
report.writeAttribute("name", method); report.writeAttribute("description", methodDescription); report.writeAttribute("class", details.getClassName().getNameWithoutPackage().asJavaName()); report.writeAttribute("package", details.getClassName().getPackage().asJavaName()); report.endObject();
@Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { final String type = desc.substring(1, desc.length() - 1); this.classInfo.registerAnnotation(type); return new ClassAnnotationValueVisitor(this.classInfo, ClassName.fromString(type)); }
@Test public void getPackageShouldReturnPackageWhenClassWithinAPackage() { assertEquals(ClassName.fromString("org.pitest.classinfo"), ClassName.fromClass( ClassNameTest.class).getPackage()); }
private static Function<ClassInfo, String> keyFromClassInfo() { return c -> keyFromSourceAndPackage(c.getSourceFileName(), c.getName() .getPackage().asJavaName()); }
private void restoreLastClass(final ClassByteArraySource byteSource, final ClassName clazzName, final ClassLoader loader) throws ClassNotFoundException { if ((this.lastMutatedClass != null) && !this.lastMutatedClass.equals(clazzName)) { restoreForLoader(this.lastUsedLoader); restoreForLoader(loader); } if ((this.lastMutatedClass == null) || !this.lastMutatedClass.equals(clazzName)) { this.lastClassPreMutation = byteSource.getBytes(clazzName.asJavaName()) .get(); } this.lastMutatedClass = clazzName; }
private Optional<MethodTree> parseMethodFromCompiledResource(ClassName clazz, Compiler compiler, Predicate<MethodTree> method) { final ResourceFolderByteArraySource source = new ResourceFolderByteArraySource(); final Optional<byte[]> bs = source.getBytes("loops/" + compiler.name() + "/" + clazz.getNameWithoutPackage().asJavaName()); if (bs.isPresent()) { final ClassTree tree = ClassTree.fromBytes(bs.get()); return tree.methods().stream().filter(method).findFirst(); } return Optional.empty(); }
@Test public void getPackageShouldReturnEmptyPackageWhenClassInPackageDefault() { assertEquals(ClassName.fromString(""), ClassName.fromString("Foo").getPackage()); }
@Test public void shouldConvertJavaNamesToInternalNames() { final ClassName testee = ClassName.fromString("com.foo.bar"); assertEquals("com/foo/bar", testee.asInternalName()); }
@Test public void getNameWithoutPackageShouldReturnNameWhenClassInPackageDefault() { assertEquals(ClassName.fromString("Foo"), ClassName.fromString("Foo").getNameWithoutPackage()); }
public String packageName() { return location.getClassName().getPackage().asInternalName(); }