Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: NavigationDecorator { public static String explodeHtml(Project project, String html) { return explode(project, html, true); } static String explode(Project project, String plain); static String explodeHtml(Project project, String html); static List<Recognizer> recognizers; }### Answer: @Test public void testExplodeHtml() throws InterruptedException { String value = NavigationDecorator.explodeHtml(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: } @Test public void testExplodeHtmlKeepAHref() throws InterruptedException { String value = NavigationDecorator.explodeHtml(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: }
### Question: WebLinkRecognizer implements Recognizer { @Override public void recognize(String content, List<Candidate> candidates) { Matcher matcher = WEB_PATTERN.matcher(content); while(matcher.find()) { candidates.add(new Candidate(matcher.start(), matcher.end(), "web:" + matcher.group())); } } @Override void recognize(String content, List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }### Answer: @Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix http: recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), "web:http: } @Test public void testMultiple() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix http: recognizer.recognize(value, list); Assert.assertEquals(2, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), "web:http: AbstractRecognizerTest.checkCandidate(list.get(1), "web:https: }
### Question: WebLinkRecognizer implements Recognizer { @Override public boolean navigate(Project project, String hyperlink) { if(hyperlink.startsWith("web:")) { project.getComponent(BrowserUtil.class).launchBrowser(EntityQuery.decode(hyperlink.substring(4))); return true; } else { return false; } } @Override void recognize(String content, List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }### Answer: @Test public void testNavigate() { handler.async(); getComponent(BrowserUtil.class)._setLauncher(new BrowserUtil.Launcher() { @Override public void launchBrowser(final String url) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("http: } }); } }); Assert.assertTrue(recognizer.navigate(getProject(), "web:http: } @Test public void testNavigate_negative() { Assert.assertFalse(recognizer.navigate(getProject(), "")); }
### Question: JavaCompileRecognizer extends ClassRecognizer { @Override public void recognize(String content, List<Candidate> candidates) { Matcher matcher = COMPILE_PATTERN.matcher(content); while(matcher.find()) { candidates.add(new ClassCandidate(matcher.start(), matcher.end(), matcher.start(2), matcher.end(2), matcher.group(3), matcher.group(3), Integer.valueOf(matcher.group(4)), null)); } } @Override void recognize(String content, List<Candidate> candidates); }### Answer: @Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix /usr/src/test/java/hello/HelloWorldTest.java:[19,27] suffix"; recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); checkClassCandidate(list.get(0), "HelloWorldTest", "HelloWorldTest", 19, null, value.indexOf("/"), value.indexOf(" suffix"), value.indexOf("HelloWorldTest"), value.indexOf(":")); } @Test public void testMultiple() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "prefix /usr/src/test/java/hello/HelloWorldTest.java:[19,27] middle\n" + "/var/src/other/OtherWorldTest.java:[11,27] suffix"; recognizer.recognize(value, list); Assert.assertEquals(2, list.size()); checkClassCandidate(list.get(0), "HelloWorldTest", "HelloWorldTest", 19, null, value.indexOf("/usr"), value.indexOf(" middle"), value.indexOf("HelloWorldTest"), value.indexOf(":[19,27]")); checkClassCandidate(list.get(1), "OtherWorldTest", "OtherWorldTest", 11, null, value.indexOf("/var"), value.indexOf(" suffix"), value.indexOf("OtherWorldTest"), value.indexOf(":[11,27]")); }
### Question: ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public User tryGetUser(String username) { UserList users = getCachedValue(1); if(users != null) { User user = users.getUser(username); if(user == null) { return new User(username, username); } return user; } else { return null; } } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }### Answer: @Test public void testTryGetUser() { User tester = projectUserService.tryGetUser("tester"); Assert.assertNull(tester); RestInvocations.loadProjectUsers(handler); projectUserService.getUser("tester"); tester = projectUserService.tryGetUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); }
### Question: HREFLinkRecognizer implements Recognizer { @Override public void recognize(String content, final List<Candidate> candidates) { try { new ParserDelegator().parse(new StringReader(content), new ParserCallback(candidates), true); } catch (IOException e) { } } @Override void recognize(String content, final List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }### Answer: @Test public void testRecognize() { LinkedList<Candidate> list = new LinkedList<Candidate>(); String value = "<p>According to: <a>Development</a>  (<a href=\"https: recognizer.recognize(value, list); Assert.assertEquals(1, list.size()); AbstractRecognizerTest.checkCandidate(list.get(0), null, value.indexOf("<a href"), value.indexOf(")</p>"), value.indexOf("<a href"), value.indexOf(")</p>")); }
### Question: HREFLinkRecognizer implements Recognizer { @Override public boolean navigate(Project project, String hyperlink) { if(hyperlink.matches("https?: project.getComponent(BrowserUtil.class).launchBrowser(hyperlink); return true; } else { return false; } } @Override void recognize(String content, final List<Candidate> candidates); @Override boolean navigate(Project project, String hyperlink); }### Answer: @Test public void testNavigate() { handler.async(); getComponent(BrowserUtil.class)._setLauncher(new BrowserUtil.Launcher() { @Override public void launchBrowser(final String url) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("http: } }); } }); Assert.assertTrue(recognizer.navigate(getProject(), "http: } @Test public void testNavigate_negative() { Assert.assertFalse(recognizer.navigate(getProject(), "ftp: }
### Question: ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public UserList getUserList() { return getValue(1); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }### Answer: @Test public void testGetUserList() { RestInvocations.loadProjectUsers(handler); UserList userList = projectUserService.getUserList(); Assert.assertEquals(1, userList.size()); User tester = userList.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); projectUserService.getUserList(); }
### Question: ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public void loadUserAsync(final String username, final Callback<User> callback) { loadUsersAsync(translate(callback, new Transform<UserList, User>() { @Override public User transform(UserList users) { User user = users.getUser(username); if(user == null) { return new User(username, username); } else { return user; } } })); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }### Answer: @Test public void testLoadUserAsync() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUserAsync("tester", new NonDispatchTestCallback<User>(handler) { @Override public void evaluate(User user) { Assert.assertEquals("tester", user.getUsername()); Assert.assertEquals("Integration Test", user.getFullName()); } }); } @Test public void testLoadUserAsync_dispatch() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUserAsync("tester", new DispatchTestCallback<User>(handler) { @Override public void evaluate(User user) { Assert.assertEquals("tester", user.getUsername()); Assert.assertEquals("Integration Test", user.getFullName()); } }); }
### Question: ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public void loadUsersAsync(Callback<UserList> callback) { getValueAsync(1, callback); } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }### Answer: @Test public void testLoadUsersAsync() throws InterruptedException { RestInvocations.loadProjectUsers(handler); handler.async(); projectUserService.loadUsersAsync(new NonDispatchTestCallback<UserList>(handler) { @Override public void evaluate(UserList userList) { Assert.assertEquals(1, userList.size()); User tester = userList.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); } }); }
### Question: ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public String getUserFullName(String username) { User user = getUser(username); if(user != null) { return user.getFullName(); } else { return null; } } ProjectUserService(Project project); void loadUsersAsync(Callback<UserList> callback); User tryGetUser(String username); void loadUserAsync(final String username, final Callback<User> callback); UserList getUserList(); User getUser(String username); String getUserFullName(String username); }### Answer: @Test public void testGetUserFullName() { RestInvocations.loadProjectUsers(handler); String fullName = projectUserService.getUserFullName("tester"); Assert.assertEquals("Integration Test", fullName); projectUserService.getUserFullName("tester"); } @Test public void testGetUserFullName_nonexisting() { RestInvocations.loadProjectUsers(handler); String fullName = projectUserService.getUserFullName("nonexisting_tester"); Assert.assertNull(fullName); projectUserService.getUserFullName("nonexisting_tester"); }
### Question: AliRestClient implements RestClient { public static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy) { return new AliRestClient(location, domain, project, userName, password, sessionStrategy); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }### Answer: @Test public void testRequireDomainWhenProjectSpecified_create() { try { AliRestClient.create("http: Assert.fail("Domain is mandatory when project is specified."); } catch (IllegalArgumentException e) { } }
### Question: MetadataSimpleService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { Metadata getEntityMetadata(String entityType) { return getValue(entityType); } MetadataSimpleService(Project project); }### Answer: @Test public void testGetEntityMetadata() throws IOException { requests(); Metadata metadata = metadataSimpleService.getEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataSimpleService.getEntityMetadata("defect")); }
### Question: MetadataSimpleService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { void getEntityMetadataAsync(String entityType, MetadataService.MetadataCallback callback) { getValueAsync(entityType, MetadataService.Proxy.create(callback)); } MetadataSimpleService(Project project); }### Answer: @Test public void testGetEntityMetadataAsync() throws InterruptedException, IOException { requests(); handler.async(); metadataSimpleService.getEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.done(new Runnable() { @Override public void run() { Assert.assertFalse("Callback inside dispatch thread", SwingUtilities.isEventDispatchThread()); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataSimpleService.getEntityMetadata("defect")); final Thread t = Thread.currentThread(); metadataSimpleService.getEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(Metadata metadata) { Assert.assertEquals("Callback outside current thread although data should be cached", t, Thread.currentThread()); } @Override public void metadataFailed() { Assert.fail("Should have succeeded"); } }); } }); } @Override public void metadataFailed() { Assert.fail("Should have succeeded"); } }); } @Test public void testGetEntityMetadataAsync_failure() throws InterruptedException, IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); handler.async(); metadataSimpleService.getEntityMetadataAsync("non-existing-type", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.fail("Should have failed for wrong entity type"); } @Override public void metadataFailed() { handler.done(); } }); }
### Question: WeakListeners { public void remove(E listener) { synchronized (listeners) { for(Iterator<MyReference<E>> it = listeners.iterator(); it.hasNext(); ) { E theListener = it.next().get(); if(theListener == null \|\| theListener.equals(listener)) { it.remove(); } } } } void fire(Action<E> action); void add(E listener, boolean weak); void add(E listener); void remove(E listener); boolean isRegistered(E listener); }### Answer: @Test public void testRemove() throws InterruptedException { Listener listener = new Listener() { @Override public void exec() { Assert.fail("Should have been removed"); } }; weakListeners.add(listener); weakListeners.remove(listener); weakListeners.fire(new WeakListeners.Action<Listener>() { @Override public void fire(Listener listener) { listener.exec(); } }); }
### Question: WeakListeners { public boolean isRegistered(E listener) { synchronized (listeners) { for(Iterator<MyReference<E>> it = listeners.iterator(); it.hasNext(); ) { E theListener = it.next().get(); if(theListener == null) { it.remove(); } else if(theListener.equals(listener)) { return true; } } return false; } } void fire(Action<E> action); void add(E listener, boolean weak); void add(E listener); void remove(E listener); boolean isRegistered(E listener); }### Answer: @Test public void testIsRegistered() { Listener listener = new Listener() { @Override public void exec() { } }; Assert.assertFalse(weakListeners.isRegistered(listener)); weakListeners.add(listener, false); Assert.assertTrue(weakListeners.isRegistered(listener)); }
### Question: FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public EntityQuery getFavorite(int id, String entityType) { return getValue(new Favorite(id, entityType)); } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }### Answer: @Test public void testGetFavorite() { RestInvocations.loadMetadata(handler, "favorite"); RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/favorites?fields=&query={id[1014]}&order-by={}", 200) .content("favoritesServiceTest_favorite.xml"); EntityQuery query = favoritesService.getFavorite(1014, "defect"); checkQuery(query); }
### Question: FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public List<EntityQuery> getAvailableQueries(String entityType) { LinkedList<EntityQuery> list = new LinkedList<EntityQuery>(); process(list, projConf.getStoredFilters(entityType), "project"); process(list, aliConfiguration.getStoredFilters(entityType), "global"); return list; } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }### Answer: @Test public void testGetAvailableQueries() { addStoredQuery(); addGlobalQuery(); List<EntityQuery> list = favoritesService.getAvailableQueries("defect"); Assert.assertEquals(2, list.size()); Assert.assertEquals("test_query (project)", list.get(0).getName()); Assert.assertEquals("1", list.get(0).getValue("id")); Assert.assertEquals("global_test_query (global)", list.get(1).getName()); Assert.assertEquals("1", list.get(1).getValue("id")); }
### Question: FavoritesService extends AbstractCachingService<FavoritesService.Favorite, EntityQuery, AbstractCachingService.Callback<EntityQuery>> { public void unresolveQuery(EntityQuery query) { for(String property: query.getPropertyMap().keySet()) { String realProperty = restService.getServerStrategy().getFieldAlias(query.getEntityType(), property); if(!property.equals(realProperty)) { query.setValue(realProperty, query.getValue(property)); query.setValue(property, null); } Field field = metadataService.getEntityMetadata(query.getEntityType()).getField(realProperty); FilterFactory factory = filterManager.getFilterFactory(new Context<EntityQuery>(query), query.getEntityType(), field, true); if(factory != null) { Node node = ExpressionParser.parse(query.getValue(realProperty)); List<String> values = new LinkedList<String>(); if(collectOrValues(node, values)) { query.setValue(realProperty, factory.multipleValues(values)); } } } } FavoritesService(Project project, EntityService entityService, AliProjectConfiguration projConf, MetadataService metadataService, FilterManager filterManager, RestService restService); EntityQuery getFavorite(int id, String entityType); EntityQuery getStoredQuery(String entityType, String queryNameAndKind); List<EntityQuery> getAvailableQueries(String entityType); void unresolveQuery(EntityQuery query); }### Answer: @Test public void testUnresolveQuery() { RestInvocations.loadMetadata(handler, "defect"); RestInvocations.loadMetadata(handler, "release-backlog-item"); EntityQuery query = new EntityQuery("defect"); query.setValue("status", "a OR b OR c"); query.setValue("owner", "me or you"); favoritesService.unresolveQuery(query); Assert.assertEquals("a;b;c", query.getValue("status")); Assert.assertEquals("me;you", query.getValue("release-backlog-item.owner")); Assert.assertNull(query.getValue("owner")); }
### Question: TeamService extends AbstractCachingEntityService<String> { public Entity getTeam(String teamName, int releaseId) { List<Entity> teams = getTeams(teamName); for(Entity team: teams) { if(team.getPropertyValue("release-id").equals(String.valueOf(releaseId))) { return team; } } return null; } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }### Answer: @Test public void testGetTeam() { Entity team = teamService.getTeam("The Team", 1001); Assert.assertEquals(101, team.getId()); teamService.getTeam("The Team", 1001); }
### Question: TeamService extends AbstractCachingEntityService<String> { public List<Entity> getTeams(String teamName) { return getValue(teamName); } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }### Answer: @Test public void testGetTeams() { List<Entity> list = teamService.getTeams("The Team"); Assert.assertEquals(2, list.size()); Assert.assertEquals(101, list.get(0).getId()); Assert.assertEquals("1000", list.get(0).getPropertyValue("release-id")); Assert.assertEquals(101, list.get(1).getId()); Assert.assertEquals("1001", list.get(1).getPropertyValue("release-id")); teamService.getTeams("The Team"); }
### Question: TeamService extends AbstractCachingEntityService<String> { public EntityList getMultipleTeams(List<String> teamNames) { EntityList entities = EntityList.empty(); for(String teamName: teamNames) { entities.addAll(getTeams(teamName)); } return entities; } TeamService(Project project, EntityService entityService); Entity getTeam(String teamName, int releaseId); List<Entity> getTeams(String teamName); EntityList getMultipleTeams(List<String> teamNames); }### Answer: @Test public void testGetMultipleTeams() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/teams?fields=id,release-id,name&query={name['The Others']}&order-by={}", 200) .content("teamServiceTest_teams2.xml"); EntityList list = teamService.getMultipleTeams(Arrays.asList("The Team", "The Others")); Assert.assertEquals(3, list.size()); Assert.assertEquals(101, list.get(0).getId()); Assert.assertEquals("1000", list.get(0).getPropertyValue("release-id")); Assert.assertEquals(101, list.get(1).getId()); Assert.assertEquals("1001", list.get(1).getPropertyValue("release-id")); Assert.assertEquals(102, list.get(2).getId()); Assert.assertEquals("1001", list.get(2).getPropertyValue("release-id")); teamService.getMultipleTeams(Arrays.asList("The Team", "The Others")); }
### Question: AliRestClient implements RestClient { @Override public void setHttpProxy(String proxyHost, int proxyPort) { httpClient.getHostConfiguration().setProxy(proxyHost, proxyPort); } private AliRestClient(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); static AliRestClient create(String location, String domain, String project, String userName, String password, SessionStrategy sessionStrategy); @Override void setTimeout(int timeout); @Override void setHttpProxy(String proxyHost, int proxyPort); @Override void setHttpProxyCredentials(String username, String password); @Override String getEncoding(); @Override SessionStrategy getSessionStrategy(); @Override void setEncoding(String encoding); @Override void setDomain(String domain); @Override void setProject(String project); @Override String getDomain(); @Override String getProject(); @Override List<Cookie> getCookies(String cookieName); @Override synchronized void login(); @Override synchronized void logout(); @Override String getForString(String template, Object... params); @Override InputStream getForStream(String template, Object... params); @Override int get(ResultInfo result, String template, Object... params); @Override int put(InputData inputData, ResultInfo result, String template, Object... params); @Override int delete(ResultInfo result, String template, Object... params); @Override int post(InputData data, ResultInfo result, String template, Object... params); @Override List<String> listDomains(); @Override List<String> listCurrentProjects(); static final Set<Integer> AUTH_FAIL_STATUSES; static final int DEFAULT_CLIENT_TIMEOUT; }### Answer: @Test public void testSetHttpProxy() throws Exception { handler.authenticate(); handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/test", 200); AliRestClient client = AliRestClient.create("http: client.setHttpProxy("localhost", ((ServerConnector)handler.getServer().getConnectors()[0]).getLocalPort()); client.getForStream("/test"); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public void loadState(Element state) { selectSprint(loadEntity(state, "release-cycle")); selectTeam(loadEntity(state, "team")); selectRelease(loadEntity(state, "release")); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testLoadState() throws Throwable { sprintTeamRequests_TestRelease(handler); WaitForEventsListener listener = new WaitForEventsListener(sprintService); Element state = new Element("SprintService"); state.setAttribute("release-id", "1001"); state.setAttribute("release-name", "Test Release"); state.setAttribute("release-cycle-id", "1001"); state.setAttribute("release-cycle-name", "Sprint 1"); state.setAttribute("team-id", "101"); state.setAttribute("team-name", "The Team"); sprintService.loadState(state); handler.consume(); listener.waitForEvents(1001, 1001, 101); Assert.assertEquals(1001, sprintService.getRelease().getId()); Assert.assertEquals(1001, sprintService.getSprint().getId()); Assert.assertEquals(101, sprintService.getTeam().getId()); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { @Override public void connectedTo(ServerType serverType) { if(ServerType.AGM.equals(restService.getServerTypeIfAvailable())) { synchronized (this) { resetValues(); final Entity release = this.releaseSelector.selected; if(release != null) { teamSelector.requestRunning = true; sprintSelector.requestRunning = true; releaseSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadTeams(release); loadSprints(release); loadReleases(); } }); } else { this.releaseSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadReleases(); } }); } } } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testConnectedTo() throws Throwable { selectTestRelease(); RestInvocations.getAuthenticationInfo(handler); releaseSprintTeamRequests_TestRelease(handler); getComponent(RestService.class).setServerType(ServerType.AGM); handler.consume(); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectRelease(final Entity release) { if((release != null && release.equals(this.releaseSelector.selected)) \|\| (release == null && this.releaseSelector.selected == null)) { return; } this.releaseSelector.selected = release; if(release != null) { if(ServerType.AGM.equals(restService.getServerTypeIfAvailable())) { sprintSelector.requestRunning = true; teamSelector.requestRunning = true; ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { loadSprints(release); loadTeams(release); } }); } } else { selectSprint(null); selectTeam(null); } fireReleaseSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testSelectRelease() throws Throwable { WaitForEventsListener listener = new WaitForEventsListener(sprintService); sprintTeamRequests_TestRelease(handler); sprintService.selectRelease(new Entity("release", 1001)); listener.waitForEvents(1001, 1002, 101); } @Test public void testSelectRelease_None() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService); sprintService.selectRelease(null); listener.waitForEvents(null, null, null); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectSprint(Entity sprint) { if((sprint != null && sprint.equals(this.sprintSelector.selected) && isSameTense(sprint, this.sprintSelector.selected)) \|\| (sprint == null && this.sprintSelector.selected == null)) { return; } this.sprintSelector.selected = sprint; fireSprintSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testSelectSprint() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService, false, true, false); sprintService.selectSprint(new Entity("release-cycle", 1001)); listener.waitForEvents(null, 1001, null); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized void selectTeam(Entity team) { if((team != null && team.equals(this.teamSelector.selected)) \|\| (team == null && this.teamSelector.selected == null)) { return; } this.teamSelector.selected = team; fireTeamSelected(); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testSelectTeam() throws Throwable { selectTestRelease(); WaitForEventsListener listener = new WaitForEventsListener(sprintService, false, false, true); sprintService.selectTeam(new Entity("team", 102)); listener.waitForEvents(null, null, 102); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public EntityList getReleases() { return getValues(releaseSelector, new Runnable() { @Override public void run() { loadReleases(); } }); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetReleases() throws Throwable { sprintService.resetValues(); releaseSprintTeamRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList releases = sprintService.getReleases(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, releases.size()); Assert.assertEquals(1001, releases.get(0).getId()); Assert.assertEquals(1000, releases.get(1).getId()); } }); } }); } handler.consume(); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public EntityList getSprints() { final Entity release = this.releaseSelector.selected; if(release != null) { return getValues(sprintSelector, new Runnable() { @Override public void run() { loadSprints(release); } }); } else { return null; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetSprints() throws Throwable { selectTestRelease(); sprintService.resetValues(); sprintRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList sprints = sprintService.getSprints(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, sprints.size()); Assert.assertEquals(1001, sprints.get(0).getId()); Assert.assertEquals(1002, sprints.get(1).getId()); } }); } }); } handler.consume(); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized EntityList getTeams() { final Entity release = this.releaseSelector.selected; if(release != null) { return getValues(teamSelector, new Runnable() { @Override public void run() { loadTeams(release); } }); } else { return null; } } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetTeams() throws Throwable { selectTestRelease(); sprintService.resetValues(); teamRequests_TestRelease(handler); for(int i = 0; i < 3; i++) { handler.async(); ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { @Override public void run() { final EntityList teams = sprintService.getTeams(); handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(2, teams.size()); Assert.assertEquals(101, teams.get(0).getId()); Assert.assertEquals(102, teams.get(1).getId()); } }); } }); } handler.consume(); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getRelease() { return releaseSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetRelease() throws Throwable { selectTestRelease(); Assert.assertEquals(1001, sprintService.getRelease().getId()); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getSprint() { return sprintSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetSprint() throws Throwable { selectTestRelease(); Assert.assertEquals(1002, sprintService.getSprint().getId()); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getTeam() { return teamSelector.selected; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetTeam() throws Throwable { selectTestRelease(); Assert.assertEquals(101, sprintService.getTeam().getId()); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public synchronized Entity getCurrentSprint() { if(sprintSelector.values == null) { return null; } for(Entity sprint: sprintSelector.values) { if(isCurrentSprint(sprint)) { return sprint; } } return null; } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testGetCurrentSprint() throws Throwable { selectTestRelease(); Assert.assertEquals(1002, sprintService.getCurrentSprint().getId()); } @Test public void testGetCurrentSprint_notMatching() throws Throwable { Assert.assertNull(sprintService.getCurrentSprint()); }
### Question: SprintService implements PersistentStateComponent<Element>, ServerTypeListener, CachingEntityListener { public static boolean isCurrentSprint(Entity sprint) { return "CURRENT".equalsIgnoreCase(sprint.getPropertyValue("tense")); } SprintService(Project project); Element getState(); void loadState(Element state); @Override void connectedTo(ServerType serverType); synchronized Entity getRelease(); synchronized Entity getSprint(); synchronized Entity getTeam(); void addListener(Listener listener); void removeListener(Listener listener); synchronized void selectRelease(final Entity release); synchronized void selectSprint(Entity sprint); synchronized void selectTeam(Entity team); synchronized Entity getCurrentSprint(); synchronized EntityList getTeams(); EntityList getSprints(); EntityList getReleases(); static boolean isSameTense(Entity sprint1, Entity sprint2); static boolean isCurrentSprint(Entity sprint); static long distance(long now, Entity entity); @Override Entity lookup(final EntityRef ref); @Override void entityLoaded(Entity entity, Event event); @Override void entityNotFound(EntityRef ref, boolean removed); }### Answer: @Test public void testIsCurrentSprint() throws Throwable { Entity sprint = new Entity("release-cycle", 1); sprint.setProperty("tense", "PAST"); Assert.assertFalse(SprintService.isCurrentSprint(sprint)); sprint.setProperty("tense", "CURRENT"); Assert.assertTrue(SprintService.isCurrentSprint(sprint)); sprint.setProperty("tense", "FUTURE"); Assert.assertFalse(SprintService.isCurrentSprint(sprint)); }
### Question: EntityService { public InputStream queryForStream(EntityQuery query) { EntityRef parent = query.getParent(); if(parent == null) { return restService.getForStream("{0}s?{1}", query.getEntityType(), queryToString(query)); } else { return restService.getForStream("{0}s/{1}/{2}s?{3}", parent.type, parent.id, query.getEntityType(), queryToString(query)); } } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }### Answer: @Test @TestTarget(ServerVersion.AGM) public void testQueryForStream() throws IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/defects?fields=&query={status[Fixed]}&order-by={}", 200) .responseBody("simply content"); EntityQuery query = new EntityQuery("defect"); query.setValue("status", "Fixed"); query.setPropertyResolved("status", true); String content = IOUtils.toString(entityService.queryForStream(query)); Assert.assertEquals("simply content", content); }
### Question: EntityService { public void unlockEntity(Entity entity) { restService.delete("{0}s/{1}/lock", entity.getType(), String.valueOf(entity.getId())); } EntityService(Project project, RestService restService, MetadataService metadataService, ErrorService errorService); void addEntityListener(EntityListener listener); void removeEntityListener(EntityListener listener); void refreshEntity(EntityRef ref); void getEntityAsync(EntityRef ref, EntityListener callback); Entity getEntity(EntityRef ref); EntityList query(EntityQuery query); InputStream queryForStream(EntityQuery query); Entity getDefectLink(int defectId, int linkId); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure); Entity updateEntity(Entity entity, Set<String> fieldsToUpdate, boolean silent, boolean reloadOnFailure, boolean fireUpdate); Entity createEntity(Entity entity, boolean silent); Entity lockEntity(Entity entity, boolean silent); boolean deleteEntity(Entity entity); void unlockEntity(Entity entity); void fireEntityLoaded(final Entity entity, final EntityListener.Event event); void fireEntityNotFound(final EntityRef ref, final boolean removed); void requestCachedEntity(final EntityRef ref, final List<String> properties, final EntityListener callback); }### Answer: @Test @TestTarget(ServerVersion.ALM11) public void testUnlockEntity() { handler.addRequest(false, "DELETE", "/qcbin/rest/domains/domain/projects/project/defects/86/lock", 200); Entity defect = new Entity("defect", 86); entityService.unlockEntity(defect); }
### Question: MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Metadata getEntityMetadata(String entityName) { return getValue(entityName); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }### Answer: @Test public void testGetEntityMetadata() throws IOException { requests(); Metadata metadata = metadataService.getEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataService.getEntityMetadata("defect")); }
### Question: MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Metadata getCachedEntityMetadata(String entityType) { return getCachedValue(entityType); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }### Answer: @Test public void testGetCachedEntityMetadata() throws IOException { requests(); Metadata metadata = metadataService.getCachedEntityMetadata("defect"); Assert.assertNull(metadata); metadataService.getEntityMetadata("defect"); metadata = metadataService.getCachedEntityMetadata("defect"); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataService.getEntityMetadata("defect")); }
### Question: MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public Exception getCachedFailure(String entityType) { return super.getCachedFailure(entityType); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }### Answer: @Test public void testGetCachedFailure() throws IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); try { metadataService.getEntityMetadata("non-existing-type"); Assert.fail("should have failed"); } catch (Exception e) { } try { metadataService.getEntityMetadata("non-existing-type"); Assert.fail("should have failed"); } catch (Exception e) { } }
### Question: MetadataService extends AbstractCachingService<String, Metadata, AbstractCachingService.Callback<Metadata>> { public void loadEntityMetadataAsync(String entityName, MetadataCallback callback) { getValueAsync(entityName, Proxy.create(callback)); } MetadataService(Project project, MetadataSimpleService metadataService, RestService restService); Metadata getEntityMetadata(String entityName); void loadEntityMetadataAsync(String entityName, MetadataCallback callback); Metadata getCachedEntityMetadata(String entityType); Exception getCachedFailure(String entityType); }### Answer: @Test public void testLoadEntityMetadataAsync() throws InterruptedException, IOException { requests(); handler.async(); metadataService.loadEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.done(new Runnable() { @Override public void run() { Assert.assertFalse("Callback inside dispatch thread", SwingUtilities.isEventDispatchThread()); Assert.assertEquals("defect", metadata.getEntityType()); Assert.assertEquals(Integer.class, metadata.getField("id").getClazz()); Assert.assertEquals(metadata, metadataService.getEntityMetadata("defect")); final Thread t = Thread.currentThread(); metadataService.loadEntityMetadataAsync("defect", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(Metadata metadata) { Assert.assertEquals("Callback outside current thread although data should be cached", t, Thread.currentThread()); } @Override public void metadataFailed() { Assert.fail("Should have succeeded"); } }); } }); } @Override public void metadataFailed() { handler.fail("Should have succeeded"); } }); } @Test public void testLoadEntityMetadataAsync_failure() throws InterruptedException, IOException { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/customization/entities/non-existing-type/fields", 404); handler.async(); metadataService.loadEntityMetadataAsync("non-existing-type", new MetadataService.MetadataCallback() { @Override public void metadataLoaded(final Metadata metadata) { handler.fail("Should have failed for wrong entity type"); } @Override public void metadataFailed() { handler.done(); } }); }
### Question: LoginController { public String login(UserForm userForm) { log.debug("LoginController.login {}", userForm); try { if (userForm == null) { return "ERROR"; } else if (loginService.login(userForm)) { return "OK"; } else { return "KO"; } } catch (Exception e) { return "ERROR"; } } String login(UserForm userForm); void logout(UserForm userForm); public LoginService loginService; }### Answer: @Test public void testLogin() { loginController.login(userForm); verify(loginService).login(userForm); verifyNoMoreInteractions(loginService); } @Test public void testLoginOk() { when(loginService.login(userForm)).thenReturn(true); assertEquals("OK", loginController.login(userForm)); verify(loginService).login(userForm); verifyNoMoreInteractions(loginService); } @Test public void testLoginKo() { when(loginService.login(userForm)).thenReturn(false); assertEquals("KO", loginController.login(userForm)); } @Test public void testLoginError() { assertEquals("ERROR", loginController.login(null)); } @Test public void testLoginWithException() { when(loginService.login(userForm)) .thenThrow(IllegalArgumentException.class); assertEquals("ERROR", loginController.login(userForm)); }
### Question: LoginService { public boolean login(UserForm userForm) { log.debug("LoginService.login {}", userForm); checkForm(userForm); String username = userForm.getUsername(); if (usersLogged.contains(username)) { throw new LoginException(username + " already logged"); } boolean login = loginRepository.login(userForm); if (login) { usersLogged.add(username); } return login; } boolean login(UserForm userForm); void logout(UserForm userForm); int getUserLoggedCount(); }### Answer: @Test void testLoginKo() { when(loginRepository.login(any(UserForm.class))).thenReturn(false); assertFalse(loginService.login(userForm)); verify(loginRepository, times(1)).login(userForm); } @Test void testLoginTwice() { when(loginRepository.login(userForm)).thenReturn(true); assertThrows(LoginException.class, () -> { loginService.login(userForm); loginService.login(userForm); }); } @Test public void testServiceLoginOk() { when(loginRepository.login(any(UserForm.class))).thenReturn(true); assertTrue(loginService.login(userForm)); verify(loginRepository, atLeast(1)).login(userForm); verifyNoMoreInteractions(loginRepository); } @Test public void testServiceLoginBad() { when(loginRepository.login(any(UserForm.class))).thenReturn(false); assertFalse(loginService.login(userForm)); verify(loginRepository, times(1)).login(userForm); verifyNoMoreInteractions(loginRepository); } @Test(expected = LoginException.class) public void testServiceLoginTwice() { when(loginRepository.login(userForm)).thenReturn(true); loginService.login(userForm); loginService.login(userForm); } @Test void testLoginOk() { when(loginRepository.login(any(UserForm.class))).thenReturn(true); assertTrue(loginService.login(userForm)); verify(loginRepository, atLeast(1)).login(userForm); }
### Question: LoginController { public void logout(UserForm userForm) { log.debug("LoginController.logout {}", userForm); loginService.logout(userForm); } String login(UserForm userForm); void logout(UserForm userForm); public LoginService loginService; }### Answer: @Test public void testLogout() { loginController.logout(userForm); verify(loginService).logout(userForm); verifyNoMoreInteractions(loginService); }
### Question: CopyTask implements Task { @Override public void execute(final TaskContext context) throws TaskException { try { final URL resource = findJsDocArchive(); copyTo(resource, context.getTempDir(), "jsdoc.zip"); } catch (IOException e) { throw new TaskException("Unable to copy jsdoc zip to temp dir.", e); } } @Override void execute(final TaskContext context); }### Answer: @Test public void testCopyDirDoesntExist() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, true, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); } @Test public void testCopyDirExists() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); tempFile.mkdirs(); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, false, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); } @Test public void testCopyFileSize() { final File tempFile = new File(temporaryFolder.getRoot(), "rooty"); final TaskContext context = new TaskContext(null, null, null, null, null, null, tempFile, false, true, false, true, null); copyTask.execute(context); Assert.assertTrue("jsdoc.zip should exist.", new File(tempFile, "jsdoc.zip").exists()); final long size = FileUtils.sizeOfDirectory(tempFile); Assert.assertTrue("should be big.", size > 400000); }
### Question: StreamLogger implements Runnable { @Override public void run() { String line; try { while ((line = bufferedReader.readLine()) != null) { log.info(line); } } catch (IOException e) { throw new TaskException("Exception while intercepting stream.", e); } IOUtils.closeQuietly(bufferedReader); IOUtils.closeQuietly(inputStreamReader); } StreamLogger(InputStream in, Log log); @Override void run(); }### Answer: @Test(timeout = 1000) public void testSingleLine() { Log mockLog = EasyMock.createStrictMock(Log.class); mockLog.info("Two peas in a bucket."); EasyMock.expectLastCall(); EasyMock.replay(mockLog); InputStream in = new ByteArrayInputStream("Two peas in a bucket.\n".getBytes()); StreamLogger logger = new StreamLogger(in, mockLog); logger.run(); EasyMock.verify(mockLog); } @Test(timeout = 1000) public void testTwoLines() { Log mockLog = EasyMock.createStrictMock(Log.class); mockLog.info("Two peas in a bucket."); mockLog.info("Big ham ham ham."); EasyMock.expectLastCall(); EasyMock.replay(mockLog); InputStream in = new ByteArrayInputStream("Two peas in a bucket.\nBig ham ham ham.\n".getBytes()); StreamLogger logger = new StreamLogger(in, mockLog); logger.run(); EasyMock.verify(mockLog); } @Test(expected = TaskException.class) public void testIoExceptionThrown() { InputStream mockStream = new InputStream() { @Override public int read() throws IOException { throw new IOException("oops"); } }; StreamLogger logger = new StreamLogger(mockStream, new SystemStreamLog()); logger.run(); }
### Question: DistancedSort extends SortFunction { public PointF getDistancePoint(ViewGroup parent, List<View> children) { PointF distancePoint = new PointF(0, 0); return translate(distancePoint, children); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }### Answer: @Test public void test_get_distance_point_returns_a_point() { ViewGroup mockParent = Mockito.mock(ViewGroup.class); List<View> mockChildren = new ArrayList<>(); mockChildren.add(Mockito.mock(View.class)); DistancedSort distancedSort = new DistancedSort(0, false); Assert.assertThat(distancedSort.getDistancePoint(mockParent, mockChildren), CoreMatchers.instanceOf(PointF.class)); }
### Question: DistancedSort extends SortFunction { PointF translate(final PointF distancePoint, List<View> children) { Collections.sort(children, new Comparator<View>() { @Override public int compare(View left, View right) { double leftDistance = getDistanceBetweenPoints(Utils.viewToPoint(left), distancePoint); double rightDistance = getDistanceBetweenPoints(Utils.viewToPoint(right), distancePoint); return Double.compare(leftDistance, rightDistance); } }); return Utils.viewToPoint(children.get(0)); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }### Answer: @Test public void test_translate_returns_a_point() { List<View> mockChildren = new ArrayList<>(); mockChildren.add(Mockito.mock(View.class)); DistancedSort distancedSort = new DistancedSort(0, false); Assert.assertThat(distancedSort.translate(new PointF(0, 0), mockChildren), CoreMatchers.instanceOf(PointF.class)); }
### Question: DistancedSort extends SortFunction { public double getDistanceBetweenPoints(PointF left, PointF right) { return Utils.euclideanDistance(left, right); } DistancedSort(long interObjectDelay, boolean reversed); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); PointF getDistancePoint(ViewGroup parent, List<View> children); double getDistanceBetweenPoints(PointF left, PointF right); }### Answer: @Test public void test_get_distance_between_points_returns_a_double() { DistancedSort distancedSort = new DistancedSort(0, false); PointF firstPoint = Mockito.mock(PointF.class); PointF secondPoint = Mockito.mock(PointF.class); Assert.assertThat(distancedSort.getDistanceBetweenPoints(firstPoint, secondPoint), CoreMatchers.instanceOf(Double.class)); }
### Question: RandomSort extends SortFunction { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { List<SpruceTimedView> timedViews = new ArrayList<>(); long currentTimeOffset = 0; for (View view : children) { timedViews.add(new SpruceTimedView(view, currentTimeOffset)); currentTimeOffset += interObjectDelay; } return timedViews; } RandomSort(long interObjectDelay); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }### Answer: @Test public void test_positive_inter_object_delay() { List<SpruceTimedView> resultViews = new RandomSort(1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new RandomSort(0) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new RandomSort(-1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); }
### Question: DefaultSort extends SortFunction { @Override public List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children) { List<SpruceTimedView> childTimedViews = new ArrayList<>(); long currentTimeOffset = 0L; for (View childView : children) { childTimedViews.add(new SpruceTimedView(childView, currentTimeOffset)); currentTimeOffset += interObjectDelay; } return childTimedViews; } DefaultSort(long interObjectDelay); @Override List<SpruceTimedView> getViewListWithTimeOffsets(ViewGroup parent, List<View> children); @Override void sortChildren(ViewGroup parent, List<View> children); }### Answer: @Test public void test_inter_object_delay_of_views_is_set_on_default_sort() { List<SpruceTimedView> resultViews = new DefaultSort(1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(2, resultViews.get(2).getTimeOffset()); } @Test public void test_inter_object_delay_of_zero() { List<SpruceTimedView> resultViews = new DefaultSort(0) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(0, resultViews.get(1).getTimeOffset()); Assert.assertEquals(0, resultViews.get(2).getTimeOffset()); } @Test public void test_negative_inter_object_delay() { List<SpruceTimedView> resultViews = new DefaultSort(-1) .getViewListWithTimeOffsets(mockParent, mockChildren); Assert.assertEquals(0, resultViews.get(0).getTimeOffset()); Assert.assertEquals(-1, resultViews.get(1).getTimeOffset()); Assert.assertEquals(-2, resultViews.get(2).getTimeOffset()); }
### Question: PopupBridge extends BrowserSwitchFragment { @Override public String getReturnUrlScheme() { return mReturnUrlScheme; } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }### Answer: @Test public void getReturnUrlScheme_returnsExpectedUrlScheme() { assertEquals(mPopupBridge.getReturnUrlScheme(), mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge"); }
### Question: PopupBridge extends BrowserSwitchFragment { @JavascriptInterface public String getReturnUrlPrefix() { return String.format("%s: } PopupBridge(); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(AppCompatActivity activity, WebView webView); @SuppressLint("SetJavaScriptEnabled") static PopupBridge newInstance(FragmentActivity activity, WebView webView); @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); @Override String getReturnUrlScheme(); @JavascriptInterface String getReturnUrlPrefix(); @JavascriptInterface void open(String url); @JavascriptInterface void sendMessage(String messageName); @JavascriptInterface void sendMessage(String messageName, String data); void setNavigationListener(PopupBridgeNavigationListener listener); void setMessageListener(PopupBridgeMessageListener listener); static final String POPUP_BRIDGE_NAME; static final String POPUP_BRIDGE_URL_HOST; }### Answer: @Test public void getReturnUrlPrefix_returnsExpectedUrlPrefix() { assertEquals(mPopupBridge.getReturnUrlPrefix(), mAppCompatActivity.getApplicationContext().getPackageName() + ".popupbridge: }
### Question: PersistentStore { static void put(String key, String value, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); sharedPreferences.edit().putString(key, value).apply(); } }### Answer: @Test public void put_placesKeyValuePairIntoSharedPrefs() { when( sharedPreferencesEditor.putString(anyString(), anyString()) ).thenReturn(sharedPreferencesEditor); PersistentStore.put("key", "value", context); InOrder inOrder = Mockito.inOrder(sharedPreferencesEditor); inOrder.verify(sharedPreferencesEditor).putString("key", "value"); inOrder.verify(sharedPreferencesEditor).apply(); }
### Question: PersistentStore { static String get(String key, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); return sharedPreferences.getString(key, null); } }### Answer: @Test public void get_retrievesValueFromSharedPrefsByKey() { when(sharedPreferences.getString("key", null)).thenReturn("sampleValue"); String result = PersistentStore.get("key", context); assertEquals(result, "sampleValue"); }
### Question: PersistentStore { static void remove(String key, Context context) { Context applicationContext = context.getApplicationContext(); SharedPreferences sharedPreferences = applicationContext.getSharedPreferences(PREFERENCES_KEY, Context.MODE_PRIVATE); sharedPreferences.edit().remove(key).apply(); } }### Answer: @Test public void remove_removesValueInSharedPrefsByKey() { when(sharedPreferencesEditor.remove(anyString())).thenReturn(sharedPreferencesEditor); PersistentStore.remove("key", context); InOrder inOrder = Mockito.inOrder(sharedPreferencesEditor); inOrder.verify(sharedPreferencesEditor).remove("key"); inOrder.verify(sharedPreferencesEditor).apply(); }
### Question: BrowserSwitchConfig { Intent createIntentToLaunchUriInBrowser(Context context, Uri uri) { Intent intent = new Intent(Intent.ACTION_VIEW, uri); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); Context applicationContext = context.getApplicationContext(); if (ChromeCustomTabs.isAvailable(applicationContext)) { ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, intent); } return intent; } }### Answer: @Test public void createIntentToLaunchUriInBrowser_returnsIntent() { when(context.getApplicationContext()).thenReturn(applicationContext); when(ChromeCustomTabs.isAvailable(applicationContext)).thenReturn(false); Uri uri = Uri.parse("https: Intent result = sut.createIntentToLaunchUriInBrowser(context, uri); assertEquals(result.getData().toString(), "https: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertEquals(result.getFlags(), Intent.FLAG_ACTIVITY_NEW_TASK); verifyStatic(ChromeCustomTabs.class, never()); ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, result); } @Test public void createIntentToLaunchUriInBrowser_optionallyConfiguresIntentForChromeCustomTabs() { when(context.getApplicationContext()).thenReturn(applicationContext); when(ChromeCustomTabs.isAvailable(applicationContext)).thenReturn(true); Uri uri = Uri.parse("https: Intent result = sut.createIntentToLaunchUriInBrowser(context, uri); assertEquals(result.getData().toString(), "https: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertEquals(result.getFlags(), Intent.FLAG_ACTIVITY_NEW_TASK); verifyStatic(ChromeCustomTabs.class); ChromeCustomTabs.addChromeCustomTabsExtras(applicationContext, result); }
### Question: BrowserSwitchConfig { Intent createIntentForBrowserSwitchActivityQuery(String returnUrlScheme) { String browserSwitchUrl = String.format("%s: Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(browserSwitchUrl)); intent.addCategory(Intent.CATEGORY_DEFAULT); intent.addCategory(Intent.CATEGORY_BROWSABLE); return intent; } }### Answer: @Test public void createIntentForBrowserSwitchActivityQuery_configuresAndReturnsIntent() { when(context.getApplicationContext()).thenReturn(applicationContext); when(applicationContext.getPackageName()).thenReturn("sample.package.name"); String returnUrlScheme = "sample.package.name.browserswitch"; Intent result = sut.createIntentForBrowserSwitchActivityQuery(returnUrlScheme); assertEquals(result.getData().toString(), "sample.package.name.browserswitch: assertEquals(result.getAction(), Intent.ACTION_VIEW); assertTrue(result.hasCategory(Intent.CATEGORY_DEFAULT)); assertTrue(result.hasCategory(Intent.CATEGORY_BROWSABLE)); }
### Question: BrowserSwitchFragment extends Fragment implements BrowserSwitchListener { @Override public void onResume() { super.onResume(); browserSwitchClient.deliverResult(this); } @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); String getReturnUrlScheme(); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, String url); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, Intent intent); void browserSwitch(BrowserSwitchOptions browserSwitchOptions); abstract void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); }### Answer: @Test public void onResume_deliversBrowserSwitchResultViaClient() { sut.browserSwitchClient = browserSwitchClient; sut.onResume(); verify(browserSwitchClient).deliverResult(sut); }
### Question: BrowserSwitchFragment extends Fragment implements BrowserSwitchListener { public String getReturnUrlScheme() { return returnUrlScheme; } @Override void onAttach(@NonNull Context context); @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); String getReturnUrlScheme(); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, String url); @SuppressWarnings("WeakerAccess") void browserSwitch(int requestCode, Intent intent); void browserSwitch(BrowserSwitchOptions browserSwitchOptions); abstract void onBrowserSwitchResult(int requestCode, BrowserSwitchResult result, @Nullable Uri returnUri); }### Answer: @Test public void getReturnUrlScheme_returnsUrlSchemeUsingPackageNameFromContext() { String result = sut.getReturnUrlScheme(); assertEquals(result, "com.braintreepayments.browserswitch.test.browserswitch"); }
### Question: ECDSA256Verifier { public boolean verify(byte[] payload, byte[] payloadSignature) { final Signature signature; try { signature = Signature.getInstance("SHA256withECDSA"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( "Could not load ECDSA algorithm. Is bouncycastle on the classpath?"); } try { signature.initVerify(publicKey); } catch (InvalidKeyException e) { throw new IllegalStateException("Public key not an ECDSA key.", e); } try { signature.update(payload); return signature.verify(payloadSignature); } catch (SignatureException e) { logger.warn("Invalid signature.", e); return false; } } @Inject ECDSA256Verifier(SignerConfig config); boolean verify(byte[] payload, byte[] payloadSignature); }### Answer: @Test public void validSignatureInvalidPayload() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); byte[] signature = signer.sign(payload); assertThat(verifier.verify("interceptedpayload".getBytes(StandardCharsets.UTF_8), signature)) .isFalse(); } @Test public void validPayloadInvalidSignature() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); assertThat(verifier.verify(payload, "badsignature".getBytes(StandardCharsets.UTF_8))).isFalse(); }
### Question: ECDSA256Signer { public byte[] sign(byte[] payload) { final Signature signature; try { signature = Signature.getInstance("SHA256withECDSA"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( "Could not load ECDSA algorithm. Is bouncycastle on the classpath?"); } try { signature.initSign(privateKey); } catch (InvalidKeyException e) { throw new IllegalStateException("Private key not an ECDSA key."); } try { signature.update(payload); return signature.sign(); } catch (SignatureException e) { throw new IllegalStateException("Could not sign payload.", e); } } @Inject ECDSA256Signer(SignerConfig config); byte[] sign(byte[] payload); }### Answer: @Test public void signedCanBeVerified() { byte[] payload = "highlysensitiveinformation".getBytes(StandardCharsets.UTF_8); byte[] signature = signer.sign(payload); assertThat(verifier.verify(payload, signature)).isTrue(); }
### Question: ArmeriaSdkHttpClient implements SdkAsyncHttpClient { @Override public String clientName() { return "ArmeriaAsync"; } ArmeriaSdkHttpClient(WebClient client); @Override CompletableFuture<Void> execute(AsyncExecuteRequest executeRequest); @Override String clientName(); @Override void close(); }### Answer: @Test void clientName() { assertThat(client.clientName()).isEqualTo("ArmeriaAsync"); }
### Question: ServiceSettingsImpl { public void addSyncRoot(final File syncRoot, Long expectedSyncTime) throws IllegalStateException { logger.debug("addSyncRoot(): syncRoot = {}", syncRoot); final Map<String, Object> props = new Hashtable<String, Object>(); props.put(ServiceSettingsConsumerImpl.KEY_ACTION, ServiceSettingsConsumerImpl.ACTION_ADD); props.put(ServiceSettingsConsumerImpl.KEY_SYNC_ROOT, syncRoot); if (expectedSyncTime != null) { props.put(ServiceSettingsConsumerImpl.KEY_EXPECTED_SYNC_TIME, expectedSyncTime); } jobManager.addJob(ServiceSettingsConsumerImpl.TOPIC_NAME, props); } void addSyncRoot(final File syncRoot, Long expectedSyncTime); void removeSyncRoot(final File syncRoot); }### Answer: @Test public void testAddSyncRoot() { this.props.put(KEY_ACTION, ACTION_ADD); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.props.put(KEY_EXPECTED_SYNC_TIME, 4000l); this.serviceSettings.addSyncRoot(new File("/virtual/root"), 4000l); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); } @Test public void testAddSyncRootNoSyncOnce() { this.props.put(KEY_ACTION, ACTION_ADD); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.props.remove(KEY_EXPECTED_SYNC_TIME); this.serviceSettings.addSyncRoot(new File("/virtual/root"), null); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); }
### Question: InitialRegistrationImpl { @Deactivate protected void deactivate() { logger.debug("deactivate()"); if (this.localDir != null) { this.serviceSettings.removeSyncRoot(this.localDir); } this.filterRoots = null; this.localDir = null; this.overwriteConfigFiles = null; this.syncOnceType = null; this.willSyncOnce = null; } }### Answer: @Test public void testDeactivate() { assertEquals(0, this.baseDir.list().length); this.initialRegistration.activate(this.props); this.initialRegistration.deactivate(); verify(this.serviceSettings, times(1)).removeSyncRoot(this.baseDir); }
### Question: ServiceSettingsConsumerImpl implements JobConsumer { protected void removeSyncRoot(final File syncRoot) throws IllegalStateException { logger.debug("removeSyncRoot(): syncRoot = {}", syncRoot); final Configuration configuration = getConfiguration(); final Dictionary<String, Object> properties = getProperties(configuration); final Set<String> syncRoots = getSyncRoots(properties); syncRoots.remove(syncRoot.getAbsolutePath()); properties.put(PROP_SYNCROOTS, syncRoots.toArray(new String[syncRoots.size()])); if (syncRoots.size() == 0) { disableSync(properties); } update(configuration, properties, null); } JobResult process(Job job); }### Answer: @Test public void testRemoveSyncRoot() throws IOException { assertNull(this.dictionary.get(PROP_ENABLED)); this.dictionary.put(PROP_SYNCROOTS, new String[] { "/virtual/old1", "/virtual/old2" }); this.serviceSettingsConsumer.removeSyncRoot(new File("/virtual/old1")); assertNull(this.dictionary.get(PROP_ENABLED)); assertArrayEquals(new String[] { "/virtual/old2" }, (String[]) this.dictionary.get(PROP_SYNCROOTS)); verify(this.configuration, times(1)).update(this.dictionary); }
### Question: ServiceSettingsImpl { public void removeSyncRoot(final File syncRoot) throws IllegalStateException { logger.debug("removeSyncRoot(): syncRoot = {}", syncRoot); final Map<String, Object> props = new Hashtable<String, Object>(); props.put(ServiceSettingsConsumerImpl.KEY_ACTION, ServiceSettingsConsumerImpl.ACTION_REMOVE); props.put(ServiceSettingsConsumerImpl.KEY_SYNC_ROOT, syncRoot); jobManager.addJob(ServiceSettingsConsumerImpl.TOPIC_NAME, props); } void addSyncRoot(final File syncRoot, Long expectedSyncTime); void removeSyncRoot(final File syncRoot); }### Answer: @Test public void testRemoveSyncRoot() { this.props.put(KEY_ACTION, ACTION_REMOVE); this.props.put(KEY_SYNC_ROOT, new File("/virtual/root")); this.serviceSettings.removeSyncRoot(new File("/virtual/root")); verify(this.jobManager, times(1)).addJob(TOPIC_NAME, this.props); }
### Question: MixPanelOutputConnector extends AbstractPipelineComponent implements OutputConnector, Configurable<JSONObject> { protected void deleteUserProfile(JSONObject payload) throws JSONException, IOException { MixpanelAPI mixpanel = getMixpanelAPI(); MessageBuilder messageBuilder = new MessageBuilder(token); String distinct_id = payload.getString("distinct_id"); JSONObject mixPanelMessage = messageBuilder.set(distinct_id, null); JSONUtil.removeValue(mixPanelMessage, "message", "$set"); JSONUtil.setValue(mixPanelMessage, "", "message", "$delete"); Long time = payload.optLong("time", 0L); if (time != 0L) { JSONUtil.setValue(mixPanelMessage, time, "message", "$time"); } sendMessageToMixpanel(mixpanel, mixPanelMessage); } @Override void setConfiguration(JSONObject jsonObject); @Override Message send(Message message); }### Answer: @Test public void test_delete_profile() throws Exception { MixPanelOutputConnector mixPanelOutputConnector = new MixPanelOutputConnector() { @Override protected MixpanelAPI getMixpanelAPI() { return new MixpanelAPI(null, mockMixpanelServer.getServerURL() + "/engage"); } }; mixPanelOutputConnector.setPipelineContext(getMockPipelineContext()); mockMixpanelServer.addRequestResponse(new RequestResponse() .setExpectedRequestURI(mockMixpanelServer.getServerURL() + "/engage") .setExpectedRequestParam("data", "W3siJHRpbWUiOjEyNDU2MTM4ODUwMDAsIiRkaXN0aW5jdF9pZCI6IjUwNDc5YjI0NjcxYmYiLCIkZGVsZXRlIjoiIn1d") .setResponsePayload("1") ); mixPanelOutputConnector.deleteUserProfile(new JSONObject(SAMPLE_DELETE_PROFILE)); mockMixpanelServer.waitForAllRequestsToComplete(); mockMixpanelServer.assertAllRequestsCompleteOK(); }
### Question: RxSwtPlugins { public static Scheduler onMainThreadScheduler(Scheduler scheduler) { if (scheduler == null) { throw new NullPointerException("scheduler == null"); } Function<Scheduler, Scheduler> f = onMainThreadHandler; if (f == null) { return scheduler; } return apply(f, scheduler); } private RxSwtPlugins(); static void setInitMainThreadSchedulerHandler(Function<Callable<Scheduler>, Scheduler> handler); static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler); static void setMainThreadSchedulerHandler(Function<Scheduler, Scheduler> handler); static Scheduler onMainThreadScheduler(Scheduler scheduler); static Function<Callable<Scheduler>, Scheduler> getInitMainThreadSchedulerHandler(); static Function<Scheduler, Scheduler> getOnMainThreadSchedulerHandler(); static void reset(); }### Answer: @Test(expected = NullPointerException.class) public void testNullSchedulerThrowsNPE() { RxSwtPlugins.onMainThreadScheduler(null); }
### Question: RxSwtPlugins { static Scheduler callRequireNonNull(Callable<Scheduler> s) { try { Scheduler scheduler = s.call(); if (scheduler == null) { throw new NullPointerException("Scheduler Callable returned null"); } return scheduler; } catch (Throwable ex) { throw Exceptions.propagate(ex); } } private RxSwtPlugins(); static void setInitMainThreadSchedulerHandler(Function<Callable<Scheduler>, Scheduler> handler); static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler); static void setMainThreadSchedulerHandler(Function<Scheduler, Scheduler> handler); static Scheduler onMainThreadScheduler(Scheduler scheduler); static Function<Callable<Scheduler>, Scheduler> getInitMainThreadSchedulerHandler(); static Function<Scheduler, Scheduler> getOnMainThreadSchedulerHandler(); static void reset(); }### Answer: @Test(expected = NullPointerException.class) public void testcallRequireNonNullThrowsNPE() { RxSwtPlugins.callRequireNonNull(null); }
### Question: RxSwtPlugins { static Scheduler applyRequireNonNull(Function<Callable<Scheduler>, Scheduler> f, Callable<Scheduler> s) { Scheduler scheduler = apply(f,s); if (scheduler == null) { throw new NullPointerException("Scheduler Callable returned null"); } return scheduler; } private RxSwtPlugins(); static void setInitMainThreadSchedulerHandler(Function<Callable<Scheduler>, Scheduler> handler); static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler); static void setMainThreadSchedulerHandler(Function<Scheduler, Scheduler> handler); static Scheduler onMainThreadScheduler(Scheduler scheduler); static Function<Callable<Scheduler>, Scheduler> getInitMainThreadSchedulerHandler(); static Function<Scheduler, Scheduler> getOnMainThreadSchedulerHandler(); static void reset(); }### Answer: @Test(expected = NullPointerException.class) public void testapplyRequireNonNullThrowsNPE() { RxSwtPlugins.applyRequireNonNull(new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> t) throws Exception { return null; } }, null); }
### Question: RxSwtPlugins { public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) { if (scheduler == null) { throw new NullPointerException("scheduler == null"); } Function<Callable<Scheduler>, Scheduler> f = onInitMainThreadHandler; if (f == null) { return callRequireNonNull(scheduler); } return applyRequireNonNull(f, scheduler); } private RxSwtPlugins(); static void setInitMainThreadSchedulerHandler(Function<Callable<Scheduler>, Scheduler> handler); static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler); static void setMainThreadSchedulerHandler(Function<Scheduler, Scheduler> handler); static Scheduler onMainThreadScheduler(Scheduler scheduler); static Function<Callable<Scheduler>, Scheduler> getInitMainThreadSchedulerHandler(); static Function<Scheduler, Scheduler> getOnMainThreadSchedulerHandler(); static void reset(); }### Answer: @Test public void overrideInitMainSchedulerThrowsWhenSchedulerCallableIsNull() { try { RxSwtPlugins.initMainThreadScheduler(null); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } } @Test public void overrideInitMainSchedulerThrowsWhenSchedulerCallableReturnsNull() { Callable<Scheduler> nullResultCallable = new Callable<Scheduler>() { @Override public Scheduler call() throws Exception { return null; } }; try { RxSwtPlugins.initMainThreadScheduler(nullResultCallable); fail(); } catch (NullPointerException e) { assertEquals("Scheduler Callable returned null", e.getMessage()); } }
### Question: SwtSchedulers { public static Scheduler defaultDisplayThread() { return RxSwtPlugins.onMainThreadScheduler(DEFAULT_DISPLAY_THREAD); } private SwtSchedulers(); static Scheduler defaultDisplayThread(); static Scheduler from(Display display); }### Answer: @Test public void testMainThreadCallsThroughToHookTest() { final AtomicInteger called = new AtomicInteger(); final Scheduler newScheduler = new EmptyScheduler(); RxSwtPlugins.setMainThreadSchedulerHandler(new Function<Scheduler, Scheduler>() { @Override public Scheduler apply(Scheduler scheduler) { called.getAndIncrement(); return newScheduler; } }); assertSame(newScheduler, SwtSchedulers.defaultDisplayThread()); assertEquals(1, called.get()); assertSame(newScheduler, SwtSchedulers.defaultDisplayThread()); assertEquals(2, called.get()); }
### Question: SwtSchedulers { public static Scheduler from(Display display) { return RxSwtPlugins.onMainThreadScheduler(new DisplayScheduler(display)); } private SwtSchedulers(); static Scheduler defaultDisplayThread(); static Scheduler from(Display display); }### Answer: @Test public void fromNullThrows() { try { SwtSchedulers.from(null); } catch (NullPointerException e) { fail("Calling SwtSchedulers.from(null) should not result in an NPE, but use the default display."); } }
### Question: RunMojo extends MojoSupport { void addFeatures(Object featureService) throws MojoExecutionException { if (featuresToInstall != null) { try { Class<? extends Object> serviceClass = featureService.getClass(); Method installFeatureMethod = serviceClass.getMethod("installFeature", String.class); String[] features = featuresToInstall.split(" , "); for (String feature : features) { installFeatureMethod.invoke(featureService, feature); Thread.sleep(1000L); } } catch (Exception e) { throw new MojoExecutionException("Failed to add features to karaf", e); } } } void execute(); static void extract(File sourceFile, File targetFolder); }### Answer: @Test public void testAddFeaturesNullFeaturesToInstall() throws MojoExecutionException { FeaturesService featureService = mock(FeaturesService.class); replay(featureService); RunMojo mojo = new RunMojo(); mojo.addFeatures(featureService); verify(featureService); } @Test public void testAddFeaturesNullFeatureService() throws SecurityException, IllegalArgumentException, IllegalAccessException { RunMojo mojo = new RunMojo(); setPrivateField(mojo, "featuresToInstall", "liquibase-core, ukelonn-db-derby-test, ukelonn"); try { mojo.addFeatures(null); } catch (MojoExecutionException e) { assertEquals("Failed to add features to karaf", e.getMessage()); } } @Test public void testAddFeatures() throws Exception { FeaturesService featureService = mock(FeaturesService.class); featureService.installFeature(anyString()); EasyMock.expectLastCall().times(3); replay(featureService); RunMojo mojo = new RunMojo(); setPrivateField(mojo, "featuresToInstall", "liquibase-core, ukelonn-db-derby-test, ukelonn"); mojo.addFeatures(featureService); verify(featureService); }
### Question: RunMojo extends MojoSupport { @SuppressWarnings({ "rawtypes", "unchecked" }) Object findFeatureService(BundleContext bundleContext) { ServiceReference ref = bundleContext.getServiceReference(FeaturesService.class); if (ref != null) { Object featureService = bundleContext.getService(ref); return featureService; } return null; } void execute(); static void extract(File sourceFile, File targetFolder); }### Answer: @Test public void testFindFeatureServiceNullServiceRef() { BundleContext context = niceMock(BundleContext.class); replay(context); RunMojo mojo = new RunMojo(); Object service = mojo.findFeatureService(context); assertNull(service); } @SuppressWarnings("unchecked") @Test public void testFindFeatureService() { FeaturesService featureService = niceMock(FeaturesService.class); replay(featureService); ServiceReference<FeaturesService> ref = niceMock(ServiceReference.class); BundleContext context = niceMock(BundleContext.class); expect(context.getServiceReference(eq(FeaturesService.class))).andReturn(ref); expect(context.getService(eq(ref))).andReturn(featureService); replay(context); RunMojo mojo = new RunMojo(); Object service = mojo.findFeatureService(context); assertNotNull(service); }
### Question: ClientConfig { public String getUser() { return user; } ClientConfig(String[] args); String getHost(); int getPort(); String getUser(); void setUser(String user); String getPassword(); int getLevel(); int getRetryAttempts(); int getRetryDelay(); String getCommand(); void setCommand(String command); boolean isBatch(); String getFile(); String getKeyFile(); long getIdleTimeout(); }### Answer: @Test public void testDefaultUser() throws Exception { String etc = System.getProperty("karaf.etc"); System.setProperty("karaf.etc", "src/test/resources/etc1"); ClientConfig cc = new ClientConfig(new String[0]); assertThat(cc.getUser(), equalTo("karaf")); cc = new ClientConfig(new String[] { "-u", "different-one" }); assertThat(cc.getUser(), equalTo("different-one")); System.setProperty("karaf.etc", "src/test/resources/etc2"); cc = new ClientConfig(new String[0]); assertThat(cc.getUser(), equalTo("test")); if (etc != null) { System.setProperty("karaf.etc", etc); } }
### Question: StoredWiringResolver implements ResolverHook { void load() { try { Files.createDirectories(path); Files.list(path).forEach(p -> { String name = p.getFileName().toString(); if (name.matches("[0-9]+")) { long id = Long.parseLong(name); try (BufferedReader reader = Files.newBufferedReader(p)) { wiring.put(id, new BundleWires(id, reader)); } catch (IOException e) { throw new UncheckedIOException(e); } } }); } catch (IOException e) { throw new UncheckedIOException(e); } } StoredWiringResolver(Path path); @Override void filterResolvable(Collection<BundleRevision> candidates); @Override void filterSingletonCollisions(BundleCapability singleton, Collection<BundleCapability> collisionCandidates); @Override void filterMatches(BundleRequirement requirement, Collection<BundleCapability> candidates); @Override void end(); }### Answer: @Test public void load() { Assert.assertEquals(EXPECTED_STOCK_WIRINGS, wiringResolver.wiring.size()); Assert.assertTrue(wiringResolver.wiring.containsKey(1L)); Assert.assertTrue(wiringResolver.wiring.containsKey(5L)); Assert.assertTrue(wiringResolver.wiring.containsKey(9L)); }
### Question: StoredWiringResolver implements ResolverHook { synchronized void delete(Bundle bundle) { if (wiring.get(bundle.getBundleId()) != null) { wiring.remove(bundle.getBundleId()).delete(path); } } StoredWiringResolver(Path path); @Override void filterResolvable(Collection<BundleRevision> candidates); @Override void filterSingletonCollisions(BundleCapability singleton, Collection<BundleCapability> collisionCandidates); @Override void filterMatches(BundleRequirement requirement, Collection<BundleCapability> candidates); @Override void end(); }### Answer: @Test public void delete() { long newBundleId = 25L; File file = new File(TEST_RESOURCES_WIRINGS + newBundleId); Bundle bundle = wiredMockBundle(newBundleId, Collections.emptyList() ); c.replay(); wiringResolver.update(bundle); Assert.assertTrue(file.exists()); Assert.assertEquals(EXPECTED_STOCK_WIRINGS + 1, wiringResolver.wiring.size()); Assert.assertTrue(wiringResolver.wiring.containsKey(newBundleId)); wiringResolver.delete(bundle); c.verify(); Assert.assertFalse(file.exists()); Assert.assertEquals(EXPECTED_STOCK_WIRINGS, wiringResolver.wiring.size()); Assert.assertFalse(wiringResolver.wiring.containsKey(newBundleId)); } @Test public void deleteNonExisting() { long otherBundleId = 30L; File file = new File(TEST_RESOURCES_WIRINGS + otherBundleId); Bundle bundle = mockBundle(otherBundleId); c.replay(); Assert.assertFalse(file.exists()); Assert.assertEquals(EXPECTED_STOCK_WIRINGS, wiringResolver.wiring.size()); Assert.assertFalse(wiringResolver.wiring.containsKey(otherBundleId)); wiringResolver.delete(bundle); c.verify(); Assert.assertFalse(file.exists()); Assert.assertEquals(EXPECTED_STOCK_WIRINGS, wiringResolver.wiring.size()); Assert.assertFalse(wiringResolver.wiring.containsKey(otherBundleId)); }
### Question: BundleWires { Set<BundleCapability> filterCandidates( BundleRequirement requirement, Collection<BundleCapability> candidates) { Set<String> wiredCapabilityIds = wiring.get(getRequirementId(requirement)); return candidates.stream() .filter( capability -> isCapabilityWiredToBundle( wiredCapabilityIds, capability ) ) .collect( Collectors.toSet() ); } BundleWires(Bundle bundle); BundleWires(long bundleId, BufferedReader reader); }### Answer: @Test public void testFilterCandidates() throws IOException { BundleWires wires = readFromFile(); BundleRequirement req = packageRequirement(packageFilter); BundleCapability candidate1 = bundleCap(targetBundleId, targetBundleVersion, true ); List<BundleCapability> candidates = new ArrayList<>(); candidates.add(candidate1); BundleCapability matchingCandidate = bundleCap(targetBundleId, "1.1.0", true ); candidates.add(matchingCandidate); c.replay(); Set<BundleCapability> goodCandidates = wires.filterCandidates( req, candidates ); assertEquals(1, goodCandidates.size()); assertEquals(candidate1, goodCandidates.iterator().next()); c.verify(); } @Test public void testFilterCandidatesSelfSatisfiedCapability() throws IOException { Bundle bundle = wiredBundle( Collections.emptyList() ); BundleCapability candidate1 = bundleCap(1, targetBundleVersion, false ); List<BundleCapability> candidates = new ArrayList<>(); candidates.add(candidate1); BundleCapability matchingCandidate = bundleCap(2, "1.1.0", false ); candidates.add(matchingCandidate); BundleRequirement req = packageRequirement(packageFilter); c.replay(); BundleWires wires = new BundleWires(bundle); Set<BundleCapability> goodCandidates = wires.filterCandidates( req, candidates ); assertEquals(1, goodCandidates.size()); assertEquals(candidate1, goodCandidates.iterator().next()); c.verify(); }
### Question: JmxRepository { public CompositeData asCompositeData() { return data; } JmxRepository(Repository repository); CompositeData asCompositeData(); static TabularData tableFrom(Collection<JmxRepository> repositories); static final CompositeType REPOSITORY; static final TabularType REPOSITORY_TABLE; }### Answer: @Test public void testJmxRepositoryCompositeData() throws Exception { Features features = new Features(); features.setName("test-1.0.0"); features.getRepository().add("mvn:org.test/test-dependency/1.0.0/xml/features"); features.getFeature().add(new Feature("test-feature", "1.0.0")); URI uri = new URI("mvn:org.test/test/1.0.0/xml/features"); Repository repository = new RepositoryImpl(uri, features, true); JmxRepository jmxRepository = new JmxRepository(repository); CompositeData compositeData = jmxRepository.asCompositeData(); assertEquals("test-1.0.0", compositeData.get(REPOSITORY_NAME)); assertEquals(uri.toString(), compositeData.get(REPOSITORY_URI)); assertTrue((Boolean) compositeData.get(REPOSITORY_BLACKLISTED)); String[] repositoryUris = (String[]) compositeData.get(REPOSITORY_REPOSITORIES); assertEquals(1, repositoryUris.length); assertEquals("mvn:org.test/test-dependency/1.0.0/xml/features", repositoryUris[0]); TabularData repositoryFeatures = (TabularData) compositeData.get(REPOSITORY_FEATURES); assertEquals(1, repositoryFeatures.size()); assertNotNull(repositoryFeatures.get(new Object[] {"test-feature", "1.0.0"})); }
### Question: Blacklist { public void blacklistBundle(LocationPattern locationPattern) { bundleBlacklist.add(locationPattern); } Blacklist(); Blacklist(List<String> blacklist); Blacklist(String blacklistUrl); boolean isRepositoryBlacklisted(String uri); boolean isFeatureBlacklisted(String name, String version); boolean isBundleBlacklisted(String uri); void merge(Blacklist others); Clause[] getClauses(); void blacklist(Features featuresModel); void blacklistRepository(LocationPattern locationPattern); void blacklistFeature(FeaturePattern featurePattern); void blacklistBundle(LocationPattern locationPattern); List<LocationPattern> getRepositoryBlacklist(); List<FeaturePattern> getFeatureBlacklist(); List<LocationPattern> getBundleBlacklist(); static Logger LOG; static final String BLACKLIST_URL; static final String BLACKLIST_TYPE; static final String TYPE_FEATURE; static final String TYPE_BUNDLE; static final String TYPE_REPOSITORY; }### Answer: @Test public void testBlacklistBundle() throws IOException { String blacklisted = "mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.jasypt/1.7_1"; Stream<Feature> features = blacklistWith(blacklisted); Stream<BundleInfo> bundles = features.flatMap(f -> f.getBundles().stream()); assertTrue(bundles.noneMatch(b -> b.getLocation().equals(blacklisted) && !b.isBlacklisted())); }
### Question: DownloadManagerHelper { public static void setExtraProtocols( Collection<String> protocols ){ StringBuilder sb = new StringBuilder( DEFAULT_IGNORED_PROTOCOL_PATTERN ); for (String proto : protocols) { sb.append("\|").append(proto); } setIgnoredProtocolPattern(sb.toString()); } private DownloadManagerHelper(); static Pattern getIgnoredProtocolPattern(); static void setExtraProtocols( Collection<String> protocols ); static String stripUrl(String url); static String stripStartLevel(String url); static String stripInlinedMavenRepositoryUrl(String url); static String removeInlinedMavenRepositoryUrl(String url); }### Answer: @Test public void testSetExtraProtocols(){ assertEquals("^(jar\|war\|war-i\|warref\|webbundle\|wrap\|spring\|blueprint):.$", DownloadManagerHelper.getIgnoredProtocolPattern().toString()); List<String> extraProtocols = new ArrayList<>(); extraProtocols.add( "extra1" ); extraProtocols.add( "extra2" ); DownloadManagerHelper.setExtraProtocols( extraProtocols ); assertEquals("^(jar\|war\|war-i\|warref\|webbundle\|wrap\|spring\|blueprint\|extra1\|extra2):.$", DownloadManagerHelper.getIgnoredProtocolPattern().toString()); }
### Question: SimpleMavenResolver implements ArtifactResolver { public URI resolve(URI artifactUri) { for (File bundleDir : mavenRepos) { File file = findFile(bundleDir, artifactUri); if (file != null) { return file.toURI(); } } throw new RuntimeException("Could not resolve " + artifactUri); } SimpleMavenResolver(List<File> mavenRepos); URI resolve(URI artifactUri); }### Answer: @Test public void testResolve() throws URISyntaxException { File basedir = new File(getClass().getClassLoader().getResource("foo").getPath()).getParentFile(); File home = new File(basedir, "test-karaf-home"); File system = new File(home, "system"); SimpleMavenResolver resolver = new SimpleMavenResolver(Collections.singletonList(system)); resolver.resolve(new URI(ARTIFACT_COORDS)); }
### Question: Statements { public String[] getLockCreateSchemaStatements(long moment) { if (lockCreateSchemaStatements == null) { lockCreateSchemaStatements = new String[] { "CREATE TABLE " + getFullLockTableName() + " (MOMENT " + getMomentColumnDataType() + ", NODE " + getNodeColumnDataType() + ")", "INSERT INTO " + getFullLockTableName() + " (MOMENT, NODE) VALUES (" + moment + ", '" + getNodeName() + "')", }; } return lockCreateSchemaStatements; } String[] getLockCreateSchemaStatements(long moment); void setLockCreateSchemaStatements(String[] lockCreateSchemaStatements); String getLockCreateStatement(); void setLockCreateStatement(String lockCreateStatement); String getLockUpdateStatement(long moment); void setLockUpdateStatement(String lockUpdateStatement); void setLockVerifySelectionNotEmptyStatement(String lockVerifySelectionNotEmptyStatement); String getLockVerifySelectionNotEmptyStatement(); String getFullLockTableName(); void setMomentColumnDataType(String momentColumnDataType); String getMomentColumnDataType(); String getNodeName(); void setNodeName(String nodeName); String getNodeColumnDataType(); void setNodeColumnDataType(String nodeColumnDataType); String getTablePrefix(); void setTablePrefix(String tablePrefix); String getTableName(); void setTableName(String tableName); }### Answer: @Test public void getDefaultLockCreateSchemaStatements() { assertArrayEquals(new String[] {DEFAULT_CREATE_TABLE_STMT, DEFAULT_POPULATE_TABLE_STMT}, statements.getLockCreateSchemaStatements(1)); } @Test public void getCustomLockCreateSchemaStatements() { customizeStatements(); String[] expectedCreateSchemaStmts = new String[] { "CREATE TABLE test.LOCK_TABLE (MOMENT NUMBER(20), NODE VARCHAR2(30))", "INSERT INTO test.LOCK_TABLE (MOMENT, NODE) VALUES (2, 'node_1')"}; assertArrayEquals(expectedCreateSchemaStmts, statements.getLockCreateSchemaStatements(2)); }
### Question: Statements { public String getLockCreateStatement() { if (lockCreateStatement == null) { lockCreateStatement = "SELECT * FROM " + getFullLockTableName() + " FOR UPDATE"; } return lockCreateStatement; } String[] getLockCreateSchemaStatements(long moment); void setLockCreateSchemaStatements(String[] lockCreateSchemaStatements); String getLockCreateStatement(); void setLockCreateStatement(String lockCreateStatement); String getLockUpdateStatement(long moment); void setLockUpdateStatement(String lockUpdateStatement); void setLockVerifySelectionNotEmptyStatement(String lockVerifySelectionNotEmptyStatement); String getLockVerifySelectionNotEmptyStatement(); String getFullLockTableName(); void setMomentColumnDataType(String momentColumnDataType); String getMomentColumnDataType(); String getNodeName(); void setNodeName(String nodeName); String getNodeColumnDataType(); void setNodeColumnDataType(String nodeColumnDataType); String getTablePrefix(); void setTablePrefix(String tablePrefix); String getTableName(); void setTableName(String tableName); }### Answer: @Test public void getDefaultLockCreateStatement() { assertEquals("SELECT * FROM KARAF_LOCK FOR UPDATE", statements.getLockCreateStatement()); } @Test public void getCustomLockCreateStatement() { customizeStatements(); assertEquals("SELECT * FROM test.LOCK_TABLE FOR UPDATE", statements.getLockCreateStatement()); }
### Question: Statements { public String getLockUpdateStatement(long moment) { if (lockUpdateStatement == null) { lockUpdateStatement = "UPDATE " + getFullLockTableName() + " SET MOMENT = " + moment; } return lockUpdateStatement; } String[] getLockCreateSchemaStatements(long moment); void setLockCreateSchemaStatements(String[] lockCreateSchemaStatements); String getLockCreateStatement(); void setLockCreateStatement(String lockCreateStatement); String getLockUpdateStatement(long moment); void setLockUpdateStatement(String lockUpdateStatement); void setLockVerifySelectionNotEmptyStatement(String lockVerifySelectionNotEmptyStatement); String getLockVerifySelectionNotEmptyStatement(); String getFullLockTableName(); void setMomentColumnDataType(String momentColumnDataType); String getMomentColumnDataType(); String getNodeName(); void setNodeName(String nodeName); String getNodeColumnDataType(); void setNodeColumnDataType(String nodeColumnDataType); String getTablePrefix(); void setTablePrefix(String tablePrefix); String getTableName(); void setTableName(String tableName); }### Answer: @Test public void getDefaultLockUpdateStatement() { assertEquals("UPDATE KARAF_LOCK SET MOMENT = 1", statements.getLockUpdateStatement(1)); } @Test public void getCustomLockUpdateStatement() { customizeStatements(); assertEquals("UPDATE test.LOCK_TABLE SET MOMENT = 2", statements.getLockUpdateStatement(2)); }
### Question: EventCollector implements EventHandler { @Override public synchronized void handleEvent(Event event) { events.addLast(event); if (events.size() > maxSize) { events.removeFirst(); } consumers.forEach(c -> c.accept(event)); } EventCollector(); @Override synchronized void handleEvent(Event event); Stream<Event> getEvents(); synchronized void addConsumer(Consumer<Event> eventConsumer); synchronized void removeConsumer(Consumer<Event> eventConsumer); }### Answer: @Test public void testHandleEvent() throws Exception { EventCollector collector = new EventCollector(); assertThat(collector.getEvents().count(), equalTo(0l)); collector.handleEvent(event("myTopic")); assertThat(collector.getEvents().count(), equalTo(1l)); assertThat(collector.getEvents().findFirst().get().getTopic(), equalTo("myTopic")); }
### Question: EventDisplayCommand implements Action { @Override public Object execute() throws Exception { EventPrinter printer = new EventPrinter(session.getConsole(), verbose); collector.getEvents().filter(matchTopic(topicFilter)).forEach(printer); return null; } @Override Object execute(); }### Answer: @Test public void testExecute() throws Exception { IMocksControl c = createControl(); EventDisplayCommand display = new EventDisplayCommand(); display.session = c.createMock(Session.class); expect(display.session.getConsole()).andReturn(System.out); display.collector = new EventCollector(); display.collector.handleEvent(new Event("myTopic", new HashMap<>())); c.replay(); display.execute(); c.verify(); }
### Question: EventTailCommand implements Action { @Override public Object execute() throws Exception { EventPrinter printer = new EventPrinter(session.getConsole(), verbose); Consumer<Event> filteredPrinter = executeIf(matchTopic(topicFilter), printer); collector.addConsumer(filteredPrinter); try { waitTillInterrupted(); } catch (InterruptedException e) { collector.removeConsumer(filteredPrinter); } return null; } @Override Object execute(); }### Answer: @Test public void testTail() throws Exception { EventTailCommand tail = new EventTailCommand(); tail.session = mock(Session.class); tail.collector = new EventCollector(); PrintStream out = System.out; expect(tail.session.getConsole()).andReturn(out); exception = null; replay(tail.session); ExecutorService executor = Executors.newSingleThreadExecutor(); executor.execute(() -> { try { tail.execute(); } catch (Exception e) { exception = e; } }); tail.collector.handleEvent(event()); Thread.sleep(200); executor.shutdownNow(); executor.awaitTermination(10, TimeUnit.SECONDS); if (exception != null) { throw exception; } verify(tail.session); }
### Question: EventPrinter implements Consumer<Event> { @Override public void accept(Event event) { out.println(getTimeStamp(event) + " - " + event.getTopic()); if (verbose) { for (String key : event.getPropertyNames()) { if (!key.equals("event.topics") && !key.equals("timestamp")) { out.println(key + ": " + getPrintValue(event, key)); } } out.println(); out.flush(); } } EventPrinter(PrintStream out, boolean verbose); @Override void accept(Event event); }### Answer: @Test public void testPrint() throws UnsupportedEncodingException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintStream out = new PrintStream(baos); new EventPrinter(out, false).accept(event()); String result = baos.toString("utf-8"); assertThat(result, equalTo("2016-01-01 12:00:00 - myTopic\n")); } @Test public void testPrintVerbose() throws UnsupportedEncodingException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintStream out = new PrintStream(baos); new EventPrinter(out, true).accept(event()); String result = baos.toString("utf-8"); assertThat(result, equalTo("2016-01-01 12:00:00 - myTopic\n" + "a: b\n" + "c: [d, e]\n\n")); }
### Question: EventSendCommand implements Action { @Override public Object execute() throws Exception { eventAdmin.sendEvent(new Event(topic, parse(properties))); return null; } @Override Object execute(); }### Answer: @Test public void testExecute() throws Exception { EventSendCommand send = new EventSendCommand(); send.eventAdmin = mock(EventAdmin.class); Capture<Event> eventCapture = newCapture(); send.eventAdmin.sendEvent(capture(eventCapture)); expectLastCall(); replay(send.eventAdmin); send.topic = "myTopic"; send.properties = Collections.singletonList("a=b"); send.execute(); verify(send.eventAdmin); Event event = eventCapture.getValue(); assertThat(event.getTopic(), equalTo("myTopic")); assertThat(event.getProperty("a"), equalTo("b")); }
### Question: EventSendCommand implements Action { static Map<String, String> parse(List<String> propList) { Map<String, String> properties = new HashMap<>(); if (propList != null) { for (String keyValue : propList) { int splitAt = keyValue.indexOf("="); if (splitAt <= 0) { throw new IllegalArgumentException("Invalid property " + keyValue); } else { String key = keyValue.substring(0, splitAt); String value = keyValue.substring(splitAt + 1); properties.put(key, value); } } } return properties; } @Override Object execute(); }### Answer: @Test public void testParse() { List<String> propList = Arrays.asList("a=b","b=c"); Map<String, String> expectedMap = new HashMap<>(); expectedMap.put("a", "b"); expectedMap.put("b", "c"); Map<String, String> props = EventSendCommand.parse(propList); assertThat(props.size(), equalTo(2)); assertThat(props.get("a"), equalTo("b")); assertThat(props.get("b"), equalTo("c")); } @Test public void testParseNull() { Map<String, String> props = EventSendCommand.parse(null); assertNotNull(props); assertThat(props.size(), equalTo(0)); } @Test(expected=IllegalArgumentException.class) public void testParseNoKeyValue() { EventSendCommand.parse(Collections.singletonList("=")); } @Test(expected=IllegalArgumentException.class) public void testParseNoKey() { EventSendCommand.parse(Collections.singletonList("=b")); } @Test public void testParseStrange() { Map<String, String> props = EventSendCommand.parse(Arrays.asList("a=b","c=d=3", "e=")); assertThat(props.size(), equalTo(3)); assertThat(props.get("a"), equalTo("b")); assertThat(props.get("c"), equalTo("d=3")); assertThat(props.get("e"), equalTo("")); }
### Question: Tree extends Node<T> { public void write(PrintStream stream) { write(new PrintWriter(stream)); } Tree(T root); void write(PrintStream stream); void write(PrintStream stream, Converter<T> converter); void write(PrintWriter writer); void write(PrintWriter writer, Converter<T> converter); }### Answer: @Test public void writeTreeWithOneChildAndNodeConverter() throws IOException { Tree<String> tree = new Tree<>("root"); tree.addChild("child"); StringWriter writer = new StringWriter(); tree.write(new PrintWriter(writer), node -> "my " + node.getValue()); BufferedReader reader = new BufferedReader(new StringReader(writer.getBuffer().toString())); assertEquals("my root" , reader.readLine()); assertEquals("+- my child" , reader.readLine()); }
### Question: MavenConfigService { static String getLocalRepoFromConfig(Dictionary<String, Object> dict) { String path = null; if (dict != null) { path = (String) dict.get("org.ops4j.pax.url.mvn.localRepository"); if (path == null) { String settings = (String) dict.get("org.ops4j.pax.url.mvn.settings"); if (settings != null) { path = getLocalRepositoryFromSettings(new File(settings)); } } } return path; } MavenConfigService(ConfigurationAdmin configurationAdmin); }### Answer: @Test public void testLocalRepoEmpty() throws Exception { Hashtable<String, Object> config = new Hashtable<>(); assertEquals(null, MavenConfigService.getLocalRepoFromConfig(config)); } @Test public void testLocalRepoExplicit() throws Exception { Hashtable<String, Object> config = new Hashtable<>(); config.put("org.ops4j.pax.url.mvn.localRepository", "foo/bar"); assertEquals("foo/bar", MavenConfigService.getLocalRepoFromConfig(config)); } @Test public void testLocalRepoFromSettings() throws Exception { Hashtable<String, Object> config = new Hashtable<>(); config.put("org.ops4j.pax.url.mvn.settings", getClass().getResource("/settings.xml").getPath()); assertEquals("foo/bar", MavenConfigService.getLocalRepoFromConfig(config)); } @Test public void testLocalRepoFromSettingsNs() throws Exception { Hashtable<String, Object> config = new Hashtable<>(); config.put("org.ops4j.pax.url.mvn.settings", getClass().getResource("/settings2.xml").getPath()); assertEquals("foo/bar", MavenConfigService.getLocalRepoFromConfig(config)); }
### Question: SshUtils { public static List<NamedFactory<Cipher>> buildCiphers(String[] names) { ServerConfig defaults = new ServerConfig(); List<NamedFactory<Cipher>> avail = defaults.getCipherFactories(); return filter(Cipher.class, avail, names); } static List<NamedFactory<S>> filter(Class<S> type, Collection<NamedFactory<S>> factories, String[] names); static List<KeyExchangeFactory> filter(List<KeyExchangeFactory> factories, String[] names); static List<NamedFactory<Mac>> buildMacs(String[] names); static List<NamedFactory<Cipher>> buildCiphers(String[] names); static List<KeyExchangeFactory> buildKexAlgorithms(String[] names); }### Answer: @Test public void testCiphersDefault() throws IOException { String ciphers = "aes128-ctr,arcfour128,aes128-cbc,3des-cbc,blowfish-cbc"; List<NamedFactory<Cipher>> list = SshUtils.buildCiphers(ciphers.split(",")); for (String cipher : ciphers.split(",")) { boolean found = false; for (NamedFactory<Cipher> factory : list) { if (factory.getName().equalsIgnoreCase(cipher)) { found = true; break; } } if (!found) { Assert.fail("Configured default cipher '" + cipher + "' cannot be resolved"); } } }
### Question: SshUtils { public static List<NamedFactory<Mac>> buildMacs(String[] names) { return filter(Mac.class, new ServerConfig().getMacFactories(), names); } static List<NamedFactory<S>> filter(Class<S> type, Collection<NamedFactory<S>> factories, String[] names); static List<KeyExchangeFactory> filter(List<KeyExchangeFactory> factories, String[] names); static List<NamedFactory<Mac>> buildMacs(String[] names); static List<NamedFactory<Cipher>> buildCiphers(String[] names); static List<KeyExchangeFactory> buildKexAlgorithms(String[] names); }### Answer: @Test public void testMacsDefault() throws IOException { String macs = "hmac-sha2-512,hmac-sha2-256,hmac-sha1"; List<NamedFactory<Mac>> list = SshUtils.buildMacs(macs.split(",")); for (String mac : macs.split(",")) { boolean found = false; for (NamedFactory<Mac> factory : list) { if (factory.getName().equalsIgnoreCase(mac)) { found = true; break; } } if (!found) { Assert.fail("Configured default HMAC '" + mac + "' cannot be resolved"); } } }
### Question: SshUtils { public static List<KeyExchangeFactory> buildKexAlgorithms(String[] names) { ServerConfig defaults = new ServerConfig(); List<KeyExchangeFactory> avail = defaults.getKeyExchangeFactories(); return filter(avail, names); } static List<NamedFactory<S>> filter(Class<S> type, Collection<NamedFactory<S>> factories, String[] names); static List<KeyExchangeFactory> filter(List<KeyExchangeFactory> factories, String[] names); static List<NamedFactory<Mac>> buildMacs(String[] names); static List<NamedFactory<Cipher>> buildCiphers(String[] names); static List<KeyExchangeFactory> buildKexAlgorithms(String[] names); }### Answer: @Test public void testKexAlgorithmsDefault() throws IOException { String kexAlgorithms = "diffie-hellman-group-exchange-sha256,ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha1,diffie-hellman-group1-sha1"; List<KeyExchangeFactory> list = SshUtils.buildKexAlgorithms(kexAlgorithms.split(",")); for (String kex : kexAlgorithms.split(",")) { boolean found = false; for (KeyExchangeFactory factory : list) { if (factory.getName().equalsIgnoreCase(kex)) { found = true; break; } } if (!found) { Assert.fail("Configured default key exchange algorithm '" + kex + "' cannot be resolved"); } } }
### Question: FilterParser { public Expression parse(String filter) { return parse(new ExprTokenizer(filter)); } Expression parse(String filter); }### Answer: @Test public void testSimpleItem() { Expression expr = new FilterParser().parse(" (a= b)"); SimpleItem item = (SimpleItem) expr; checkItem(item, "a", FilterType.equal, "b"); } @Test public void testNotSimpleItem() { NotExpression not = (NotExpression) new FilterParser().parse("(!(a=b))"); checkItem(not.expression, "a", FilterType.equal, "b"); } @Test public void testPackageImport() { AndExpression expr = (AndExpression) new FilterParser().parse("(&(osgi.wiring.package=org.mypackage)(version>=1.9.0)(!(version>=2.0.0)))"); Assert.assertEquals(3, expr.expressions.length); checkItem(expr.expressions[0], "osgi.wiring.package", FilterType.equal, "org.mypackage"); checkItem(expr.expressions[1], "version", FilterType.gt, "1.9.0"); NotExpression notVersion = (NotExpression)expr.expressions[2]; checkItem(notVersion.expression, "version", FilterType.gt, "2.0.0"); } @Test public void testPackageImportNoVersions() { Expression expr = new FilterParser().parse("(osgi.wiring.package=org.mypackage)"); checkItem(expr, "osgi.wiring.package", FilterType.equal, "org.mypackage"); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.