@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)); }
@Override protected BlockCoverage mapToData(final Map<String, Object> map) { final String method = (String) map.get(METHOD); final Location location = new Location(ClassName.fromString((String) map.get(CLASSNAME)), MethodName.fromString(method.substring(0, method.indexOf(OPEN_PAREN))), method.substring(method.indexOf(OPEN_PAREN))); final BlockLocation blockLocation = new BlockLocation(location, Integer.parseInt((String) map.get(NUMBER))); @SuppressWarnings("unchecked") final Collection<String> tests = (Collection<String>) map.get(TESTS); return new BlockCoverage(blockLocation, tests); }
@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); }
@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; } }
@Test public void shouldTreatSameClassAsEqual() { assertEquals(ClassName.fromString("org/example/Foo"), ClassName.fromString("org.example.Foo")); }
private static boolean isMutatedClass(final String name) { return (mutant != null) && mutant.getDetails().getClassName() .equals(ClassName.fromString(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(); }
@Test public void shouldAllowClientsToRetrieveBytecode() { this.testee.fetchClassBytes(ClassName.fromString("Foo")); verify(this.repository).querySource(ClassName.fromString("Foo")); }
@Test public void withoutSuffixCharsShouldReturnPacakgeAndClassWithoutSuffixChars() { assertEquals(ClassName.fromString("com.example.Foo"), ClassName.fromString( "com.example.FooTest").withoutSuffixChars(4)); }
@Test public void shouldFetchClassWhenApplied() { final Repository repository = mock(Repository.class); final NameToClassInfo testee = new NameToClassInfo(repository); testee.apply(ClassName.fromString("foo")); verify(repository).fetchClass(ClassName.fromString("foo")); }
@Test public void shouldOnlyCheckSourceForUnknownClassesOnce() { this.testee = new Repository(this.source); when(this.source.getBytes(anyString())).thenReturn(Optional.<byte[]> empty()); this.testee.hasClass(ClassName.fromString("foo")); this.testee.hasClass(ClassName.fromString("foo")); verify(this.source, times(1)).getBytes("foo"); }
@Test public void shouldOnlyQuerySourceForAnUnknownClassOnce() { this.testee = new Repository(this.source); when(this.source.getBytes(anyString())).thenReturn(Optional.<byte[]> empty()); this.testee.hasClass(ClassName.fromString("foo")); this.testee.fetchClass(ClassName.fromString("foo")); verify(this.source, times(1)).getBytes("foo"); }
private void setCurrentClassPath(final HierarchicalClassId currentId) { final ClassInfo currentClass = ClassInfoMother.make(currentId.getId()); when(this.classInfoSource.fetchClass(ClassName.fromString("foo"))) .thenReturn(Optional.ofNullable(currentClass)); }
private void assertCreatesOneTestUnitForTwoMutations() { final MutationDetails mutation1 = createDetails("foo"); final MutationDetails mutation2 = createDetails("foo"); when(this.source.createMutations(any(ClassName.class))).thenReturn( Arrays.asList(mutation1, mutation2)); final List<MutationAnalysisUnit> actual = this.testee .createMutationTestUnits(Arrays.asList(ClassName.fromString("foo"))); assertEquals(1, actual.size()); }
@Test public void shouldProvideAccessToClassData() { final Collection<ClassName> classes = Arrays.asList(ClassName .fromString("foo")); this.testee.getClassInfo(classes); verify(this.code).getClassInfo(classes); }
@Test public void shouldReturnNoneWhenAskedForUnknownClass() { assertEquals(Optional.empty(), this.testee.fetchClass(ClassName.fromString("never.heard.of.you"))); }
@Test public void shouldTreatClassesWithSameHashAsUnChanged() { final ClassName foo = ClassName.fromString("foo"); final HierarchicalClassId currentId = new HierarchicalClassId(0, foo, "0"); setCurrentClassPath(currentId); this.historicClassPath.put(foo, makeHistory(currentId)); assertFalse(this.testee.hasClassChanged(ClassName.fromString("foo"))); }
@Test public void shouldFilterMutantsInTryCatchFinallyCompiledWithAspectJ() { this.data.setDetectInlinedCode(true); final ClassName clazz = ClassName.fromString("trywithresources/TryCatchFinallyExample_aspectj"); final Collection<MutationDetails> actual = findMutants(clazz); assertThat(actual).hasSize(3); }
@Test public void shouldTreatClassesWithDifferentHashesAsChanged() { final long currentHash = 42; final ClassName foo = ClassName.fromString("foo"); final ClassIdentifier currentId = new ClassIdentifier(currentHash, foo); setCurrentClassPath(ClassInfoMother.make(currentId)); this.historicClassPath.put(foo, makeHistory(new HierarchicalClassId( currentHash + 1, foo, "0"))); assertTrue(this.testee.hasClassChanged(ClassName.fromString("foo"))); }
public static CoverageResultBuilder aCoverageResult() { final ClassName fooTest = ClassName.fromString("FooTest"); return QB .builder(CoverageResultBuilder.class, CoverageResultSeed()) .withTestUnitDescription( new Description("fooTest", fooTest.asJavaName())) .withExecutionTime(1).withGreenSuite(true) .withVisitedBlocks(Collections.<BlockLocation> emptyList()); }