Example #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldThrowOnUnpackingMapWithDuplicateKeys() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldThrowOnUnpackingMapWithDuplicateKeys()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.PackMapHeader(2);
            packer.Pack("key");
            packer.pack(intValue(1));
            packer.Pack("key");
            packer.pack(intValue(2));

            // When
            try
            {
                PackedInputArray input = new PackedInputArray(output.Bytes());
                Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input);
                unpacker.Unpack();

                fail("exception expected");
            }
            catch (BoltIOException ex)
            {
                assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Duplicate map key `key`."), Neo4jError.from(ex));
            }
        }
Example #2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToPackAndUnpackMap() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldBeAbleToPackAndUnpackMap()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.PackMapHeader(ALICE.properties().size());
            ALICE.properties().@foreach((s, value) =>
            {
                try
                {
                    packer.pack(s);
                    packer.pack(value);
                }
                catch (IOException e)
                {
                    throw new UncheckedIOException(e);
                }
            });
            AnyValue unpacked = unpacked(output.Bytes());

            // Then
            assertThat(unpacked, instanceOf(typeof(MapValue)));
            MapValue unpackedMap = ( MapValue )unpacked;

            assertThat(unpackedMap, equalTo(ALICE.properties()));
        }
Example #3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldFailWhenTryingToPackAndUnpackMapContainingNullKeys() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldFailWhenTryingToPackAndUnpackMapContainingNullKeys()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);

            IDictionary <string, AnyValue> map = new Dictionary <string, AnyValue>();

            map[null]  = longValue(42L);
            map["foo"] = longValue(1337L);
            packer.PackMapHeader(map.Count);
            foreach (KeyValuePair <string, AnyValue> entry in map.SetOfKeyValuePairs())
            {
                packer.pack(entry.Key);
                packer.pack(entry.Value);
            }

            // When
            try
            {
                PackedInputArray input = new PackedInputArray(output.Bytes());
                Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input);
                unpacker.Unpack();

                fail("exception expected");
            }
            catch (BoltIOException ex)
            {
                assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Value `null` is not supported as key in maps, must be a non-nullable string."), Neo4jError.from(ex));
            }
        }
Example #4
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCallExternalErrorOnInitWithDuplicateKeys() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldCallExternalErrorOnInitWithDuplicateKeys()
        {
            BoltStateMachine          stateMachine = mock(typeof(BoltStateMachine));
            SynchronousBoltConnection connection   = new SynchronousBoltConnection(stateMachine);

            _channel = new EmbeddedChannel(NewDecoder(connection));

            // Generate INIT message with duplicate keys
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = PackerUnderTest.newPacker(@out);
            packer.PackStructHeader(2, InitMessage.SIGNATURE);
            packer.Pack("Test/User Agent 1.0");
            packer.PackMapHeader(3);
            packer.Pack("scheme");
            packer.Pack("basic");
            packer.Pack("principal");
            packer.Pack("user");
            packer.Pack("scheme");
            packer.Pack("password");

            _channel.writeInbound(Unpooled.wrappedBuffer(@out.Bytes()));
            _channel.finishAndReleaseAll();

            verify(stateMachine).handleExternalFailure(eq(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Duplicate map key `scheme`.")), any());
        }
Example #5
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] packed(org.neo4j.values.AnyValue object) throws java.io.IOException
        private sbyte[] Packed(AnyValue @object)
        {
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.Pack(@object);
            return(output.Bytes());
        }
Example #6
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] packMessageWithSignature(byte signature) throws java.io.IOException
        private sbyte[] PackMessageWithSignature(sbyte signature)
        {
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = PackerUnderTest.newPacker(@out);
            packer.PackStructHeader(2, signature);
            packer.Pack("RETURN 'Hello World!'");
            packer.pack(EMPTY_MAP);
            return(@out.Bytes());
        }
Example #7
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] beginMessage(java.util.Map<String,Object> metadata) throws java.io.IOException
        private sbyte[] BeginMessage(IDictionary <string, object> metadata)
        {
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = Util.Neo4jPack.newPacker(@out);

            packer.PackStructHeader(1, BeginMessage.SIGNATURE);
            packer.pack(asMapValue(metadata));

            return(@out.Bytes());
        }
Example #8
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTreatCharArrayAsListOfStrings() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldTreatCharArrayAsListOfStrings()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.pack(charArray(new char[] { 'W', 'H', 'Y' }));
            object unpacked = unpacked(output.Bytes());

            // Then
            assertThat(unpacked, instanceOf(typeof(ListValue)));
            assertThat(unpacked, equalTo(VirtualValues.list(stringValue("W"), stringValue("H"), stringValue("Y"))));
        }
