//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(); }