//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldIncludeStackTraceInUnexpectedCheckException() public virtual void ShouldIncludeStackTraceInUnexpectedCheckException() { // GIVEN ConsistencySummaryStatistics summary = mock(typeof(ConsistencySummaryStatistics)); RecordAccess records = mock(typeof(RecordAccess)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<String> loggedError = new java.util.concurrent.atomic.AtomicReference<>(); AtomicReference <string> loggedError = new AtomicReference <string>(); InconsistencyLogger logger = new InconsistencyLoggerAnonymousInnerClass(this, loggedError); InconsistencyReport inconsistencyReport = new InconsistencyReport(logger, summary); ConsistencyReporter reporter = new ConsistencyReporter(records, inconsistencyReport); NodeRecord node = new NodeRecord(10); RecordCheck <NodeRecord, ConsistencyReport_NodeConsistencyReport> checker = mock(typeof(RecordCheck)); Exception exception = new Exception("My specific exception"); doThrow(exception).when(checker).check(any(typeof(NodeRecord)), any(typeof(CheckerEngine)), any(typeof(RecordAccess))); // WHEN reporter.ForNode(node, checker); // THEN assertNotNull(loggedError.get()); string error = loggedError.get(); assertThat(error, containsString("at ")); assertThat(error, containsString(TestName.MethodName)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test @SuppressWarnings("unchecked") public void shouldLogInconsistency() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldLogInconsistency() { // given InconsistencyReport report = mock(typeof(InconsistencyReport)); ConsistencyReport_Reporter reporter = new ConsistencyReporter(mock(typeof(RecordAccess)), report); // when ReportMethod.invoke(reporter, Parameters(ReportMethod)); // then if (Method.getAnnotation(typeof(ConsistencyReport_Warning)) == null) { if (ReportMethod.Name.EndsWith("Change")) { verify(report).error(any(typeof(RecordType)), any(typeof(AbstractBaseRecord)), any(typeof(AbstractBaseRecord)), argThat(HasExpectedFormat()), any(typeof(object[]))); } else { verify(report).error(any(typeof(RecordType)), any(typeof(AbstractBaseRecord)), argThat(HasExpectedFormat()), NullSafeAny()); } } else { if (ReportMethod.Name.EndsWith("Change")) { verify(report).warning(any(typeof(RecordType)), any(typeof(AbstractBaseRecord)), any(typeof(AbstractBaseRecord)), argThat(HasExpectedFormat()), any(typeof(object[]))); } else { verify(report).warning(any(typeof(RecordType)), any(typeof(AbstractBaseRecord)), argThat(HasExpectedFormat()), NullSafeAny()); } } }
public virtual void Skip() { lock (this) { if (_engine != null) { ConsistencyReporter.DispatchSkip(_engine); _engine = null; } } }
public override string ToString() { lock (this) { if (_engine == null) { return(string.Format("CompletedReferenceCheck{{{0}}}", _checker)); } else { return(ConsistencyReporter.PendingCheckToString(_engine, _checker)); } } }
public virtual void CheckDiffReference(REFERENCED oldReferenced, REFERENCED newReferenced, RecordAccess records) { ConsistencyReporter.DispatchChangeReference(Engine(), _checker, oldReferenced, newReferenced, records); }
public virtual void CheckReference(REFERENCED referenced, RecordAccess records) { ConsistencyReporter.DispatchReference(Engine(), _checker, referenced, records); }
public ReportHandlerAnonymousInnerClass(ConsistencyReporter outerInstance, Org.Neo4j.Consistency.report.InconsistencyReport report, Org.Neo4j.Consistency.report.ConsistencyReporter.ProxyFactory <REPORT> proxyFactory, RecordType recordType, RecordAccess records, AbstractBaseRecord record, Org.Neo4j.Consistency.report.ConsistencyReporter.Monitor monitor) : base(report, proxyFactory, recordType, records, record, monitor) { this.outerInstance = outerInstance; }