//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldPackUnpackBytesHeaderWithCorrectBufferSize() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldPackUnpackBytesHeaderWithCorrectBufferSize() { Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); MachineClient client = new MachineClient(8); PackStream.Unpacker unpacker = client.Unpacker(); for (int size = 0; size <= 65536; size++) { machine.Reset(); packer.PackBytesHeader(size); packer.Flush(); // Then int bufferSize = ComputeOutputBufferSize(size, false); sbyte[] output = machine.Output(); assertThat(output.Length, equalTo(bufferSize)); client.Reset(output); int value = unpacker.UnpackBytesHeader(); assertThat(value, equalTo(size)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackListStream() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackListStream() { // Given Machine machine = new Machine(); // When PackStream.Packer packer = machine.Packer(); packer.PackListStreamHeader(); packer.Pack("eins"); packer.Pack("zwei"); packer.Pack("drei"); packer.PackEndOfStream(); packer.Flush(); PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then assertThat(unpacker.UnpackListHeader(), equalTo(PackStream.UNKNOWN_SIZE)); assertThat(unpacker.UnpackString(), equalTo("eins")); assertThat(unpacker.UnpackString(), equalTo("zwei")); assertThat(unpacker.UnpackString(), equalTo("drei")); unpacker.UnpackEndOfStream(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void handlesDataCrossingBufferBoundaries() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void HandlesDataCrossingBufferBoundaries() { // Given Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); packer.pack(long.MaxValue); packer.pack(long.MaxValue); packer.Flush(); ReadableByteChannel ch = Channels.newChannel(new MemoryStream(machine.Output())); PackStream.Unpacker unpacker = new PackStream.Unpacker((new BufferedChannelInput(11)).Reset(ch)); // Serialized ch will look like, and misalign with the 11-byte unpack buffer: // [XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX][XX] // mkr \___________data______________/ mkr \___________data______________/ // \____________unpack buffer_________________/ // When long first = unpacker.UnpackLong(); long second = unpacker.UnpackLong(); // Then assertEquals(long.MaxValue, first); assertEquals(long.MaxValue, second); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackMapStream() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackMapStream() { // Given Machine machine = new Machine(); // When PackStream.Packer packer = machine.Packer(); packer.PackMapStreamHeader(); packer.Pack("one"); packer.pack(1); packer.Pack("two"); packer.pack(2); packer.PackEndOfStream(); packer.Flush(); PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then assertThat(unpacker.UnpackMapHeader(), equalTo(PackStream.UNKNOWN_SIZE)); assertThat(unpacker.UnpackString(), equalTo("one")); assertThat(unpacker.UnpackLong(), equalTo(1L)); assertThat(unpacker.UnpackString(), equalTo("two")); assertThat(unpacker.UnpackLong(), equalTo(2L)); unpacker.UnpackEndOfStream(); }
internal MachineClient(int capacity) { Readable = new ResetableReadableByteChannel(); BufferedChannelInput input = (new BufferedChannelInput(capacity)).Reset(Readable); UnpackerConflict = new PackStream.Unpacker(input); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldPackUnpackHeaderWithCorrectBufferSize(PackType type) throws Throwable private void ShouldPackUnpackHeaderWithCorrectBufferSize(PackType type) { Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); MachineClient client = new MachineClient(8); PackStream.Unpacker unpacker = client.Unpacker(); for (int size = 0; size <= 65536; size++) { machine.Reset(); switch (type) { case Org.Neo4j.Bolt.v1.packstream.PackType.Map: packer.PackMapHeader(size); break; case Org.Neo4j.Bolt.v1.packstream.PackType.List: packer.PackListHeader(size); break; case Org.Neo4j.Bolt.v1.packstream.PackType.String: packer.PackStringHeader(size); break; default: throw new System.ArgumentException("Unsupported type: " + type + "."); } packer.Flush(); int bufferSize = ComputeOutputBufferSize(size, true); sbyte[] output = machine.Output(); assertThat(output.Length, equalTo(bufferSize)); client.Reset(output); int value = 0; switch (type) { case Org.Neo4j.Bolt.v1.packstream.PackType.Map: value = ( int )unpacker.UnpackMapHeader(); break; case Org.Neo4j.Bolt.v1.packstream.PackType.List: value = ( int )unpacker.UnpackListHeader(); break; case Org.Neo4j.Bolt.v1.packstream.PackType.String: value = unpacker.UnpackStringHeader(); break; default: throw new System.ArgumentException("Unsupported type: " + type + "."); } assertThat(value, equalTo(size)); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void unpackHeaderSizeGreaterThanIntMaxValue(PackType type) throws Throwable private void UnpackHeaderSizeGreaterThanIntMaxValue(PackType type) { sbyte marker32; switch (type) { case Org.Neo4j.Bolt.v1.packstream.PackType.Map: marker32 = PackStream.Map_32; break; case Org.Neo4j.Bolt.v1.packstream.PackType.List: marker32 = PackStream.List_32; break; case Org.Neo4j.Bolt.v1.packstream.PackType.String: marker32 = PackStream.String_32; break; case Org.Neo4j.Bolt.v1.packstream.PackType.Bytes: marker32 = PackStream.Bytes_32; break; default: throw new System.ArgumentException("Unsupported type: " + type + "."); } sbyte[] input = new sbyte[] { marker32, unchecked (( sbyte )0xff), unchecked (( sbyte )0xff), unchecked (( sbyte )0xff), unchecked (( sbyte )0xff) }; MachineClient client = new MachineClient(8); client.Reset(input); PackStream.Unpacker unpacker = client.Unpacker(); switch (type) { case Org.Neo4j.Bolt.v1.packstream.PackType.Map: unpacker.UnpackMapHeader(); break; case Org.Neo4j.Bolt.v1.packstream.PackType.List: unpacker.UnpackListHeader(); break; case Org.Neo4j.Bolt.v1.packstream.PackType.String: unpacker.UnpackStringHeader(); break; case Org.Neo4j.Bolt.v1.packstream.PackType.Bytes: unpacker.UnpackBytesHeader(); break; default: throw new System.ArgumentException("Unsupported type: " + type + "."); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertPeekType(PackType type, Object value) throws java.io.IOException private void AssertPeekType(PackType type, object value) { // Given Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); DoTheThing(packer, value); packer.Flush(); PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // When & Then assertEquals(type, unpacker.PeekNextType()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackFalse() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackFalse() { // Given Machine machine = new Machine(); // When machine.Packer().pack(false); machine.Packer().flush(); // Then sbyte[] bytes = machine.Output(); assertThat(bytes, equalTo(new sbyte[] { unchecked (( sbyte )0xC2) })); // When PackStream.Unpacker unpacker = NewUnpacker(bytes); // Then assertThat(unpacker.UnpackBoolean(), equalTo(false)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackNull() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackNull() { // Given Machine machine = new Machine(); // When machine.Packer().packNull(); machine.Packer().flush(); // Then sbyte[] bytes = machine.Output(); assertThat(bytes, equalTo(new sbyte[] { unchecked (( sbyte )0xC0) })); // When PackStream.Unpacker unpacker = NewUnpacker(bytes); unpacker.UnpackNull(); // Then // it does not blow up }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackListOneItemAtATime() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackListOneItemAtATime() { // Given Machine machine = new Machine(); // When PackStream.Packer packer = machine.Packer(); packer.PackListHeader(3); packer.pack(12); packer.pack(13); packer.pack(14); packer.Flush(); PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then assertThat(unpacker.UnpackListHeader(), equalTo(3L)); assertThat(unpacker.UnpackLong(), equalTo(12L)); assertThat(unpacker.UnpackLong(), equalTo(13L)); assertThat(unpacker.UnpackLong(), equalTo(14L)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanDoStreamingStructUnpacking() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanDoStreamingStructUnpacking() { // Given Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); packer.PackStructHeader(4, ( sbyte )'~'); packer.pack(1); packer.pack(2); packer.pack(3); packer.PackListHeader(2); packer.pack(4); packer.pack(5); packer.Flush(); // When I unpack this value PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then I can do streaming unpacking long size = unpacker.UnpackStructHeader(); char signature = unpacker.UnpackStructSignature(); long a = unpacker.UnpackLong(); long b = unpacker.UnpackLong(); long c = unpacker.UnpackLong(); long innerSize = unpacker.UnpackListHeader(); long d = unpacker.UnpackLong(); long e = unpacker.UnpackLong(); // And all the values should be sane assertEquals(4, size); assertEquals('~', signature); assertEquals(2, innerSize); assertEquals(1, a); assertEquals(2, b); assertEquals(3, c); assertEquals(4, d); assertEquals(5, e); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackShortIntegers() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackShortIntegers() { // Given Machine machine = new Machine(); for (long i = -32768; i < 32768; i++) { // When machine.Reset(); machine.Packer().pack(i); machine.Packer().flush(); // Then sbyte[] bytes = machine.Output(); assertThat(bytes.Length, lessThanOrEqualTo(3)); // When PackStream.Unpacker unpacker = NewUnpacker(bytes); // Then assertThat(unpacker.UnpackLong(), equalTo(i)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanDoStreamingMapUnpacking() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanDoStreamingMapUnpacking() { // Given Machine machine = new Machine(); PackStream.Packer packer = machine.Packer(); packer.PackMapHeader(2); packer.Pack("name"); packer.Pack("Bob"); packer.Pack("cat_ages"); packer.PackListHeader(2); packer.Pack(4.3); packer.Pack(true); packer.Flush(); // When I unpack this value PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then I can do streaming unpacking long size = unpacker.UnpackMapHeader(); string k1 = unpacker.UnpackString(); string v1 = unpacker.UnpackString(); string k2 = unpacker.UnpackString(); long innerSize = unpacker.UnpackListHeader(); double d = unpacker.UnpackDouble(); bool e = unpacker.UnpackBoolean(); // And all the values should be sane assertEquals(2, size); assertEquals(2, innerSize); assertEquals("name", k1); assertEquals("Bob", v1); assertEquals("cat_ages", k2); assertEquals(4.3, d, 0.0001); assertTrue(e); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void testCanPackAndUnpackStruct() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TestCanPackAndUnpackStruct() { // Given Machine machine = new Machine(); // When PackStream.Packer packer = machine.Packer(); packer.PackStructHeader(3, ( sbyte )'N'); packer.pack(12); packer.PackListHeader(2); packer.Pack("Person"); packer.Pack("Employee"); packer.PackMapHeader(2); packer.Pack("name"); packer.Pack("Alice"); packer.Pack("age"); packer.pack(33); packer.Flush(); PackStream.Unpacker unpacker = NewUnpacker(machine.Output()); // Then assertThat(unpacker.UnpackStructHeader(), equalTo(3L)); assertThat(unpacker.UnpackStructSignature(), equalTo('N')); assertThat(unpacker.UnpackLong(), equalTo(12L)); assertThat(unpacker.UnpackListHeader(), equalTo(2L)); assertThat(unpacker.UnpackString(), equalTo("Person")); assertThat(unpacker.UnpackString(), equalTo("Employee")); assertThat(unpacker.UnpackMapHeader(), equalTo(2L)); assertThat(unpacker.UnpackString(), equalTo("name")); assertThat(unpacker.UnpackString(), equalTo("Alice")); assertThat(unpacker.UnpackString(), equalTo("age")); assertThat(unpacker.UnpackLong(), equalTo(33L)); }