buffer = new MutableAsciiBuffer(byteBuffer);
private void bufferContainsMessage(final byte[] message) { logEntryLength = message.length; final MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(message); bufferContainsMessage(SESSION_ID, SEQUENCE_NUMBER, asciiBuffer, MESSAGE_TYPE); }
int pollData() throws IOException { final ByteBuffer buffer = ByteBuffer.allocateDirect(BUFFER_SIZE); final MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(buffer); socket.configureBlocking(false); final int read = socket.read(buffer); socket.configureBlocking(true); if (read > 0) { DebugLogger.log(FIX_TEST, "< [" + asciiBuffer.getAscii(OFFSET, read) + "] for poll"); } return read; }
private AcceptorSession newAcceptorSession() { final AcceptorSession acceptorSession = new AcceptorSession(HEARTBEAT_INTERVAL, CONNECTION_ID, fakeClock, mockProxy, mockPublication, idStrategy, SENDING_TIME_WINDOW, mockReceivedMsgSeqNo, mockSentMsgSeqNo, LIBRARY_ID, 1, SEQUENCE_INDEX, CONNECTED, DEFAULT_REASONABLE_TRANSMISSION_TIME_IN_MS, new MutableAsciiBuffer(new byte[DEFAULT_SESSION_BUFFER_SIZE]), DEFAULT_ENABLE_LAST_MSG_SEQ_NUM_PROCESSED); acceptorSession.logonListener(mockLogonListener); return acceptorSession; }
private void assertEncodesMonthYear(final String input, final MonthYear monthYear) { final int expectedLength = input.length(); final UnsafeBuffer buffer = new UnsafeBuffer(new byte[expectedLength]); final MutableAsciiBuffer asciiFlyweight = new MutableAsciiBuffer(buffer); final int length = monthYear.encode(asciiFlyweight, 0); assertEquals(String.format("Failed to encode %s correctly", input), expectedLength, length); } }
private void encode(final int timestamp) { final UnsafeBuffer buffer = new UnsafeBuffer(new byte[LocalMktDateEncoder.LENGTH]); final MutableAsciiBuffer timestampBytes = new MutableAsciiBuffer(buffer); LocalMktDateEncoder.encode(timestamp, timestampBytes, 0); } }
public static FixMessagePredicate whereHeader( final Predicate<HeaderDecoder> matches) { final HeaderDecoder header = new HeaderDecoder(); final ExpandableArrayBuffer buffer = new ExpandableArrayBuffer(1024); final AsciiBuffer asciiBuffer = new MutableAsciiBuffer(); return message -> { final int length = message.bodyLength(); buffer.checkLimit(length); message.getBody(buffer, 0, length); asciiBuffer.wrap(buffer); header.decode(asciiBuffer, 0, length); return matches.test(header); }; }
private void assertDecodesMonthYear(final String input, final MonthYear expectedMonthYear) { final UnsafeBuffer buffer = new UnsafeBuffer(new byte[input.length()]); final MutableAsciiBuffer asciiFlyweight = new MutableAsciiBuffer(buffer); asciiFlyweight.putAscii(0, input); final boolean decode = monthYear.decode(asciiFlyweight, 0, input.length()); assertTrue(String.format("Failed to decode %s correctly", input), decode); assertEquals(expectedMonthYear, monthYear); }
private void assertReplayHandlerInvoked(final int endSeqNo) { final ArgumentCaptor<DirectBuffer> bufferCaptor = ArgumentCaptor.forClass(DirectBuffer.class); final ArgumentCaptor<Integer> offsetCaptor = ArgumentCaptor.forClass(Integer.class); final ArgumentCaptor<Integer> lengthCaptor = ArgumentCaptor.forClass(Integer.class); verify(replayHandler, times(2)).onReplayedMessage( bufferCaptor.capture(), offsetCaptor.capture(), lengthCaptor.capture(), eq(LIBRARY_ID), eq(SESSION_ID), eq(SEQUENCE_INDEX), eq(MESSAGE_TYPE)); final HeaderDecoder fixHeader = new HeaderDecoder(); final AsciiBuffer asciiBuffer = new MutableAsciiBuffer(bufferCaptor.getValue()); fixHeader.decode(asciiBuffer, offsetCaptor.getValue(), lengthCaptor.getValue()); assertEquals(Constants.VERSION, fixHeader.beginStringAsString()); assertEquals(BUFFER_SENDER, fixHeader.senderCompIDAsString()); assertEquals(BUFFER_TARGET, fixHeader.targetCompIDAsString()); assertEquals(ExampleMessageDecoder.MESSAGE_TYPE_AS_STRING, fixHeader.msgTypeAsString()); assertEquals(endSeqNo, fixHeader.msgSeqNum()); }
eq(OK), eq(END_SEQ_NO)); final AsciiBuffer buffer = new MutableAsciiBuffer(bufferCaptor.getValue()); final int offset = offsetCaptor.getValue(); final int length = lengthCaptor.getValue();
private void canParseTimestamp(final int length) { final long expectedEpochMillis = toEpochMillis(timestamp); final byte[] bytes = timestamp.getBytes(US_ASCII); final MutableAsciiBuffer buffer = new MutableAsciiBuffer(new byte[LENGTH_WITH_MICROSECONDS + 2]); buffer.putBytes(1, bytes); final long epochMillis = UtcTimestampDecoder.decode(buffer, 1, length); assertEquals("Failed Millis testcase for: " + timestamp, expectedEpochMillis, epochMillis); long expectedEpochMicros = expectedEpochMillis * MICROS_IN_MILLIS; // If they've got the suffix field, then test microseconds, add 1 to the value if (timestamp.length() == LENGTH_WITH_MILLISECONDS) { expectedEpochMicros++; buffer.putAscii(timestamp.length() + 1, "001"); } final long epochMicros = UtcTimestampDecoder.decodeMicros(buffer, 1, length + 3); assertEquals("Failed Micros testcase for: " + timestamp, expectedEpochMicros, epochMicros); }
@Test public void canStaticEncodeTimestampWithOffset() { final MutableAsciiBuffer string = new MutableAsciiBuffer(new byte[expectedLength + 2]); final int length = UtcTimestampEncoder.encode(epochMillis, string, 1); assertEquals("encoded wrong length", expectedLength, length); assertThat(string, sequenceEqualsAscii(expectedTimestamp, 1, length)); }
@Test public void canStaticEncodeTimestampWithOffsetMicros() { final MutableAsciiBuffer string = new MutableAsciiBuffer(new byte[expectedLengthMicros + 2]); final int length = UtcTimestampEncoder.encodeMicros(epochMicros, string, 1); assertEquals("encoded wrong length", expectedLengthMicros, length); assertThat(string, sequenceEqualsAscii(expectedTimestampMicros, 1, length)); }
@Test public void canEncodeDecimalFloat() { final int length = input.length(); final UnsafeBuffer buffer = new UnsafeBuffer(new byte[LONGEST_FLOAT_LENGTH]); final MutableAsciiBuffer string = new MutableAsciiBuffer(buffer); final DecimalFloat price = new DecimalFloat(value, scale); final int encodedLength = string.putFloatAscii(1, price); assertEquals(input, string.getAscii(1, length)); assertEquals(length, encodedLength); } }
<T extends Decoder> T readMessage(final T decoder) { final ByteBuffer buffer = ByteBuffer.allocateDirect(BUFFER_SIZE); final MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(buffer); try { final int read = socket.read(buffer); DebugLogger.log(FIX_TEST, "< [" + asciiBuffer.getAscii(OFFSET, read) + "] for attempted: " + decoder.getClass()); decoder.decode(asciiBuffer, OFFSET, read); if (!decoder.validate()) { fail("Failed: " + RejectReason.decode(decoder.rejectReason()) + " for " + decoder.invalidTagId()); } } catch (final IOException ex) { LangUtil.rethrowUnchecked(ex); } return decoder; }
@Test public void canParseTimestamp() { final int localDays = toLocalDay(timestamp); final UnsafeBuffer buffer = new UnsafeBuffer(new byte[LocalMktDateEncoder.LENGTH]); final MutableAsciiBuffer timestampBytes = new MutableAsciiBuffer(buffer); LocalMktDateEncoder.encode(localDays, timestampBytes, 0); assertThat(timestampBytes, sequenceEqualsAscii(timestamp, 0, LocalMktDateEncoder.LENGTH)); } }
private void canDecodeDecimalFloatFromBytes(final byte[] bytes) { final MutableAsciiBuffer string = new MutableAsciiBuffer(new byte[bytes.length + 2]); string.putBytes(1, bytes); final DecimalFloat price = new DecimalFloat(); string.getFloat(price, 1, bytes.length); Assert.assertEquals("Incorrect Value", value, price.value()); Assert.assertEquals("Incorrect Scale", scale, price.scale()); }
private void bufferContainsMessage( final long sessionId, final int sequenceNumber, final int sequenceIndex, final Encoder exampleMessage, final HeaderEncoder header, final int messageType) { final UtcTimestampEncoder timestampEncoder = new UtcTimestampEncoder(); final int timestampLength = timestampEncoder.encode(ORIGINAL_SENDING_EPOCH_MS); MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(new byte[BIG_BUFFER_LENGTH]); header .sendingTime(timestampEncoder.buffer(), timestampLength) .senderCompID(BUFFER_SENDER) .targetCompID(BUFFER_TARGET) .msgSeqNum(sequenceNumber); final long result = exampleMessage.encode(asciiBuffer, 0); logEntryLength = Encoder.length(result); final int encodedOffset = Encoder.offset(result); asciiBuffer = new MutableAsciiBuffer(asciiBuffer, encodedOffset, logEntryLength); bufferContainsMessage(sessionId, sequenceIndex, asciiBuffer, messageType); }
final MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(new byte[sessionBufferSize]); final SessionProxy sessionProxy = sessionProxy(connectionId, asciiBuffer); final int initialReceivedSequenceNumber = initiatorNewSequenceNumber(
protected long bufferHasResendRequest(final int endSeqNo, final String targetCompId) { final UtcTimestampEncoder timestampEncoder = new UtcTimestampEncoder(); timestampEncoder.encode(System.currentTimeMillis()); final ResendRequestEncoder resendRequest = new ResendRequestEncoder(); resendRequest .header() .sendingTime(timestampEncoder.buffer()) .msgSeqNum(1) .senderCompID(RESEND_SENDER) .targetCompID(targetCompId); return resendRequest .beginSeqNo(BEGIN_SEQ_NO) .endSeqNo(endSeqNo) .encode(new MutableAsciiBuffer(buffer), ENCODE_OFFSET); }