public HierarchicalClassId getHierarchicalId() { return new HierarchicalClassId(this.id, getDeepHash()); }
@Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final ClassHistory other = (ClassHistory) obj; if (this.coverageId == null) { if (other.coverageId != null) { return false; } } else if (!this.coverageId.equals(other.coverageId)) { return false; } if (this.id == null) { if (other.id != null) { return false; } } else if (!this.id.equals(other.id)) { return false; } return true; }
public ClassName getName() { return this.id.getName(); }
@Test public void shouldCreateDifferentHierarchicalHashWhenOuterClassChanges() { final ClassInfo outer = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classA = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classB = new ClassInfo(emptyClassPointer(), pointerTo(outer), this.data); assertFalse(classA.getHierarchicalId().getHierarchicalHash() .equals(classB.getHierarchicalId().getHierarchicalHash())); }
@Test public void shouldRecordClassPath() { final ClassName clazz = ClassName.fromClass(Foo.class); final HierarchicalClassId fooId = new HierarchicalClassId( new ClassIdentifier(0, clazz), "0"); final ClassInfo foo = ClassInfoMother.make(fooId.getId()); when(this.code.getCodeUnderTestNames()).thenReturn( Collections.singleton(clazz)); when(this.code.getClassInfo(any(List.class))).thenReturn( Collections.singletonList(foo)); createAndRunTestee(); verify(this.history).recordClassPath(Arrays.asList(fooId), this.coverageDb); }
@Override public int hashCode() { final int prime = 31; int result = 1; result = (prime * result) + ((this.coverageId == null) ? 0 : this.coverageId.hashCode()); result = (prime * result) + ((this.id == null) ? 0 : this.id.hashCode()); return result; }
private void setCurrentClassPath(final HierarchicalClassId currentId) { final ClassInfo currentClass = ClassInfoMother.make(currentId.getId()); when(this.classInfoSource.fetchClass(ClassName.fromString("foo"))) .thenReturn(Optional.ofNullable(currentClass)); }
@Test public void shouldCreateDifferentHierarchicalHashWhenParentClassChanges() { final ClassInfo parent = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classA = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classB = new ClassInfo(pointerTo(parent), emptyClassPointer(), this.data); assertFalse(classA.getHierarchicalId().getHierarchicalHash() .equals(classB.getHierarchicalId().getHierarchicalHash())); }
@Test public void shouldRecordAndRetrieveClassPath() { final ClassHistory foo = new ClassHistory(new HierarchicalClassId( new ClassIdentifier(0, ClassName.fromString("foo")), ""), COV); final ClassHistory bar = new ClassHistory(new HierarchicalClassId( new ClassIdentifier(0, ClassName.fromString("bar")), ""), COV); recordClassPathWithTestee(foo.getId(), bar.getId()); final Reader reader = new StringReader(this.output.toString()); this.testee = new ObjectOutputStreamHistoryStore(this.writerFactory, Optional.ofNullable(reader)); this.testee.initialize(); final Map<ClassName, ClassHistory> expected = new HashMap<>(); expected.put(foo.getName(), foo); expected.put(bar.getName(), bar); assertEquals(expected, this.testee.getHistoricClassPath()); }
@Test public void shouldCreateDifferentHierarchicalHashWhenParentClassChanges() { final ClassInfo parent = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classA = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classB = new ClassInfo(pointerTo(parent), emptyClassPointer(), this.data); assertFalse(classA.getHierarchicalId().getHierarchicalHash() .equals(classB.getHierarchicalId().getHierarchicalHash())); }
@Override public boolean hasClassChanged(final ClassName className) { final ClassHistory historic = this.previousClassPath.get(className); if (historic == null) { return true; } final Optional<ClassInfo> current = this.code.fetchClass(className); return !current.get().getHierarchicalId().equals(historic.getId()); }
@Override public void recordClassPath(final Collection<HierarchicalClassId> ids, final CoverageDatabase coverageInfo) { final PrintWriter output = this.outputFactory.create(); output.println(ids.size()); for (final HierarchicalClassId each : ids) { final ClassHistory coverage = new ClassHistory(each, coverageInfo.getCoverageIdForClass(each.getName()).toString(16)); output.println(serialize(coverage)); } output.flush(); }
@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 shouldCreateDifferentHierarchicalHashWhenOuterClassChanges() { final ClassInfo outer = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classA = new ClassInfo(emptyClassPointer(), emptyClassPointer(), this.data); final ClassInfo classB = new ClassInfo(emptyClassPointer(), pointerTo(outer), this.data); assertFalse(classA.getHierarchicalId().getHierarchicalHash() .equals(classB.getHierarchicalId().getHierarchicalHash())); }
@Test public void shouldReadCorruptFiles() throws IOException { final HierarchicalClassId foo = new HierarchicalClassId( new ClassIdentifier(0, ClassName.fromString("foo")), ""); recordClassPathWithTestee(foo); final MutationResult mr = new MutationResult( MutationTestResultMother.createDetails("foo"), new MutationStatusTestPair(1, DetectionStatus.KILLED, "testName")); this.testee.recordResult(mr); this.output.append("rubbish"); final Reader reader = new StringReader(this.output.toString()); this.testee = new ObjectOutputStreamHistoryStore(this.writerFactory, Optional.ofNullable(reader)); this.testee.initialize(); assertFalse(this.testee.getHistoricResults().isEmpty()); }
@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"))); }
@Test public void shouldRecordAndRetrieveResults() { final HierarchicalClassId foo = new HierarchicalClassId( new ClassIdentifier(0, ClassName.fromString("foo")), ""); recordClassPathWithTestee(foo); final MutationResult mr = new MutationResult( MutationTestResultMother.createDetails("foo"), new MutationStatusTestPair(1, DetectionStatus.KILLED, "testName")); this.testee.recordResult(mr); final Reader reader = new StringReader(this.output.toString()); this.testee = new ObjectOutputStreamHistoryStore(this.writerFactory, Optional.ofNullable(reader)); this.testee.initialize(); final Map<MutationIdentifier, MutationStatusTestPair> expected = new HashMap<>(); expected.put(mr.getDetails().getId(), mr.getStatusTestPair()); assertEquals(expected, this.testee.getHistoricResults()); }
public HierarchicalClassId getHierarchicalId() { return new HierarchicalClassId(this.id, getDeepHash()); }