Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: ImapConnection { public boolean isConnected() { return inputStream != null && outputStream != null && socket != null && socket.isConnected() && !socket.isClosed(); } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider, int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void isConnected_withoutPreviousOpen_shouldReturnFalse() throws Exception { ImapConnection imapConnection = createImapConnection( settings, socketFactory, connectivityManager, oAuth2TokenProvider); boolean result = imapConnection.isConnected(); assertFalse(result); } @Test public void isConnected_afterOpen_shouldReturnTrue() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); boolean result = imapConnection.isConnected(); assertTrue(result); server.verifyConnectionStillOpen(); server.shutdown(); }
### Question: ImapConnection { public void close() { open = false; stacktraceForClose = new Exception(); untagQuietly(socket); IOUtils.closeQuietly(inputStream); IOUtils.closeQuietly(outputStream); IOUtils.closeQuietly(socket); inputStream = null; outputStream = null; socket = null; } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider, int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void close_withoutOpen_shouldNotThrow() throws Exception { ImapConnection imapConnection = createImapConnection( settings, socketFactory, connectivityManager, oAuth2TokenProvider); imapConnection.close(); } @Test public void close_afterOpen_shouldCloseConnection() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); imapConnection.close(); server.verifyConnectionClosed(); server.shutdown(); }
### Question: ImapConnection { protected boolean isIdleCapable() { if (K9MailLib.isDebug()) { Timber.v("Connection %s has %d capabilities", getLogId(), capabilities.size()); } return capabilities.contains(Capabilities.IDLE); } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider, int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void isIdleCapable_withoutIdleCapability() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); boolean result = imapConnection.isIdleCapable(); assertFalse(result); server.shutdown(); } @Test public void isIdleCapable_withIdleCapability() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpenWithCapabilities(server, "IDLE"); boolean result = imapConnection.isIdleCapable(); assertTrue(result); server.shutdown(); }
### Question: ImapConnection { public void sendContinuation(String continuation) throws IOException { outputStream.write(continuation.getBytes()); outputStream.write('\r'); outputStream.write('\n'); outputStream.flush(); if (K9MailLib.isDebug() && DEBUG_PROTOCOL_IMAP) { Timber.v("%s>>> %s", getLogId(), continuation); } } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider, int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void sendContinuation() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); simpleOpenDialog(server, "IDLE"); server.expect("4 IDLE"); server.output("+ idling"); server.expect("DONE"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); imapConnection.sendCommand("IDLE", false); imapConnection.readResponse(); imapConnection.sendContinuation("DONE"); server.waitForInteractionToComplete(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
### Question: FolderNameCodec { public String encode(String folderName) { ByteBuffer byteBuffer = modifiedUtf7Charset.encode(folderName); byte[] bytes = new byte[byteBuffer.limit()]; byteBuffer.get(bytes); return new String(bytes, asciiCharset); } private FolderNameCodec(); static FolderNameCodec newInstance(); String encode(String folderName); String decode(String encodedFolderName); }### Answer: @Test public void encode_withAsciiArgument_shouldReturnInput() throws Exception { String folderName = "ASCII"; String result = folderNameCode.encode(folderName); assertEquals(folderName, result); } @Test public void encode_withNonAsciiArgument_shouldReturnEncodedString() throws Exception { String folderName = "über"; String result = folderNameCode.encode(folderName); assertEquals("&APw-ber", result); }
### Question: FolderNameCodec { public String decode(String encodedFolderName) throws CharacterCodingException { CharsetDecoder decoder = modifiedUtf7Charset.newDecoder().onMalformedInput(CodingErrorAction.REPORT); ByteBuffer byteBuffer = ByteBuffer.wrap(encodedFolderName.getBytes(asciiCharset)); CharBuffer charBuffer = decoder.decode(byteBuffer); return charBuffer.toString(); } private FolderNameCodec(); static FolderNameCodec newInstance(); String encode(String folderName); String decode(String encodedFolderName); }### Answer: @Test public void decode_withEncodedArgument_shouldReturnDecodedString() throws Exception { String encodedFolderName = "&ANw-bergr&APYA3w-entr&AOQ-ger"; String result = folderNameCode.decode(encodedFolderName); assertEquals("Übergrößenträger", result); } @Test public void decode_withInvalidEncodedArgument_shouldThrow() throws Exception { String encodedFolderName = "&12-foo"; try { folderNameCode.decode(encodedFolderName); fail("Expected exception"); } catch (CharacterCodingException ignored) { } }
### Question: ImapStore extends RemoteStore { @Override @NonNull public ImapFolder getFolder(String folderId) { ImapFolder folder; synchronized (folderCache) { folder = folderCache.get(folderId); if (folder == null) { folder = new ImapFolder(this, folderId); folderCache.put(folderId, folder); } } return folder; } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); }### Answer: @Test public void getFolder_shouldReturnImapFolderInstance() throws Exception { Folder result = imapStore.getFolder("INBOX"); assertEquals(ImapFolder.class, result.getClass()); } @Test public void getFolder_calledTwice_shouldReturnFirstInstance() throws Exception { String folderName = "Trash"; Folder imapFolder = imapStore.getFolder(folderName); Folder result = imapStore.getFolder(folderName); assertEquals(imapFolder, result); }
### Question: ImapStore extends RemoteStore { @Override public void checkSettings() throws MessagingException { try { ImapConnection connection = createImapConnection(); connection.open(); autoconfigureFolders(connection); connection.close(); } catch (IOException ioe) { throw new MessagingException("Unable to connect", ioe); } } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); }### Answer: @Test public void checkSettings_shouldCreateImapConnectionAndCallOpen() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnection); imapStore.checkSettings(); verify(imapConnection).open(); } @Test public void checkSettings_withOpenThrowing_shouldThrowMessagingException() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); doThrow(IOException.class).when(imapConnection).open(); imapStore.enqueueImapConnection(imapConnection); try { imapStore.checkSettings(); fail("Expected exception"); } catch (MessagingException e) { assertEquals("Unable to connect", e.getMessage()); assertNotNull(e.getCause()); assertEquals(IOException.class, e.getCause().getClass()); } }
### Question: ImapStore extends RemoteStore { ImapConnection getConnection() throws MessagingException { ImapConnection connection; while ((connection = pollConnection()) != null) { try { connection.executeSimpleCommand(Commands.NOOP); break; } catch (IOException ioe) { connection.close(); } } if (connection == null) { connection = createImapConnection(); } return connection; } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory, ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); }### Answer: @Test public void getConnection_shouldCreateImapConnection() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnection); ImapConnection result = imapStore.getConnection(); assertSame(imapConnection, result); } @Test public void getConnection_calledTwiceWithoutRelease_shouldCreateTwoImapConnection() throws Exception { ImapConnection imapConnectionOne = mock(ImapConnection.class); ImapConnection imapConnectionTwo = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnectionOne); imapStore.enqueueImapConnection(imapConnectionTwo); ImapConnection resultOne = imapStore.getConnection(); ImapConnection resultTwo = imapStore.getConnection(); assertSame(imapConnectionOne, resultOne); assertSame(imapConnectionTwo, resultTwo); }
### Question: ImapPushState { public static ImapPushState parse(String pushState) { if (pushState == null \|\| !pushState.startsWith(PUSH_STATE_PREFIX)) { return createDefaultImapPushState(); } String value = pushState.substring(PUSH_STATE_PREFIX_LENGTH); try { long newUidNext = Long.parseLong(value); return new ImapPushState(newUidNext); } catch (NumberFormatException e) { Timber.e(e, "Unable to part uidNext value %s", value); } return createDefaultImapPushState(); } ImapPushState(long uidNext); static ImapPushState parse(String pushState); @Override String toString(); final long uidNext; }### Answer: @Test public void parse_withValidArgument() throws Exception { ImapPushState result = ImapPushState.parse("uidNext=42"); assertNotNull(result); assertEquals(42L, result.uidNext); } @Test public void parse_withNullArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse(null); assertNotNull(result); assertEquals(-1L, result.uidNext); } @Test public void parse_withEmptyArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse(""); assertNotNull(result); assertEquals(-1L, result.uidNext); } @Test public void parse_withInvalidArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("xyz"); assertNotNull(result); assertEquals(-1L, result.uidNext); } @Test public void parse_withIncompleteArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("uidNext="); assertNotNull(result); assertEquals(-1L, result.uidNext); } @Test public void parse_withoutIntegerAsUidNext_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("uidNext=xyz"); assertNotNull(result); assertEquals(-1L, result.uidNext); }
### Question: ImapPushState { @Override public String toString() { return "uidNext=" + uidNext; } ImapPushState(long uidNext); static ImapPushState parse(String pushState); @Override String toString(); final long uidNext; }### Answer: @Test public void toString_shouldReturnExpectedResult() throws Exception { ImapPushState imapPushState = new ImapPushState(23L); String result = imapPushState.toString(); assertEquals("uidNext=23", result); }
### Question: ImapResponseParser { private Object parseLiteral() throws IOException { expect('{'); int size = Integer.parseInt(readStringUntil('}')); expect('\r'); expect('\n'); if (size == 0) { return ""; } if (response.getCallback() != null) { FixedLengthInputStream fixed = new FixedLengthInputStream(inputStream, size); Exception callbackException = null; Object result = null; try { result = response.getCallback().foundLiteral(response, fixed); } catch (IOException e) { throw e; } catch (Exception e) { callbackException = e; } boolean someDataWasRead = fixed.available() != size; if (someDataWasRead) { if (result == null && callbackException == null) { throw new AssertionError("Callback consumed some data but returned no result"); } fixed.skipRemaining(); } if (callbackException != null) { if (exception == null) { exception = callbackException; } return "EXCEPTION"; } if (result != null) { return result; } } byte[] data = new byte[size]; int read = 0; while (read != size) { int count = inputStream.read(data, read, size - read); if (count == -1) { throw new IOException("parseLiteral(): end of stream reached"); } read += count; } return new String(data, "US-ASCII"); } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void testParseLiteral() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("test", response.getString(0)); }
### Question: ImapResponseParser { private String parseQuoted() throws IOException { expect('"'); StringBuilder sb = new StringBuilder(); int ch; boolean escape = false; while ((ch = inputStream.read()) != -1) { if (!escape && ch == '\\') { escape = true; } else if (!escape && ch == '"') { return sb.toString(); } else { sb.append((char) ch); escape = false; } } throw new IOException("parseQuoted(): end of stream reached"); } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); }### Answer: @Test public void testParseQuoted() throws Exception { ImapResponseParser parser = createParser("* \"qu\\\"oted\"\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("qu\"oted", response.getString(0)); }
### Question: ImapPusher implements Pusher { @Override public void start(List<String> folderNames) { synchronized (folderPushers) { stop(); setLastRefresh(currentTimeMillis()); for (String folderName : folderNames) { ImapFolderPusher pusher = createImapFolderPusher(folderName); folderPushers.add(pusher); pusher.start(); } } } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); }### Answer: @Test public void start_withSingleFolderName_shouldCreateImapFolderPusherAndCallStartOnIt() throws Exception { List<String> folderNames = Collections.singletonList("INBOX"); imapPusher.start(folderNames); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(1, imapFolderPushers.size()); ImapFolderPusher imapFolderPusher = imapFolderPushers.get(0); verify(imapFolderPusher).start(); } @Test public void start_withTwoFolderNames_shouldCreateTwoImapFolderPushersAndCallStart() throws Exception { List<String> folderNames = Arrays.asList("Important", "Drafts"); imapPusher.start(folderNames); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(2, imapFolderPushers.size()); ImapFolderPusher imapFolderPusherOne = imapFolderPushers.get(0); ImapFolderPusher imapFolderPusherTwo = imapFolderPushers.get(1); verify(imapFolderPusherOne).start(); verify(imapFolderPusherTwo).start(); }
### Question: ImapPusher implements Pusher { @Override public void stop() { if (K9MailLib.isDebug()) { Timber.i("Requested stop of IMAP pusher"); } synchronized (folderPushers) { for (ImapFolderPusher folderPusher : folderPushers) { try { if (K9MailLib.isDebug()) { Timber.i("Requesting stop of IMAP folderPusher %s", folderPusher.getId()); } folderPusher.stop(); } catch (Exception e) { Timber.e(e, "Got exception while stopping %s", folderPusher.getId()); } } folderPushers.clear(); } } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); }### Answer: @Test public void stop_withoutStartBeingCalled_shouldNotCreateAnyImapFolderPushers() throws Exception { imapPusher.stop(); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(0, imapFolderPushers.size()); }
### Question: ImapPusher implements Pusher { @Override public int getRefreshInterval() { return (store.getStoreConfig().getIdleRefreshMinutes() * 60 * 1000); } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); }### Answer: @Test public void getRefreshInterval() throws Exception { StoreConfig storeConfig = mock(StoreConfig.class); when(storeConfig.getIdleRefreshMinutes()).thenReturn(23); when(imapStore.getStoreConfig()).thenReturn(storeConfig); int result = imapPusher.getRefreshInterval(); assertEquals(23 * 60 * 1000, result); }
### Question: ImapPusher implements Pusher { @Override public long getLastRefresh() { return lastRefresh; } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); }### Answer: @Test public void getLastRefresh_shouldBeMinusOneInitially() throws Exception { long result = imapPusher.getLastRefresh(); assertEquals(-1L, result); }
### Question: ImapList extends ArrayList<Object> { public boolean containsKey(String key) { if (key == null) { return false; } for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return true; } } return false; } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); }### Answer: @Test public void containsKey_returnsTrueForKeys() throws IOException { ImapList list = buildSampleList(); assertTrue(list.containsKey("ONE")); assertTrue(list.containsKey("TWO")); assertFalse(list.containsKey("THREE")); assertFalse(list.containsKey("nonexistent")); } @Test public void containsKey_returnsFalseForStringThatCantBeKey() throws IOException { ImapList list = buildSampleList(); assertFalse(list.containsKey("THREE")); } @Test public void containsKey_returnsFalseForStringNotInList() throws IOException { ImapList list = buildSampleList(); assertFalse(list.containsKey("nonexistent")); }
### Question: ImapList extends ArrayList<Object> { public Object getKeyedValue(String key) { for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return get(i + 1); } } return null; } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); }### Answer: @Test public void getKeyedValue_providesCorrespondingValues() { ImapList list = buildSampleList(); assertEquals("TWO", list.getKeyedValue("ONE")); assertEquals("THREE", list.getKeyedValue("TWO")); assertNull(list.getKeyedValue("THREE")); assertNull(list.getKeyedValue("nonexistent")); }
### Question: ImapList extends ArrayList<Object> { public int getKeyIndex(String key) { for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return i; } } throw new IllegalArgumentException("getKeyIndex() only works for keys that are in the collection."); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); }### Answer: @Test public void getKeyIndex_providesIndexForKeys() { ImapList list = buildSampleList(); assertEquals(0, list.getKeyIndex("ONE")); assertEquals(1, list.getKeyIndex("TWO")); } @Test(expected = IllegalArgumentException.class) public void getKeyIndex_throwsExceptionForValue() { ImapList list = buildSampleList(); list.getKeyIndex("THREE"); } @Test(expected = IllegalArgumentException.class) public void getKeyIndex_throwsExceptionForNonExistantKey() { ImapList list = buildSampleList(); list.getKeyIndex("nonexistent"); }
### Question: ImapList extends ArrayList<Object> { public Date getDate(int index) throws MessagingException { return getDate(getString(index)); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); }### Answer: @Test public void getDate_returnsCorrectDateForValidString() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("10-Mar-2000 12:02:01 GMT"); Calendar c = Calendar.getInstance(); c.setTime(list.getDate(1)); assertEquals(2000, c.get(Calendar.YEAR)); assertEquals(Calendar.MARCH, c.get(Calendar.MONTH)); assertEquals(10, c.get(Calendar.DAY_OF_MONTH)); } @Test(expected = MessagingException.class) public void getDate_throwsExceptionForInvalidDate() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("InvalidDate"); list.getDate(1); } @Test public void getDate_returnsNullForNIL() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("NIL"); assertNull(list.getDate(1)); }
### Question: ImapList extends ArrayList<Object> { public Date getKeyedDate(String key) throws MessagingException { return getDate(getKeyedString(key)); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); }### Answer: @Test public void getKeyedDate_returnsCorrectDateForValidString() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("10-Mar-2000 12:02:01 GMT"); Calendar c = Calendar.getInstance(); c.setTime(list.getKeyedDate("INTERNALDATE")); assertEquals(2000, c.get(Calendar.YEAR)); assertEquals(Calendar.MARCH, c.get(Calendar.MONTH)); assertEquals(10, c.get(Calendar.DAY_OF_MONTH)); } @Test(expected = MessagingException.class) public void getKeyedDate_throwsExceptionForInvalidDate() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("InvalidDate"); list.getKeyedDate("INTERNALDATE"); } @Test public void getKeyedDate_returnsNullForNIL() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("NIL"); assertNull(list.getKeyedDate("INTERNALDATE")); }
### Question: SelectOrExamineResponse { public static SelectOrExamineResponse parse(ImapResponse response) { if (!response.isTagged() \|\| !equalsIgnoreCase(response.get(0), Responses.OK)) { return null; } if (!response.isList(1)) { return noOpenModeInResponse(); } ImapList responseTextList = response.getList(1); if (!responseTextList.isString(0)) { return noOpenModeInResponse(); } String responseCode = responseTextList.getString(0); if ("READ-ONLY".equalsIgnoreCase(responseCode)) { return new SelectOrExamineResponse(false); } else if ("READ-WRITE".equalsIgnoreCase(responseCode)) { return new SelectOrExamineResponse(true); } return noOpenModeInResponse(); } private SelectOrExamineResponse(Boolean readWriteMode); static SelectOrExamineResponse parse(ImapResponse response); boolean hasOpenMode(); int getOpenMode(); }### Answer: @Test public void parse_withUntaggedResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("* OK [READ-WRITE] Select completed."); SelectOrExamineResponse result = SelectOrExamineResponse.parse(imapResponse); assertNull(result); } @Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x BYE"); SelectOrExamineResponse result = SelectOrExamineResponse.parse(imapResponse); assertNull(result); }
### Question: BoundaryGenerator { public String generateBoundary() { StringBuilder builder = new StringBuilder(4 + BOUNDARY_CHARACTER_COUNT); builder.append("----"); for (int i = 0; i < BOUNDARY_CHARACTER_COUNT; i++) { builder.append(BASE36_MAP[random.nextInt(36)]); } return builder.toString(); } @VisibleForTesting BoundaryGenerator(Random random); static BoundaryGenerator getInstance(); String generateBoundary(); }### Answer: @Test public void generateBoundary_allZeros() throws Exception { Random random = createRandom(0); BoundaryGenerator boundaryGenerator = new BoundaryGenerator(random); String result = boundaryGenerator.generateBoundary(); assertEquals("----000000000000000000000000000000", result); } @Test public void generateBoundary() throws Exception { Random random = createRandom(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 35); BoundaryGenerator boundaryGenerator = new BoundaryGenerator(random); String result = boundaryGenerator.generateBoundary(); assertEquals("----0123456789ABCDEFGHIJKLMNOPQRSZ", result); }
### Question: StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }### Answer: @Test public void TestEmptyStringReturnZero() { Assert.assertEquals(0, stringCalculator.add("")); } @Test public void TestNumberStringReturnValue() { Assert.assertEquals(1, stringCalculator.add("1")); Assert.assertEquals(2, stringCalculator.add("2")); } @Test public void TestTwoNumbersStringReturnSum() { Assert.assertEquals(3, stringCalculator.add("1,2")); Assert.assertEquals(5, stringCalculator.add("2,3")); } @Test public void TestAnyNumbersStringReturnSum() { Assert.assertEquals(10, stringCalculator.add("1,2,3,4")); } @Test public void TestAnyNumbersComaOrReturnLineDelimiterStringReturnSum() { Assert.assertEquals(6, stringCalculator.add("1,2\n3")); } @Test public void TestAnyNumbersCustomDelimiterStringReturnSum() { Assert.assertEquals(3, stringCalculator.add(" }
### Question: StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }### Answer: @Test public void emptyStringReturnsZero() { assertEquals(0, this.stringCalculator.add("")); } @Test public void numberStringReturnsNumber() { assertEquals(1, this.stringCalculator.add("1")); } @Test public void stringNumbersCommaDelimitedReturnsSum() { assertEquals(3, this.stringCalculator.add("1,2")); } @Test public void multipleStringNumbersCommaDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1,2,3")); } @Test public void multipleStringNumbersCommaOrReturnLineDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1\n2,3")); assertEquals(6, this.stringCalculator.add("1,2\n3")); } @Test public void multipleStringNumbersCustomDelimitedReturnsSum() { assertEquals("Should return 3", 3, this.stringCalculator.add(" }
### Question: DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }### Answer: @Test public void parseWithTimewords() { MatchedDate matchedDate = new MatchedDate("Wed Feb 24 2016 00:01 UTC+1201", null); MatchedDate parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2016-02-24T00:01:00", DataUtils.formatInUTC(parse.getDate())); assertEquals("TIMEWORDS", parse.getPattern()); assertEquals("Wed Feb 24 2016 00:01 UTC+1201", parse.getValue()); }
### Question: DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }### Answer: @Test public void normalizerSplitter() { assertEquals(Lists.newArrayList("\\?.$-->>", "a-->>b"), DataUtils.parseStringList("\\?.$-->>\na-->>b\r\r\n\n")); }
### Question: DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }### Answer: @Test public void dateFormatInUTC() { Long DATE_2017_01_04_12_26_00 = 1483532760805L; assertEquals("2017-01-04T12:26:00", DataUtils.formatInUTC(new DateTime(DATE_2017_01_04_12_26_00))); }
### Question: EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } protected EsHttpSourceOperations(ElasticConnection connection, String index, String type); static EsHttpSourceOperations getInstance(ElasticConnection connection, String index, String type); List<HttpSource> findEnabledSources(); HttpSource get(String url); PageableList<HttpSource> filter(String text); PageableList<HttpSource> filter(String text, int offset); List<HttpSource> all(); void save(HttpSource source); void delete(String url); void deleteAll(); }### Answer: @Test @Ignore public void test() { ElasticConnection connection = ElasticConnection.getConnection("localhost", 9200, "http"); EsHttpSourceOperations esHttpSourceOperations = new EsHttpSourceOperations(connection, "demo-http_sources", "http_source"); PageableList<HttpSource> data = esHttpSourceOperations.filter(null); for (HttpSource source : data.getItems()) { System.out.println(">>" + source); } }
### Question: ElasticConnection { public static Builder builder() { return new Builder(); } private ElasticConnection(BulkProcessor processor, RestHighLevelClient restHighLevelClient, RestClientBuilder restClient); static Builder builder(); RestHighLevelClient getRestHighLevelClient(); BulkProcessor getProcessor(); static ElasticConnection getConnection(String hostname); static ElasticConnection getConnection(String hostname, int restPort, String restScheme); void close(); }### Answer: @Test public void testBuilder() { BulkProcessor.Listener listener = new BulkProcessor.Listener() { @Override public void afterBulk(long executionId, BulkRequest request, BulkResponse response) { for (BulkItemResponse item : response.getItems()) { if (item.isFailed()) { LOG.error("Bulk item failure: '{}' for request '{}'", item.getFailure(), request.requests().get(item.getItemId())); } } } @Override public void afterBulk(long executionId, BulkRequest request, Throwable response) { LOG.error("Bulk failed:" + response); } @Override public void beforeBulk(long executionId, BulkRequest request) { for (DocWriteRequest r :request.requests()) { try { if (r instanceof IndexRequest) { IndexRequest indexRequest = (IndexRequest) r; indexRequest.id(URLDecoder.decode(indexRequest.id(), "utf-8")); } else if (r instanceof UpdateRequest) { UpdateRequest updateRequest = (UpdateRequest) r; updateRequest.id(URLDecoder.decode(updateRequest.id(), "utf-8")); } } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } }; ElasticConnection connection = ElasticConnection.builder() .hostname("0.0.0.0") .restPort(443) .restScheme("https") .bulkActions(1) .flushIntervalString("1s") .listener(listener) .build(); assertNotNull(connection); }
### Question: QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s[+-]\\s)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#\| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } static List<String> parseQuery(String query); }### Answer: @Test public void parseQuery() { List<String> parts = QueryParser.parseQuery("+Turkey-Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey -Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("Turkey -Inflation"); assertEquals(Lists.newArrayList("Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey attack"); assertEquals(Lists.newArrayList("+Turkey", "attack"), parts); }
### Question: UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); }### Answer: @Test public void testExtraction00() throws Exception { String html = loadArticle("aljazeera1"); String url = "https: Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); assertEquals("https: } @Test public void testExtraction01() throws Exception { String html = loadArticle("kedainietis"); String url = "url"; Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); }
### Question: ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg); static void printOpCode(Instruction ins, ConstantPoolGen cpg); static T getConstantLDC(InstructionHandle h, ConstantPoolGen cpg, Class<T> clazz); static Integer getConstantInt(InstructionHandle h); static Number getPushNumber(InstructionHandle h); static T getPrevInstruction(InstructionHandle startHandle, Class<T> clazz); }### Answer: @Test public void probeByteCodeDebug() { PrintStream sysOut = mock(PrintStream.class); System.out.println("Sysout hijack!"); PrintStream oldPrintStream = System.out; try { System.setOut(sysOut); InvokeInstruction ins = mock(InvokeInstruction.class); ConstantPoolGen cpg = mock(ConstantPoolGen.class); when(ins.getClassName(Matchers.<ConstantPoolGen>any())).thenReturn("ClassTest"); when(ins.getMethodName(Matchers.<ConstantPoolGen>any())).thenReturn("method"); when(ins.getSignature(Matchers.<ConstantPoolGen>any())).thenReturn("(Lsignature)Lblah"); ByteCode.printOpCode(ins, cpg); verify(sysOut, atLeastOnce()).println(contains("ClassTest.method")); } finally { System.setOut(oldPrintStream); System.out.println("Sysout is back!"); } }
### Question: LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } LangIdV3(); LangIdV3(Model model); @Override DetectedLanguage classify(CharSequence str, boolean normalizeConfidence); @Override void reset(); @Override void append(CharSequence str); @Override void append(ByteBuffer buffer); @Override void append(byte [] array, int start, int length); @Override DetectedLanguage classify(boolean normalizeConfidence); @Override List<DetectedLanguage> rank(boolean normalizeConfidence); }### Answer: @Test public void testSanity() { LangIdV3 langid = new LangIdV3(); for (String [] langString : new String [][] { {"en", "Mike McCandless rocks the boat."}, {"pl", "W Szczebrzeszynie chrząszcz brzmi w trzcinie"}, {"it", "Piano italiano per la crescita: negoziato in Europa sugli investimenti «virtuosi»"} }) { DetectedLanguage result = langid.classify(langString[1], true); assertEquals(langString[0], result.langCode); } }
### Question: UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }### Answer: @Test public void shouldCreateUser() throws Exception { when(userRepositoryMock.save(isA(User.class))).thenAnswer(invocation -> invocation.getArgument(0)); final User user = testSubject.create("Clark", "$"); assertThat(user.getName()).isEqualTo("Clark"); assertThat(user.getCurrency()).isEqualTo("$"); }
### Question: AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }### Answer: @Test public void shouldListAccounts() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); Account savings = AccountTestUtils.createSavingsAccount(bob); when(accountRepositoryMock.findByUserId(bob.getId())).thenReturn(asList(checkings, savings)); List<Account> accounts = testSubject.list(bob.getId()); assertThat(accounts).containsExactlyInAnyOrder(checkings, savings); }
### Question: AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }### Answer: @Test public void shoudlGetAccount() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); when(accountRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(checkings)); Account accounts = testSubject.get(checkings.getId()); assertThat(accounts).isEqualTo(checkings); }
### Question: AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }### Answer: @Test public void shouldCreateAnAccount() { User bob = UserTestUtils.createBob(); when(userRepositoryMock.getOne(bob.getId())).thenReturn(bob); when(accountRepositoryMock.saveAndFlush(isA(Account.class))).thenAnswer(invocation -> invocation.getArgument(0)); Account account = testSubject.create(bob.getId(), "Cash", true); assertThat(account).isNotNull(); assertThat(account.getUser()).isNotNull(); assertThat(account.getUser().getId()).isEqualTo(bob.getId()); assertThat(account.getDescription()).isEqualTo("Cash"); assertThat(account.isOnBudget()).isTrue(); }
### Question: AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }### Answer: @Test public void descriptionShouldNotBeEmpty() { final AccountResource resource = new AccountResource("", true); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("description").getCode()).isEqualTo("description.empty"); } @Test public void onBudgetShouldNotBeEmpty() { final AccountResource resource = new AccountResource("Cash", null); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("onBudget").getCode()).isEqualTo("onBudget.empty"); }
### Question: AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); }### Answer: @Test public void shouldGetOneAccount() throws Exception { User bob = UserTestUtils.createBob(); Account savingsAccount = AccountTestUtils.createSavingsAccount(bob); when(accountServiceMock.get(savingsAccount.getId())).thenReturn(savingsAccount); final MockHttpServletRequestBuilder requestBuilder = get("/users/{userId}/accounts/{id}", bob.getId(), savingsAccount.getId()).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final AccountResource userResource = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(userResource.getDescription()).isEqualTo(savingsAccount.getDescription()); assertThat(userResource.getOnBudget()).isEqualTo(savingsAccount.isOnBudget()); }
### Question: AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } AccountResourceAssembler(); @Override AccountResource toResource(Account entity); }### Answer: @Test public void shouldCreateResource() { Account entity = AccountTestUtils.createCheckingsAccount(UserTestUtils.createBob()); AccountResource resource = testSubject.toResource(entity); assertThat(resource.getDescription()).isEqualTo(entity.getDescription()); assertThat(resource.getOnBudget()).isEqualTo(entity.isOnBudget()); }
### Question: CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } Specification<Category> byUser(User user); }### Answer: @Test public void byUser() { User user = userRepository.save(new User("Bob", "€")); MasterCategory mcMonthly = masterCategoryRepository.save(new MasterCategory().setName("Monthly").setUser(user)); MasterCategory mcSavings = masterCategoryRepository.save(new MasterCategory().setName("Savings").setUser(user)); categoryRepository.saveAll(asList( new Category().setName("Rent").setMasterCategory(mcMonthly), new Category().setName("Internet").setMasterCategory(mcMonthly), new Category().setName("Rainy Day Funds").setMasterCategory(mcSavings), new Category().setName("Christmas").setMasterCategory(mcSavings) )); Specification<Category> specification = testSubject.byUser(user); List<Category> categories = categoryRepository.findAll(specification); assertThat(categories).extracting("name").containsExactlyInAnyOrder("Rent", "Internet", "Rainy Day Funds", "Christmas"); }
### Question: UserService { public List<User> list() { return userRepository.findAll(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }### Answer: @Test public void shouldReturnAllUser() throws Exception { final List<User> bobAndJane = UserTestUtils.createBobAndJane(); when(userRepositoryMock.findAll()).thenReturn(bobAndJane); final List<User> list = testSubject.list(); assertThat(list).isEqualTo(bobAndJane); }
### Question: UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }### Answer: @Test public void shouldFindOneUser() { final User bob = UserTestUtils.createBob(); when(userRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(bob)); final User user = testSubject.get(bob.getId()); assertThat(user).isEqualToComparingFieldByField(bob); }
### Question: UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }### Answer: @Test public void shouldReadTestProperty() { assertThat(testSubject.getTestProperty()).isEqualTo("mockedTestProperty"); }
### Question: UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } @Autowired UserResourceAssembler(List<ResourceLinks<User>> resourceLinks); }### Answer: @Test public void createResource() throws Exception { UserResource userResource = testSubject.createResource(new User(NAME, CURRENCY)); assertThat(userResource.getName()).isEqualTo(NAME); assertThat(userResource.getCurrency()).isEqualTo(CURRENCY); }
### Question: UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }### Answer: @Test public void nameShouldNotBeEmpty() { final UserResource userResource = new UserResource("", "€"); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("name").getCode()).isEqualTo("name.empty"); } @Test public void currencyShouldNotBeEmpty() { final UserResource userResource = new UserResource("Foo", ""); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("currency").getCode()).isEqualTo("currency.empty"); }
### Question: UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } UserControllerUserLinks(); @Override Collection<Link> generateLinks(User entity); }### Answer: @Test public void generateLinks() { List<Link> links = new ArrayList<>(testSubject.generateLinks(createUser())); assertThat(links.size()).isEqualTo(2); assertThat(links.get(0).getRel()).isEqualTo("self"); assertThat(links.get(0).getHref()).isEqualTo("/users/1"); assertThat(links.get(1).getRel()).isEqualTo("users"); assertThat(links.get(1).getHref()).isEqualTo("/users"); }
### Question: UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }### Answer: @Test public void shouldGetOneUser() throws Exception { when(userServiceMock.get(anyLong())).thenReturn(UserTestUtils.createBob()); final MockHttpServletRequestBuilder requestBuilder = get("/users/{id}", 1L).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource userResource = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(userResource.getName()).isEqualTo("Bob"); assertThat(userResource.getCurrency()).isEqualTo("€"); }
### Question: UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }### Answer: @Test public void shouldCreateUser() throws Exception { final String name = "Martha"; final String currency = "€"; final UserResource userResource = new UserResource(name, currency); when(userServiceMock.create(anyString(), anyString())).thenAnswer(invocation -> new User().setId(1L) .setName(invocation.getArgument(0)) .setCurrency(invocation.getArgument(1)) ); final MockHttpServletRequestBuilder requestBuilder = post("/users").accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(userResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource result = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(result.getName()).isEqualTo(name); assertThat(result.getCurrency()).isEqualTo(currency); verify(userServiceMock).create(name, currency); }
### Question: Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } protected Order(int index, BarSeries series, OrderType type); protected Order(int index, BarSeries series, OrderType type, Num amount); protected Order(int index, BarSeries series, OrderType type, Num amount, CostModel transactionCostModel); protected Order(int index, OrderType type, Num pricePerAsset); protected Order(int index, OrderType type, Num pricePerAsset, Num amount); protected Order(int index, OrderType type, Num pricePerAsset, Num amount, CostModel transactionCostModel); OrderType getType(); Num getCost(); int getIndex(); Num getPricePerAsset(); Num getNetPrice(); Num getAmount(); CostModel getCostModel(); boolean isBuy(); boolean isSell(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static Order buyAt(int index, BarSeries series); static Order buyAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order buyAt(int index, Num price, Num amount); static Order buyAt(int index, BarSeries series, Num amount); static Order buyAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series); static Order sellAt(int index, Num price, Num amount); static Order sellAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series, Num amount); static Order sellAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); Num getValue(); }### Answer: @Test public void overrideToString() { assertEquals(opEquals1.toString(), opEquals2.toString()); assertNotEquals(opEquals1.toString(), opNotEquals1.toString()); assertNotEquals(opEquals1.toString(), opNotEquals2.toString()); }
### Question: NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(6), numOf(2))); }
### Question: AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedDownIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedDownIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedDownIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
### Question: RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3.5), numOf(2.2))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.7))); }
### Question: ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); }
### Question: AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculate() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(3, series), Order.buyAt(4, series), Order.sellAt(5, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(2d / 3, average.calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(0), average.calculate(series, trade)); trade = new Trade(Order.buyAt(1, series), Order.sellAt(2, series)); assertNumEquals(1, average.calculate(series, trade)); }
### Question: IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } IsEqualRule(Indicator<Num> indicator, Number value); IsEqualRule(Indicator<Num> indicator, Num value); IsEqualRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); }
### Question: AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(12), numOf(8))); assertFalse(criterion.betterThan(numOf(8), numOf(12))); }
### Question: NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(3, series), Order.buyAt(1, series), Order.sellAt(5, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
### Question: NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(50), numOf(45))); assertFalse(criterion.betterThan(numOf(45), numOf(50))); }
### Question: IsHighestRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { HighestValueIndicator highest = new HighestValueIndicator(ref, barCount); Num highestVal = highest.getValue(index); Num refVal = ref.getValue(index); final boolean satisfied = !refVal.isNaN() && !highestVal.isNaN() && refVal.equals(highestVal); traceIsSatisfied(index, satisfied); return satisfied; } IsHighestRule(Indicator<Num> ref, int barCount); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertTrue(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: TotalLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ValueAtRiskCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); }
### Question: InSlopeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { DifferenceIndicator diff = new DifferenceIndicator(ref, prev); Num val = diff.getValue(index); boolean minSlopeSatisfied = minSlope.isNaN() \|\| val.isGreaterThanOrEqual(minSlope); boolean maxSlopeSatisfied = maxSlope.isNaN() \|\| val.isLessThanOrEqual(maxSlope); boolean isNaN = minSlope.isNaN() && maxSlope.isNaN(); final boolean satisfied = minSlopeSatisfied && maxSlopeSatisfied && !isNaN; traceIsSatisfied(index, satisfied); return satisfied; } InSlopeRule(Indicator<Num> ref, Num minSlope); InSlopeRule(Indicator<Num> ref, Num minSlope, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num minSlope, Num maxSlope); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rulePositiveSlope.isSatisfied(0)); assertTrue(rulePositiveSlope.isSatisfied(1)); assertFalse(rulePositiveSlope.isSatisfied(2)); assertFalse(rulePositiveSlope.isSatisfied(9)); assertFalse(ruleNegativeSlope.isSatisfied(0)); assertFalse(ruleNegativeSlope.isSatisfied(1)); assertTrue(ruleNegativeSlope.isSatisfied(5)); assertFalse(ruleNegativeSlope.isSatisfied(9)); }
### Question: NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0, buyAndHold.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(2, buyAndHold.calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(); AnalysisCriterion tradesCriterion = getCriterion(); assertNumEquals(1, tradesCriterion.calculate(series, trade)); }
### Question: NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: OverIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isGreaterThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } OverIndicatorRule(Indicator<Num> indicator, Number threshold); OverIndicatorRule(Indicator<Num> indicator, Num threshold); OverIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); }
### Question: LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, double a, double b); @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = new LinearTransactionCostCriterion(1000, 0.5); assertTrue(criterion.betterThan(numOf(3.1), numOf(4.2))); assertFalse(criterion.betterThan(numOf(2.1), numOf(1.9))); }
### Question: MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(0.9), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.2), numOf(0.4))); }
### Question: ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(5000), numOf(4500))); assertFalse(criterion.betterThan(numOf(4500), numOf(5000))); }
### Question: ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void calculatePerTrade() { ZeroCostModel model = new ZeroCostModel(); int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), model); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), model); Trade trade = new Trade(entry, exit, model, model); Num cost = model.calculate(trade, holdingPeriod); assertNumEquals(cost, DoubleNum.valueOf(0)); } @Test public void calculatePerPrice() { ZeroCostModel model = new ZeroCostModel(); Num cost = model.calculate(DoubleNum.valueOf(100), DoubleNum.valueOf(1)); assertNumEquals(cost, DoubleNum.valueOf(0)); }
### Question: ZeroCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { ZeroCostModel model = new ZeroCostModel(); CostModel modelSame = new ZeroCostModel(); CostModel modelOther = new LinearTransactionCostModel(0.1); boolean equality = model.equals(modelSame); boolean inequality = model.equals(modelOther); assertTrue(equality); assertFalse(inequality); }
### Question: LinearBorrowingCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearBorrowingCostModel) otherModel).feePerPeriod == this.feePerPeriod; } return equality; } LinearBorrowingCostModel(double feePerPeriod); Num calculate(Num price, Num amount); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { LinearBorrowingCostModel model = new LinearBorrowingCostModel(0.1); CostModel modelSameClass = new LinearBorrowingCostModel(0.2); CostModel modelSameFee = new LinearBorrowingCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); }
### Question: LinearTransactionCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearTransactionCostModel) otherModel).feePerTrade == this.feePerTrade; } return equality; } LinearTransactionCostModel(double feePerTrade); Num calculate(Trade trade, int currentIndex); Num calculate(Trade trade); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); }### Answer: @Test public void testEquality() { LinearTransactionCostModel model = new LinearTransactionCostModel(0.1); CostModel modelSameClass = new LinearTransactionCostModel(0.2); CostModel modelSameFee = new LinearTransactionCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); }
### Question: OrRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) \|\| rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } OrRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertTrue(satisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.or(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.or(unsatisfiedRule).isSatisfied(0)); assertTrue(satisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(unsatisfiedRule).isSatisfied(10)); }
### Question: Trade implements Serializable { public boolean isOpened() { return (entry != null) && (exit == null); } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); }### Answer: @Test public void whenNewShouldNotExit() { assertFalse(newTrade.isOpened()); }
### Question: Trade implements Serializable { @Override public String toString() { return "Entry: " + entry + " exit: " + exit; } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); }### Answer: @Test public void overrideToString() { assertEquals(trEquals1.toString(), trEquals2.toString()); assertNotEquals(trEquals1.toString(), trNotEquals1.toString()); assertNotEquals(trEquals1.toString(), trNotEquals2.toString()); }
### Question: StrategyExecutionLogging { public static void main(String[] args) { loadLoggerConfiguration(); BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = CCICorrectionStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); seriesManager.run(strategy); unloadLoggerConfiguration(); } static void main(String[] args); }### Answer: @Test public void test() { StrategyExecutionLogging.main(null); }
### Question: RSI2Strategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { RSI2Strategy.main(null); }
### Question: GlobalExtremaStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { GlobalExtremaStrategy.main(null); }
### Question: CCICorrectionStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { CCICorrectionStrategy.main(null); }
### Question: MovingMomentumStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { MovingMomentumStrategy.main(null); }
### Question: Quickstart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Num firstClosePrice = series.getBar(0).getClosePrice(); System.out.println("First close price: " + firstClosePrice.doubleValue()); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); System.out.println(firstClosePrice.isEqual(closePrice.getValue(0))); SMAIndicator shortSma = new SMAIndicator(closePrice, 5); System.out.println("5-bars-SMA value at the 42nd index: " + shortSma.getValue(42).doubleValue()); SMAIndicator longSma = new SMAIndicator(closePrice, 30); Rule buyingRule = new CrossedUpIndicatorRule(shortSma, longSma) .or(new CrossedDownIndicatorRule(closePrice, 800)); Rule sellingRule = new CrossedDownIndicatorRule(shortSma, longSma) .or(new StopLossRule(closePrice, series.numOf(3))).or(new StopGainRule(closePrice, series.numOf(2))); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(new BaseStrategy(buyingRule, sellingRule)); System.out.println("Number of trades for our strategy: " + tradingRecord.getTradeCount()); AnalysisCriterion profitTradesRatio = new AverageProfitableTradesCriterion(); System.out.println("Profitable trades ratio: " + profitTradesRatio.calculate(series, tradingRecord)); AnalysisCriterion rewardRiskRatio = new RewardRiskRatioCriterion(); System.out.println("Reward-risk ratio: " + rewardRiskRatio.calculate(series, tradingRecord)); AnalysisCriterion vsBuyAndHold = new VersusBuyAndHoldCriterion(new TotalProfitCriterion()); System.out.println("Our profit vs buy-and-hold profit: " + vsBuyAndHold.calculate(series, tradingRecord)); } static void main(String[] args); }### Answer: @Test public void test() { Quickstart.main(null); }
### Question: BuildBarSeries { @SuppressWarnings("unused") public static void main(String[] args) { BarSeries a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BaseBarSeriesBuilder.setDefaultFunction(DoubleNum::valueOf); a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BarSeries b = buildWithDouble(); BarSeries c = buildWithBigDecimal(); BarSeries d = buildManually(); BarSeries e = buildManuallyDoubleNum(); BarSeries f = buildManuallyAndAddBarManually(); BarSeries g = buildAndAddBarsFromList(); } @SuppressWarnings("unused") static void main(String[] args); }### Answer: @Test public void test() { BuildBarSeries.main(null); }
### Question: IsRisingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isGreaterThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsRisingRule(Indicator<Num> ref, int barCount); IsRisingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: WalkForward { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); List<BarSeries> subseries = splitSeries(series, Duration.ofHours(6), Duration.ofDays(7)); Map<Strategy, String> strategies = buildStrategiesMap(series); AnalysisCriterion profitCriterion = new TotalProfitCriterion(); for (BarSeries slice : subseries) { System.out.println("Sub-series: " + slice.getSeriesPeriodDescription()); BarSeriesManager sliceManager = new BarSeriesManager(slice); for (Map.Entry<Strategy, String> entry : strategies.entrySet()) { Strategy strategy = entry.getKey(); String name = entry.getValue(); TradingRecord tradingRecord = sliceManager.run(strategy); Num profit = profitCriterion.calculate(slice, tradingRecord); System.out.println("\tProfit for " + name + ": " + profit); } Strategy bestStrategy = profitCriterion.chooseBest(sliceManager, new ArrayList<Strategy>(strategies.keySet())); System.out.println("\t\t--> Best strategy: " + strategies.get(bestStrategy) + "\n"); } } static List<Integer> getSplitBeginIndexes(BarSeries series, Duration splitDuration); static BarSeries subseries(BarSeries series, int beginIndex, Duration duration); static List<BarSeries> splitSeries(BarSeries series, Duration splitDuration, Duration sliceDuration); static Map<Strategy, String> buildStrategiesMap(BarSeries series); static void main(String[] args); }### Answer: @Test public void test() { WalkForward.main(null); }
### Question: CandlestickChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); OHLCDataset ohlcDataset = createOHLCDataset(series); TimeSeriesCollection xyDataset = createAdditionalDataset(series); JFreeChart chart = ChartFactory.createCandlestickChart("Bitstamp BTC price", "Time", "USD", ohlcDataset, true); CandlestickRenderer renderer = new CandlestickRenderer(); renderer.setAutoWidthMethod(CandlestickRenderer.WIDTHMETHOD_SMALLEST); XYPlot plot = chart.getXYPlot(); plot.setRenderer(renderer); int index = 1; plot.setDataset(index, xyDataset); plot.mapDatasetToRangeAxis(index, 0); XYLineAndShapeRenderer renderer2 = new XYLineAndShapeRenderer(true, false); renderer2.setSeriesPaint(index, Color.blue); plot.setRenderer(index, renderer2); plot.setRangeGridlinePaint(Color.lightGray); plot.setBackgroundPaint(Color.white); NumberAxis numberAxis = (NumberAxis) plot.getRangeAxis(); numberAxis.setAutoRangeIncludesZero(false); plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { CandlestickChart.main(null); }
### Question: IndicatorsToChart { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); EMAIndicator avg14 = new EMAIndicator(closePrice, 14); StandardDeviationIndicator sd14 = new StandardDeviationIndicator(closePrice, 14); BollingerBandsMiddleIndicator middleBBand = new BollingerBandsMiddleIndicator(avg14); BollingerBandsLowerIndicator lowBBand = new BollingerBandsLowerIndicator(middleBBand, sd14); BollingerBandsUpperIndicator upBBand = new BollingerBandsUpperIndicator(middleBBand, sd14); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartBarSeries(series, closePrice, "Apple Inc. (AAPL) - NASDAQ GS")); dataset.addSeries(buildChartBarSeries(series, lowBBand, "Low Bollinger Band")); dataset.addSeries(buildChartBarSeries(series, upBBand, "High Bollinger Band")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Apple Inc. 2013 Close Prices", "Date", "Price Per Unit", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("yyyy-MM-dd")); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { IndicatorsToChart.main(null); }
### Question: StrategyAnalysis { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); TotalProfitCriterion totalProfit = new TotalProfitCriterion(); System.out.println("Total profit: " + totalProfit.calculate(series, tradingRecord)); System.out.println("Number of bars: " + new NumberOfBarsCriterion().calculate(series, tradingRecord)); System.out .println("Average profit (per bar): " + new AverageProfitCriterion().calculate(series, tradingRecord)); System.out.println("Number of trades: " + new NumberOfTradesCriterion().calculate(series, tradingRecord)); System.out.println( "Profitable trades ratio: " + new AverageProfitableTradesCriterion().calculate(series, tradingRecord)); System.out.println("Maximum drawdown: " + new MaximumDrawdownCriterion().calculate(series, tradingRecord)); System.out.println("Reward-risk ratio: " + new RewardRiskRatioCriterion().calculate(series, tradingRecord)); System.out.println("Total transaction cost (from $1000): " + new LinearTransactionCostCriterion(1000, 0.005).calculate(series, tradingRecord)); System.out.println("Buy-and-hold: " + new BuyAndHoldCriterion().calculate(series, tradingRecord)); System.out.println("Custom strategy profit vs buy-and-hold strategy profit: " + new VersusBuyAndHoldCriterion(totalProfit).calculate(series, tradingRecord)); } static void main(String[] args); }### Answer: @Test public void test() { StrategyAnalysis.main(null); }
### Question: TradeCost { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildShortSellingMomentumStrategy(series); double feePerTrade = 0.0005; double borrowingFee = 0.00001; CostModel transactionCostModel = new LinearTransactionCostModel(feePerTrade); CostModel borrowingCostModel = new LinearBorrowingCostModel(borrowingFee); BarSeriesManager seriesManager = new BarSeriesManager(series, transactionCostModel, borrowingCostModel); Order.OrderType entryOrder = Order.OrderType.SELL; TradingRecord tradingRecord = seriesManager.run(strategy, entryOrder); DecimalFormat df = new DecimalFormat("##.##"); System.out.println("------------ Borrowing Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println( "Borrowing cost for " + df.format(trade.getExit().getIndex() - trade.getEntry().getIndex()) + " periods is: " + df.format(trade.getHoldingCost().doubleValue()))); System.out.println("------------ Transaction Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println("Transaction cost for selling: " + df.format(trade.getEntry().getCost().doubleValue()) + " -- Transaction cost for buying: " + df.format(trade.getExit().getCost().doubleValue()))); } static void main(String[] args); }### Answer: @Test public void test() { TradeCost.main(null); }
### Question: CashFlowToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); CashFlow cashFlow = new CashFlow(series, tradingRecord); TimeSeriesCollection datasetAxis1 = new TimeSeriesCollection(); datasetAxis1.addSeries(buildChartBarSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); TimeSeriesCollection datasetAxis2 = new TimeSeriesCollection(); datasetAxis2.addSeries(buildChartBarSeries(series, cashFlow, "Cash Flow")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", datasetAxis1, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addCashFlowAxis(plot, datasetAxis2); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { CashFlowToChart.main(null); }
### Question: BuyAndSellSignalsToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartTimeSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addBuySellSignals(series, strategy, plot); displayChart(chart); } static void main(String[] args); }### Answer: @Test public void test() { BuyAndSellSignalsToChart.main(null); }
### Question: TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("******************** Initialization ******************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecord(); System.out.println("**********************************************************"); for (int i = 0; i < 50; i++) { Thread.sleep(30); Bar newBar = generateRandomBar(); System.out.println("------------------------------------------------------\n" + "Bar " + i + " added, close price = " + newBar.getClosePrice().doubleValue()); series.addBar(newBar); int endIndex = series.getEndIndex(); if (strategy.shouldEnter(endIndex)) { System.out.println("Strategy should ENTER on " + endIndex); boolean entered = tradingRecord.enter(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (entered) { Order entry = tradingRecord.getLastEntry(); System.out.println("Entered on " + entry.getIndex() + " (price=" + entry.getNetPrice().doubleValue() + ", amount=" + entry.getAmount().doubleValue() + ")"); } } else if (strategy.shouldExit(endIndex)) { System.out.println("Strategy should EXIT on " + endIndex); boolean exited = tradingRecord.exit(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (exited) { Order exit = tradingRecord.getLastExit(); System.out.println("Exited on " + exit.getIndex() + " (price=" + exit.getNetPrice().doubleValue() + ", amount=" + exit.getAmount().doubleValue() + ")"); } } } } static void main(String[] args); }### Answer: @Test public void test() throws InterruptedException { TradingBotOnMovingBarSeries.main(null); }
### Question: CsvTradesLoader { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tNumber of trades: " + series.getBar(0).getTrades() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } static BarSeries loadBitstampSeries(); static void main(String[] args); }### Answer: @Test public void test() { CsvTradesLoader.main(null); }
### Question: CsvBarsLoader { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tOpen price: " + series.getBar(0).getOpenPrice() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } static BarSeries loadAppleIncSeries(); static BarSeries loadCsvSeries(String filename); static void main(String[] args); }### Answer: @Test public void test() { CsvBarsLoader.main(null); }
### Question: XorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) ^ rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } XorRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertTrue(satisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.xor(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.xor(unsatisfiedRule).isSatisfied(0)); assertFalse(satisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertFalse(BooleanRule.TRUE.xor(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.xor(unsatisfiedRule).isSatisfied(10)); }

Subsets and Splits