//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSupportOpenSSLOnSupportedPlatforms() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSupportOpenSSLOnSupportedPlatforms() { // depends on the statically linked uber-jar with boring ssl: http://netty.io/wiki/forked-tomcat-native.html assumeTrue(SystemUtils.IS_OS_WINDOWS || SystemUtils.IS_OS_LINUX || SystemUtils.IS_OS_MAC_OSX); assumeThat(System.getProperty("os.arch"), equalTo("x86_64")); assumeThat(SystemUtils.JAVA_VENDOR, isOneOf("Oracle Corporation", "Sun Microsystems Inc.")); // given SslResource sslServerResource = selfSignedKeyId(0).trustKeyId(1).install(TestDir.directory("server")); SslResource sslClientResource = selfSignedKeyId(1).trustKeyId(0).install(TestDir.directory("client")); _server = new SecureServer(SslContextFactory.MakeSslPolicy(sslServerResource, SslProvider.OPENSSL)); _server.start(); _client = new SecureClient(SslContextFactory.MakeSslPolicy(sslClientResource, SslProvider.OPENSSL)); _client.connect(_server.port()); // when ByteBuf request = ByteBufAllocator.DEFAULT.buffer().writeBytes(_request); _client.channel().writeAndFlush(request); // then _expected = ByteBufAllocator.DEFAULT.buffer().writeBytes(SecureServer.Response); _client.sslHandshakeFuture().get(1, MINUTES); _client.assertResponse(_expected); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldProvideExpectedMetaData() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldProvideExpectedMetaData() { ChunkedInput <ByteBuf> replicatedContent = ChunkedReplicatedContent.Chunked(( sbyte )1, new ThreeChunks(this, -1, 8)); UnpooledByteBufAllocator allocator = UnpooledByteBufAllocator.DEFAULT; ByteBuf byteBuf = replicatedContent.readChunk(allocator); // is not last assertFalse(byteBuf.readBoolean()); // first chunk has content assertEquals(( sbyte )1, byteBuf.readByte()); byteBuf.release(); byteBuf = replicatedContent.readChunk(allocator); // is not last assertFalse(byteBuf.readBoolean()); byteBuf.release(); byteBuf = replicatedContent.readChunk(allocator); // is last assertTrue(byteBuf.readBoolean()); byteBuf.release(); assertNull(replicatedContent.readChunk(allocator)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void marshal(org.neo4j.storageengine.api.WritableChannel writableChannel, TransactionRepresentationReplicatedTransaction replicatedTransaction) throws java.io.IOException public static void Marshal(WritableChannel writableChannel, TransactionRepresentationReplicatedTransaction replicatedTransaction) { if (writableChannel is ByteBufBacked) { /* * Marshals more efficiently if Channel is going over the network. In practice, this means maintaining support for * RaftV1 without loosing performance */ ByteBuf buffer = (( ByteBufBacked )writableChannel).byteBuf(); int metaDataIndex = buffer.writerIndex(); int txStartIndex = metaDataIndex + Integer.BYTES; // leave room for length to be set later. buffer.writerIndex(txStartIndex); WriteTx(writableChannel, replicatedTransaction.Tx()); int txLength = buffer.writerIndex() - txStartIndex; buffer.setInt(metaDataIndex, txLength); } else { /* * Unknown length. This should only be reached in tests. When a ReplicatedTransaction is marshaled to file it has already passed over the network * and is of a different type. More efficient marshalling is used in ByteArrayReplicatedTransaction. */ MemoryStream outputStream = new MemoryStream(1024); OutputStreamWritableChannel outputStreamWritableChannel = new OutputStreamWritableChannel(outputStream); WriteTx(outputStreamWritableChannel, replicatedTransaction.Tx()); int length = outputStream.size(); writableChannel.PutInt(length); writableChannel.Put(outputStream.toByteArray(), length); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldThrowExceptionForHalfWrittenInstance() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldThrowExceptionForHalfWrittenInstance() { // given // a CoreMember and a ByteBuffer to write it to MemberId.Marshal marshal = new MemberId.Marshal(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.causalclustering.identity.MemberId aRealMember = new org.neo4j.causalclustering.identity.MemberId(java.util.UUID.randomUUID()); MemberId aRealMember = new MemberId(System.Guid.randomUUID()); ByteBuf buffer = Unpooled.buffer(1000); // and the CoreMember is serialized but for 5 bytes at the end marshal.MarshalConflict(aRealMember, new BoundedNetworkWritableChannel(buffer)); ByteBuf bufferWithMissingBytes = buffer.copy(0, buffer.writerIndex() - 5); // when try { marshal.Unmarshal(new NetworkReadableClosableChannelNetty4(bufferWithMissingBytes)); fail("Should have thrown exception"); } catch (EndOfStreamException) { // expected } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotCountBytesAlreadyInBuffer() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotCountBytesAlreadyInBuffer() { // Given int sizeLimit = 100; ByteBuf buffer = Unpooled.buffer(); int padding = Long.BYTES; buffer.writeLong(0); BoundedNetworkWritableChannel channel = new BoundedNetworkWritableChannel(buffer, sizeLimit); // When for (int i = 0; i < sizeLimit - padding; i++) { channel.Put(( sbyte )0); } // then it should be ok // again, when for (int i = 0; i < padding; i++) { channel.Put(( sbyte )0); } // then again, it should work // finally, when we pass the limit try { channel.Put(( sbyte )0); fail("Should not allow more bytes than what the limit dictates"); } catch (MessageTooBigException) { // then } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static byte[] chunk(int maxChunkSize, byte[][] messages) throws java.io.IOException public static sbyte[] Chunk(int maxChunkSize, sbyte[][] messages) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ByteBuffer outputBuffer = ByteBuffer.allocate(1024 * 8); ByteBuffer outputBuffer = ByteBuffer.allocate(1024 * 8); Channel ch = mock(typeof(Channel)); when(ch.alloc()).thenReturn(UnpooledByteBufAllocator.DEFAULT); when(ch.writeAndFlush(any(), Null)).then(inv => { ByteBuf buf = inv.getArgument(0); outputBuffer.limit(outputBuffer.position() + buf.readableBytes()); buf.readBytes(outputBuffer); buf.release(); return(null); }); int maxBufferSize = maxChunkSize + CHUNK_HEADER_SIZE; ChunkedOutput @out = new ChunkedOutput(ch, maxBufferSize, maxBufferSize, TransportThrottleGroup.NO_THROTTLE); foreach (sbyte[] message in messages) { @out.BeginMessage(); @out.WriteBytes(message, 0, message.Length); @out.MessageSucceeded(); } @out.Flush(); @out.Dispose(); sbyte[] bytes = new sbyte[outputBuffer.limit()]; outputBuffer.position(0); outputBuffer.get(bytes); return(bytes); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHandleHandshakeFollowedImmediatelyByMessage() public virtual void ShouldHandleHandshakeFollowedImmediatelyByMessage() { // Given BoltProtocol protocol = NewBoltProtocol(1); BoltProtocolFactory handlerFactory = NewProtocolFactory(1, protocol); EmbeddedChannel channel = new EmbeddedChannel(new ProtocolHandshaker(handlerFactory, _boltChannel, _logProvider, false, true)); // When ByteBuf input = Unpooled.wrappedBuffer(new sbyte[] { ( sbyte )0x60, ( sbyte )0x60, unchecked (( sbyte )0xB0), ( sbyte )0x17 }, new sbyte[] { 0, 0, 0, 0 }, new sbyte[] { 0, 0, 0, 1 }, new sbyte[] { 0, 0, 0, 0 }, new sbyte[] { 0, 0, 0, 0 }, new sbyte[] { 1, 2, 3, 4 }); // this is a message channel.writeInbound(input); // Then assertEquals(1, channel.outboundMessages().size()); assertByteBufEquals(Unpooled.buffer().writeInt(1), channel.readOutbound()); assertEquals(1, channel.inboundMessages().size()); assertByteBufEquals(Unpooled.wrappedBuffer(new sbyte[] { 1, 2, 3, 4 }), channel.readInbound()); Thrown.expect(typeof(NoSuchElementException)); channel.pipeline().remove(typeof(ProtocolHandshaker)); assertTrue(channel.Active); verify(protocol).install(); }
private static void ReleaseIfPossible(ByteBuf buf) { if (buf.refCnt() > 0) { buf.release(); } }
private static void SendToChannel(GetIndexFilesRequest expectedIndexSnapshotRequest, EmbeddedChannel embeddedChannel) { embeddedChannel.writeOutbound(expectedIndexSnapshotRequest); ByteBuf @object = embeddedChannel.readOutbound(); embeddedChannel.writeInbound(@object); }
public static ReplicatedTransaction Decode(ByteBuf byteBuf) { int length = byteBuf.readableBytes(); sbyte[] bytes = new sbyte[length]; byteBuf.readBytes(bytes); return(ReplicatedTransaction.from(bytes)); }
private static void SendToChannel(PrepareStoreCopyResponse prepareStoreCopyResponse, EmbeddedChannel embeddedChannel) { embeddedChannel.writeOutbound(prepareStoreCopyResponse); ByteBuf @object = embeddedChannel.readOutbound(); embeddedChannel.writeInbound(@object); }
public static DummyRequest Decode(ByteBuf byteBuf) { int length = byteBuf.readableBytes(); sbyte[] array = new sbyte[length]; byteBuf.readBytes(array); return(new DummyRequest(array)); }
public static void SendToChannel <E>(E e, EmbeddedChannel embeddedChannel) { embeddedChannel.writeOutbound(e); ByteBuf @object = embeddedChannel.readOutbound(); embeddedChannel.writeInbound(@object); }
private static void SendToChannel(GetStoreFileRequest getStoreFileRequest, EmbeddedChannel embeddedChannel) { embeddedChannel.writeOutbound(getStoreFileRequest); ByteBuf @object = embeddedChannel.readOutbound(); embeddedChannel.writeInbound(@object); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void encode(io.netty.buffer.ByteBuf buffer, io.netty.handler.stream.ChunkedInput<io.netty.buffer.ByteBuf> marshal) throws Exception private static void Encode(ByteBuf buffer, ChunkedInput <ByteBuf> marshal) { while (!marshal.EndOfInput) { ByteBuf tmp = marshal.readChunk(UnpooledByteBufAllocator.DEFAULT); if (tmp != null) { buffer.writeBytes(tmp); tmp.release(); } } }
public static void AssertByteBufEquals(ByteBuf expected, ByteBuf actual) { try { assertEquals(expected, actual); } finally { ReleaseIfPossible(expected); ReleaseIfPossible(actual); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDecodeEmptyChunk() public virtual void ShouldDecodeEmptyChunk() { // chunk contains just the size header which is zero ByteBuf input = copyShort(0); assertTrue(_channel.writeInbound(input)); assertTrue(_channel.finish()); // there should only be a single chunk available for reading assertEquals(1, _channel.inboundMessages().size()); // it should have no size header and empty body assertByteBufEquals(wrappedBuffer(new sbyte[0]), _channel.readInbound()); }
public static void Marshal(ByteBuf buffer, string @string) { if (string.ReferenceEquals(@string, null)) { buffer.writeInt(NULL_STRING_LENGTH); } else { sbyte[] bytes = @string.GetBytes(UTF_8); buffer.writeInt(bytes.Length); buffer.writeBytes(bytes); } }
internal static ByteBuf SerializeTerms(RaftLogEntry[] raftLogEntries, ByteBufAllocator byteBufAllocator) { int capacity = (sizeof(sbyte) * 8) + (sizeof(int) * 8) + (sizeof(long) * 8) * raftLogEntries.Length; ByteBuf buffer = byteBufAllocator.buffer(capacity, capacity); buffer.writeByte(ContentType.RaftLogEntryTerms.get()); buffer.writeInt(raftLogEntries.Length); foreach (RaftLogEntry raftLogEntry in raftLogEntries) { buffer.writeLong(raftLogEntry.Term()); } return(buffer); }
public static string Unmarshal(ByteBuf buffer) { int len = buffer.readInt(); if (len == NULL_STRING_LENGTH) { return(null); } sbyte[] bytes = new sbyte[len]; buffer.readBytes(bytes); return(StringHelper.NewString(bytes, UTF_8)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSerializeAndDeserializeNull() public virtual void ShouldSerializeAndDeserializeNull() { // given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final io.netty.buffer.ByteBuf buffer = buffers.buffer(); ByteBuf buffer = Buffers.buffer(); // when StringMarshal.Marshal(buffer, null); string reconstructed = StringMarshal.Unmarshal(buffer); // then assertNull(reconstructed); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDecodeMaxSizeChunk() public virtual void ShouldDecodeMaxSizeChunk() { sbyte[] message = new sbyte[0xFFFF]; ByteBuf input = buffer(); input.writeShort(message.Length); input.writeBytes(message); assertTrue(_channel.writeInbound(input)); assertTrue(_channel.finish()); assertEquals(1, _channel.inboundMessages().size()); assertByteBufEquals(wrappedBuffer(message), _channel.readInbound()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSerializeAndDeserializeEmptyString() public virtual void ShouldSerializeAndDeserializeEmptyString() { // given const string testString = ""; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final io.netty.buffer.ByteBuf buffer = buffers.buffer(); ByteBuf buffer = Buffers.buffer(); // when StringMarshal.Marshal(buffer, testString); string reconstructed = StringMarshal.Unmarshal(buffer); // then assertNotSame(testString, reconstructed); assertEquals(testString, reconstructed); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRejectIfInsecureWhenEncryptionRequired() public virtual void ShouldRejectIfInsecureWhenEncryptionRequired() { // Given BoltProtocol protocol = NewBoltProtocol(1); BoltProtocolFactory handlerFactory = NewProtocolFactory(1, protocol); EmbeddedChannel channel = new EmbeddedChannel(new ProtocolHandshaker(handlerFactory, _boltChannel, _logProvider, true, false)); // When ByteBuf input = Unpooled.wrappedBuffer(new sbyte[] { ( sbyte )0x60, ( sbyte )0x60, unchecked (( sbyte )0xB0), ( sbyte )0x17 }, new sbyte[] { 0, 0, 0, 1 }, new sbyte[] { 0, 0, 0, 2 }, new sbyte[] { 0, 0, 0, 3 }, new sbyte[] { 0, 0, 0, 4 }); // fourth choice - no protocol channel.writeInbound(input); // Then assertEquals(0, channel.outboundMessages().size()); assertFalse(channel.Active); verify(protocol, never()).install(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFallbackToNoProtocolIfNoMatch() public virtual void ShouldFallbackToNoProtocolIfNoMatch() { // Given BoltProtocol protocol = NewBoltProtocol(1); BoltProtocolFactory handlerFactory = NewProtocolFactory(1, protocol); EmbeddedChannel channel = new EmbeddedChannel(new ProtocolHandshaker(handlerFactory, _boltChannel, _logProvider, false, true)); // When ByteBuf input = Unpooled.wrappedBuffer(new sbyte[] { ( sbyte )0x60, ( sbyte )0x60, unchecked (( sbyte )0xB0), ( sbyte )0x17 }, new sbyte[] { 0, 0, 0, 0 }, new sbyte[] { 0, 0, 0, 2 }, new sbyte[] { 0, 0, 0, 3 }, new sbyte[] { 0, 0, 0, 4 }); // fourth choice - no protocol channel.writeInbound(input); // Then assertEquals(1, channel.outboundMessages().size()); assertByteBufEquals(Unpooled.buffer().writeInt(0), channel.readOutbound()); assertFalse(channel.Active); verify(protocol, never()).install(); }
public override void ChannelRead(ChannelHandlerContext ctx, object msg) { if (msg is ByteBuf) { ByteBuf buffer = ( ByteBuf )msg; if (_contentTypeProtocol.isExpecting(ContentType.ContentType)) { sbyte messageCode = buffer.readByte(); ContentType contentType = GetContentType(messageCode); _contentTypeProtocol.expect(contentType); if (buffer.readableBytes() == 0) { ReferenceCountUtil.release(msg); return; } } } ctx.fireChannelRead(msg); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDecodeSplitChunk() public virtual void ShouldDecodeSplitChunk() { // first part of the chunk contains size header and some bytes ByteBuf input1 = buffer(); input1.writeShort(9); input1.writeByte(1); input1.writeByte(11); input1.writeByte(2); // nothing should be available for reading assertFalse(_channel.writeInbound(input1)); // second part contains just a single byte ByteBuf input2 = buffer(); input2.writeByte(22); // nothing should be available for reading assertFalse(_channel.writeInbound(input2)); // third part contains couple more bytes ByteBuf input3 = buffer(); input3.writeByte(3); input3.writeByte(33); input3.writeByte(4); // nothing should be available for reading assertFalse(_channel.writeInbound(input3)); // fourth part contains couple more bytes, and the chunk is now complete ByteBuf input4 = buffer(); input4.writeByte(44); input4.writeByte(5); // there should be something to read now assertTrue(_channel.writeInbound(input4)); assertTrue(_channel.finish()); // there should only be a single chunk available for reading assertEquals(1, _channel.inboundMessages().size()); // it should have no size header and expected body assertByteBufEquals(wrappedBuffer(new sbyte[] { 1, 11, 2, 22, 3, 33, 4, 44, 5 }), _channel.readInbound()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldMarshalToSameByteIfByteBufBackedOrNot() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldMarshalToSameByteIfByteBufBackedOrNot() { PhysicalTransactionRepresentation expectedTx = new PhysicalTransactionRepresentation(Collections.singleton(new Command.NodeCommand(new NodeRecord(1), new NodeRecord(2)))); expectedTx.SetHeader(new sbyte[0], 1, 2, 3, 4, 5, 6); TransactionRepresentationReplicatedTransaction replicatedTransaction = ReplicatedTransaction.from(expectedTx); MemoryStream stream = new MemoryStream(); ByteBuf buffer = Buffers.buffer(); OutputStreamWritableChannel outputStreamWritableChannel = new OutputStreamWritableChannel(stream); NetworkWritableChannel networkWritableChannel = new NetworkWritableChannel(buffer); replicatedTransaction.Marshal(outputStreamWritableChannel); replicatedTransaction.Marshal(networkWritableChannel); sbyte[] bufferArray = Arrays.copyOf(buffer.array(), buffer.writerIndex()); Assertions.assertArrayEquals(bufferArray, stream.toByteArray()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSerializeAndDeserialize() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSerializeAndDeserialize() { // given MemberId.Marshal marshal = new MemberId.Marshal(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.causalclustering.identity.MemberId member = new org.neo4j.causalclustering.identity.MemberId(java.util.UUID.randomUUID()); MemberId member = new MemberId(System.Guid.randomUUID()); // when ByteBuf buffer = Unpooled.buffer(1_000); marshal.MarshalConflict(member, new BoundedNetworkWritableChannel(buffer)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.causalclustering.identity.MemberId recovered = marshal.unmarshal(new org.neo4j.causalclustering.messaging.NetworkReadableClosableChannelNetty4(buffer)); MemberId recovered = marshal.Unmarshal(new NetworkReadableClosableChannelNetty4(buffer)); // then assertEquals(member, recovered); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldWriteToBufferInChunks() public virtual void ShouldWriteToBufferInChunks() { int chunkSize = 5; sbyte[] data = new sbyte[] { 1, 2, 3, 4, 5, 6 }; sbyte[] readData = new sbyte[6]; ByteArrayChunkedEncoder byteArraySerializer = new ByteArrayChunkedEncoder(data, chunkSize); ByteBuf buffer = byteArraySerializer.ReadChunk(Buffers); buffer.readBytes(readData, 0, chunkSize); assertEquals(0, buffer.readableBytes()); buffer = byteArraySerializer.ReadChunk(Buffers); buffer.readBytes(readData, chunkSize, 1); assertArrayEquals(data, readData); assertEquals(0, buffer.readableBytes()); assertNull(byteArraySerializer.ReadChunk(Buffers)); }