//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void updatesShouldEqualRegardlessOfCreationMethod()
public virtual void UpdatesShouldEqualRegardlessOfCreationMethod()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> singleAdd = IndexEntryUpdate.add(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> singleAdd = IndexEntryUpdate.Add(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
Value[] singleAsArray = new Value[] { _singleValue };
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> multiAdd = IndexEntryUpdate.add(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleAsArray);
IndexEntryUpdate <object> multiAdd = IndexEntryUpdate.Add(0, SchemaDescriptorFactory.forLabel(3, 4), singleAsArray);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> singleRemove = IndexEntryUpdate.remove(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> singleRemove = IndexEntryUpdate.Remove(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> multiRemove = IndexEntryUpdate.remove(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleAsArray);
IndexEntryUpdate <object> multiRemove = IndexEntryUpdate.Remove(0, SchemaDescriptorFactory.forLabel(3, 4), singleAsArray);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> singleChange = IndexEntryUpdate.change(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue, singleValue);
IndexEntryUpdate <object> singleChange = IndexEntryUpdate.Change(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue, _singleValue);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> multiChange = IndexEntryUpdate.change(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleAsArray, singleAsArray);
IndexEntryUpdate <object> multiChange = IndexEntryUpdate.Change(0, SchemaDescriptorFactory.forLabel(3, 4), singleAsArray, singleAsArray);
assertThat(singleAdd, equalTo(multiAdd));
assertThat(singleRemove, equalTo(multiRemove));
assertThat(singleChange, equalTo(multiChange));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldMakeEntryConflictsForOneNode()
public virtual void ShouldMakeEntryConflictsForOneNode()
{
LabelSchemaDescriptor schema = SchemaDescriptorFactory.forLabel(LABEL_ID, 2);
IndexEntryConflictException e = new IndexEntryConflictException(0L, StatementConstants.NO_SUCH_NODE, Value);
assertThat(e.EvidenceMessage(SchemaUtil.idTokenNameLookup, schema), equalTo("Node(0) already exists with label `label[1]` and property `property[2]` = 'hi'"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldMakeEntryConflicts()
public virtual void ShouldMakeEntryConflicts()
{
LabelSchemaDescriptor schema = SchemaDescriptorFactory.forLabel(LABEL_ID, 2);
IndexEntryConflictException e = new IndexEntryConflictException(0L, 1L, Value);
assertThat(e.EvidenceMessage(SchemaUtil.idTokenNameLookup, schema), equalTo("Both Node(0) and Node(1) have the label `label[1]` and property `property[2]` = 'hi'"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldPersistFulltextIndexSettings() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldPersistFulltextIndexSettings()
{
// Given
File indexFolder = Directory.directory("indexFolder");
string analyzerName = "simple";
string eventuallyConsistency = "true";
string defaultAnalyzer = "defaultAnalyzer";
int[] propertyIds = new int[] { 1, 2, 3 };
MultiTokenSchemaDescriptor schema = SchemaDescriptorFactory.multiToken(new int[] { 1, 2 }, EntityType.NODE, propertyIds);
// A fulltext index descriptor with configurations
Properties properties = properties(analyzerName, eventuallyConsistency);
FulltextSchemaDescriptor fulltextSchemaDescriptor = new FulltextSchemaDescriptor(schema, properties);
StoreIndexDescriptor storeIndexDescriptor = StoreIndexDescriptorFromSchema(fulltextSchemaDescriptor);
TokenRegistry tokenRegistry = SimpleTokenHolder.CreatePopulatedTokenRegistry(Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_PROPERTY_KEY, propertyIds);
SimpleTokenHolder tokenHolder = new SimpleTokenHolder(tokenRegistry);
FulltextIndexDescriptor fulltextIndexDescriptor = readOrInitialiseDescriptor(storeIndexDescriptor, defaultAnalyzer, tokenHolder, indexFolder, Fs);
assertEquals(analyzerName, fulltextIndexDescriptor.AnalyzerName());
assertEquals(bool.Parse(eventuallyConsistency), fulltextIndexDescriptor.EventuallyConsistent);
// When persisting it
FulltextIndexSettings.SaveFulltextIndexSettings(fulltextIndexDescriptor, indexFolder, Fs);
// Then we should be able to load it back with settings being the same
StoreIndexDescriptor loadingIndexDescriptor = StoreIndexDescriptorFromSchema(schema);
FulltextIndexDescriptor loadedDescriptor = readOrInitialiseDescriptor(loadingIndexDescriptor, defaultAnalyzer, tokenHolder, indexFolder, Fs);
assertEquals(fulltextIndexDescriptor.AnalyzerName(), loadedDescriptor.AnalyzerName());
assertEquals(fulltextIndexDescriptor.EventuallyConsistent, loadedDescriptor.EventuallyConsistent);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void dropShouldDeleteEntireIndexFolder()
public virtual void DropShouldDeleteEntireIndexFolder()
{
// given
File root = Storage.directory().directory("root");
IndexDirectoryStructure directoryStructure = IndexDirectoryStructure.directoriesByProvider(root).forProvider(GenericNativeIndexProvider.Descriptor);
long indexId = 8;
File indexDirectory = directoryStructure.DirectoryForIndex(indexId);
StoreIndexDescriptor descriptor = IndexDescriptorFactory.forSchema(SchemaDescriptorFactory.forLabel(1, 1)).withId(indexId);
IndexSpecificSpaceFillingCurveSettingsCache spatialSettings = mock(typeof(IndexSpecificSpaceFillingCurveSettingsCache));
PageCache pageCache = Storage.pageCache();
FileSystemAbstraction fs = Storage.fileSystem();
File indexFile = new File(indexDirectory, "my-index");
GenericLayout layout = new GenericLayout(1, spatialSettings);
RecoveryCleanupWorkCollector immediate = immediate();
IndexDropAction dropAction = new FileSystemIndexDropAction(fs, directoryStructure);
GenericNativeIndexPopulator populator = new GenericNativeIndexPopulator(pageCache, fs, indexFile, layout, EMPTY, descriptor, spatialSettings, directoryStructure, mock(typeof(SpaceFillingCurveConfiguration)), dropAction, false);
populator.Create();
// when
assertTrue(fs.ListFiles(indexDirectory).Length > 0);
populator.Drop();
// then
assertFalse(fs.FileExists(indexDirectory));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldMakeCompositeEntryConflicts()
public virtual void ShouldMakeCompositeEntryConflicts()
{
LabelSchemaDescriptor schema = SchemaDescriptorFactory.forLabel(LABEL_ID, 2, 3, 4);
ValueTuple values = ValueTuple.of(true, "hi", new long[] { 6L, 4L });
IndexEntryConflictException e = new IndexEntryConflictException(0L, 1L, values);
assertThat(e.EvidenceMessage(SchemaUtil.idTokenNameLookup, schema), equalTo("Both Node(0) and Node(1) have the label `label[1]` " + "and properties `property[2]` = true, `property[3]` = 'hi', `property[4]` = [6, 4]"));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void createCompositeIndex(org.neo4j.graphdb.GraphDatabaseService graphDb, String label, String... properties) throws Exception
protected internal override void CreateCompositeIndex(GraphDatabaseService graphDb, string label, params string[] properties)
{
GraphDatabaseAPI @internal = ( GraphDatabaseAPI )graphDb;
KernelTransaction ktx = @internal.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true);
SchemaWrite schemaWrite = ktx.SchemaWrite();
TokenWrite token = ktx.TokenWrite();
schemaWrite.IndexCreate(SchemaDescriptorFactory.forLabel(token.LabelGetOrCreateForName("Person"), token.PropertyKeyGetOrCreateForName("firstname"), token.PropertyKeyGetOrCreateForName("surname")));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void addShouldThrowIfAskedForChanged()
public virtual void AddShouldThrowIfAskedForChanged()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> single = IndexEntryUpdate.add(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> single = IndexEntryUpdate.Add(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
Thrown.expect(typeof(System.NotSupportedException));
single.BeforeValues();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.internal.kernel.api.IndexReference createIndex() throws org.neo4j.internal.kernel.api.exceptions.KernelException
private IndexReference CreateIndex()
{
using (Transaction transaction = _kernel.beginTransaction(@implicit, AUTH_DISABLED))
{
IndexReference reference = transaction.SchemaWrite().indexCreate(SchemaDescriptorFactory.forLabel(1, 1));
transaction.Success();
return(reference);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.storageengine.api.schema.IndexDescriptor createAnIndex(HighlyAvailableGraphDatabase db, org.neo4j.graphdb.Label label, String propertyName) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private static IndexDescriptor CreateAnIndex(HighlyAvailableGraphDatabase db, Label label, string propertyName)
{
using (Transaction tx = Db.beginTx())
{
KernelTransaction ktx = KernelTransaction(db);
int labelId = ktx.TokenWrite().labelGetOrCreateForName(label.Name());
int propertyKeyId = ktx.TokenWrite().propertyKeyGetOrCreateForName(propertyName);
IndexReference index = ktx.SchemaWrite().indexCreate(SchemaDescriptorFactory.forLabel(labelId, propertyKeyId));
tx.Success();
return(( IndexDescriptor )index);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void samplingTriggeredWhenIdsArePresent() throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void SamplingTriggeredWhenIdsArePresent()
{
// Given
IndexSamplingManagerBean.StoreAccess storeAccess = new IndexSamplingManagerBean.StoreAccess();
storeAccess.Registered(_dataSource);
// When
storeAccess.TriggerIndexSampling(EXISTING_LABEL, EXISTING_PROPERTY, false);
// Then
verify(_indexingService, times(1)).triggerIndexSampling(SchemaDescriptorFactory.forLabel(LABEL_ID, PROPERTY_ID), IndexSamplingMode.TRIGGER_REBUILD_UPDATED);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void indexEntryUpdatesShouldBeEqual()
public virtual void IndexEntryUpdatesShouldBeEqual()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> a = IndexEntryUpdate.add(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> a = IndexEntryUpdate.Add(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> b = IndexEntryUpdate.add(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> b = IndexEntryUpdate.Add(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
assertThat(a, equalTo(b));
assertThat(a.GetHashCode(), equalTo(b.GetHashCode()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void removeShouldRetainValues()
public virtual void RemoveShouldRetainValues()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> single = IndexEntryUpdate.remove(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue);
IndexEntryUpdate <object> single = IndexEntryUpdate.Remove(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> multi = IndexEntryUpdate.remove(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4, 5), multiValue);
IndexEntryUpdate <object> multi = IndexEntryUpdate.Remove(0, SchemaDescriptorFactory.forLabel(3, 4, 5), _multiValue);
assertThat(single, not(equalTo(multi)));
assertThat(single.Values(), equalTo(new object[] { _singleValue }));
assertThat(multi.Values(), equalTo(_multiValue));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void changedShouldRetainValues()
public virtual void ChangedShouldRetainValues()
{
Value singleAfter = Values.of("Hello");
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> singleChange = IndexEntryUpdate.change(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4), singleValue, singleAfter);
IndexEntryUpdate <object> singleChange = IndexEntryUpdate.Change(0, SchemaDescriptorFactory.forLabel(3, 4), _singleValue, singleAfter);
Value[] multiAfter = new Value[] { Values.of("Hello"), Values.of("Hi") };
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: IndexEntryUpdate<?> multiChange = IndexEntryUpdate.change(0, org.neo4j.kernel.api.schema.SchemaDescriptorFactory.forLabel(3, 4, 5), multiValue, multiAfter);
IndexEntryUpdate <object> multiChange = IndexEntryUpdate.Change(0, SchemaDescriptorFactory.forLabel(3, 4, 5), _multiValue, multiAfter);
assertThat(new object[] { _singleValue }, equalTo(singleChange.BeforeValues()));
assertThat(new object[] { singleAfter }, equalTo(singleChange.Values()));
assertThat(_multiValue, equalTo(multiChange.BeforeValues()));
assertThat(multiAfter, equalTo(multiChange.Values()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBePossibleToCreateIndexWithDuplicateLabel() throws org.neo4j.internal.kernel.api.exceptions.KernelException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotBePossibleToCreateIndexWithDuplicateLabel()
{
// given
SchemaWrite schemaWrite = SchemaWriteInNewTransaction();
// when
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.api.schema.MultiTokenSchemaDescriptor descriptor = org.neo4j.kernel.api.schema.SchemaDescriptorFactory.multiToken(new int[]{0, 0}, org.neo4j.storageengine.api.EntityType.NODE, 1);
MultiTokenSchemaDescriptor descriptor = SchemaDescriptorFactory.multiToken(new int[] { 0, 0 }, EntityType.NODE, 1);
schemaWrite.IndexCreate(descriptor);
fail("Should have failed");
}
catch (RepeatedLabelInSchemaException)
{
// then good
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.internal.kernel.api.schema.SchemaDescriptor readMultiTokenSchema(ByteBuffer source) throws org.neo4j.internal.kernel.api.exceptions.schema.MalformedSchemaRuleException
private static SchemaDescriptor ReadMultiTokenSchema(ByteBuffer source)
{
sbyte schemaDescriptorType = source.get();
EntityType type;
switch (schemaDescriptorType)
{
case SIMPLE_LABEL:
type = EntityType.NODE;
break;
case SIMPLE_REL_TYPE:
type = EntityType.RELATIONSHIP;
break;
default:
throw new MalformedSchemaRuleException(format("Got unknown schema descriptor type '%d'.", schemaDescriptorType));
}
int[] entityTokenIds = ReadTokenIdList(source);
int[] propertyIds = ReadTokenIdList(source);
return(SchemaDescriptorFactory.multiToken(entityTokenIds, type, propertyIds));
}
public virtual void TriggerIndexSampling(string labelKey, string propertyKey, bool forceSample)
{
int labelKeyId = NO_TOKEN;
int propertyKeyId = NO_TOKEN;
State state = this.State;
if (state != null)
{
labelKeyId = state.TokenHolders.labelTokens().getIdByName(labelKey);
propertyKeyId = state.TokenHolders.propertyKeyTokens().getIdByName(propertyKey);
}
if (state == null || labelKeyId == NO_TOKEN || propertyKeyId == NO_TOKEN)
{
throw new System.ArgumentException("No property or label key was found associated with " + propertyKey + " and " + labelKey);
}
try
{
state.IndexingService.triggerIndexSampling(SchemaDescriptorFactory.forLabel(labelKeyId, propertyKeyId), GetIndexSamplingMode(forceSample));
}
catch (IndexNotFoundKernelException e)
{
throw new System.ArgumentException(e.Message);
}
}
// READ HELP
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.internal.kernel.api.schema.SchemaDescriptor readSchema(ByteBuffer source) throws org.neo4j.internal.kernel.api.exceptions.schema.MalformedSchemaRuleException
private static SchemaDescriptor ReadSchema(ByteBuffer source)
{
int[] propertyIds;
sbyte schemaDescriptorType = source.get();
switch (schemaDescriptorType)
{
case SIMPLE_LABEL:
int labelId = source.Int;
propertyIds = ReadTokenIdList(source);
return(SchemaDescriptorFactory.forLabel(labelId, propertyIds));
case SIMPLE_REL_TYPE:
int relTypeId = source.Int;
propertyIds = ReadTokenIdList(source);
return(SchemaDescriptorFactory.forRelType(relTypeId, propertyIds));
case GENERIC_MULTI_TOKEN_TYPE:
return(ReadMultiTokenSchema(source));
default:
throw new MalformedSchemaRuleException(format("Got unknown schema descriptor type '%d'.", schemaDescriptorType));
}
}
protected internal override LabelSchemaDescriptor LabelSchemaDescriptor(int labelId, params int[] propertyIds)
{
return(SchemaDescriptorFactory.forLabel(labelId, propertyIds));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReadBasicEntities() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReadBasicEntities()
{
// GIVEN
MemoryStream @out = new MemoryStream(1_000);
FormattedLog log = FormattedLog.toOutputStream(@out);
InconsistencyMessageLogger logger = new InconsistencyMessageLogger(log);
long nodeId = 5;
long indexNodeId = 7;
long nodeNotInTheIndexId = 17;
long indexId = 99;
long relationshipGroupId = 10;
long relationshipId = 15;
long propertyId = 20;
logger.Error(RecordType.NODE, new NodeRecord(nodeId), "Some error", "something");
logger.Error(RecordType.RELATIONSHIP, new RelationshipRecord(relationshipId), "Some error", "something");
logger.Error(RecordType.RELATIONSHIP_GROUP, new RelationshipGroupRecord(relationshipGroupId), "Some error", "something");
logger.Error(RecordType.PROPERTY, new PropertyRecord(propertyId), "Some error", "something");
logger.Error(RecordType.INDEX, new IndexEntry(IndexDescriptorFactory.forSchema(SchemaDescriptorFactory.forLabel(1, 1)).withId(indexNodeId), idTokenNameLookup, 0), "Some index error", "Something wrong with index");
logger.Error(RecordType.NODE, new NodeRecord(nodeNotInTheIndexId), "Some index error", IndexDescriptorFactory.forSchema(forLabel(1, 2), new IndexProviderDescriptor("key", "version")).withId(indexId).ToString());
string text = @out.ToString();
// WHEN
ReportInconsistencies inconsistencies = new ReportInconsistencies();
InconsistencyReportReader reader = new InconsistencyReportReader(inconsistencies);
reader.Read(new StreamReader(new StringReader(text)));
// THEN
assertTrue(inconsistencies.ContainsNodeId(nodeId));
// assertTrue( inconsistencies.containsNodeId( indexNodeId ) );
assertTrue(inconsistencies.ContainsNodeId(nodeNotInTheIndexId));
assertTrue(inconsistencies.ContainsRelationshipId(relationshipId));
assertTrue(inconsistencies.ContainsRelationshipGroupId(relationshipGroupId));
assertTrue(inconsistencies.ContainsPropertyId(propertyId));
assertTrue(inconsistencies.ContainsSchemaIndexId(indexId));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUpdateHighIdsOnExternalTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldUpdateHighIdsOnExternalTransaction()
{
// GIVEN
NeoStores neoStores = NeoStoresRule.builder().build();
HighIdTransactionApplier tracker = new HighIdTransactionApplier(neoStores);
// WHEN
// Nodes
tracker.VisitNodeCommand(Commands.CreateNode(10, 2, 3));
tracker.VisitNodeCommand(Commands.CreateNode(20, 4, 5));
// Relationships
tracker.VisitRelationshipCommand(Commands.CreateRelationship(4, 10, 20, 0));
tracker.VisitRelationshipCommand(Commands.CreateRelationship(45, 10, 20, 1));
// Label tokens
tracker.VisitLabelTokenCommand(Commands.CreateLabelToken(3, 0));
tracker.VisitLabelTokenCommand(Commands.CreateLabelToken(5, 1));
// Property tokens
tracker.VisitPropertyKeyTokenCommand(Commands.CreatePropertyKeyToken(3, 0));
tracker.VisitPropertyKeyTokenCommand(Commands.CreatePropertyKeyToken(5, 1));
// Relationship type tokens
tracker.VisitRelationshipTypeTokenCommand(Commands.CreateRelationshipTypeToken(3, 0));
tracker.VisitRelationshipTypeTokenCommand(Commands.CreateRelationshipTypeToken(5, 1));
// Relationship groups
tracker.VisitRelationshipGroupCommand(Commands.CreateRelationshipGroup(10, 1));
tracker.VisitRelationshipGroupCommand(Commands.CreateRelationshipGroup(20, 2));
// Schema rules
tracker.VisitSchemaRuleCommand(Commands.CreateIndexRule(EMPTY.ProviderDescriptor, 10, SchemaDescriptorFactory.forLabel(0, 1)));
tracker.VisitSchemaRuleCommand(Commands.CreateIndexRule(EMPTY.ProviderDescriptor, 20, SchemaDescriptorFactory.forLabel(1, 2)));
// Properties
tracker.VisitPropertyCommand(Commands.CreateProperty(10, PropertyType.STRING, 0, 6, 7));
tracker.VisitPropertyCommand(Commands.CreateProperty(20, PropertyType.ARRAY, 1, 8, 9));
tracker.Close();
// THEN
assertEquals("NodeStore", 20 + 1, neoStores.NodeStore.HighId);
assertEquals("DynamicNodeLabelStore", 5 + 1, neoStores.NodeStore.DynamicLabelStore.HighId);
assertEquals("RelationshipStore", 45 + 1, neoStores.RelationshipStore.HighId);
assertEquals("RelationshipTypeStore", 5 + 1, neoStores.RelationshipTypeTokenStore.HighId);
assertEquals("RelationshipType NameStore", 1 + 1, neoStores.RelationshipTypeTokenStore.NameStore.HighId);
assertEquals("PropertyKeyStore", 5 + 1, neoStores.PropertyKeyTokenStore.HighId);
assertEquals("PropertyKey NameStore", 1 + 1, neoStores.PropertyKeyTokenStore.NameStore.HighId);
assertEquals("LabelStore", 5 + 1, neoStores.LabelTokenStore.HighId);
assertEquals("Label NameStore", 1 + 1, neoStores.LabelTokenStore.NameStore.HighId);
assertEquals("PropertyStore", 20 + 1, neoStores.PropertyStore.HighId);
assertEquals("PropertyStore DynamicStringStore", 7 + 1, neoStores.PropertyStore.StringStore.HighId);
assertEquals("PropertyStore DynamicArrayStore", 9 + 1, neoStores.PropertyStore.ArrayStore.HighId);
assertEquals("SchemaStore", 20 + 1, neoStores.SchemaStore.HighId);
}
internal override LabelSchemaDescriptor MakeDescriptor(int typeId, int propertyKeyId)
{
return(SchemaDescriptorFactory.forLabel(typeId, propertyKeyId));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.internal.kernel.api.schema.constraints.ConstraintDescriptor createUniqueConstraint(int labelId, int pkId) throws Exception
private ConstraintDescriptor CreateUniqueConstraint(int labelId, int pkId)
{
KernelTransaction ktx = ktx();
return(ktx.SchemaWrite().uniquePropertyConstraintCreate(SchemaDescriptorFactory.forLabel(labelId, pkId)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.internal.kernel.api.schema.constraints.ConstraintDescriptor createConstraint() throws org.neo4j.internal.kernel.api.exceptions.KernelException
private ConstraintDescriptor CreateConstraint()
{
using (Transaction transaction = _kernel.beginTransaction(@implicit, AUTH_DISABLED))
{
ConstraintDescriptor descriptor = transaction.SchemaWrite().uniquePropertyConstraintCreate(SchemaDescriptorFactory.forLabel(1, 1));
transaction.Success();
return(descriptor);
}
}
public static IndexDescriptor UniqueForLabel(int labelId, params int[] propertyIds)
{
return(IndexDescriptorFactory.uniqueForSchema(SchemaDescriptorFactory.forLabel(labelId, propertyIds), null, ProviderDescriptor));
}
private void InitializeInstanceFields()
{
_index = IndexDescriptorFactory.uniqueForSchema(SchemaDescriptorFactory.forLabel(_labelId, _propertyKeyId));
_predicate = exact(_propertyKeyId, _value);
_resourceId = indexEntryResourceId(_labelId, _predicate);
}
public static IndexDescriptor NamedUniqueForLabel(string name, int labelId, params int[] propertyIds)
{
return(IndexDescriptorFactory.uniqueForSchema(SchemaDescriptorFactory.forLabel(labelId, propertyIds), name, ProviderDescriptor));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.internal.kernel.api.IndexReference createSchemaIndex(int labelId, int pkId) throws Exception
private IndexReference CreateSchemaIndex(int labelId, int pkId)
{
KernelTransaction ktx = ktx();
return(ktx.SchemaWrite().indexCreate(SchemaDescriptorFactory.forLabel(labelId, pkId)));
}