//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void readArrayAndStringPropertiesWithDifferentBlockSizes()
public virtual void ReadArrayAndStringPropertiesWithDifferentBlockSizes()
{
string stringValue = RandomStringUtils.randomAlphanumeric(10000);
sbyte[] arrayValue = RandomStringUtils.randomAlphanumeric(10000).Bytes;
GraphDatabaseService db = (new TestGraphDatabaseFactory()).setFileSystem(Fs.get()).newImpermanentDatabaseBuilder().setConfig(GraphDatabaseSettings.string_block_size, "1024").setConfig(GraphDatabaseSettings.array_block_size, "2048").newGraphDatabase();
try
{
long nodeId;
using (Transaction tx = Db.beginTx())
{
Node node = Db.createNode();
nodeId = node.Id;
node.SetProperty("string", stringValue);
node.SetProperty("array", arrayValue);
tx.Success();
}
using (Transaction tx = Db.beginTx())
{
Node node = Db.getNodeById(nodeId);
assertEquals(stringValue, node.GetProperty("string"));
assertArrayEquals(arrayValue, ( sbyte[] )node.GetProperty("array"));
tx.Success();
}
}
finally
{
Db.shutdown();
}
}
public static void CreateNodeKeyConstraint(GraphDatabaseService db, string label, params string[] properties)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
string keyProperties = java.util.properties.Select(property => format("n.`%s`", property)).collect(joining(","));
Db.execute(format("CREATE CONSTRAINT ON (n:`%s`) ASSERT (%s) IS NODE KEY", label, keyProperties));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotIndexNodesWithWrongLabel() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotIndexNodesWithWrongLabel()
{
// Given
File file = new File(DbRule.DatabaseDirAbsolutePath);
BatchInserter inserter = BatchInserters.inserter(file, FileSystemRule.get());
inserter.createNode(map("name", "Bob"), label("User"), label("Admin"));
inserter.CreateDeferredSchemaIndex(label("Banana")).on("name").create();
// When
inserter.Shutdown();
// Then
GraphDatabaseService db = DbRule.GraphDatabaseAPI;
try
{
using (Transaction tx = Db.beginTx())
{
assertThat(count(Db.findNodes(label("Banana"), "name", "Bob")), equalTo(0L));
}
}
finally
{
Db.shutdown();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void compositeNodeKeyConstraintUpdate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CompositeNodeKeyConstraintUpdate()
{
GraphDatabaseService database = (new EnterpriseGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(TestDirectory.storeDir()).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();
Label label = Label.label("label");
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode(label);
node.SetProperty("b", ( short )3);
node.SetProperty("a", new double[] { 0.6, 0.4, 0.2 });
transaction.Success();
}
using (Transaction transaction = database.BeginTx())
{
string query = format("CREATE CONSTRAINT ON (n:%s) ASSERT (n.%s,n.%s) IS NODE KEY", label.Name(), "a", "b");
database.Execute(query);
transaction.Success();
}
AwaitIndex(database);
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode(label);
node.SetProperty("a", ( short )7);
node.SetProperty("b", new double[] { 0.7, 0.5, 0.3 });
transaction.Success();
}
database.Shutdown();
ConsistencyCheckService.Result consistencyCheckResult = CheckDbConsistency(TestDirectory.storeDir());
assertTrue("Database is consistent", consistencyCheckResult.Successful);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deletedNodesNotCheckedByExistenceConstraints()
public virtual void DeletedNodesNotCheckedByExistenceConstraints()
{
GraphDatabaseService database = (new EnterpriseGraphDatabaseFactory()).newEmbeddedDatabase(TestDirectory.directory());
try
{
using (Transaction transaction = database.BeginTx())
{
database.Execute("CREATE CONSTRAINT ON (book:Book) ASSERT exists(book.isbn)");
transaction.Success();
}
using (Transaction transaction = database.BeginTx())
{
database.Execute("CREATE (:label1 {name: \"Pelle\"})<-[:T1]-(:label2 {name: \"Elin\"})-[:T2]->(:label3)");
transaction.Success();
}
using (Transaction transaction = database.BeginTx())
{
database.Execute("MATCH (n:label1 {name: \"Pelle\"})<-[r:T1]-(:label2 {name: \"Elin\"})-[:T2]->(:label3) DELETE r,n");
transaction.Success();
}
}
finally
{
database.Shutdown();
}
}
/// <summary>
/// Reading a node command might leave a node record which referred to
/// labels in one or more dynamic records as marked as heavy even if that
/// node already had references to dynamic records, changed in a transaction,
/// but had no labels on that node changed within that same transaction.
/// Now defensively only marks as heavy if there were one or more dynamic
/// records provided when providing the record object with the label field
/// value. This would give the opportunity to load the dynamic records the
/// next time that record would be ensured heavy.
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRecoverNodeWithDynamicLabelRecords()
public virtual void ShouldRecoverNodeWithDynamicLabelRecords()
{
// GIVEN
_database = (new TestGraphDatabaseFactory()).setFileSystem(Fs).newImpermanentDatabase();
Node node;
Label[] labels = new Label[] { label("a"), label("b"), label("c"), label("d"), label("e"), label("f"), label("g"), label("h"), label("i"), label("j"), label("k") };
using (Transaction tx = _database.beginTx())
{
node = _database.createNode(labels);
tx.Success();
}
// WHEN
using (Transaction tx = _database.beginTx())
{
node.SetProperty("prop", "value");
tx.Success();
}
EphemeralFileSystemAbstraction snapshot = Fs.snapshot();
_database.shutdown();
_database = (new TestGraphDatabaseFactory()).setFileSystem(snapshot).newImpermanentDatabase();
// THEN
using (Transaction ignored = _database.beginTx())
{
node = _database.getNodeById(node.Id);
foreach (Label label in labels)
{
assertTrue(node.HasLabel(label));
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void SetUp()
{
TestHighlyAvailableGraphDatabaseFactory factory = new TestHighlyAvailableGraphDatabaseFactory();
Monitors monitors = new Monitors();
monitors.AddMonitorListener(_monitor);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
factory.RemoveKernelExtensions(extension => extension.GetType().FullName.Contains("LabelScan"));
ClusterManager clusterManager = (new ClusterManager.Builder(TestDirectory.directory("root"))).withDbFactory(factory).withMonitors(monitors).withStoreDirInitializer((serverId, storeDir) =>
{
if (serverId == 1)
{
GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();
try
{
CreateSomeLabeledNodes(db, new Label[] { Labels.First }, new Label[] { Labels.First, Labels.Second }, new Label[] { Labels.Second });
}
finally
{
Db.shutdown();
}
}
}).build();
_life.add(clusterManager);
_life.start();
_cluster = clusterManager.Cluster;
_cluster.await(allSeesAllAsAvailable());
_cluster.await(allAvailabilityGuardsReleased());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void extractTransactionalInformationFromLogs(String path, java.io.File customLogLocation, org.neo4j.io.layout.DatabaseLayout databaseLayout, java.io.File storeDir) throws java.io.IOException
private void ExtractTransactionalInformationFromLogs(string path, File customLogLocation, DatabaseLayout databaseLayout, File storeDir)
{
LogService logService = new SimpleLogService(NullLogProvider.Instance, NullLogProvider.Instance);
File neoStore = databaseLayout.MetadataStore();
GraphDatabaseService database = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(logical_logs_location, path).newGraphDatabase();
for (int i = 0; i < 10; i++)
{
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode();
transaction.Success();
}
}
database.Shutdown();
MetaDataStore.setRecord(_pageCache, neoStore, MetaDataStore.Position.LAST_CLOSED_TRANSACTION_LOG_VERSION, MetaDataRecordFormat.FIELD_NOT_PRESENT);
Config config = Config.defaults(logical_logs_location, path);
StoreMigrator migrator = new StoreMigrator(_fileSystemRule.get(), _pageCache, config, logService, _jobScheduler);
LogPosition logPosition = migrator.ExtractTransactionLogPosition(neoStore, databaseLayout, 100);
File[] logFiles = customLogLocation.listFiles();
assertNotNull(logFiles);
assertEquals(0, logPosition.LogVersion);
assertEquals(logFiles[0].length(), logPosition.ByteOffset);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAccountForDeletedNodes()
public virtual void ShouldAccountForDeletedNodes()
{
// given
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
Node node;
using (Transaction tx = graphDb.BeginTx())
{
node = graphDb.CreateNode(label("Foo"));
graphDb.CreateNode(label("Foo"));
tx.Success();
}
using (Transaction tx = graphDb.BeginTx())
{
node.Delete();
tx.Success();
}
// when
long fooCount = NumberOfNodesWith(label("Foo"));
// then
assertEquals(1, fooCount);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAccountForRemovedLabels()
public virtual void ShouldAccountForRemovedLabels()
{
// given
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
Node n1;
Node n2;
Node n3;
using (Transaction tx = graphDb.BeginTx())
{
n1 = graphDb.CreateNode(label("Foo"), label("Bar"));
n2 = graphDb.CreateNode(label("Bar"));
n3 = graphDb.CreateNode(label("Foo"));
tx.Success();
}
using (Transaction tx = graphDb.BeginTx())
{
n1.RemoveLabel(label("Bar"));
n2.RemoveLabel(label("Bar"));
n3.RemoveLabel(label("Foo"));
tx.Success();
}
// when
long fooCount = NumberOfNodesWith(label("Foo"));
long barCount = NumberOfNodesWith(label("Bar"));
// then
assertEquals(1, fooCount);
assertEquals(0, barCount);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDropIndexOnRecovery() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDropIndexOnRecovery()
{
// given a transaction stream ending in an INDEX DROP command.
CommittedTransactionRepresentation dropTransaction = PrepareDropTransaction();
File storeDir = Directory.databaseDir();
GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(storeDir);
CreateIndex(db);
Db.shutdown();
AppendDropTransactionToTransactionLog(Directory.databaseDir(), dropTransaction);
// when recovering this (the drop transaction with the index file intact)
Monitors monitors = new Monitors();
AssertRecoveryIsPerformed recoveryMonitor = new AssertRecoveryIsPerformed();
monitors.AddMonitorListener(recoveryMonitor);
db = (new TestGraphDatabaseFactory()).setMonitors(monitors).newEmbeddedDatabase(storeDir);
try
{
assertTrue(recoveryMonitor.RecoveryWasPerformed);
// then
using (Transaction tx = Db.beginTx())
{
assertEquals(0, count(Db.schema().Indexes));
tx.Success();
}
}
finally
{
// and the ability to shut down w/o failing on still open files
Db.shutdown();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCountRelationshipsByType()
public virtual void ShouldCountRelationshipsByType()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService graphDb = db.getGraphDatabaseAPI();
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
using (Transaction tx = graphDb.BeginTx())
{
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("FOO"));
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("FOO"));
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("BAR"));
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("BAR"));
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("BAR"));
graphDb.CreateNode().createRelationshipTo(graphDb.CreateNode(), withName("BAZ"));
tx.Success();
}
// when
long total = NumberOfRelationships();
long foo = NumberOfRelationships(withName("FOO"));
long bar = NumberOfRelationships(withName("BAR"));
long baz = NumberOfRelationships(withName("BAZ"));
long qux = NumberOfRelationships(withName("QUX"));
// then
assertEquals(2, foo);
assertEquals(3, bar);
assertEquals(1, baz);
assertEquals(0, qux);
assertEquals(6, total);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToMakeRepeatedCallsToSetNodePropertyWithMultiplePropertiesPerBlock() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToMakeRepeatedCallsToSetNodePropertyWithMultiplePropertiesPerBlock()
{
File file = DbRule.databaseLayout().databaseDirectory();
BatchInserter inserter = BatchInserters.inserter(file, FileSystemRule.get());
long nodeId = inserter.createNode(Collections.emptyMap());
const object finalValue1 = 87;
const object finalValue2 = 3.14;
inserter.SetNodeProperty(nodeId, "a", "some property value");
inserter.SetNodeProperty(nodeId, "a", 42);
inserter.SetNodeProperty(nodeId, "b", finalValue2);
inserter.SetNodeProperty(nodeId, "a", finalValue2);
inserter.SetNodeProperty(nodeId, "a", true);
inserter.SetNodeProperty(nodeId, "a", finalValue1);
inserter.Shutdown();
GraphDatabaseService db = DbRule.GraphDatabaseAPI;
try
{
using (Transaction ignored = Db.beginTx())
{
assertThat(Db.getNodeById(nodeId).getProperty("a"), equalTo(finalValue1));
assertThat(Db.getNodeById(nodeId).getProperty("b"), equalTo(finalValue2));
}
}
finally
{
Db.shutdown();
}
}
private void AssertFindSingleHit <T>(GraphDatabaseService db, Index <T> nodeIndex, string key, string value, T entity) where T : Org.Neo4j.Graphdb.PropertyContainer
{
// when get using hasNext + next, then
assertEquals(entity, FindSingle(db, nodeIndex, key, value, hits =>
{
assertTrue(hits.hasNext());
T result = hits.next();
assertFalse(hits.hasNext());
return(result);
}));
// when get using getSingle, then
assertEquals(entity, FindSingle(db, nodeIndex, key, value, hits =>
{
T result = hits.Single;
assertFalse(hits.hasNext());
return(result);
}));
// when get using hasNext + getSingle, then
assertEquals(entity, FindSingle(db, nodeIndex, key, value, hits =>
{
assertTrue(hits.hasNext());
T result = hits.Single;
assertFalse(hits.hasNext());
return(result);
}));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldGiveNiceErrorWhenShutdownLegacy()
public virtual void ShouldGiveNiceErrorWhenShutdownLegacy()
{
GraphDatabaseService graphDb = _graph;
Node node = graphDb.CreateNode();
Commit();
graphDb.Shutdown();
try
{
node.Relationships;
fail("Did not get a nice exception");
}
catch (DatabaseShutdownException)
{ // good
}
try
{
graphDb.CreateNode();
fail("Create node did not produce expected error");
}
catch (DatabaseShutdownException)
{ // good
}
}
private StoreAccess CreateStoreWithOneHighDegreeNodeAndSeveralDegreeTwoNodes(int nDegreeTwoNodes)
{
File storeDirectory = _testDirectory.databaseDir();
GraphDatabaseService database = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDirectory).setConfig(GraphDatabaseSettings.record_format, RecordFormatName).setConfig("dbms.backup.enabled", "false").newGraphDatabase();
using (Transaction transaction = database.BeginTx())
{
Node denseNode = database.CreateNode();
for (int i = 0; i < nDegreeTwoNodes; i++)
{
Node degreeTwoNode = database.CreateNode();
Node leafNode = database.CreateNode();
if (i % 2 == 0)
{
denseNode.CreateRelationshipTo(degreeTwoNode, TestRelationshipType.Connected);
}
else
{
degreeTwoNode.CreateRelationshipTo(denseNode, TestRelationshipType.Connected);
}
degreeTwoNode.CreateRelationshipTo(leafNode, TestRelationshipType.Connected);
}
transaction.Success();
}
database.Shutdown();
PageCache pageCache = PageCacheRule.getPageCache(_fileSystemRule.get());
StoreAccess storeAccess = new StoreAccess(_fileSystemRule.get(), pageCache, _testDirectory.databaseLayout(), Config.defaults());
return(storeAccess.Initialize());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReportTotalNumberOfRelationships()
public virtual void ShouldReportTotalNumberOfRelationships()
{
// given
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
long before = NumberOfRelationships();
long during;
using (Transaction tx = graphDb.BeginTx())
{
Node node = graphDb.CreateNode();
node.CreateRelationshipTo(graphDb.CreateNode(), withName("KNOWS"));
node.CreateRelationshipTo(graphDb.CreateNode(), withName("KNOWS"));
node.CreateRelationshipTo(graphDb.CreateNode(), withName("KNOWS"));
during = CountsForRelationship(null, null, null);
tx.Success();
}
// when
long after = NumberOfRelationships();
// then
assertEquals(0, before);
assertEquals(3, during);
assertEquals(3, after);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotSeeNodeCountsOfOtherTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotSeeNodeCountsOfOtherTransaction()
{
// given
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.test.Barrier_Control barrier = new org.neo4j.test.Barrier_Control();
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
long before = NumberOfNodes();
Future <long> done = Threading.execute(new NamedFunctionAnonymousInnerClass(this, graphDb, barrier)
, graphDb);
barrier.Await();
// when
long during = NumberOfNodes();
barrier.Release();
long whatOtherThreadSees = done.get();
long after = NumberOfNodes();
// then
assertEquals(0, before);
assertEquals(0, during);
assertEquals(after, whatOtherThreadSees);
assertEquals(2, after);
}
private void WaitIndexesOnline(GraphDatabaseService database)
{
using (Transaction ignored = database.BeginTx())
{
database.Schema().awaitIndexesOnline(5, TimeUnit.MINUTES);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldIndexNodesWithMultipleLabels() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldIndexNodesWithMultipleLabels()
{
// Given
File path = DbRule.databaseLayout().databaseDirectory();
BatchInserter inserter = BatchInserters.inserter(path, FileSystemRule.get());
inserter.createNode(map("name", "Bob"), label("User"), label("Admin"));
inserter.CreateDeferredSchemaIndex(label("User")).on("name").create();
inserter.CreateDeferredSchemaIndex(label("Admin")).on("name").create();
// When
inserter.Shutdown();
// Then
GraphDatabaseService db = DbRule.GraphDatabaseAPI;
try
{
using (Transaction tx = Db.beginTx())
{
assertThat(count(Db.findNodes(label("User"), "name", "Bob")), equalTo(1L));
assertThat(count(Db.findNodes(label("Admin"), "name", "Bob")), equalTo(1L));
}
}
finally
{
Db.shutdown();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldIncludeNumberOfNodesDeletedInTransaction()
public virtual void ShouldIncludeNumberOfNodesDeletedInTransaction()
{
// given
GraphDatabaseService graphDb = Db.GraphDatabaseAPI;
Node one;
using (Transaction tx = graphDb.BeginTx())
{
one = graphDb.CreateNode();
graphDb.CreateNode();
tx.Success();
}
long before = NumberOfNodes();
using (Transaction tx = graphDb.BeginTx())
{
// when
one.Delete();
long nodeCount = CountsForNode();
// then
assertEquals(before - 1, nodeCount);
tx.Success();
}
}
internal SimpleRandomMutation(long nodeCount, GraphDatabaseService db, Mutation rareMutation, Mutation commonMutation)
{
this._nodeCount = nodeCount;
this._db = db;
this._rareMutation = rareMutation;
this._commonMutation = commonMutation;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @AfterClass public static void stopDb()
public static void StopDb()
{
if (_graphdb != null)
{
_graphdb.shutdown();
}
_graphdb = null;
}
private static void AwaitIndex(GraphDatabaseService database)
{
using (Transaction tx = database.BeginTx())
{
database.Schema().awaitIndexesOnline(2, TimeUnit.MINUTES);
tx.Success();
}
}
public static void AwaitIndexes(GraphDatabaseService db)
{
using (Transaction tx = Db.beginTx())
{
Db.schema().awaitIndexesOnline(10, TimeUnit.SECONDS);
tx.Success();
}
}
private static void WaitIndexes(GraphDatabaseService db)
{
using (Transaction transaction = Db.beginTx())
{
Db.schema().awaitIndexesOnline(5, TimeUnit.SECONDS);
transaction.Success();
}
}
/// <summary>
/// Used by non-cc </summary>
/// <param name="db">
/// @return </param>
public static DbRepresentation CreateSomeData(GraphDatabaseService db)
{
using (Transaction tx = Db.beginTx())
{
CreateSomeData(db, tx);
}
return(DbRepresentation.of(db));
}
/// <summary>
/// Used by cc </summary>
/// <param name="db"> </param>
/// <param name="tx"> </param>
public static void CreateSomeData(GraphDatabaseService db, Transaction tx)
{
Node node = Db.createNode();
node.SetProperty(PROP_NAME, "Neo");
node.SetProperty(PROP_RANDOM, GlobalRandom.NextDouble * 10000);
Db.createNode().createRelationshipTo(node, RelationshipType.withName("KNOWS"));
tx.Success();
}
private void CleanDatabaseContent(GraphDatabaseService db)
{
using (Transaction tx = Db.beginTx())
{
Db.AllRelationships.forEach(Relationship.delete);
Db.AllNodes.forEach(Node.delete);
tx.Success();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void crashAndRestart() throws Exception
private void CrashAndRestart()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService db1 = db;
GraphDatabaseService db1 = _db;
FileSystemAbstraction uncleanFs = FsRule.snapshot(db1.shutdown);
_db = DatabaseFactory(uncleanFs).newImpermanentDatabase();
}