public static Match<AbstractInsnNode> methodCallThatReturns(final ClassName type) { return (c, t) -> { if ( t instanceof MethodInsnNode ) { return ((MethodInsnNode) t).desc.endsWith(type.asInternalName() + ";"); } return false; }; }
public static Match<AbstractInsnNode> methodCallTo(final ClassName owner, final String name) { return (c, t) -> { if ( t instanceof MethodInsnNode ) { final MethodInsnNode call = (MethodInsnNode) t; return call.name.equals(name) && call.owner.equals(owner.asInternalName()); } return false; }; }
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); }
@Override public List<MutationDetails> findMutations( final ClassName classToMutate) { final ClassContext context = new ClassContext(); context.setTargetMutation(Optional.<MutationIdentifier> empty()); Optional<byte[]> bytes = GregorMutater.this.byteSource.getBytes( classToMutate.asInternalName()); return bytes.map(findMutations(context)) .orElse(Collections.<MutationDetails>emptyList()); }
private Path classBasePath(Class<?> clazz) { final ClassName name = ClassName.fromClass(clazz); return this.fileSystem.getPath("target/export",name.asInternalName().split("/")); } }
private boolean isLineCovered(final int line) { final Predicate<ClassInfo> predicate = a -> !AnnotatedLineFactory.this.statistics.getTestsForClassLine( new ClassLine(a.getName().asInternalName(), line)).isEmpty(); return FCollection.contains(this.classesInFile, predicate); }
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 apply(final int opCode, final MethodVisitor mv) { mv.visitInsn(Opcodes.POP); mv.visitInsn(Opcodes.DCONST_0); mv.visitMethodInsn(Opcodes.INVOKESTATIC, ClassName.fromClass(Double.class).asInternalName(), "valueOf", "(D)Ljava/lang/Double;", false); mv.visitInsn(Opcodes.ARETURN); }
@Override public void apply(final int opCode, final MethodVisitor mv) { mv.visitInsn(Opcodes.POP); mv.visitInsn(Opcodes.LCONST_0); mv.visitMethodInsn(Opcodes.INVOKESTATIC, ClassName.fromClass(Long.class).asInternalName(), "valueOf", "(J)Ljava/lang/Long;", false); mv.visitInsn(Opcodes.ARETURN); }
@Override public void apply(final int opCode, final MethodVisitor mv) { mv.visitInsn(Opcodes.POP); mv.visitInsn(Opcodes.FCONST_0); mv.visitMethodInsn(Opcodes.INVOKESTATIC, ClassName.fromClass(Float.class).asInternalName(), "valueOf", "(F)Ljava/lang/Float;", false); mv.visitInsn(Opcodes.ARETURN); }
private String getOuterClassNameFor(final Class<?> clazz) { return this.testee.fetchClass(clazz).get().getOuterClass().get() .getName().asInternalName(); }
@Override public void apply(final int opCode, final MethodVisitor mv) { mv.visitInsn(Opcodes.POP); mv.visitInsn(Opcodes.ICONST_0); mv.visitMethodInsn(Opcodes.INVOKESTATIC, ClassName.fromClass(owner).asInternalName(), "valueOf", sig, false); mv.visitInsn(Opcodes.ARETURN); }
@Test public void shouldResolveObjectAsSuperClassWhenNoCommonParentExists() { assertEquals(ClassName.fromClass(Object.class).asInternalName(), callTesteeWith(Integer.class, String.class)); }
@Test public void shouldResolveParentInterfaceWhenFirstInterfaceExtendsTheSecond() { assertEquals(ClassName.fromClass(ICommon.class).asInternalName(), callTesteeWith(ICommon2.class, ICommon.class)); }
@Test public void shouldResolveCommonParentWhenNotImmediateParentOfFirstType() { assertEquals(ClassName.fromClass(Parent.class).asInternalName(), callTesteeWith(GrandChild.class, Child1.class)); }
@Test public void shouldCommonParentInterfaceWhenNotImmediateParentOfFirstType() { assertEquals(ClassName.fromClass(ICommon3.class).asInternalName(), callTesteeWith(ICommonGreatGrandChild.class, ICommon3.class)); }
@Test public void shouldResolveSuperClassWhenCommonParentExists() { assertEquals(ClassName.fromClass(Parent.class).asInternalName(), callTesteeWith(Child1.class, Child2.class)); }
@Test public void shouldResolveObjectAsSuperClassWhenImplementCommonInterface() { assertEquals(ClassName.fromClass(Object.class).asInternalName(), callTesteeWith(ImplementsICommon1.class, ImplementsICommon2.class)); }
@Test public void shouldResolveObjectAsSuperClassWhenInterfacesExtendCommonInterface() { assertEquals(ClassName.fromClass(Object.class).asInternalName(), callTesteeWith(ICommon2.class, ICommon3.class)); }
@Test public void shouldCommonParentInterfaceWhenNotImmediateParentOfSecondType() { assertEquals(ClassName.fromClass(ICommon3.class).asInternalName(), callTesteeWith(ICommon3.class, ICommonGreatGrandChild.class)); }