//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void relationshipIdReusableOnlyAfterTransactionFinish() public virtual void RelationshipIdReusableOnlyAfterTransactionFinish() { Label testLabel = Label.label("testLabel"); long relationshipId = CreateRelationship(testLabel); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController idMaintenanceController = getIdMaintenanceController(); IdController idMaintenanceController = IdMaintenanceController; using (Transaction transaction = DbRule.beginTx(), ResourceIterator <Node> nodes = DbRule.findNodes(testLabel)) { IList <Node> nodeList = Iterators.asList(nodes); foreach (Node node in nodeList) { IEnumerable <Relationship> relationships = node.GetRelationships(TestRelationshipType.Marker); foreach (Relationship relationship in relationships) { relationship.Delete(); } } idMaintenanceController.Maintenance(); Node node1 = DbRule.createNode(testLabel); Node node2 = DbRule.createNode(testLabel); Relationship relationshipTo = node1.CreateRelationshipTo(node2, TestRelationshipType.Marker); assertNotEquals("Relationships should have different ids.", relationshipId, relationshipTo.Id); transaction.Success(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void writeTransactionsAndRotateTwice() throws java.io.IOException private void WriteTransactionsAndRotateTwice() { LogRotation logRotation = Db.DependencyResolver.resolveDependency(typeof(LogRotation)); // Apparently we always keep an extra log file what even though the threshold is reached... produce two then using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } logRotation.RotateLogFile(); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } logRotation.RotateLogFile(); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } }
/* * Tests for a particular bug with dense nodes. It used to be that if a dense node had relationships * for only one direction, if a request for relationships of the other direction was made, no relationships * would be returned, ever. */ //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void givenDenseNodeWhenAskForWrongDirectionThenIncorrectNrOfRelsReturned() public virtual void GivenDenseNodeWhenAskForWrongDirectionThenIncorrectNrOfRelsReturned() { // Given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int denseNodeThreshold = int.Parse(org.neo4j.graphdb.factory.GraphDatabaseSettings.dense_node_threshold.getDefaultValue()) + 1; int denseNodeThreshold = int.Parse(GraphDatabaseSettings.dense_node_threshold.DefaultValue) + 1; Node node1; using (Transaction tx = Db.beginTx()) { node1 = Db.createNode(); Node node2 = Db.createNode(); for (int i = 0; i < denseNodeThreshold; i++) { node1.CreateRelationshipTo(node2, RelationshipType.withName("FOO")); } tx.Success(); } // When/Then using (Transaction ignored = Db.beginTx()) { Node node1b = Db.getNodeById(node1.Id); IEnumerable <Relationship> rels = node1b.GetRelationships(Direction.INCOMING); assertEquals(0, Iterables.count(rels)); IEnumerable <Relationship> rels2 = node1b.GetRelationships(Direction.OUTGOING); assertEquals(denseNodeThreshold, Iterables.count(rels2)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldApplyChangesWithIntermediateConstraintViolations() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldApplyChangesWithIntermediateConstraintViolations() { // given using (Transaction tx = Db.beginTx()) { Db.schema().constraintFor(_foo).assertPropertyIsUnique(BAR).create(); tx.Success(); } Node fourtyTwo; Node fourtyOne; using (Transaction tx = Db.beginTx()) { fourtyTwo = Db.createNode(_foo); fourtyTwo.SetProperty(BAR, Value1); fourtyOne = Db.createNode(_foo); fourtyOne.SetProperty(BAR, Value2); tx.Success(); } // when using (Transaction tx = Db.beginTx()) { fourtyOne.Delete(); fourtyTwo.SetProperty(BAR, Value2); tx.Success(); } // then using (Transaction tx = Db.beginTx()) { assertEquals(Value2, fourtyTwo.GetProperty(BAR)); try { fourtyOne.GetProperty(BAR); fail("Should be deleted"); } catch (NotFoundException) { // good } tx.Success(); assertEquals(fourtyTwo, Db.findNode(_foo, BAR, Value2)); assertNull(Db.findNode(_foo, BAR, Value1)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 30_000) public void terminateExpiredTransaction() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TerminateExpiredTransaction() { using (Transaction transaction = Database.beginTx()) { Database.createNode(); transaction.Success(); } ExpectedException.expectMessage("The transaction has been terminated."); using (Transaction transaction = Database.beginTx()) { Node nodeById = Database.getNodeById(NODE_ID); nodeById.SetProperty("a", "b"); _executor.submit(StartAnotherTransaction()).get(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @BeforeClass public static void given() public static void Given() { // database with an index on `(:Node).prop` using (Transaction tx = Db.beginTx()) { Db.schema().indexFor(label("Node")).on("prop").create(); tx.Success(); } using (Transaction tx = Db.beginTx()) { Db.schema().awaitIndexesOnline(10, SECONDS); tx.Success(); } }
internal virtual void SetNodeProp(long nodeId, string propertyKey, string value) { using (Transaction tx = Db.beginTx()) { Node node = Db.getNodeById(nodeId); node.SetProperty(propertyKey, value); tx.Success(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldListAllProperties() public virtual void ShouldListAllProperties() { // Given IDictionary <string, object> properties = new Dictionary <string, object>(); properties["boolean"] = true; properties["short_string"] = "abc"; properties["string"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW" + "XYZabcdefghijklmnopqrstuvwxyz"; properties["long"] = long.MaxValue; properties["short_array"] = new long[] { 1, 2, 3, 4 }; properties["array"] = new long[] { long.MaxValue - 1, long.MaxValue - 2, long.MaxValue - 3, long.MaxValue - 4, long.MaxValue - 5, long.MaxValue - 6, long.MaxValue - 7, long.MaxValue - 8, long.MaxValue - 9, long.MaxValue - 10, long.MaxValue - 11 }; long containerId; using (Transaction tx = Db.beginTx()) { containerId = CreatePropertyContainer(); PropertyContainer container = LookupPropertyContainer(containerId); foreach (KeyValuePair <string, object> entry in properties.SetOfKeyValuePairs()) { container.SetProperty(entry.Key, entry.Value); } tx.Success(); } // When IDictionary <string, object> listedProperties; using (Transaction tx = Db.beginTx()) { listedProperties = LookupPropertyContainer(containerId).AllProperties; tx.Success(); } // Then assertEquals(properties.Count, listedProperties.Count); foreach (string key in properties.Keys) { assertObjectOrArrayEquals(properties[key], listedProperties[key]); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFailToCreateConstraintIfSomeNodeLacksTheMandatoryProperty() public virtual void ShouldFailToCreateConstraintIfSomeNodeLacksTheMandatoryProperty() { // given using (Transaction tx = Db.beginTx()) { CreateOffender(Db, KEY); tx.Success(); } // when try { using (Transaction tx = Db.beginTx()) { CreateConstraint(Db, KEY, PROPERTY); tx.Success(); } fail("expected exception"); } // then catch (QueryExecutionException e) { assertThat(e.InnerException.Message, startsWith("Unable to create CONSTRAINT")); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void failedIndexShouldRepairAutomatically() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void FailedIndexShouldRepairAutomatically() { // given using (Transaction tx = Db.beginTx()) { Db.schema().indexFor(_person).on("name").create(); tx.Success(); } AwaitIndexesOnline(5, SECONDS); CreateNamed(_person, "Johan"); // when - we restart the database in a state where the index is not operational Db.restartDatabase(new SabotageNativeIndex(Random.random())); // then - the database should still be operational CreateNamed(_person, "Lars"); AwaitIndexesOnline(5, SECONDS); IndexStateShouldBe(equalTo(ONLINE)); AssertFindsNamed(_person, "Lars"); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldInterpretNoSpecifiedRelationshipsAsAll() public virtual void ShouldInterpretNoSpecifiedRelationshipsAsAll() { // GIVEN Node node = CreateSomeData(); PathExpander expander = RelationshipExpanderBuilder.DescribeRelationships(map()); // WHEN ISet <Relationship> expanded; using (Transaction tx = Db.beginTx()) { expanded = asSet(expander.expand(singleNodePath(node), NO_STATE)); tx.Success(); } using (Transaction tx = Db.beginTx()) { // THEN assertEquals(asSet(node.Relationships), expanded); tx.Success(); } }
private Node CreateTestNode() { Node node; using (Transaction transaction = DbRule.beginTx()) { node = DbRule.createNode(_label); KernelTransaction ktx = DbRule.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true); _labelId = ktx.TokenRead().nodeLabel(_label.name()); transaction.Success(); } return(node); }
private void InitialData() { Label unusedLabel = Label.label("unusedLabel"); RelationshipType unusedRelType = RelationshipType.withName("unusedRelType"); string unusedPropKey = "unusedPropKey"; using (Transaction tx = Db.beginTx()) { Node node1 = Db.createNode(unusedLabel); node1.SetProperty(unusedPropKey, "value"); Node node2 = Db.createNode(unusedLabel); node2.SetProperty(unusedPropKey, 1); node1.CreateRelationshipTo(node2, unusedRelType); tx.Success(); } }
private void VerifyFoundNodes(Label label, string sizeMismatchMessage, params long[] expectedNodeIds) { using (Transaction ignored = DbRule.beginTx()) { ResourceIterator <Node> nodes = DbRule.findNodes(label); IList <Node> nodeList = Iterators.asList(nodes); assertThat(sizeMismatchMessage, nodeList, Matchers.hasSize(expectedNodeIds.Length)); int index = 0; foreach (Node node in nodeList) { assertEquals(expectedNodeIds[index++], node.Id); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldListUsedIndexes() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldListUsedIndexes() { // given string label = "IndexedLabel"; string property = "indexedProperty"; using (Transaction tx = _db.beginTx()) { _db.schema().indexFor(label(label)).on(property).create(); tx.Success(); } EnsureIndexesAreOnline(); ShouldListUsedIndexes(label, property); }
private ThrowingFunction <CyclicBarrier, Node, Exception> MergeThen <T1>(ThrowingConsumer <T1> action) where T1 : Exception { return(barrier => { using (Transaction tx = Db.beginTx()) { Node node = MergeNode(); barrier.await(); action.Accept(node); tx.success(); return node; } }); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @BeforeClass public static void initStorage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public static void InitStorage() { using (Transaction transaction = Db.beginTx()) { TokenWrite tokenWrite = Transaction.tokenWrite(); tokenWrite.PropertyKeyGetOrCreateForName(PROP1); tokenWrite.PropertyKeyGetOrCreateForName(PROP2); tokenWrite.LabelGetOrCreateForName(LABEL1); tokenWrite.LabelGetOrCreateForName(LABEL2); tokenWrite.RelationshipTypeGetOrCreateForName(TYPE1); transaction.Success(); } SchemaStore schemaStore = ResolveDependency(typeof(RecordStorageEngine)).testAccessNeoStores().SchemaStore; _storage = new SchemaStorage(schemaStore); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHandleSizesCloseToTheLimit() public virtual void ShouldHandleSizesCloseToTheLimit() { // given CreateIndex(KEY); // when IDictionary <string, long> strings = new Dictionary <string, long>(); using (Transaction tx = Db.beginTx()) { for (int i = 0; i < 1_000; i++) { string @string; do { @string = Random.nextAlphaNumericString(3_000, 4_000); } while (strings.ContainsKey(@string)); Node node = Db.createNode(LABEL); node.SetProperty(KEY, @string); strings[@string] = node.Id; } tx.Success(); } // then using (Transaction tx = Db.beginTx()) { foreach (string @string in strings.Keys) { Node node = Db.findNode(LABEL, KEY, @string); assertEquals(strings[@string], node.Id); } tx.Success(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 15000) public void commitDuringContinuousCheckpointing() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CommitDuringContinuousCheckpointing() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.graphdb.index.Index<org.neo4j.graphdb.Node> index; Index <Node> index; using (Transaction tx = Db.beginTx()) { index = Db.index().forNodes(INDEX_NAME, stringMap(Org.Neo4j.Graphdb.index.IndexManager_Fields.PROVIDER, DummyIndexExtensionFactory.IDENTIFIER)); tx.Success(); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean done = new java.util.concurrent.atomic.AtomicBoolean(); AtomicBoolean done = new AtomicBoolean(); Workers <ThreadStart> workers = new Workers <ThreadStart>(this.GetType().Name); for (int i = 0; i < TOTAL_ACTIVE_THREADS; i++) { workers.Start(new RunnableAnonymousInnerClass(this, index, tx, done)); } Thread.Sleep(SECONDS.toMillis(2)); done.set(true); workers.AwaitAndThrowOnError(); NeoStores neoStores = GetDependency(typeof(RecordStorageEngine)).testAccessNeoStores(); assertThat("Count store should be rotated once at least", neoStores.Counts.txId(), greaterThan(0L)); long lastRotationTx = GetDependency(typeof(CheckPointer)).forceCheckPoint(new SimpleTriggerInfo("test")); TransactionIdStore txIdStore = GetDependency(typeof(TransactionIdStore)); assertEquals("NeoStore last closed transaction id should be equal last count store rotation transaction id.", txIdStore.LastClosedTransactionId, lastRotationTx); assertEquals("Last closed transaction should be last rotated tx in count store", txIdStore.LastClosedTransactionId, neoStores.Counts.txId()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldChaseTheLivingRelationships() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldChaseTheLivingRelationships() { // GIVEN a sound relationship chain int numberOfRelationships = THRESHOLD / 2; Node node; using (Transaction tx = Db.beginTx()) { node = Db.createNode(); for (int i = 0; i < numberOfRelationships; i++) { node.CreateRelationshipTo(Db.createNode(), TEST); } tx.Success(); } Relationship[] relationships; using (Transaction tx = Db.beginTx()) { relationships = asArray(typeof(Relationship), node.Relationships); tx.Success(); } using (Transaction tx = Db.beginTx()) { // WHEN getting the relationship iterator, i.e. starting to traverse this relationship chain, // the cursor eagerly goes to the first relationship before we call #hasNexxt/#next. IEnumerator <Relationship> iterator = node.Relationships.GetEnumerator(); // Therefore we delete relationships [1] and [2] (the second and third), since currently // the relationship iterator has read [0] and have already decided to go to [1] after our next // call to #next DeleteRelationshipsInSeparateThread(relationships[1], relationships[2]); // THEN the relationship iterator should recognize the unused relationship, but still try to find // the next used relationship in this chain by following the pointers in the unused records. AssertNext(relationships[0], iterator); AssertNext(relationships[3], iterator); AssertNext(relationships[4], iterator); //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: assertFalse(iterator.hasNext()); tx.Success(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void prepDB() public virtual void PrepDB() { using (Transaction transaction = Db.beginTx()) { _node1 = Db.createNode(label("hej"), label("ha"), label("he")); _node1.setProperty("hej", "value"); _node1.setProperty("ha", "value1"); _node1.setProperty("he", "value2"); _node1.setProperty("ho", "value3"); _node1.setProperty("hi", "value4"); _node2 = Db.createNode(); Relationship rel = _node1.createRelationshipTo(_node2, RelationshipType.withName("hej")); rel.SetProperty("hej", "valuuu"); rel.SetProperty("ha", "value1"); rel.SetProperty("he", "value2"); rel.SetProperty("ho", "value3"); rel.SetProperty("hi", "value4"); transaction.Success(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDropUniquenessConstraintWithBackingIndexNotInUse() public virtual void ShouldDropUniquenessConstraintWithBackingIndexNotInUse() { // given using ( Transaction tx = Db.beginTx() ) { Db.schema().constraintFor(_label).assertPropertyIsUnique(_key).create(); tx.Success(); } // when intentionally breaking the schema by setting the backing index rule to unused RecordStorageEngine storageEngine = Db.DependencyResolver.resolveDependency( typeof( RecordStorageEngine ) ); SchemaStore schemaStore = storageEngine.TestAccessNeoStores().SchemaStore; SchemaRule indexRule = single( filter( rule => rule is StoreIndexDescriptor, schemaStore.LoadAllSchemaRules() ) ); SetSchemaRecordNotInUse( schemaStore, indexRule.Id ); // At this point the SchemaCache doesn't know about this change so we have to reload it storageEngine.LoadSchemaCache(); using ( Transaction tx = Db.beginTx() ) { single( Db.schema().getConstraints(_label).GetEnumerator() ).drop(); tx.Success(); } // then using ( Transaction ignore = Db.beginTx() ) { assertFalse( Db.schema().Constraints.GetEnumerator().hasNext() ); assertFalse( Db.schema().Indexes.GetEnumerator().hasNext() ); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void createTokens() public virtual void CreateTokens() { using (Transaction tx = Db.beginTx()) { for (int i = 0; i < _threads; i++) { Db.createNode(Label(i)).setProperty(KEY, i); } tx.Success(); } }