//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 shouldOnlySummarizeStatisticsWhenAllReferencesAreChecked()
public virtual void ShouldOnlySummarizeStatisticsWhenAllReferencesAreChecked()
{
// given
ConsistencySummaryStatistics summary = mock(typeof(ConsistencySummaryStatistics));
RecordAccess records = mock(typeof(RecordAccess));
ConsistencyReporter.ReportHandler handler = new ConsistencyReporter.ReportHandler(new InconsistencyReport(mock(typeof(InconsistencyLogger)), summary), mock(typeof(ConsistencyReporter.ProxyFactory)), RecordType.PROPERTY, records, new PropertyRecord(0), NO_MONITOR);
RecordReference <PropertyRecord> reference = mock(typeof(RecordReference));
ComparativeRecordChecker <PropertyRecord, PropertyRecord, ConsistencyReport_PropertyConsistencyReport> checker = mock(typeof(ComparativeRecordChecker));
handler.comparativeCheck(reference, checker);
ArgumentCaptor <PendingReferenceCheck <PropertyRecord> > captor = ( ArgumentCaptor )ArgumentCaptor.forClass(typeof(PendingReferenceCheck));
verify(reference).dispatch(captor.capture());
PendingReferenceCheck pendingRefCheck = captor.Value;
// when
handler.updateSummary();
// then
verifyZeroInteractions(summary);
// when
pendingRefCheck.skip();
// then
verify(summary).update(RecordType.PROPERTY, 0, 0);
verifyNoMoreInteractions(summary);
}
protected internal override void OtherRecords(RecordAccess filter, long id)
{
filter.Relationship(id);
filter.Property(id);
filter.String(id);
filter.Array(id);
}
public override IAstNode VisitReadFieldStmt(MicroCParser.ReadFieldStmtContext context)
{
var label = ++_label;
string recName = context.name.Text;
string fieldName = context.field.Text;
var recSymbol = _symbolTable.LookupSymbol(recName);
if (recSymbol == null)
{
throw new ArgumentException($"Record: {recName} does not exist");
}
var fieldSymbol = recSymbol.Children.SingleOrDefault(f => f.Name == fieldName);
if (fieldSymbol == null)
{
throw new ArgumentException($"Record: {recName} does not include a field: {fieldName}");
}
var recIdent = new Identifier(recName, recSymbol.Type, recSymbol.Id);
var fieldIdent = new Identifier(fieldName, fieldSymbol.Type, fieldSymbol.Id);
RecordAccess sa = new RecordAccess(recIdent, fieldIdent);
var readStmt = new ReadStmt(sa);
readStmt.Label = label;
return(readStmt);
}
private IADomain ReadTransfer(ReadStmt readStmt, IADomain domain)
{
var newDomain = CopyDomain(domain);
if (domain.IsBottom())
{
return(newDomain);
}
var ident = readStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
if (readStmt.Left is ArrayAccess)
{
var ra = readStmt.Left as ArrayAccess;
var indexInterval = IAUtil.Arithmetic(ra.Right, domain);
if (indexInterval.IsBottom)
{
return(Bottom().GetDomain());
}
}
newDomain[ident] = new Interval(ExtendedZ.NegativeInfinity(), ExtendedZ.PositiveInfinity()).ToIntervalK(_program);
return(newDomain);
}
private ReadItem ResolveRecord(RecordSchema schema)
{
ReadItem recordReader;
if (!_recordReaders.TryGetValue(schema, out recordReader))
{
lock (_recordReaders)
{
if (!_recordReaders.TryGetValue(schema, out recordReader))
{
RecordAccess recordAccess = GetRecordAccess(schema);
var fieldReaders = new List <FieldReader>();
recordReader = (r, d) => ReadRecord(r, d, recordAccess, fieldReaders);
_recordReaders.Add(schema, recordReader);
foreach (Field f in schema)
{
Field field = f;
ReadItem readItem = ResolveReader(field.Schema);
if (IsReusable(field.Schema.Type))
{
fieldReaders.Add((rec, d) => recordAccess.AddField(rec, field.Name, field.Pos,
readItem(recordAccess.GetField(rec, field.Name, field.Pos), d)));
}
else
{
fieldReaders.Add((rec, d) => recordAccess.AddField(rec, field.Name, field.Pos,
readItem(null, d)));
}
}
}
}
}
return(recordReader);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldServePropertyKeysAndRelationshipLabelsFromSuppliedArrayCaches()
internal virtual void ShouldServePropertyKeysAndRelationshipLabelsFromSuppliedArrayCaches()
{
// given
RecordAccess @delegate = mock(typeof(RecordAccess));
PropertyKeyTokenRecord propertyKey0 = new PropertyKeyTokenRecord(0);
PropertyKeyTokenRecord propertyKey2 = new PropertyKeyTokenRecord(2);
PropertyKeyTokenRecord propertyKey1 = new PropertyKeyTokenRecord(1);
RelationshipTypeTokenRecord relationshipType0 = new RelationshipTypeTokenRecord(0);
RelationshipTypeTokenRecord relationshipType1 = new RelationshipTypeTokenRecord(1);
RelationshipTypeTokenRecord relationshipType2 = new RelationshipTypeTokenRecord(2);
LabelTokenRecord label0 = new LabelTokenRecord(0);
LabelTokenRecord label1 = new LabelTokenRecord(1);
LabelTokenRecord label2 = new LabelTokenRecord(2);
CacheSmallStoresRecordAccess recordAccess = new CacheSmallStoresRecordAccess(@delegate, new PropertyKeyTokenRecord[] { propertyKey0, propertyKey1, propertyKey2 }, new RelationshipTypeTokenRecord[] { relationshipType0, relationshipType1, relationshipType2 }, new LabelTokenRecord[] { label0, label1, label2 });
// when
assertThat(recordAccess.PropertyKey(0), IsDirectReferenceTo(propertyKey0));
assertThat(recordAccess.PropertyKey(1), IsDirectReferenceTo(propertyKey1));
assertThat(recordAccess.PropertyKey(2), IsDirectReferenceTo(propertyKey2));
assertThat(recordAccess.RelationshipType(0), IsDirectReferenceTo(relationshipType0));
assertThat(recordAccess.RelationshipType(1), IsDirectReferenceTo(relationshipType1));
assertThat(recordAccess.RelationshipType(2), IsDirectReferenceTo(relationshipType2));
assertThat(recordAccess.Label(0), IsDirectReferenceTo(label0));
assertThat(recordAccess.Label(1), IsDirectReferenceTo(label1));
assertThat(recordAccess.Label(2), IsDirectReferenceTo(label2));
// then
verifyZeroInteractions(@delegate);
}
internal ReportInvocationHandler(InconsistencyReport report, ProxyFactory <REPORT> factory, RecordType type, RecordAccess records, Monitor monitor)
{
this.ReportConflict = report;
this.Factory = factory;
this.Type = type;
this.Records = records;
this.Monitor = monitor;
}
public AstPrinterNode Visit(RecordAccess node)
{
var printer = new AstPrinterNode(node.ToString());
printer.AddChild(node.RecordIdent.Accept(this));
printer.AddChild(node.FieldToAccess.Accept(this));
return(printer);
}
public static void Save(IValueSink sink, RecordAccess value)
{
sink.EnterSequence();
Value <int> .Save(sink, value.FileStartRecord);
Value <uint> .Save(sink, value.RequestedRecordCount);
sink.LeaveSequence();
}
public static void Save(IValueSink sink, RecordAccess value)
{
sink.EnterSequence();
Value <int> .Save(sink, value.FileStartRecord);
Value <uint> .Save(sink, value.RecordCount);
Value <ReadOnlyArray <byte[]> > .Save(sink, value.FileRecordData);
sink.LeaveSequence();
}
private object ReadRecord(object reuse, Decoder decoder, RecordAccess recordAccess, IEnumerable <FieldReader> readSteps)
{
var rec = recordAccess.CreateRecord(reuse);
foreach (FieldReader fr in readSteps)
{
fr(rec, decoder);
// TODO: on exception, report offending field
}
return(rec);
}
public virtual void CreateToken(string name, long id, RecordAccess <R, Void> recordAccess)
{
R record = recordAccess.Create(id, null).forChangingData();
record.InUse = true;
record.setCreated();
ICollection <DynamicRecord> nameRecords = _store.allocateNameRecords(encodeString(name));
record.NameId = ( int )Iterables.first(nameRecords).Id;
record.addNameRecords(nameRecords);
}
public RecordChangeSet(RecordAccess_Loader <NodeRecord, Void> nodeLoader, RecordAccess_Loader <PropertyRecord, PrimitiveRecord> propertyLoader, RecordAccess_Loader <RelationshipRecord, Void> relationshipLoader, RecordAccess_Loader <RelationshipGroupRecord, int> relationshipGroupLoader, RecordAccess_Loader <SchemaRecord, SchemaRule> schemaRuleLoader, RecordAccess_Loader <PropertyKeyTokenRecord, Void> propertyKeyTokenLoader, RecordAccess_Loader <LabelTokenRecord, Void> labelTokenLoader, RecordAccess_Loader <RelationshipTypeTokenRecord, Void> relationshipTypeTokenLoader)
{
this._nodeRecords = new RecordChanges <NodeRecord, Void>(nodeLoader, _changeCounter);
this._propertyRecords = new RecordChanges <PropertyRecord, PrimitiveRecord>(propertyLoader, _changeCounter);
this._relRecords = new RecordChanges <RelationshipRecord, Void>(relationshipLoader, _changeCounter);
this._relGroupRecords = new RecordChanges <RelationshipGroupRecord, int>(relationshipGroupLoader, _changeCounter);
this._schemaRuleChanges = new RecordChanges <SchemaRecord, SchemaRule>(schemaRuleLoader, _changeCounter);
this._propertyKeyTokenChanges = new RecordChanges <PropertyKeyTokenRecord, Void>(propertyKeyTokenLoader, _changeCounter);
this._labelTokenChanges = new RecordChanges <LabelTokenRecord, Void>(labelTokenLoader, _changeCounter);
this._relationshipTypeTokenChanges = new RecordChanges <RelationshipTypeTokenRecord, Void>(relationshipTypeTokenLoader, _changeCounter);
}
private static PropertyRecord[] ExtractPropertyRecords(RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecordAccess, long nextProp)
{
IList <PropertyRecord> result = new List <PropertyRecord>();
while (!Record.NULL_REFERENCE.@is(nextProp))
{
PropertyRecord record = propertyRecordAccess.GetIfLoaded(nextProp).forReadingLinkage();
result.Add(record);
nextProp = record.NextProp;
}
return(result.ToArray());
}
public virtual void GetPropertyChain(long nextProp, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, Listener <PropertyBlock> collector)
{
while (nextProp != Record.NO_NEXT_PROPERTY.intValue())
{
PropertyRecord propRecord = propertyRecords.GetOrLoad(nextProp, null).forReadingData();
foreach (PropertyBlock propBlock in propRecord)
{
collector.Receive(propBlock);
}
nextProp = propRecord.NextProp;
}
}
public bool Visit(RecordAccess node)
{
node.RecordIdent.Accept(this);
_symStack.Push(((SymRecordType)node.RecordIdent.SymType).Table);
_inLastNamespace = true;
node.FieldToAccess.Accept(this);
_inLastNamespace = false;
_symStack.Pop();
node.SymType = node.FieldToAccess.SymType;
node.IsLValue = true;
return(true);
}
private IADomain AssignTransfer(AssignStmt assignStmt, IADomain domain)
{
var newDomain = CopyDomain(domain);
if (domain.IsBottom())
{
return(newDomain);
}
var ident = assignStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
var newValue = assignStmt.Left switch
{
VarAccess varAccess => IAUtil.Arithmetic(assignStmt.Right, domain),
RecordAccess recordAccess => IAUtil.Arithmetic(assignStmt.Right, domain),
ArrayAccess arrayAccess => IAUtil.Arithmetic(assignStmt.Right, domain)
.Join(domain[ident]),
//.Join(IAUtil.Arithmetic(arrayAccess.Right, domain)),
};
if (assignStmt.Left is ArrayAccess)
{
var ra = assignStmt.Left as ArrayAccess;
var indexInterval = IAUtil.Arithmetic(ra.Right, domain);
if (indexInterval.IsBottom)
{
return(Bottom().GetDomain());
}
var arrayIndices = new Interval(new ExtendedZ(0), new ExtendedZ(ra.Left.Size - 1));
var meet = indexInterval.Meet(arrayIndices);
if (indexInterval.Meet(arrayIndices).IsBottom)
{
return(Bottom().GetDomain());
}
}
if (newValue.IsBottom)
{
return(Bottom().GetDomain());
}
newDomain[ident] = newValue.ToIntervalK(_program);
return(newDomain);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: org.neo4j.consistency.report.ConsistencySummaryStatistics execute(org.neo4j.kernel.api.direct.DirectStoreAccess stores, org.neo4j.logging.Log log, org.neo4j.consistency.report.ConsistencyReporter.Monitor reportMonitor) throws ConsistencyCheckIncompleteException
internal virtual ConsistencySummaryStatistics Execute(DirectStoreAccess stores, Log log, ConsistencyReporter.Monitor reportMonitor)
{
ConsistencySummaryStatistics summary = new ConsistencySummaryStatistics();
InconsistencyReport report = new InconsistencyReport(new InconsistencyMessageLogger(log), summary);
OwnerCheck ownerCheck = new OwnerCheck(_checkPropertyOwners);
CountsBuilderDecorator countsBuilder = new CountsBuilderDecorator(stores.NativeStores());
CheckDecorator decorator = new Org.Neo4j.Consistency.checking.CheckDecorator_ChainCheckDecorator(ownerCheck, countsBuilder);
CacheAccess cacheAccess = new DefaultCacheAccess(AUTO_WITHOUT_PAGECACHE.newByteArray(stores.NativeStores().NodeStore.HighId, new sbyte[ByteArrayBitsManipulator.MAX_BYTES]), _statistics.Counts, _threads);
RecordAccess records = RecordAccess(stores.NativeStores(), cacheAccess);
Execute(stores, decorator, records, report, cacheAccess, reportMonitor);
ownerCheck.ScanForOrphanChains(_progressFactory);
if (_checkGraph)
{
CountsAccessor countsAccessor = stores.NativeStores().Counts;
bool checkCounts = true;
if (_startCountsStore && countsAccessor is CountsTracker)
{
CountsTracker tracker = ( CountsTracker )countsAccessor;
// Perhaps other read-only use cases thinks it's fine to just rebuild an in-memory counts store,
// but the consistency checker should instead prevent rebuild and report that the counts store is broken or missing
tracker.Initializer = new RebuildPreventingCountsInitializer(this);
try
{
tracker.Start();
}
catch (Exception e)
{
log.Error("Counts store is missing, broken or of an older format and will not be consistency checked", e);
summary.Update(RecordType.COUNTS, 1, 0);
checkCounts = false;
}
}
if (checkCounts)
{
countsBuilder.CheckCounts(countsAccessor, new ConsistencyReporter(records, report), _progressFactory);
}
}
if (!summary.Consistent)
{
log.Warn("Inconsistencies found: " + summary);
}
return(summary);
}
public virtual void DeletePropertyChain(PrimitiveRecord primitive, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords)
{
long nextProp = primitive.NextProp;
while (nextProp != Record.NO_NEXT_PROPERTY.intValue())
{
RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> propertyChange = propertyRecords.GetOrLoad(nextProp, primitive);
// TODO forChanging/forReading piggy-backing
PropertyRecord propRecord = propertyChange.ForChangingData();
DeletePropertyRecordIncludingValueRecords(propRecord);
nextProp = propRecord.NextProp;
propRecord.Changed = primitive;
}
primitive.NextProp = Record.NO_NEXT_PROPERTY.intValue();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSummarizeStatisticsAfterCheck()
public virtual void ShouldSummarizeStatisticsAfterCheck()
{
// given
ConsistencySummaryStatistics summary = mock(typeof(ConsistencySummaryStatistics));
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") org.neo4j.consistency.store.RecordAccess records = mock(org.neo4j.consistency.store.RecordAccess.class);
RecordAccess records = mock(typeof(RecordAccess));
ConsistencyReporter.ReportHandler handler = new ConsistencyReporter.ReportHandler(new InconsistencyReport(mock(typeof(InconsistencyLogger)), summary), mock(typeof(ConsistencyReporter.ProxyFactory)), RecordType.PROPERTY, records, new PropertyRecord(0), NO_MONITOR);
// when
handler.updateSummary();
// then
verify(summary).update(RecordType.PROPERTY, 0, 0);
verifyNoMoreInteractions(summary);
}
private DSDomain ReadTransfer(ReadStmt readStmt, DSDomain domain)
{
var ident = readStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
var newDomain = CopyDomain(domain);
newDomain[ident] = new HashSet <DSSign>()
{
DSSign.Negative, DSSign.Positive, DSSign.Zero
};
return(newDomain);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSkipOtherKindsOfRecords()
public virtual void ShouldSkipOtherKindsOfRecords()
{
// given
RecordAccess recordAccess = mock(typeof(RecordAccess));
// when
IList <RecordAccess> filters = MultiPassStore().multiPassFilters(recordAccess, MultiPassStore.values());
// then
foreach (RecordAccess filter in filters)
{
foreach (long id in new long[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 })
{
OtherRecords(filter, id);
}
}
verifyZeroInteractions(recordAccess);
}
private FVDomain ReadTransfer(ReadStmt readStmt, FVDomain domain)
{
var ident = readStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
if (!domain.Contains(ident))
{
return(domain);
}
return(readStmt.Left switch
{
ArrayAccess arrayAccess => domain.Union(AnalysisUtil.FreeVariables(arrayAccess.Right)).ToFVDomain(),
_ => domain.Except(ident.Singleton()).ToFVDomain(),
});
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldDelegateLookupForMostStores()
internal virtual void ShouldDelegateLookupForMostStores()
{
// given
RecordAccess @delegate = mock(typeof(RecordAccess));
CacheSmallStoresRecordAccess recordAccess = new CacheSmallStoresRecordAccess(@delegate, null, null, null);
// when
recordAccess.Node(42);
recordAccess.Relationship(2001);
recordAccess.Property(2468);
recordAccess.String(666);
recordAccess.Array(11);
// then
verify(@delegate).node(42);
verify(@delegate).relationship(2001);
verify(@delegate).property(2468);
verify(@delegate).@string(666);
verify(@delegate).array(11);
}
private void Connect(long nodeId, long firstRelId, RelationshipRecord rel, RecordAccess <RelationshipRecord, Void> relRecords, ResourceLocker locks)
{
long newCount = 1;
if (firstRelId != Record.NO_NEXT_RELATIONSHIP.intValue())
{
locks.AcquireExclusive(LockTracer.NONE, ResourceTypes.RELATIONSHIP, firstRelId);
RelationshipRecord firstRel = relRecords.GetOrLoad(firstRelId, null).forChangingLinkage();
bool changed = false;
if (firstRel.FirstNode == nodeId)
{
newCount = firstRel.FirstPrevRel + 1;
firstRel.FirstPrevRel = rel.Id;
firstRel.FirstInFirstChain = false;
changed = true;
}
if (firstRel.SecondNode == nodeId)
{
newCount = firstRel.SecondPrevRel + 1;
firstRel.SecondPrevRel = rel.Id;
firstRel.FirstInSecondChain = false;
changed = true;
}
if (!changed)
{
throw new InvalidRecordException(nodeId + " doesn't match " + firstRel);
}
}
// Set the relationship count
if (rel.FirstNode == nodeId)
{
rel.FirstPrevRel = newCount;
rel.FirstInFirstChain = true;
}
if (rel.SecondNode == nodeId)
{
rel.SecondPrevRel = newCount;
rel.FirstInSecondChain = true;
}
}
private void UnlinkPropertyRecord <P>(PropertyRecord propRecord, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, RecordAccess_RecordProxy <P, Void> primitiveRecordChange) where P : Org.Neo4j.Kernel.impl.store.record.PrimitiveRecord
{
P primitive = primitiveRecordChange.ForReadingLinkage();
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
Debug.Assert(propRecord.Size() == 0);
long prevProp = propRecord.PrevProp;
long nextProp = propRecord.NextProp;
if (primitive.NextProp == propRecord.Id)
{
Debug.Assert(propRecord.PrevProp == Record.NO_PREVIOUS_PROPERTY.intValue(), propRecord + " for ");
+primitive;
primitiveRecordChange.ForChangingLinkage().NextProp = nextProp;
}
if (prevProp != Record.NO_PREVIOUS_PROPERTY.intValue())
{
PropertyRecord prevPropRecord = propertyRecords.GetOrLoad(prevProp, primitive).forChangingLinkage();
Debug.Assert(prevPropRecord.InUse(), prevPropRecord + "->" + propRecord + " for " + primitive);
prevPropRecord.NextProp = nextProp;
prevPropRecord.Changed = primitive;
}
if (nextProp != Record.NO_NEXT_PROPERTY.intValue())
{
PropertyRecord nextPropRecord = propertyRecords.GetOrLoad(nextProp, primitive).forChangingLinkage();
Debug.Assert(nextPropRecord.InUse(), propRecord + "->" + nextPropRecord + " for " + primitive);
nextPropRecord.PrevProp = prevProp;
nextPropRecord.Changed = primitive;
}
propRecord.InUse = false;
/*
* The following two are not needed - the above line does all the work (PropertyStore
* does not write out the prev/next for !inUse records). It is nice to set this
* however to check for consistency when assertPropertyChain().
*/
propRecord.PrevProp = Record.NO_PREVIOUS_PROPERTY.intValue();
propRecord.NextProp = Record.NO_NEXT_PROPERTY.intValue();
propRecord.Changed = primitive;
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRunChecksInSingleThreadedPass() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRunChecksInSingleThreadedPass()
{
// given
StoreAccess store = fixture.directStoreAccess().nativeStores();
int threads = defaultConsistencyCheckThreadsNumber();
CacheAccess cacheAccess = new DefaultCacheAccess(new DefaultCounts(threads), threads);
RecordAccess access = FullCheck.RecordAccess(store, cacheAccess);
FullCheck singlePass = new FullCheck(TuningConfiguration, ProgressMonitorFactory.NONE, Statistics.NONE, threads, true);
ConsistencySummaryStatistics singlePassSummary = new ConsistencySummaryStatistics();
InconsistencyLogger logger = mock(typeof(InconsistencyLogger));
InvocationLog singlePassChecks = new InvocationLog();
// when
singlePass.Execute(fixture.directStoreAccess(), new LogDecorator(singlePassChecks), access, new InconsistencyReport(logger, singlePassSummary), cacheAccess, NO_MONITOR);
// then
verifyZeroInteractions(logger);
assertEquals("Expected no inconsistencies in single pass.", 0, singlePassSummary.TotalInconsistencyCount);
}
public virtual bool AssertPropertyChain(PrimitiveRecord primitive, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords)
{
IList <PropertyRecord> toCheck = new LinkedList <PropertyRecord>();
long nextIdToFetch = primitive.NextProp;
while (nextIdToFetch != Record.NO_NEXT_PROPERTY.intValue())
{
PropertyRecord propRecord = propertyRecords.GetOrLoad(nextIdToFetch, primitive).forReadingLinkage();
toCheck.Add(propRecord);
Debug.Assert(propRecord.InUse(), primitive + "->");
+Arrays.ToString(toCheck.ToArray());
Debug.Assert(propRecord.Size() <= PropertyType.PayloadSize, propRecord + " size " + propRecord.Size());
nextIdToFetch = propRecord.NextProp;
}
if (toCheck.Count == 0)
{
Debug.Assert(primitive.NextProp == Record.NO_NEXT_PROPERTY.intValue(), primitive);
return(true);
}
PropertyRecord first = toCheck[0];
PropertyRecord last = toCheck[toCheck.Count - 1];
Debug.Assert(first.PrevProp == Record.NO_PREVIOUS_PROPERTY.intValue(), primitive + "->");
+Arrays.ToString(toCheck.ToArray());
Debug.Assert(last.NextProp == Record.NO_NEXT_PROPERTY.intValue(), primitive + "->");
+Arrays.ToString(toCheck.ToArray());
PropertyRecord current;
PropertyRecord previous = first;
for (int i = 1; i < toCheck.Count; i++)
{
current = toCheck[i];
Debug.Assert(current.PrevProp == previous.Id, primitive + "->");
+Arrays.ToString(toCheck.ToArray());
Debug.Assert(previous.NextProp == current.Id, primitive + "->");
+Arrays.ToString(toCheck.ToArray());
previous = current;
}
return(true);
}
private void ConvertNodeToDenseIfNecessary(NodeRecord node, RecordAccess <RelationshipRecord, Void> relRecords, RecordAccess <RelationshipGroupRecord, int> relGroupRecords, ResourceLocker locks)
{
if (node.Dense)
{
return;
}
long relId = node.NextRel;
if (relId != Record.NO_NEXT_RELATIONSHIP.intValue())
{
RecordAccess_RecordProxy <RelationshipRecord, Void> relChange = relRecords.GetOrLoad(relId, null);
RelationshipRecord rel = relChange.ForReadingLinkage();
if (RelCount(node.Id, rel) >= _denseNodeThreshold)
{
locks.AcquireExclusive(LockTracer.NONE, ResourceTypes.RELATIONSHIP, relId);
// Re-read the record after we've locked it since another transaction might have
// changed in the meantime.
relChange = relRecords.GetOrLoad(relId, null);
ConvertNodeToDenseNode(node, relChange.ForChangingLinkage(), relRecords, relGroupRecords, locks);
}
}
}
public static void Save(IValueSink sink, RecordAccess value)
{
sink.EnterSequence();
Value<int>.Save(sink, value.FileStartRecord);
Value<uint>.Save(sink, value.ReturnedRecordCount);
Value<ReadOnlyArray<byte[]>>.Save(sink, value.FileRecordData);
sink.LeaveSequence();
}
public static void Save(IValueSink sink, RecordAccess value)
{
sink.EnterSequence();
Value<int>.Save(sink, value.FileStartRecord);
Value<uint>.Save(sink, value.RequestedRecordCount);
sink.LeaveSequence();
}