Example #9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTreatSingleCharAsSingleCharacterString() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldTreatSingleCharAsSingleCharacterString()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.pack(charValue('C'));
            AnyValue unpacked = unpacked(output.Bytes());

            // Then
            assertThat(unpacked, instanceOf(typeof(TextValue)));
            assertThat(unpacked, equalTo(stringValue("C")));
        }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] createRunWith(org.neo4j.function.ThrowingConsumer<org.neo4j.bolt.messaging.Neo4jPack_Packer, java.io.IOException> valuePacker) throws java.io.IOException
        private sbyte[] CreateRunWith(ThrowingConsumer <Org.Neo4j.Bolt.messaging.Neo4jPack_Packer, IOException> valuePacker)
        {
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = (new Neo4jPackV2()).newPacker(@out);

            packer.PackStructHeader(2, RunMessage.SIGNATURE);
            packer.Pack("RETURN $x");
            packer.PackMapHeader(1);
            packer.Pack("x");
            valuePacker.Accept(packer);

            return(@out.Bytes());
        }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] createRunWithV2Value(org.neo4j.values.AnyValue value) throws java.io.IOException
        private sbyte[] CreateRunWithV2Value(AnyValue value)
        {
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = (new Neo4jPackV2()).newPacker(@out);

            packer.PackStructHeader(2, RunMessage.SIGNATURE);
            packer.Pack("RETURN $x");
            packer.PackMapHeader(1);
            packer.Pack("x");
            packer.Pack(value);

            return(@out.Bytes());
        }
Example #12
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPackUtf8() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldPackUtf8()
        {
            // Given
            string value = "\uD83D\uDE31";

            sbyte[]           bytes     = value.GetBytes(Encoding.UTF8);
            TextValue         textValue = utf8Value(bytes, 0, bytes.Length);
            PackedOutputArray output    = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.pack(textValue);

            // When
            AnyValue unpacked = unpacked(output.Bytes());

            assertThat(unpacked, @is(instanceOf(typeof(UTF8StringValue))));

            // Then
            assertThat(unpacked, equalTo(textValue));
        }
Example #13
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldThrowOnUnknownStructType() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldThrowOnUnknownStructType()
        {
            PackedOutputArray @out = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = PackerUnderTest.newPacker(@out);
            packer.PackStructHeader(2, RunMessage.SIGNATURE);
            packer.Pack("RETURN $x");
            packer.PackMapHeader(1);
            packer.Pack("x");
            packer.PackStructHeader(0, ( sbyte )'A');

            try
            {
                Unpack(@out.Bytes());
            }
            catch (BoltIOException ex)
            {
                assertThat(ex.Message, equalTo("Struct types of 0x41 are not recognized."));
            }
        }
Example #14
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBeAbleToUnpackUnboundRelationship() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldNotBeAbleToUnpackUnboundRelationship()
        {
            // Given
            PackedOutputArray @out = new PackedOutputArray();

            Neo4jPackV1.Packer packer = _neo4jPack.newPacker(@out);

            packer.packStructHeader(3, UNBOUND_RELATIONSHIP);
            packer.pack(ValueUtils.of(1L));
            packer.pack(ValueUtils.of("RELATES_TO"));
            packer.pack(ValueUtils.asMapValue(MapUtil.map("a", 1L, "b", "x")));

            try
            {
                // When
                Unpacked(@out.Bytes());
                fail("exception expected.");
            }
            catch (BoltIOException ex)
            {
                assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, "Relationship values cannot be unpacked with this version of bolt."), Neo4jError.from(ex));
            }
        }
Example #15
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldThrowOnUnpackingMapWithUnsupportedKeyType() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldThrowOnUnpackingMapWithUnsupportedKeyType()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.PackMapHeader(2);
            packer.Pack(ValueUtils.of(1L));
            packer.pack(intValue(1));

            // When
            try
            {
                PackedInputArray input = new PackedInputArray(output.Bytes());
                Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input);
                unpacker.Unpack();

                fail("exception expected");
            }
            catch (BoltIOException ex)
            {
                assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, "Bad key type: INTEGER"), Neo4jError.from(ex));
            }
        }
Example #16
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToPackAndUnpackList() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldBeAbleToPackAndUnpackList()
        {
            // Given
            PackedOutputArray output = new PackedOutputArray();

            Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output);
            packer.PackListHeader(ALICE.labels().length());
            IList <string> expected = new List <string>();
            TextArray      labels   = ALICE.labels();

            for (int i = 0; i < labels.Length(); i++)
            {
                string labelName = labels.StringValue(i);
                packer.Pack(labelName);
                expected.Add(labelName);
            }
            AnyValue unpacked = unpacked(output.Bytes());

            // Then
            assertThat(unpacked, instanceOf(typeof(ListValue)));
            ListValue unpackedList = ( ListValue )unpacked;

            assertThat(unpackedList, equalTo(ValueUtils.asListValue(expected)));
        }