/// <summary> /// Convert value represented by type and raw bits to corresponding <seealso cref="NumberValue"/>. If type is not <seealso cref="BYTE"/>, <seealso cref="SHORT"/>, /// <seealso cref="INT"/>, <seealso cref="LONG"/>, <seealso cref="FLOAT"/> or <seealso cref="DOUBLE"/>, the raw bits will be interpreted as a long. /// </summary> /// <param name="rawBits"> Raw bits of value </param> /// <param name="type"> Type of value </param> /// <returns> <seealso cref="NumberValue"/> with type and value given by provided raw bits and type. </returns> internal static NumberValue AsNumberValue(long rawBits, sbyte type) { switch (type) { case BYTE: return(Values.byteValue(( sbyte )rawBits)); case SHORT: return(Values.shortValue(( short )rawBits)); case INT: return(Values.intValue(( int )rawBits)); case LONG: return(Values.longValue(rawBits)); case FLOAT: return(Values.floatValue(Float.intBitsToFloat(( int )rawBits))); case DOUBLE: return(Values.doubleValue(Double.longBitsToDouble(rawBits))); default: // If type is not recognized, interpret as long. return(Values.longValue(rawBits)); } }
private TextValue String(RecordPropertyCursor cursor, long reference, PageCursor page) { ByteBuffer buffer = cursor.Buffer = _read.loadString(reference, cursor.Buffer, page); buffer.flip(); return(Values.stringValue(UTF8.decode(buffer.array(), 0, buffer.limit()))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void roundingErrorsFromLongToDoubleShouldNotPreventTxFromCommitting() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void RoundingErrorsFromLongToDoubleShouldNotPreventTxFromCommitting() { // Given // a node with a constrained label and a long value long propertyValue = 285414114323346805L; long firstNode = ConstrainedNode("label1", "key1", propertyValue); Transaction transaction = NewTransaction(AnonymousContext.writeToken()); long node = CreateLabeledNode(transaction, "label1"); assertNotEquals(firstNode, node); // When // a new node with the same constraint is added, with a value not equal but which would be mapped to the same double propertyValue++; // note how propertyValue is definitely not equal to propertyValue++ but they do equal if they are cast to double int propertyKeyId = transaction.TokenWrite().propertyKeyGetOrCreateForName("key1"); transaction.DataWrite().nodeSetProperty(node, propertyKeyId, Values.of(propertyValue)); // Then // the commit should still succeed Commit(); }
public override AnyValue MapText(TextValue value) { if (value.Length() > _maxTextParameterLength) { return(Values.stringValue(value.StringValue().Substring(0, _maxTextParameterLength))); } return(value); }
private void AssertCanEncodeAndDecodeToSameValue(object value, int payloadSize) { PropertyBlock target = new PropertyBlock(); bool encoded = ShortArray.encode(0, value, target, payloadSize); assertTrue(encoded); assertEquals(Values.of(value), ShortArray.decode(target)); }
protected internal override Value AssertCorrectType(Value value) { if (!Values.isGeometryValue(value)) { throw new System.ArgumentException("Key layout does only support geometries, tried to create key from " + value); } return(value); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long createLabeledNode(org.neo4j.internal.kernel.api.Transaction transaction, String label, String key, Object value) throws org.neo4j.internal.kernel.api.exceptions.KernelException private long CreateLabeledNode(Transaction transaction, string label, string key, object value) { long node = CreateLabeledNode(transaction, label); int propertyKeyId = transaction.TokenWrite().propertyKeyGetOrCreateForName(key); transaction.DataWrite().nodeSetProperty(node, propertyKeyId, Values.of(value)); return(node); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: long createEntity(org.neo4j.internal.kernel.api.Transaction transaction, String type, String property, String value) throws Exception internal override long CreateEntity(Transaction transaction, string type, string property, string value) { long node = CreateEntity(transaction, type); int propertyKey = transaction.TokenWrite().propertyKeyGetOrCreateForName(property); transaction.DataWrite().nodeSetProperty(node, propertyKey, Values.of(value)); return(node); }
public override void Validate(Value value) { _textValueValidator.validate(value); if (Values.isArrayValue(value)) { _textValueValidator.validate(ArrayEncoder.encode(value).GetBytes()); } }
// EXACT //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testExact() public virtual void TestExact() { AssertExactPredicate("string"); AssertExactPredicate(1); AssertExactPredicate(1.0); AssertExactPredicate(true); AssertExactPredicate(new long[] { 1L }); AssertExactPredicate(Values.pointValue(CoordinateReferenceSystem.WGS84, 12.3, 45.6)); }
private static Value[] ToValues(object[] objects) { Value[] values = new Value[objects.Length]; for (int i = 0; i < objects.Length; i++) { object @object = objects[i]; values[i] = @object is Value ? ( Value )@object : Values.of(@object); } return(values); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSpanMultiplePropertyRecords() public virtual void ShouldSpanMultiplePropertyRecords() { // given PropertyValueRecordSizeCalculator calculator = NewCalculator(); // when int size = calculator.ApplyAsInt(new Value[] { Values.of(10), Values.of("test"), Values.of(( sbyte )5), Values.of(String(80)), Values.of("a bit longer short string"), Values.of(1234567890123456789L), Values.of(5), Values.of("value") }); // then assertEquals(_propertyRecordSize * 3 + DYNAMIC_RECORD_SIZE, size); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotAddOrRemoveFromIndexForNonAutoIndexedProperty() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotAddOrRemoveFromIndexForNonAutoIndexedProperty() { // Given _index.startAutoIndexingProperty(_indexedPropertyName); // When _index.propertyChanged(_ops, 11, _nonIndexedProperty, Values.of("Goodbye!"), Values.of("Hello!")); // Then verifyZeroInteractions(_ops); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldIncludeDynamicRecordSizes() public virtual void ShouldIncludeDynamicRecordSizes() { // given PropertyValueRecordSizeCalculator calculator = NewCalculator(); // when int size = calculator.ApplyAsInt(new Value[] { Values.of(String(80)), Values.of(new string[] { String(150) }) }); // then assertEquals(_propertyRecordSize + DYNAMIC_RECORD_SIZE + DYNAMIC_RECORD_SIZE * 2, size); }
private LongValue ReadLong() { if (PropertyBlock.valueIsInlined(CurrentBlock())) { return(Values.longValue(( long )(( ulong )PropertyBlock.fetchLong(CurrentBlock()) >> 1))); } else { return(Values.longValue(Blocks[_block + 1])); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.neo4j.bolt.runtime.BoltStateMachineState processRunMessage(org.neo4j.bolt.v3.messaging.request.RunMessage message, org.neo4j.bolt.runtime.StateMachineContext context) throws org.neo4j.internal.kernel.api.exceptions.KernelException private BoltStateMachineState ProcessRunMessage(RunMessage message, StateMachineContext context) { long start = context.Clock().millis(); StatementProcessor statementProcessor = context.ConnectionState().StatementProcessor; StatementMetadata statementMetadata = statementProcessor.Run(message.Statement(), message.Params()); long end = context.Clock().millis(); context.ConnectionState().onMetadata(FIELDS_KEY, stringArray(statementMetadata.FieldNames())); context.ConnectionState().onMetadata(FIRST_RECORD_AVAILABLE_KEY, Values.longValue(end - start)); return(_streamingState); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldIgnoreInlinedUnchangedProperty() public virtual void ShouldIgnoreInlinedUnchangedProperty() { // GIVEN int key = 10; Value value = Values.of(12341); PropertyRecord before = PropertyRecord(Property(key, value)); PropertyRecord after = PropertyRecord(Property(key, value)); // WHEN assertThat(Convert(_none, _none, Change(before, after)), equalTo(EntityUpdates.ForEntity(0, false).build())); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldIncludePropertyRecordSize() public virtual void ShouldIncludePropertyRecordSize() { // given PropertyValueRecordSizeCalculator calculator = NewCalculator(); // when int size = calculator.ApplyAsInt(new Value[] { Values.of(10) }); // then assertEquals(PropertyRecordFormat.RECORD_SIZE, size); }
private void Encode(string @string) { PropertyBlock block = new PropertyBlock(); TextValue expectedValue = Values.stringValue(@string); _propertyStore.encodeValue(block, KEY_ID, expectedValue); assertEquals(0, block.ValueRecords.Count); Value readValue = block.Type.value(block, _propertyStore); assertEquals(expectedValue, readValue); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleBooleans() internal virtual void ShouldHandleBooleans() { // Given Value array = Values.booleanArray(new bool[] { true, false, true }); PrettyPrinter printer = new PrettyPrinter(); // When array.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("[true, false, true]")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleByteArrays() internal virtual void ShouldHandleByteArrays() { // Given Value array = Values.byteArray(new sbyte[] { 2, 3, 42 }); PrettyPrinter printer = new PrettyPrinter(); // When array.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("[2, 3, 42]")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleArrays() internal virtual void ShouldHandleArrays() { // Given PrettyPrinter printer = new PrettyPrinter(); TextArray array = Values.stringArray("a", "b", "c"); // When array.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("[\"a\", \"b\", \"c\"]")); }
public override void Validate(Value value) { if (value == null || value == Values.NO_VALUE) { throw new System.ArgumentException("Null value"); } if (Values.isTextValue(value) && (( TextValue )value).length() >= _checkThreshold) { int length = IndexKeyLength(value); ValidateLength(length); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandlePoints() internal virtual void ShouldHandlePoints() { // Given PointValue pointValue = Values.pointValue(CoordinateReferenceSystem.Cartesian, 11d, 12d); PrettyPrinter printer = new PrettyPrinter(); // When pointValue.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("{geometry: {type: \"Point\", coordinates: [11.0, 12.0], " + "crs: {type: link, properties: " + "{href: \"http://spatialreference.org/ref/sr-org/7203/\", code: " + "7203}}}}")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleNodeValue() internal virtual void ShouldHandleNodeValue() { // Given NodeValue node = VirtualValues.nodeValue(42L, Values.stringArray("L1", "L2", "L3"), Props("foo", intValue(42), "bar", list(intValue(1337), stringValue("baz")))); PrettyPrinter printer = new PrettyPrinter(); // When node.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("(id=42 :L1:L2:L3 {bar: [1337, \"baz\"], foo: 42})")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleNodeValueWithoutProperties() internal virtual void ShouldHandleNodeValueWithoutProperties() { // Given NodeValue node = VirtualValues.nodeValue(42L, Values.stringArray("L1", "L2", "L3"), EMPTY_MAP); PrettyPrinter printer = new PrettyPrinter(); // When node.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("(id=42 :L1:L2:L3)")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleEdgeValueWithoutLabelsNorProperties() internal virtual void ShouldHandleEdgeValueWithoutLabelsNorProperties() { // Given NodeValue node = VirtualValues.nodeValue(42L, Values.stringArray(), EMPTY_MAP); PrettyPrinter printer = new PrettyPrinter(); // When node.WriteTo(printer); // Then assertThat(printer.Value(), equalTo("(id=42)")); }
// EXISTS //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testExists() public virtual void TestExists() { ExistsPredicate p = IndexQuery.Exists(_propId); assertTrue(Test(p, "string")); assertTrue(Test(p, 1)); assertTrue(Test(p, 1.0)); assertTrue(Test(p, true)); assertTrue(Test(p, new long[] { 1L })); assertTrue(Test(p, Values.pointValue(CoordinateReferenceSystem.WGS84, 12.3, 45.6))); assertFalse(Test(p, null)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotReportConflictOnSameValueSameEntityId() throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotReportConflictOnSameValueSameEntityId() { // given Value value = Values.of(123); long entityId = 10; // when NativeIndexValue merged = _detector.merge(Key(entityId, value), Key(entityId, value), NativeIndexValue.Instance, NativeIndexValue.Instance); // then assertNull(merged); _detector.checkConflict(array()); // <-- should not throw conflict exception }
public static void AssertEqualsMaybeNull <T>(object o1, object o2, T entity, string key) where T : Org.Neo4j.Graphdb.PropertyContainer { string entityDescription = "For " + entity + " and " + key; if (o1 == null || o2 == null) { assertSame(entityDescription + ". " + Strings.prettyPrint(o1) + " != " + Strings.prettyPrint(o2), o1, o2); } else { assertEquals(entityDescription, Values.of(o1), Values.of(o2)); } }