method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
WebDavMessage extends MimeMessage { @Override public void setFlag(Flag flag, boolean set) throws MessagingException { super.setFlag(flag, set); mFolder.setFlags(Collections.singletonList(this), Collections.singleton(flag), set); } WebDavMessage(String uid, Folder folder); void setUrl(String url); String getUrl(); void setSize(int size); void setFlagInternal(Flag flag, boolean set); void setNewHeaders(ParsedMessageEnvelope envelope); @Override void delete(String trashFolderName); @Override void setFlag(Flag flag, boolean set); }### Answer:
@Test public void setFlag_asks_folder_to_set_flag() throws MessagingException { message.setFlag(Flag.FLAGGED, true); verify(mockFolder).setFlags(Collections.singletonList(message), Collections.singleton(Flag.FLAGGED), true); } |
### Question:
ResponseCodeExtractor { public static String getResponseCode(ImapResponse response) { if (response.size() < 2 || !response.isList(1)) { return null; } ImapList responseTextCode = response.getList(1); return responseTextCode.size() != 1 ? null : responseTextCode.getString(0); } private ResponseCodeExtractor(); static String getResponseCode(ImapResponse response); static final String AUTHENTICATION_FAILED; }### Answer:
@Test public void getResponseCode_withResponseCode() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [AUTHENTICATIONFAILED] No sir"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertEquals("AUTHENTICATIONFAILED", result); }
@Test public void getResponseCode_withoutResponseCode() throws Exception { ImapResponse imapResponse = createImapResponse("x NO Authentication failed"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertNull(result); }
@Test public void getResponseCode_withoutSingleItemResponse() throws Exception { ImapResponse imapResponse = createImapResponse("x NO"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertNull(result); } |
### Question:
NamespaceResponse { public static NamespaceResponse parse(List<ImapResponse> responses) { for (ImapResponse response : responses) { NamespaceResponse prefix = parse(response); if (prefix != null) { return prefix; } } return null; } private NamespaceResponse(String prefix, String hierarchyDelimiter); static NamespaceResponse parse(List<ImapResponse> responses); String getPrefix(); String getHierarchyDelimiter(); }### Answer:
@Test public void parse_withoutNamespaceResponse_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* OK Some text here"); assertNull(result); }
@Test public void parse_withTooShortNamespaceResponse_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE NIL NIL"); assertNull(result); }
@Test public void parse_withPersonalNamespacesNotPresent_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE NIL NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyListForPersonalNamespaces_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE () NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyListForFirstPersonalNamespace_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE (()) NIL NIL"); assertNull(result); }
@Test public void parse_withIncompleteFirstPersonalNamespace_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE ((\"\")) NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyResponseList() throws Exception { NamespaceResponse result = NamespaceResponse.parse(Collections.<ImapResponse>emptyList()); assertNull(result); } |
### Question:
ListResponse { public static List<ListResponse> parseList(List<ImapResponse> responses) { return parse(responses, Responses.LIST); } private ListResponse(List<String> attributes, String hierarchyDelimiter, String name); static List<ListResponse> parseList(List<ImapResponse> responses); static List<ListResponse> parseLsub(List<ImapResponse> responses); List<String> getAttributes(); boolean hasAttribute(String attribute); @Nullable String getHierarchyDelimiter(); String getName(); }### Answer:
@Test public void parseList_withValidResponses_shouldReturnListResponses() throws Exception { List<ImapResponse> responses = asList( createImapResponse("* LIST () \"/\" blurdybloop"), createImapResponse("* LIST (\\Noselect) \"/\" foo"), createImapResponse("* LIST () \"/\" foo/bar"), createImapResponse("* LIST (\\NoInferiors) NIL INBOX"), createImapResponse("X OK LIST completed") ); List<ListResponse> result = ListResponse.parseList(responses); assertEquals(4, result.size()); assertListResponseEquals(noAttributes(), "/", "blurdybloop", result.get(0)); assertListResponseEquals(singletonList("\\Noselect"), "/", "foo", result.get(1)); assertListResponseEquals(noAttributes(), "/", "foo/bar", result.get(2)); assertListResponseEquals(singletonList("\\NoInferiors"), null, "INBOX", result.get(3)); } |
### Question:
ListResponse { public static List<ListResponse> parseLsub(List<ImapResponse> responses) { return parse(responses, Responses.LSUB); } private ListResponse(List<String> attributes, String hierarchyDelimiter, String name); static List<ListResponse> parseList(List<ImapResponse> responses); static List<ListResponse> parseLsub(List<ImapResponse> responses); List<String> getAttributes(); boolean hasAttribute(String attribute); @Nullable String getHierarchyDelimiter(); String getName(); }### Answer:
@Test public void parseLsub_withValidResponse_shouldReturnListResponse() throws Exception { List<ImapResponse> responses = singletonList(createImapResponse("* LSUB () \".\" \"Folder\"")); List<ListResponse> result = ListResponse.parseLsub(responses); assertEquals(1, result.size()); assertListResponseEquals(noAttributes(), ".", "Folder", result.get(0)); } |
### 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:
ImapConnection { public List<ImapResponse> executeSimpleCommand(String command) throws IOException, MessagingException { return executeSimpleCommand(command, false); } 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 executeSingleCommand_withOkResponse_shouldReturnResult() throws Exception { MockImapServer server = new MockImapServer(); simpleOpenDialog(server, ""); server.expect("4 CREATE Folder"); server.output("4 OK Folder created"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); List<ImapResponse> result = imapConnection.executeSimpleCommand("CREATE Folder"); assertEquals(result.size(), 1); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void executeSingleCommand_withNoResponse_shouldThrowNegativeImapResponseException() throws Exception { MockImapServer server = new MockImapServer(); simpleOpenDialog(server, ""); server.expect("4 CREATE Folder"); server.output("4 NO Folder exists"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.executeSimpleCommand("CREATE Folder"); fail("Expected exception"); } catch (NegativeImapResponseException e) { assertEquals("Folder exists", e.getLastResponse().getString(1)); } 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:
ImapUtility { public static List<String> getImapSequenceValues(String set) { List<String> list = new ArrayList<String>(); if (set != null) { String[] setItems = set.split(","); for (String item : setItems) { if (item.indexOf(':') == -1) { if (isNumberValid(item)) { list.add(item); } } else { list.addAll(getImapRangeValues(item)); } } } return list; } static List<String> getImapSequenceValues(String set); static List<String> getImapRangeValues(String range); static String encodeString(String str); static ImapResponse getLastResponse(List<ImapResponse> responses); }### Answer:
@Test public void testGetImapSequenceValues() { String[] expected; List<String> actual; expected = new String[] {"1"}; actual = ImapUtility.getImapSequenceValues("1"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"2147483648"}; actual = ImapUtility.getImapSequenceValues("2147483648"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"4294967295"}; actual = ImapUtility.getImapSequenceValues("4294967295"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"1", "3", "2"}; actual = ImapUtility.getImapSequenceValues("1,3,2"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"4", "5", "6"}; actual = ImapUtility.getImapSequenceValues("4:6"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"9", "8", "7"}; actual = ImapUtility.getImapSequenceValues("9:7"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"1", "2", "3", "4", "9", "8", "7"}; actual = ImapUtility.getImapSequenceValues("1,2:4,9:7"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"2147483646", "2147483647", "2147483648"}; actual = ImapUtility.getImapSequenceValues("2147483646:2147483648"); assertArrayEquals(expected, actual.toArray()); expected = new String[] { "1", "5" }; actual = ImapUtility.getImapSequenceValues("1,x,5"); assertArrayEquals(expected, actual.toArray()); expected = new String[] { "1", "2", "3" }; actual = ImapUtility.getImapSequenceValues("a:d,1:3"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues(""); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues(null); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("a"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("1:x"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("4294967296:4294967297"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("4294967296"); assertArrayEquals(expected, actual.toArray()); } |
### Question:
ImapUtility { public static List<String> getImapRangeValues(String range) { List<String> list = new ArrayList<String>(); try { if (range != null) { int colonPos = range.indexOf(':'); if (colonPos > 0) { long first = Long.parseLong(range.substring(0, colonPos)); long second = Long.parseLong(range.substring(colonPos + 1)); if (is32bitValue(first) && is32bitValue(second)) { if (first < second) { for (long i = first; i <= second; i++) { list.add(Long.toString(i)); } } else { for (long i = first; i >= second; i--) { list.add(Long.toString(i)); } } } else { Timber.d("Invalid range: %s", range); } } } } catch (NumberFormatException e) { Timber.d(e, "Invalid range value: %s", range); } return list; } static List<String> getImapSequenceValues(String set); static List<String> getImapRangeValues(String range); static String encodeString(String str); static ImapResponse getLastResponse(List<ImapResponse> responses); }### Answer:
@Test public void testGetImapRangeValues() { String[] expected; List<String> actual; expected = new String[] {"1", "2", "3"}; actual = ImapUtility.getImapRangeValues("1:3"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"16", "15", "14"}; actual = ImapUtility.getImapRangeValues("16:14"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues(""); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues(null); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("a"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("6"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:3,6"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:x"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:*"); assertArrayEquals(expected, actual.toArray()); } |
### 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:
AlertResponse { public static String getAlertText(ImapResponse response) { if (response.size() < 3 || !response.isList(1)) { return null; } ImapList responseTextCode = response.getList(1); if (responseTextCode.size() != 1 || !equalsIgnoreCase(responseTextCode.get(0), ALERT_RESPONSE_CODE)) { return null; } return response.getString(2); } private AlertResponse(); static String getAlertText(ImapResponse response); }### Answer:
@Test public void getAlertText_withProperAlertResponse() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT] Please don't do that"); String result = AlertResponse.getAlertText(imapResponse); assertEquals("Please don't do that", result); }
@Test public void getAlertText_withoutResponseCodeText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withoutAlertText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT]"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withoutResponseCodeTextList_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO ALERT ALARM!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withResponseCodeTextContainingTooManyItems_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT SOMETHING] ALARM!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withWrongResponseCodeText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALARM] ALERT!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); } |
### Question:
CapabilityResponse { public static CapabilityResponse parse(List<ImapResponse> responses) { for (ImapResponse response : responses) { CapabilityResponse result; if (!response.isEmpty() && equalsIgnoreCase(response.get(0), Responses.OK) && response.isList(1)) { ImapList capabilityList = response.getList(1); result = parse(capabilityList); } else if (response.getTag() == null) { result = parse(response); } else { result = null; } if (result != null) { return result; } } return null; } private CapabilityResponse(Set<String> capabilities); static CapabilityResponse parse(List<ImapResponse> responses); Set<String> getCapabilities(); }### Answer:
@Test public void parse_withTaggedResponse_shouldReturnNull() throws Exception { CapabilityResponse result = parse("1 OK"); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { CapabilityResponse result = parse("* BAD Go Away"); assertNull(result); }
@Test public void parse_withOkResponseWithoutList_shouldReturnNull() throws Exception { CapabilityResponse result = parse("* OK Welcome"); assertNull(result); }
@Test public void parse_withListInCapabilityResponse_shouldReturnNull() throws Exception { ImapList list = createImapResponse("* CAPABILITY IMAP4rev1 []"); CapabilityResponse result = CapabilityResponse.parse(list); assertNull(result); }
@Test public void parse_withoutCapabilityResponse_shouldReturnNull() throws Exception { ImapList list = createImapResponse("* EXISTS 1"); CapabilityResponse result = CapabilityResponse.parse(list); assertNull(result); }
@Test public void parse_withEmptyResponseList_shouldReturnNull() throws Exception { List<ImapResponse> responses = Collections.emptyList(); CapabilityResponse result = CapabilityResponse.parse(responses); assertNull(result); }
@Test public void parse_withoutCapabilityResponseInResponseList_shouldReturnNull() throws Exception { List<ImapResponse> responses = Collections.singletonList(createImapResponse("* EXISTS 42")); CapabilityResponse result = CapabilityResponse.parse(responses); assertNull(result); } |
### Question:
PermanentFlagsResponse { public static PermanentFlagsResponse parse(ImapResponse response) { if (response.isTagged() || !equalsIgnoreCase(response.get(0), Responses.OK) || !response.isList(1)) { return null; } ImapList responseTextList = response.getList(1); if (responseTextList.size() < 2 || !equalsIgnoreCase(responseTextList.get(0), Responses.PERMANENTFLAGS) || !responseTextList.isList(1)) { return null; } ImapList permanentFlagsList = responseTextList.getList(1); int size = permanentFlagsList.size(); Set<Flag> flags = new HashSet<>(size); boolean canCreateKeywords = false; for (int i = 0; i < size; i++) { if (!permanentFlagsList.isString(i)) { return null; } String flag = permanentFlagsList.getString(i); String compareFlag = flag.toLowerCase(Locale.US); switch (compareFlag) { case "\\deleted": { flags.add(Flag.DELETED); break; } case "\\answered": { flags.add(Flag.ANSWERED); break; } case "\\seen": { flags.add(Flag.SEEN); break; } case "\\flagged": { flags.add(Flag.FLAGGED); break; } case "$forwarded": { flags.add(Flag.FORWARDED); break; } case "\\*": { canCreateKeywords = true; break; } } } return new PermanentFlagsResponse(flags, canCreateKeywords); } private PermanentFlagsResponse(Set<Flag> flags, boolean canCreateKeywords); static PermanentFlagsResponse parse(ImapResponse response); Set<Flag> getFlags(); boolean canCreateKeywords(); }### Answer:
@Test public void parse_withTaggedResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("1 OK [PERMANENTFLAGS (\\Deleted \\Seen)] Flags permitted."); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* BYE See you"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutResponseText_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK Success"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withTooShortResponseText_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutPermanentFlagsResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [UIDNEXT 1]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutPermanentFlagsList_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS none]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withInvalidElementInPermanentFlagsList_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS (\\Seen ())]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(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:
ImapFolder extends Folder<ImapMessage> { @Override public void open(int mode) throws MessagingException { internalOpen(mode); if (messageCount == -1) { throw new MessagingException("Did not find message count during open"); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void open_calledTwice_shouldReuseSameImapConnection() throws Exception { ImapFolder imapFolder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); imapFolder.open(OPEN_MODE_RW); imapFolder.open(OPEN_MODE_RW); verify(imapStore, times(1)).getConnection(); } |
### Question:
ImapFolder extends Folder<ImapMessage> { private boolean exists(String escapedFolderName) throws MessagingException { try { connection.executeSimpleCommand(String.format("STATUS %s (RECENT)", escapedFolderName)); return true; } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } catch (NegativeImapResponseException e) { return false; } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void exists_withoutNegativeImapResponse_shouldReturnTrue() throws Exception { ImapFolder imapFolder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); boolean folderExists = imapFolder.exists(); assertTrue(folderExists); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public boolean create(FolderType type) throws MessagingException { ImapConnection connection; synchronized (this) { if (this.connection == null) { connection = store.getConnection(); } else { connection = this.connection; } } try { String encodedFolderName = folderNameCodec.encode(getPrefixedId()); String escapedFolderName = ImapUtility.encodeString(encodedFolderName); connection.executeSimpleCommand(String.format("CREATE %s", escapedFolderName)); return true; } catch (NegativeImapResponseException e) { return false; } catch (IOException ioe) { throw ioExceptionHandler(this.connection, ioe); } finally { if (this.connection == null) { store.releaseConnection(connection); } } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void create_withoutNegativeImapResponse_shouldReturnTrue() throws Exception { ImapFolder imapFolder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); boolean success = imapFolder.create(FolderType.HOLDS_MESSAGES); assertTrue(success); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public Map<String, String> moveMessages(List<? extends Message> messages, Folder folder) throws MessagingException { if (messages.isEmpty()) { return null; } Map<String, String> uidMapping = copyMessages(messages, folder); setFlags(messages, Collections.singleton(Flag.DELETED), true); return uidMapping; } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void moveMessages_withEmptyMessageList_shouldReturnNull() throws Exception { ImapFolder sourceFolder = createFolder("Source"); ImapFolder destinationFolder = createFolder("Destination"); List<ImapMessage> messages = Collections.emptyList(); Map<String, String> uidMapping = sourceFolder.moveMessages(messages, destinationFolder); assertNull(uidMapping); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public void delete(List<? extends Message> messages, String trashFolderName) throws MessagingException { if (messages.isEmpty()) { return; } if (trashFolderName == null || getId().equalsIgnoreCase(trashFolderName)) { setFlags(messages, Collections.singleton(Flag.DELETED), true); } else { ImapFolder remoteTrashFolder = getStore().getFolder(trashFolderName); String encodedTrashFolderName = folderNameCodec.encode(remoteTrashFolder.getPrefixedId()); String escapedTrashFolderName = ImapUtility.encodeString(encodedTrashFolderName); if (!exists(escapedTrashFolderName)) { if (K9MailLib.isDebug()) { Timber.i("IMAPMessage.delete: attempting to create remote '%s' folder for %s", trashFolderName, getLogId()); } remoteTrashFolder.create(FolderType.HOLDS_MESSAGES); } if (exists(escapedTrashFolderName)) { if (K9MailLib.isDebug()) { Timber.d("IMAPMessage.delete: copying remote %d messages to '%s' for %s", messages.size(), trashFolderName, getLogId()); } moveMessages(messages, remoteTrashFolder); } else { throw new MessagingException("IMAPMessage.delete: remote Trash folder " + trashFolderName + " does not exist and could not be created for " + getLogId(), true); } } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void delete_withEmptyMessageList_shouldNotInteractWithImapConnection() throws Exception { ImapFolder folder = createFolder("Source"); List<ImapMessage> messages = Collections.emptyList(); folder.delete(messages, "Trash"); verifyNoMoreInteractions(imapConnection); }
@Test(expected = Error.class) public void delete_notImplemented() throws Exception { ImapFolder folder = createFolder("Folder"); folder.delete(false); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public int getUnreadMessageCount() throws MessagingException { return getRemoteMessageCount("UNSEEN NOT DELETED"); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getUnreadMessageCount_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getUnreadMessageCount(); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getUnreadMessageCount() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = singletonList(createImapResponse("* SEARCH 1 2 3")); when(imapConnection.executeSimpleCommand("SEARCH 1:* UNSEEN NOT DELETED")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); int unreadMessageCount = folder.getUnreadMessageCount(); assertEquals(3, unreadMessageCount); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public int getFlaggedMessageCount() throws MessagingException { return getRemoteMessageCount("FLAGGED NOT DELETED"); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getFlaggedMessageCount_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getFlaggedMessageCount(); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getFlaggedMessageCount() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = asList( createImapResponse("* SEARCH 1 2"), createImapResponse("* SEARCH 23 42") ); when(imapConnection.executeSimpleCommand("SEARCH 1:* FLAGGED NOT DELETED")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); int flaggedMessageCount = folder.getFlaggedMessageCount(); assertEquals(4, flaggedMessageCount); } |
### Question:
ImapFolder extends Folder<ImapMessage> { protected long getHighestUid() throws MessagingException { try { String command = "UID SEARCH *:*"; List<ImapResponse> responses = executeSimpleCommand(command); SearchResponse searchResponse = SearchResponse.parse(responses); return extractHighestUid(searchResponse); } catch (NegativeImapResponseException e) { return -1L; } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getHighestUid() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = singletonList(createImapResponse("* SEARCH 42")); when(imapConnection.executeSimpleCommand("UID SEARCH *:*")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); long highestUid = folder.getHighestUid(); assertEquals(42L, highestUid); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public List<ImapMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<ImapMessage> listener) throws MessagingException { return getMessages(start, end, earliestDate, false, listener); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getMessages_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessages(1, 5, null, null); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getMessages_sequenceNumbers_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessages(asList(1L, 2L, 5L), false, null); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } } |
### Question:
ImapFolder extends Folder<ImapMessage> { protected List<ImapMessage> getMessagesFromUids(final List<String> mesgUids) throws MessagingException { ImapSearcher searcher = new ImapSearcher() { @Override public List<ImapResponse> search() throws IOException, MessagingException { String command = String.format("UID SEARCH UID %s", combine(mesgUids.toArray(), ',')); return executeSimpleCommand(command); } }; return search(searcher, null); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getMessagesFromUids_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessagesFromUids(asList("11", "22", "25")); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getMessagesFromUids() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = asList( createImapResponse("* SEARCH 11"), createImapResponse("* SEARCH 22"), createImapResponse("* SEARCH 25") ); when(imapConnection.executeSimpleCommand("UID SEARCH UID 11,22,25")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); List<ImapMessage> messages = folder.getMessagesFromUids(asList("11", "22", "25")); assertNotNull(messages); assertEquals(newSet("11", "22", "25"), extractMessageUids(messages)); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate) throws IOException, MessagingException { checkOpen(); if (indexOfOldestMessage == 1) { return false; } String dateSearchString = getDateSearchString(earliestDate); int endIndex = indexOfOldestMessage - 1; while (endIndex > 0) { int startIndex = Math.max(0, endIndex - MORE_MESSAGES_WINDOW_SIZE) + 1; if (existsNonDeletedMessageInRange(startIndex, endIndex, dateSearchString)) { return true; } endIndex = endIndex - MORE_MESSAGES_WINDOW_SIZE; } return false; } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void areMoreMessagesAvailable_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.areMoreMessagesAvailable(10, new Date()); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public String getNewPushState(String oldSerializedPushState, Message message) { try { String uid = message.getUid(); long messageUid = Long.parseLong(uid); ImapPushState oldPushState = ImapPushState.parse(oldSerializedPushState); if (messageUid >= oldPushState.uidNext) { long uidNext = messageUid + 1; ImapPushState newPushState = new ImapPushState(uidNext); return newPushState.toString(); } else { return null; } } catch (Exception e) { Timber.e(e, "Exception while updated push state for %s", getLogId()); return null; } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getNewPushState_withNewerUid_shouldReturnNewPushState() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); ImapMessage message = createImapMessage("2"); String newPushState = folder.getNewPushState("uidNext=2", message); assertEquals("uidNext=3", newPushState); }
@Test public void getNewPushState_withoutNewerUid_shouldReturnNull() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); ImapMessage message = createImapMessage("1"); String newPushState = folder.getNewPushState("uidNext=2", message); assertNull(newPushState); } |
### Question:
ImapFolder extends Folder<ImapMessage> { @Override public ImapMessage getMessage(String uid) throws MessagingException { return new ImapMessage(uid, this); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); }### Answer:
@Test public void getMessageByUid_returnsNewImapMessageWithUidInFolder() throws Exception { ImapFolder folder = createFolder("Folder"); ImapMessage message = folder.getMessage("uid"); assertEquals("uid", message.getUid()); assertEquals(folder, message.getFolder()); } |
### 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:
Message implements Part, Body { @Override public boolean equals(Object o) { if (o == null || !(o instanceof Message)) { return false; } Message other = (Message)o; return (getUid().equals(other.getUid()) && getFolder().getId().equals(other.getFolder().getId())); } boolean olderThan(Date earliestDate); @Override boolean equals(Object o); @Override int hashCode(); String getUid(); void setUid(String uid); Folder getFolder(); abstract String getSubject(); abstract void setSubject(String subject); Date getInternalDate(); void setInternalDate(Date internalDate); abstract Date getSentDate(); abstract void setSentDate(Date sentDate, boolean hideTimeZone); abstract Address[] getRecipients(RecipientType type); abstract void setRecipients(RecipientType type, Address[] addresses); void setRecipient(RecipientType type, Address address); abstract Address[] getFrom(); abstract void setFrom(Address from); abstract Address[] getSender(); abstract void setSender(Address sender); abstract Address[] getReplyTo(); abstract void setReplyTo(Address[] from); abstract String getMessageId(); abstract void setInReplyTo(String inReplyTo); abstract String[] getReferences(); abstract void setReferences(String references); @Override abstract Body getBody(); @Override abstract void addHeader(String name, String value); @Override abstract void addRawHeader(String name, String raw); @Override abstract void setHeader(String name, String value); @NonNull @Override abstract String[] getHeader(String name); abstract Set<String> getHeaderNames(); @Override abstract void removeHeader(String name); @Override abstract void setBody(Body body); abstract boolean hasAttachments(); abstract long getSize(); void delete(String trashFolderName); Set<Flag> getFlags(); void setFlag(Flag flag, boolean set); void setFlags(final Set<Flag> flags, boolean set); boolean isSet(Flag flag); void destroy(); @Override abstract void setEncoding(String encoding); abstract void setCharset(String charset); long calculateSize(); @Override abstract Message clone(); }### Answer:
@Test public void equals_whenFolderIdDifferent_isFalse() { SimpleFolder folder1 = new SimpleFolder(); folder1.id = "1"; SimpleFolder folder2 = new SimpleFolder(); folder2.id = "2"; String uid = "uid"; Message m1 = new StoredMimeMessage(folder1, uid); Message m2 = new StoredMimeMessage(folder2, uid); boolean result = m1.equals(m2); assertFalse(result); }
@Test public void equals_whenUidDifferent_isFalse() { SimpleFolder folder = new SimpleFolder(); folder.id = "1"; String uid1 = "uid1"; String uid2 = "uid2"; Message m1 = new StoredMimeMessage(folder, uid1); Message m2 = new StoredMimeMessage(folder, uid2); boolean result = m1.equals(m2); assertFalse(result); }
@Test public void equals_whenUidAndFolderSame_isTrue() { SimpleFolder folder1 = new SimpleFolder(); folder1.id = "1"; SimpleFolder folder2 = new SimpleFolder(); folder2.id = "1"; String uid = "uid"; Message m1 = new StoredMimeMessage(folder1, uid); Message m2 = new StoredMimeMessage(folder2, uid); boolean result = m1.equals(m2); assertTrue(result); } |
### Question:
HttpUriParser implements UriParser { @Override public int linkifyUri(String text, int startPos, StringBuffer outputBuffer) { int currentPos = startPos; String shortScheme = text.substring(currentPos, Math.min(currentPos + 7, text.length())); String longScheme = text.substring(currentPos, Math.min(currentPos + 8, text.length())); if (longScheme.equalsIgnoreCase("https: currentPos += "https: } else if (shortScheme.equalsIgnoreCase("http: currentPos += "http: } else if (shortScheme.equalsIgnoreCase("rtsp: currentPos += "rtsp: } else { return startPos; } int matchedAuthorityEnd = tryMatchAuthority(text, currentPos); if (matchedAuthorityEnd == currentPos) { return startPos; } currentPos = matchedAuthorityEnd; if (currentPos < text.length() && text.charAt(currentPos) == '/') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, "/:@"); } if (currentPos < text.length() && text.charAt(currentPos) == '?') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, ":@/?"); } if (currentPos < text.length() && text.charAt(currentPos) == '#') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, ":@/?"); } String httpUri = text.substring(startPos, currentPos); outputBuffer.append("<a href=\"") .append(httpUri) .append("\">") .append(httpUri) .append("</a>"); return currentPos; } @Override int linkifyUri(String text, int startPos, StringBuffer outputBuffer); }### Answer:
@Test public void domainWithTrailingSpace() { String text = "http: int endPos = parser.linkifyUri(text, 0, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void domainWithTrailingNewline() { String text = "http: int endPos = parser.linkifyUri(text, 0, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void domainWithTrailingAngleBracket() { String text = "<http: int endPos = parser.linkifyUri(text, 1, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void uriInMiddleAfterInput() { String prefix = "prefix "; String uri = "http: String text = prefix + uri; parser.linkifyUri(text, prefix.length(), outputBuffer); assertLinkOnly(uri, outputBuffer); }
@Test public void uriInMiddleOfInput() { String prefix = "prefix "; String uri = "http: String postfix = " postfix"; String text = prefix + uri + postfix; parser.linkifyUri(text, prefix.length(), outputBuffer); assertLinkOnly(uri, outputBuffer); } |
### 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 ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }### Answer:
@Test public void comma_or_return_line_separated_numbers_return_sum() { Assert.assertEquals(6, this.calculator.add("1\n2,3")); }
@Test public void any_delimited_numbers_return_sum() { Assert.assertEquals(3, this.calculator.add(" }
@Test public void negative_number_throw_exception() { this.exception.expect(RuntimeException.class); this.exception.expectMessage("negativos no soportados: -1"); this.calculator.add("-1"); }
@Test public void multiple_negative_number_throw_exception() { this.exception.expect(RuntimeException.class); this.exception.expectMessage("negativos no soportados: -1,-2"); this.calculator.add("-1,-2"); }
@Test public void numbers_greater_than_thousand_not_sum() { Assert.assertEquals(3, this.calculator.add("1,2,1001")); }
@Test public void any_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
@Test public void any_multiple_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
@Test public void empty_string_return_zero() { Assert.assertEquals(0, this.calculator.add("")); }
@Test public void one_number_return_number() { Assert.assertEquals(1, this.calculator.add("1")); Assert.assertEquals(2, this.calculator.add("2")); }
@Test public void two_comma_separated_number_return_sum() { Assert.assertEquals(3, this.calculator.add("1,2")); }
@Test public void comma_separated_numbers_return_sum() { Assert.assertEquals(6, this.calculator.add("1,2,3")); } |
### 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:
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }### Answer:
@Test public final void sameMovesReturnDraw() { Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SCISSORS, RockPaper.SCISSORS)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.PAPER, RockPaper.PAPER)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.ROCK, RockPaper.ROCK)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.LIZZARD, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SPOCK, RockPaper.SPOCK)); }
@Test public final void scissorsCutPaper() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.SCISSORS, RockPaper.PAPER)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.PAPER, RockPaper.SCISSORS)); }
@Test public final void paperCoversRock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.ROCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.ROCK, RockPaper.PAPER)); }
@Test public final void rockCrushersLizard() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.ROCK, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.LIZZARD, RockPaper.ROCK)); }
@Test public final void paperDisprovesSpock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.SPOCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.SPOCK, RockPaper.PAPER)); } |
### Question:
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; }### Answer:
@Test public void headersAndStatus() { Map<String, List<String>> headers = Maps.newHashMap(); headers.put("Etag", Lists.newArrayList("c1dc8d7be85325149", "ed5fc4d62b84752")); headers.put("Date", Lists.newArrayList("Wed, 11 Jan 2017 13:00:18 GMT")); HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals(new Integer(200), result.getHttpStatus()); assertEquals(2, result.getHeaders().size()); assertEquals("c1dc8d7be85325149\ned5fc4d62b84752", result.getHeaders().get("Etag")); assertEquals("Wed, 11 Jan 2017 13:00:18 GMT", result.getHeaders().get("Date")); }
@Test public void htmlParsing() { HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertEquals("Bloomberg.com", result.getTitle()); assertEquals(33, result.getMetaValues().size()); assertTrue(result.getMetaValues().contains("<meta property=\"og:url\" content=\"https: assertEquals(361, result.getLinks().size()); assertTrue(result.getLinks().contains("https: }
@Test @Ignore public void fetchAndParse() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals("TokenMill - Natural Language Processing", result.getTitle()); assertEquals(10, result.getMetaValues().size()); assertEquals(42, result.getLinks().size()); assertTrue(result.getLinks().contains("http: assertTrue(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertEquals(Lists.newArrayList(), result.getRobotsSitemaps()); assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); }
@Test @Ignore public void fetchAndParseRobotsTxt() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertFalse(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertTrue(result.getRobotsSitemaps().contains("http: assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); } |
### 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:
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }### Answer:
@Test public void simple_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"b\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
@Test public void double_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"{{value}}\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
@Test public void simple_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a.b"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
@Test public void double_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.c.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
@Test public void double_nested_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); }
@Test public void mixed_data_types() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}, \"num\": 343, \"bool\": true}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); } |
### Question:
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } @OnScheduled void startup(ConfigurationContext context); @Override void onTrigger(ReportingContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }### Answer:
@Test public void testIsValid() throws MalformedObjectNameException { ObjectName o = new ObjectName("domain", "key", "value"); Set<String> mapNames = ImmutableSet.of("foo"); HazelcastMapMetricsReporter hazelcastMapMetricsReporter = new HazelcastMapMetricsReporter(); boolean isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, "cluster"); assertFalse(isValid); String c = "foo"; o = new ObjectName("com.hazelcast", "key", "value"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); o = new ObjectName("com.hazelcast", "name", "foo"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); Hashtable<String, String> keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); keys.put("instance", "foo"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertTrue(isValid); } |
### Question:
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } @OnScheduled void startup(ConfigurationContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }### Answer:
@Test public void testCollectMeasurements() throws InitializationException { InfluxNiFiClusterMetricsReporter metricsInfluxDbReporter = new InfluxNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); BatchPoints batchPoints = BatchPoints .database("mock_database") .build(); metricsInfluxDbReporter.collectMeasurements(System.currentTimeMillis(), metrics, batchPoints); List<Point> points = batchPoints.getPoints(); assertEquals(4, points.size()); } |
### Question:
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); @OnScheduled void startup(ConfigurationContext context); static final PropertyDescriptor CREDENTIALS_FILE; static final PropertyDescriptor ACCESS_KEY; static final PropertyDescriptor SECRET_KEY; }### Answer:
@Test public void testCollectMeasurements() throws InitializationException { CloudwatchNiFiClusterMetricsReporter metricsCloudwatchReporter = new CloudwatchNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); List<Dimension> dimensions = new ArrayList<>(); List<MetricDatum> cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(10, cloudwatchMetrics.size()); metricsCloudwatchReporter.collectsJVMMetrics = true; metricsCloudwatchReporter.collectsMemory = true; cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(12, cloudwatchMetrics.size()); } |
### 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:
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); final int[] sparse; final int[] dense; final int[] counts; public int elementsCount; }### Answer:
@Test public void testSimple() { DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(10, 5); assertEquals(0, s.elementsCount); s.increment(3); assertEquals(1, s.elementsCount); assertEquals(1, s.counts[0]); assertEquals(3, s.dense[0]); s.increment(10); assertEquals(2, s.elementsCount); assertEquals(1, s.counts[1]); assertEquals(10, s.dense[1]); s.increment(3); assertEquals(2, s.elementsCount); assertEquals(2, s.counts[0]); }
@Test @Repeat(iterations = 20) public void testRandomized() { int maxValue = randomIntBetween(0, 1000); int maxValues = randomIntBetween(0, maxValue); int [] values = new int [maxValues]; for (int i = 0; i < values.length; i++) { values[i] = randomIntBetween(0, maxValue); } DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(maxValue, maxValues); IntIntOpenHashMap ref = IntIntOpenHashMap.newInstance(); for (int i = 0; i < maxValues * 10; i++) { int r = values[randomIntBetween(0, values.length - 1)]; ref.addTo(r, 1); s.increment(r); } IntIntOpenHashMap result = IntIntOpenHashMap.newInstance(); for (int i = 0; i < s.elementsCount; i++) { int k = s.dense[i]; int v = s.counts[i]; assertTrue(!result.containsKey(k)); result.put(k, v); } assertEquals(ref, result); } |
### 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:
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } Model(String [] langClasses, float [] ptc, float [] pc, short [] dsa, int[][] dsaOutput); static Model readExternal(ObjectInput in); static Model detectOnly(Set<String> langCodes); Set<String> getDetectedLanguages(); static synchronized Model defaultModel(); }### Answer:
@Test @Seeds(value = { @Seed, @Seed("deadbeef") }) public void testSameResultWithTrimmedLanguages() { final Set<String> allowed = Sets.newHashSet("en", "de", "es", "fr", "it", "pl"); LangIdV3 v1 = new LangIdV3(); LangIdV3 v2 = new LangIdV3(Model.detectOnly(allowed)); for (int i = 0; i < 10000; i++) { String in = randomRealisticUnicodeOfCodepointLengthBetween(1, 300); DetectedLanguage c1 = v1.classify(in, true); DetectedLanguage c2 = v2.classify(in, true); if (allowed.contains(c1.langCode)) { assertEquals(c1.langCode, c2.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:
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } @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 shouldCreateAccount() throws Exception { String description = "Cash"; boolean onBudget = true; long userId = 42L; AccountResource accountResource = new AccountResource(description, onBudget); when(accountServiceMock.create(anyLong(), anyString(), anyBoolean())).thenAnswer(invocation -> new Account(invocation.getArgument(1), invocation.getArgument(2), new User().setId(invocation.getArgument(0))).setId(1L)); final MockHttpServletRequestBuilder requestBuilder = post("/users/{userId}/accounts", userId).accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(accountResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); AccountResource result = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(result.getDescription()).isEqualTo(description); assertThat(result.getOnBudget()).isEqualTo(onBudget); verify(accountServiceMock).create(userId, description, onBudget); } |
### 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 Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @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 calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1.0243, averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(110d / 100).pow(numOf(1d / 3)), averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(95d / 100 * 70d / 100).pow(numOf(1d / 6)), averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateWithNoBarsShouldReturn1() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1, averageProfit.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithOneTrade() { series = new MockBarSeries(numFunction, 100, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(105d / 100).pow(numOf(0.5)), average.calculate(series, trade)); } |
### 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:
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @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 rewardRiskRatioCriterion() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(4, series), Order.buyAt(5, series), Order.sellAt(7, series)); double totalProfit = (105d / 100) * (90d / 95d) * (120d / 95); double peak = (105d / 100) * (100d / 95); double low = (105d / 100) * (90d / 95) * (80d / 95); assertNumEquals(totalProfit / ((peak - low) / peak), rrc.calculate(series, tradingRecord)); }
@Test public void rewardRiskRatioCriterionOnlyWithGain() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); assertTrue(rrc.calculate(series, tradingRecord).isNaN()); }
@Test public void rewardRiskRatioCriterionWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); assertTrue(rrc.calculate(series, new BaseTradingRecord()).isNaN()); }
@Test public void withOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 95, 100, 90, 95, 80, 120); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion ratioCriterion = getCriterion(); assertNumEquals((95d / 100) / ((1d - 0.95d)), ratioCriterion.calculate(series, trade)); } |
### 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 Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } 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 calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(Math.log(90d / 104)), esCriterion.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrade() { List<Double> prices = IntStream.rangeClosed(1, 100).asDoubleStream().boxed().sorted(Collections.reverseOrder()) .collect(Collectors.toList()); series = new MockBarSeries(numFunction, prices); Trade trade = new Trade(Order.buyAt(series.getBeginIndex(), series), Order.sellAt(series.getEndIndex(), series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(-0.35835189384561106), esCriterion.calculate(series, trade)); }
@Test public void calculateWithNoBarsShouldReturn0() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithBuyAndHold() { series = new MockBarSeries(numFunction, 100d, 99d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, trade)); } |
### 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)); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.