//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.bolt.messaging.RequestMessage decode(org.neo4j.bolt.messaging.Neo4jPack_Unpacker unpacker) throws java.io.IOException
public override RequestMessage Decode(Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker)
{
string statement = unpacker.UnpackString();
MapValue @params = unpacker.UnpackMap();
return(new RunMessage(statement, @params));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUseSingleBookmarkWhenGivenOnlySingle() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldUseSingleBookmarkWhenGivenOnlySingle()
{
MapValue @params = @params("neo4j:bookmark:v1:tx82", null);
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(82, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUseMultipleBookmarksWhenGivenOnlyMultiple() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldUseMultipleBookmarksWhenGivenOnlyMultiple()
{
MapValue @params = @params(null, asList("neo4j:bookmark:v1:tx85", "neo4j:bookmark:v1:tx47", "neo4j:bookmark:v1:tx15", "neo4j:bookmark:v1:tx6"));
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(85, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUseMultipleBookmarksWhenGivenBothSingleAndMultiple() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldUseMultipleBookmarksWhenGivenBothSingleAndMultiple()
{
MapValue @params = @params("neo4j:bookmark:v1:tx42", asList("neo4j:bookmark:v1:tx10", "neo4j:bookmark:v1:tx99", "neo4j:bookmark:v1:tx3"));
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(99, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUseSingleBookmarkWhenGivenBothSingleAndEmptyListAsMultiple() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldUseSingleBookmarkWhenGivenBothSingleAndEmptyListAsMultiple()
{
MapValue @params = @params("neo4j:bookmark:v1:tx67", emptyList());
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(67, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldThrowWhenMultipleBookmarksIsNotAListOfStrings()
internal virtual void ShouldThrowWhenMultipleBookmarksIsNotAListOfStrings()
{
MapValue @params = @params("neo4j:bookmark:v1:tx67", asList(new string[] { "neo4j:bookmark:v1:tx50" }, new object[] { "neo4j:bookmark:v1:tx89" }));
BookmarkFormatException e = assertThrows(typeof(BookmarkFormatException), () => Bookmark.FromParamsOrNull(@params));
assertTrue(e.CausesFailureMessage());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldThrowWhenOneOfMultipleBookmarksIsMalformed()
internal virtual void ShouldThrowWhenOneOfMultipleBookmarksIsMalformed()
{
MapValue @params = @params("neo4j:bookmark:v1:tx67", asList("neo4j:bookmark:v1:tx99", "neo4j:bookmark:v1:tx12", "neo4j:bookmark:www:tx99"));
BookmarkFormatException e = assertThrows(typeof(BookmarkFormatException), () => Bookmark.FromParamsOrNull(@params));
assertTrue(e.CausesFailureMessage());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldThrowWhenSingleBookmarkIsMalformed()
internal virtual void ShouldThrowWhenSingleBookmarkIsMalformed()
{
MapValue @params = @params("neo4j:strange-bookmark:v1:tx6", null);
BookmarkFormatException e = assertThrows(typeof(BookmarkFormatException), () => Bookmark.FromParamsOrNull(@params));
assertTrue(e.CausesFailureMessage());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUseSingleBookmarkWhenGivenBothSingleAndNullAsMultiple() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldUseSingleBookmarkWhenGivenBothSingleAndNullAsMultiple()
{
MapValue @params = @params("neo4j:bookmark:v1:tx58", null);
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(58, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldSkipNullsInMultipleBookmarks() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldSkipNullsInMultipleBookmarks()
{
MapValue @params = @params(null, asList("neo4j:bookmark:v1:tx3", "neo4j:bookmark:v1:tx5", null, "neo4j:bookmark:v1:tx17"));
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
assertEquals(17, bookmark.TxId());
}
internal TruncatedQuerySnapshot(string fullQueryText, System.Func <ExecutionPlanDescription> queryPlanSupplier, MapValue queryParameters, long?elapsedTimeMicros, long?compilationTimeMicros, long?startTimestampMillis, int maxQueryTextLength)
{
this.FullQueryTextHash = fullQueryText.GetHashCode();
this.QueryText = TruncateQueryText(fullQueryText, maxQueryTextLength);
this.QueryPlanSupplier = queryPlanSupplier;
this.QueryParameters = TruncateParameters(queryParameters);
this.ElapsedTimeMicros = elapsedTimeMicros;
this.CompilationTimeMicros = compilationTimeMicros;
this.StartTimestampMillis = startTimestampMillis;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void read(org.neo4j.bolt.messaging.BoltResponseMessageWriter messageWriter) throws java.io.IOException
public virtual void Read(BoltResponseMessageWriter messageWriter)
{
try
{
_unpacker.unpackStructHeader();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int signature = (int) unpacker.unpackStructSignature();
int signature = ( int )_unpacker.unpackStructSignature();
BoltResponseMessage message = BoltResponseMessage.withSignature(signature);
try
{
switch (message.innerEnumValue)
{
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.SUCCESS:
MapValue successMetadata = _unpacker.unpackMap();
messageWriter.Write(new SuccessMessage(successMetadata));
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.RECORD:
long length = _unpacker.unpackListHeader();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.values.AnyValue[] fields = new org.neo4j.values.AnyValue[(int) length];
AnyValue[] fields = new AnyValue[( int )length];
for (int i = 0; i < length; i++)
{
fields[i] = _unpacker.unpack();
}
messageWriter.Write(new RecordMessage(record(fields)));
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.IGNORED:
messageWriter.Write(IgnoredMessage.IGNORED_MESSAGE);
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.FAILURE:
MapValue failureMetadata = _unpacker.unpackMap();
string code = failureMetadata.ContainsKey("code") ? (( StringValue )failureMetadata.Get("code")).stringValue() : Org.Neo4j.Kernel.Api.Exceptions.Status_General.UnknownError.name();
string msg = failureMetadata.ContainsKey("message") ? (( StringValue )failureMetadata.Get("message")).stringValue() : "<No message supplied>";
messageWriter.Write(new FailureMessage(Neo4jError.codeFromString(code), msg));
break;
default:
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Message 0x{0} is not supported.", signature.ToString("x")));
}
}
catch (System.ArgumentException)
{
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Message 0x{0} is not a valid message signature.", signature.ToString("x")));
}
}
catch (PackStream.PackStreamException e)
{
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Unable to read message type. Error was: {0}.", e.Message), e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.graphdb.Result profileQuery(String query, org.neo4j.values.virtual.MapValue parameters, org.neo4j.kernel.impl.query.TransactionalContext context) throws org.neo4j.kernel.impl.query.QueryExecutionKernelException
public override Result ProfileQuery(string query, MapValue parameters, TransactionalContext context)
{
try
{
return(_inner.execute(query, parameters, context, true));
}
catch (CypherException e)
{
throw new QueryExecutionKernelException(e);
}
}
public override Result ExecuteQuery(string query, MapValue parameters, TransactionalContext tc)
{
try
{
_availability.assertDatabaseAvailable();
return(_sourceModule.neoStoreDataSource.ExecutionEngine.executeQuery(query, parameters, tc));
}
catch (QueryExecutionKernelException e)
{
throw e.AsUserException();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldParseAndFormatSingleBookmarkContainingTransactionId() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldParseAndFormatSingleBookmarkContainingTransactionId()
{
// given
string expected = "neo4j:bookmark:v1:tx1234";
MapValue @params = SingletonMap("bookmark", expected);
// when
string actual = (new Bookmark(Bookmark.FromParamsOrNull(@params).txId())).ToString();
// then
assertEquals(expected, actual);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldFormatAndParseSingleBookmarkContainingTransactionId() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldFormatAndParseSingleBookmarkContainingTransactionId()
{
// given
long txId = 1234;
MapValue @params = SingletonMap("bookmark", (new Bookmark(txId)).ToString());
// when
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
// then
assertEquals(txId, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldHandleMaps()
internal virtual void ShouldHandleMaps()
{
// Given
PrettyPrinter printer = new PrettyPrinter();
MapValue mapValue = Props("k1", intValue(42));
// When
mapValue.WriteTo(printer);
// Then
assertThat(printer.Value(), equalTo("{k1: 42}"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldParseAndFormatMultipleBookmarkContainingTransactionId() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldParseAndFormatMultipleBookmarkContainingTransactionId()
{
// given
string txId1 = "neo4j:bookmark:v1:tx1234";
string txId2 = "neo4j:bookmark:v1:tx12345";
MapValue @params = SingletonMap("bookmarks", asList(txId1, txId2));
// when
string actual = (new Bookmark(Bookmark.FromParamsOrNull(@params).txId())).ToString();
// then
assertEquals(txId2, actual);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldFormatAndParseMultipleBookmarksContainingTransactionId() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldFormatAndParseMultipleBookmarksContainingTransactionId()
{
// given
long txId1 = 1234;
long txId2 = 12345;
MapValue @params = SingletonMap("bookmarks", asList((new Bookmark(txId1)).ToString(), (new Bookmark(txId2)).ToString()));
// when
Bookmark bookmark = Bookmark.FromParamsOrNull(@params);
// then
assertEquals(txId2, bookmark.TxId());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldEncodeSuccessMessage() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldEncodeSuccessMessage()
{
// Given
Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = mock(typeof(Org.Neo4j.Bolt.messaging.Neo4jPack_Packer));
SuccessMessageEncoder encoder = new SuccessMessageEncoder();
// When
MapValue meta = mock(typeof(MapValue));
encoder.Encode(packer, new SuccessMessage(meta));
// Then
verify(packer).packStructHeader(anyInt(), eq(SuccessMessage.SIGNATURE));
verify(packer).pack(meta);
}
private static MapValue TruncateParameters(MapValue parameters)
{
string[] keys = new string[parameters.Size()];
AnyValue[] values = new AnyValue[keys.Length];
int i = 0;
foreach (string key in parameters.Keys)
{
keys[i] = key.Length <= _maxParameterKeyLength ? key : key.Substring(0, _maxParameterKeyLength);
values[i] = parameters.Get(key).map(_valueTruncater);
i++;
}
return(VirtualValues.map(keys, values));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldWriteSuccessMessage() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldWriteSuccessMessage()
{
PackOutput output = mock(typeof(PackOutput));
Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = mock(typeof(Org.Neo4j.Bolt.messaging.Neo4jPack_Packer));
BoltResponseMessageWriterV1 writer = NewWriter(output, packer);
MapValue metadata = map(new string[] { "a", "b", "c" }, new AnyValue[] { intValue(1), stringValue("2"), date(2010, 0x2, 0x2) });
writer.Write(new SuccessMessage(metadata));
InOrder inOrder = inOrder(output, packer);
inOrder.verify(output).beginMessage();
inOrder.verify(packer).pack(metadata);
inOrder.verify(output).messageSucceeded();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldConvertValuesWithVirtualEntities()
public virtual void ShouldConvertValuesWithVirtualEntities()
{
// Given
ListValue nodeList = VirtualValues.list(NodeProxyValue, DirectNodeValue, NodeReference);
ListValue expectedNodeList = VirtualValues.list(NodeProxyValue, DirectNodeValue, NodeProxyValue);
ListValue relationshipList = VirtualValues.list(RelationshipProxyValue, DirectRelationshipValue, RelationshipReference);
ListValue expectedRelationshipList = VirtualValues.list(RelationshipProxyValue, DirectRelationshipValue, RelationshipProxyValue);
MapValue nodeMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { NodeProxyValue, DirectNodeValue, NodeReference });
MapValue expectedNodeMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { NodeProxyValue, DirectNodeValue, NodeProxyValue });
MapValue relationshipMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { RelationshipProxyValue, DirectRelationshipValue, RelationshipReference });
MapValue expectedRelationshipMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { RelationshipProxyValue, DirectRelationshipValue, RelationshipProxyValue });
ListValue nestedNodeList = VirtualValues.list(nodeList, nodeMap, NodeReference);
ListValue expectedNestedNodeList = VirtualValues.list(expectedNodeList, expectedNodeMap, NodeProxyValue);
ListValue nestedRelationshipList = VirtualValues.list(relationshipList, relationshipMap, RelationshipReference);
ListValue expectedNestedRelationshipList = VirtualValues.list(expectedRelationshipList, expectedRelationshipMap, RelationshipProxyValue);
MapValue nestedNodeMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { nodeList, nodeMap, nestedNodeList });
MapValue expectedNestedNodeMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { expectedNodeList, expectedNodeMap, expectedNestedNodeList });
MapValue nestedRelationshipMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { relationshipList, relationshipMap, nestedRelationshipList });
MapValue expectedNestedRelationshipMap = VirtualValues.map(new string[] { "a", "b", "c" }, new AnyValue[] { expectedRelationshipList, expectedRelationshipMap, expectedNestedRelationshipList });
// Verify
VerifyConvertsValue(expectedNodeList, nodeList);
VerifyConvertsValue(expectedRelationshipList, relationshipList);
VerifyConvertsValue(expectedNodeMap, nodeMap);
VerifyConvertsValue(expectedRelationshipMap, relationshipMap);
VerifyConvertsValue(expectedNestedNodeList, nestedNodeList);
VerifyConvertsValue(expectedNestedRelationshipList, nestedRelationshipList);
VerifyConvertsValue(expectedNestedNodeMap, nestedNodeMap);
VerifyConvertsValue(expectedNestedRelationshipMap, nestedRelationshipMap);
}
internal RelationshipReference RelationshipReference = VirtualValues.relationship(11L); // Should equal relationshipProxyValue when converted
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotTouchValuesThatDoNotNeedConversion()
public virtual void ShouldNotTouchValuesThatDoNotNeedConversion()
{
// Given
ListValue nodeList = VirtualValues.list(NodeProxyValue, DirectNodeValue);
ListValue relationshipList = VirtualValues.list(RelationshipProxyValue, DirectRelationshipValue);
MapValue nodeMap = VirtualValues.map(new string[] { "a", "b" }, new AnyValue[] { NodeProxyValue, DirectNodeValue });
MapValue relationshipMap = VirtualValues.map(new string[] { "a", "b" }, new AnyValue[] { RelationshipProxyValue, DirectRelationshipValue });
// Verify
VerifyDoesNotTouchValue(NodeProxyValue);
VerifyDoesNotTouchValue(RelationshipProxyValue);
VerifyDoesNotTouchValue(DirectNodeValue);
VerifyDoesNotTouchValue(DirectRelationshipValue);
VerifyDoesNotTouchValue(nodeList);
VerifyDoesNotTouchValue(relationshipList);
VerifyDoesNotTouchValue(nodeMap);
VerifyDoesNotTouchValue(relationshipMap);
// This is not an exhaustive test since the other cases are very uninteresting...
VerifyDoesNotTouchValue(Values.booleanValue(false));
VerifyDoesNotTouchValue(Values.stringValue("Hello"));
VerifyDoesNotTouchValue(Values.longValue(42L));
// ...
}
protected internal override BoltResultHandle NewBoltResultHandle(string statement, MapValue @params, TransactionalContext transactionalContext)
{
return(new BoltResultHandleV3(this, statement, @params, transactionalContext));
}
protected internal override LocalTimeValue Truncate(TemporalUnit unit, TemporalValue input, MapValue fields, System.Func <ZoneId> defaultZone)
{
return(LocalTimeValue.truncate(unit, input, fields, defaultZone));
}
protected internal override LocalTimeValue Build(MapValue map, System.Func <ZoneId> defaultZone)
{
return(LocalTimeValue.build(map, defaultZone));
}
internal BoltResultHandleV3(TransactionStateMachineV3SPI outerInstance, string statement, MapValue @params, TransactionalContext transactionalContext) : base(outerInstance, statement, @params, transactionalContext)
{
this._outerInstance = outerInstance;
}
public Org.Neo4j.Graphdb.Result ProfileQuery(string query, [email protected] parameter, TransactionalContext context) { throw NoQueryEngineConflict(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: abstract State run(MutableTransactionState ctx, org.neo4j.bolt.runtime.TransactionStateMachineSPI spi, String statement, org.neo4j.values.virtual.MapValue params, org.neo4j.bolt.v1.runtime.bookmarking.Bookmark bookmark, java.time.Duration txTimeout, java.util.Map<String,Object> txMetadata) throws org.neo4j.internal.kernel.api.exceptions.KernelException;
internal abstract State run(MutableTransactionState ctx, Org.Neo4j.Bolt.runtime.TransactionStateMachineSPI spi, string statement, [email protected] @params, Org.Neo4j.Bolt.v1.runtime.bookmarking.Bookmark bookmark, java.time.Duration txTimeout, IDictionary <string, object> txMetadata);
