private Path classBasePath(Class<?> clazz) { final ClassName name = ClassName.fromClass(clazz); return this.fileSystem.getPath("target/export",name.asInternalName().split("/")); } }
@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); }
private Collection<MutationDetails> findMutants(Class<?> clazz) { this.data.setTargetClasses(Collections.singleton(clazz.getName())); this.cbas = ClassloaderByteArraySource.fromContext(); return findMutants(ClassName.fromClass(clazz)); }
@Test public void shouldStoreTypeArrayValuesAsClassNames() throws ClassNotFoundException { final String sampleName = HasCategory.class.getName(); final ClassInfoBuilder actual = getClassInfo(sampleName, ClassUtils.classAsBytes(sampleName)); assertEquals(1, actual.classAnnotationValues.size()); final Object[] expectedCategoryNames = { First.class.getName(), Second.class.getName() }; final Object[] actualCategoryNames = (Object[]) actual.classAnnotationValues .get(ClassName.fromClass(Category.class)); assertArrayEquals(expectedCategoryNames, actualCategoryNames); }
private Sample sampleForClass(Class<?> clazz) { final ClassloaderByteArraySource source = ClassloaderByteArraySource.fromContext(); final Sample s = new Sample(); s.className = ClassName.fromClass(clazz); s.clazz = ClassTree.fromBytes(source.getBytes(clazz.getName()).get()); s.compiler = "current"; return s; } }
@Test public void shouldReportSuperClassAsObjectWhenNoneDeclared() { final Optional<ClassInfo> aClass = this.testee.fetchClass(Foo.class); assertEquals(ClassName.fromClass(Object.class), aClass.get().getSuperClass() .get().getName()); }
@Test public void shouldReportSuperClassAsObjectWhenNoneDeclared() { final Optional<ClassInfo> aClass = this.testee.fetchClass(Foo.class); assertEquals(ClassName.fromClass(Object.class), aClass.get().getSuperClass() .get().getName()); }
@Test public void shouldReportSuperClass() { final Optional<ClassInfo> aClass = this.testee.fetchClass(Bar.class); assertEquals(ClassName.fromClass(Foo.class), aClass.get().getSuperClass() .get().getName()); }
@Test public void shouldWriteMutantBytesToDisk() { final Collection<MutationDetails> mutations = executeFor(VeryMutable.class); final Mutant firstMutant = this.mutator.getMutation(mutations.iterator().next().getId()); final Path shouldBeCreated = mutantBasePath(VeryMutable.class,0).resolve(ClassName.fromClass(VeryMutable.class).asJavaName() + ".class"); assertThat(shouldBeCreated).hasBinaryContent(firstMutant.getBytes()); }
@Test public void shouldMapLinesWhenLinesSpanBlocks() throws Exception { final Map<BlockLocation, Set<Integer>> actual = analyse(com.example.LineNumbersSpanBlocks.class); final Location l = Location.location( ClassName.fromClass(com.example.LineNumbersSpanBlocks.class), MethodName.fromString("foo"), "(I)I"); assertThat(actual.get(BlockLocation.blockLocation(l, 2))).containsOnly(12); }
@Test public void shouldIncludeLastLinesConstructorsInBlock() throws Exception { final Map<BlockLocation, Set<Integer>> actual = analyse(LastLineOfContructorCheck.class); final Location l = Location.location( ClassName.fromClass(LastLineOfContructorCheck.class), MethodName.fromString("<init>"), "()V"); assertThat(actual.get(BlockLocation.blockLocation(l, 0))).contains(6); }
@Test public void shouldFilterMutationsThatRemoveForLoopIncrement() { GregorMutater mutator = createMutator(RemoveIncrementsMutator.REMOVE_INCREMENTS_MUTATOR); List<MutationDetails> mutations = mutator.findMutations(ClassName.fromClass(MutateMyForLoop.class)); assertThat(mutations).hasSize(2); testee.begin(forClass(MutateMyForLoop.class)); Collection<MutationDetails> actual = testee.intercept(mutations, mutator); testee.end(); assertThat(actual).hasSize(1); }
@Test public void shouldNotFilterMutationsInMethodsThatAppearToAlreadyHaveInfiniteLoops() { GregorMutater mutator = createMutator(RemoveIncrementsMutator.REMOVE_INCREMENTS_MUTATOR); // our analysis incorrectly identifies some loops as infinite - must skip these List<MutationDetails> mutations = mutator.findMutations(ClassName.fromClass(DontFilterMyAlreadyInfiniteLoop.class)); assertThat(mutations).hasSize(1); testee.begin(forClass(DontFilterMyAlreadyInfiniteLoop.class)); Collection<MutationDetails> actual = testee.intercept(mutations, mutator); testee.end(); assertThat(actual).hasSize(1); }
@Test public void shouldNotFilterMutationsInMethodsThatAppearToAlreadyHaveInfiniteLoops() { final GregorMutater mutator = createMutator(RemoveIncrementsMutator.REMOVE_INCREMENTS_MUTATOR); // our analysis incorrectly identifies some loops as infinite - must skip these final List<MutationDetails> mutations = mutator.findMutations(ClassName.fromClass(DontFilterMyAlreadyInfiniteLoop.class)); assertThat(mutations).hasSize(1); this.testee.begin(forClass(DontFilterMyAlreadyInfiniteLoop.class)); final Collection<MutationDetails> actual = this.testee.intercept(mutations, mutator); this.testee.end(); assertThat(actual).hasSize(1); }
@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)); }
private Collection<MutationDetails> executeFor(Class<?> clazz) { final Collection<MutationDetails> mutations = this.mutator.findMutations(ClassName.fromClass(clazz)); this.testee.begin(tree(VeryMutable.class)); this.testee.intercept(mutations, this.mutator); this.testee.end(); return mutations; }