method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
DataManager { public Single<List<News>> getAllNewses(Integer offset) { return getNewses(null, offset); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getAllNewses() throws Exception { TestObserver<List<News>> testObserver = mDataManager.getAllNewses(0).test().await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<List<News>> getNewses(String nodeId, Integer offset) { return mService.getNewses(buildAuthorization(), nodeId, offset, PAGE_LIMIT) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getNewses() throws Exception { TestObserver<List<News>> testObserver = mDataManager.getNewses(null, 0).test().await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<List<NewsReply>> getNewsReplies(int newsId, int offset) { return mService.getNewsReplies(buildAuthorization(), newsId, offset, PAGE_LIMIT) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getNewsReplies() throws Exception { TestObserver<List<NewsReply>> testObserver = mDataManager.getNewsReplies(1, 0).test() .await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<List<Topic>> getUserTopics(String userLogin, int offset) { return mService.getUserTopics(buildAuthorization(), userLogin, offset, PAGE_LIMIT) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getUserTopics() throws Exception { TestObserver<List<Topic>> testObserver = mDataManager.getUserTopics("xshengcn", 0).test() .await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<List<Topic>> getUserFavorites(String userLogin, int offset) { return mService.getUserFavorites(buildAuthorization(), userLogin, offset, PAGE_LIMIT) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getUserFavorites() throws Exception { TestObserver<List<Topic>> testObserver = mDataManager.getUserFavorites("xshengcn", 0).test() .await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<List<UserReply>> getUserReplies(String userLogin, int offset) { return mService.getUserReplies(buildAuthorization(), userLogin, offset, PAGE_LIMIT) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getUserReplies() throws Exception { TestObserver<List<UserReply>> testObserver = mDataManager.getUserReplies("xshengcn", 0) .test().await(); testObserver.assertNoErrors(); testObserver.assertComplete(); } |
### Question:
DataManager { public Single<UserDetail> getMe() { return mService.getMe(buildAuthorization()).doOnSuccess(mPreferencesHelper::setUserDetail) .compose(applySingleSchedulers()); } DataManager(@NonNull OkHttpClient client, @NonNull PreferencesHelper preferencesHelper); String buildAuthorization(); Single<Token> login(String username, String password); Single<List<Topic>> getTopics(int offset); Single<TopicDetail> createTopic(int nodeId, String title, String body); Single<List<News>> getAllNewses(Integer offset); Single<List<News>> getNewses(String nodeId, Integer offset); Single<List<NewsReply>> getNewsReplies(int newsId, int offset); Single<List<Topic>> getUserTopics(String userLogin, int offset); Single<List<Topic>> getUserFavorites(String userLogin, int offset); Single<List<UserReply>> getUserReplies(String userLogin, int offset); Single<UserDetail> getMe(); Single<UserDetail> getMe(boolean forced); Single<NotificationUnread> getNotificationsUnreadCount(); Single<List<Notification>> getNotifications(int offset); Single<TopicAndReplies> getTopicAndComments(int topicId); Single<TopicDetail> getTopicDetail(int id); Single<List<TopicReply>> getTopicReplies(int topicId, int offset); Single<TopicReply> publishComment(int id, String body); Single<ImageResult> uploadPhoto(String filePath); Single<Map<TopicNodeCategory, List<TopicNode>>> getTopicNodes(); Single<List<Project>> getProjects(int offset); Single<List<SiteListItem>> getSites(); Single<UserDetail> getUserDetail(String userLogin); static final int PAGE_LIMIT; static final String DATE_FORMAT; }### Answer:
@Test public void getMe() throws Exception { TestObserver<UserDetail> testObserver = mDataManager.getMe().test().await(); testObserver.assertError(HttpException.class); testObserver.assertNotComplete(); } |
### Question:
ExpressionUtil { public static String getArithmeticExpressionStr( Map<String, ArchetypeElementVO> elementMap, ExpressionItem expressionItem, Map<RefStat, Set<String>> stats) { return getArithmeticExpressionStr(elementMap, expressionItem, stats, null); } static String getArithmeticExpressionStr(
Map<String, ArchetypeElementVO> elementMap,
ExpressionItem expressionItem, Map<RefStat, Set<String>> stats); static String getVariableWithAttributeStr(String rmName, Variable var); static String getDataValueMethod(String gtCode); static boolean isFunction(String attribute); static final String CODE_FUNCTION_SEPARATOR; }### Answer:
@Test public void testGetArithmeticExpressionStrForComplexDurationOperation() throws Exception { Map<String, ArchetypeElementVO> elementMap = new HashMap<>(); Map<RefStat, Set<String>> stats = new HashMap<>(); ConstantExpression constantExpression = new ConstantExpression("1,d"); ExpressionItem expressionItem = new BinaryExpression(new BinaryExpression(constantExpression, constantExpression, OperatorKind.ADDITION), constantExpression, OperatorKind.ADDITION); String arithmeticExpressionStr = ExpressionUtil.getArithmeticExpressionStr(elementMap, expressionItem, stats); assertThat(arithmeticExpressionStr, equalTo("(((DVUtil.calculateDuration(\"1,d\",\"+\"))+(DVUtil.calculateDuration(\"1,d\",\"+\")))+(DVUtil.calculateDuration(\"1,d\",\"+\")))")); } |
### Question:
Ordinals { public OrdinalVO getOrdinalVO(String templateId, String elementId, String code) { archetypeManager.loadArchetypesAndTemplatesIfNeeded(templateId, elementId); if (templateId == null) { if (!ordinalByElementId.containsKey(elementId)) { throw new RuntimeException(format("Could not find element '%s'", elementId)); } return getOrdinals(elementId) .stream() .filter(o -> o.getCode().equals(code)) .findFirst() .orElseThrow(() -> new RuntimeException(format("Could not find code '%s' in element '%s'", code, elementId))); } else { if (!getTemplateOrdinals(templateId).containsKey(elementId)) { throw new RuntimeException(format("Could not find element '%s' with template '%s'", elementId, templateId)); } return getTemplateOrdinals(templateId).get(elementId) .stream() .filter(o -> o.getCode().equals(code)) .findFirst() .orElseThrow(() -> new RuntimeException(format("Could not find code '%s' in element '%s' with template '%s'", code, elementId, templateId))); } } Ordinals(ArchetypeManager archetypeManager); void init(); OrdinalVO getOrdinalVO(String templateId, String elementId, String code); List<OrdinalVO> getOrdinalVOs(String idTemplate, String elementId); String getText(OrdinalVO ordinalVO, String lang); String getText(String idTemplate, String idElement, String ordinalKey, String lang); String getDescription(OrdinalVO ordinalVO, String lang); String getDescription(String idTemplate, String idElement, String ordinalKey, String lang); }### Answer:
@Test(expectedExceptions = RuntimeException.class) public void should_not_find_ordinal() { Ordinals ordinals = new Ordinals(mock(ArchetypeManager.class)); ordinals.getOrdinalVO(null, TEST_ARCHETYPE_ID + "/archetypeElementPath1", "testCode1"); } |
### Question:
Archetypes extends AbstractCMManager<ArchetypeDTO> { public Archetype getArchetypeAOMById(String archetypeId) { return getArchetypeAOMsByIds(Collections.singleton(archetypeId)).iterator().next(); } Archetypes(
ArchetypeManager archetypeManager,
ExecutorService executorService); @Override void registerCMElementsInCache(Collection<ArchetypeDTO> cmElements); @Override Class<ArchetypeDTO> getCMElementClass(); void processArchetypes(Collection<ArchetypeDTO> archetypeDTOs); void processArchetype(ArchetypeDTO archetypeDTO); static ImageIcon getIcon(String archetypeId); static String getEntryType(final String archetypeId); Map<String, Archetype> getArchetypeMap(); Archetype getArchetypeAOMById(String archetypeId); Collection<Archetype> getArchetypeAOMsByIds(Collection<String> archetypeIds); Collection<Archetype> getArchetypeAOMsInCacheById(Collection<String> archetypeIds); org.openehr.jaxb.am.Archetype getArchetypeAOM2ById(String archetypeId); ArchetypeObjectBundleCustomVO getArchetypeAOBCVOById(String archetypeId); ArchetypeManager getArchetypeManager(); TemplateMap generateTemplateMap(String archetypeId); static final ImageIcon ICON; }### Answer:
@Test public void testGetArchetypeAOMById() throws Exception { String archetypeId = "openEHR-EHR-OBSERVATION.body_weight.v1"; Archetype archetype = archetypes.getArchetypeAOMById(archetypeId); assertThat(archetype, notNullValue()); } |
### Question:
Archetypes extends AbstractCMManager<ArchetypeDTO> { public void processArchetype(ArchetypeDTO archetypeDTO) { new ArchetypeObjectBundleManager(archetypeDTO, archetypeManager).buildArchetypeObjectBundleCustomVO(); } Archetypes(
ArchetypeManager archetypeManager,
ExecutorService executorService); @Override void registerCMElementsInCache(Collection<ArchetypeDTO> cmElements); @Override Class<ArchetypeDTO> getCMElementClass(); void processArchetypes(Collection<ArchetypeDTO> archetypeDTOs); void processArchetype(ArchetypeDTO archetypeDTO); static ImageIcon getIcon(String archetypeId); static String getEntryType(final String archetypeId); Map<String, Archetype> getArchetypeMap(); Archetype getArchetypeAOMById(String archetypeId); Collection<Archetype> getArchetypeAOMsByIds(Collection<String> archetypeIds); Collection<Archetype> getArchetypeAOMsInCacheById(Collection<String> archetypeIds); org.openehr.jaxb.am.Archetype getArchetypeAOM2ById(String archetypeId); ArchetypeObjectBundleCustomVO getArchetypeAOBCVOById(String archetypeId); ArchetypeManager getArchetypeManager(); TemplateMap generateTemplateMap(String archetypeId); static final ImageIcon ICON; }### Answer:
@Test public void testProcessArchetype() { Collection<ArchetypeDTO> archetypeDTOs = archetypes.getCMElementByIds(Arrays.asList("openEHR-EHR-OBSERVATION.body_weight.v1", "openEHR-EHR-OBSERVATION.chadsvas_score.v1")); archetypes.processArchetypes(archetypeDTOs); } |
### Question:
ArchetypeElements { public ArchetypeElementVO getArchetypeElement(String templateId, String elementId) { archetypeManager.loadArchetypesAndTemplatesIfNeeded(templateId, elementId); if (templateId == null) { if (!archetypeElementsById.containsKey(elementId)) { throw new RuntimeException(format("Could not find element '%s'", elementId)); } return archetypeElementsById.get(elementId); } else { if (!getArchetypeElementsInTemplate(templateId).containsKey(elementId)) { throw new RuntimeException(format("Could not find element '%s' for template '%s'", elementId, templateId)); } return getArchetypeElementsInTemplate(templateId).get(elementId); } } ArchetypeElements(ArchetypeManager archetypeManager); ArchetypeElementVO getCurrentDateTimeArchetypeElementVO(); void init(); void loadArchetypeElements(
String archetypeId,
String templateId,
Collection<ArchetypeElementVO> archetypeElementVOs); ArchetypeElementVO getArchetypeElement(String templateId, String elementId); boolean isArchetypeElement(String templateId, String elementId); String getText(ArchetypeElementVO archetypeElementVO, String lang); String getText(String templateId, String elementId, String lang); String getDescription(ArchetypeElementVO archetypeElementVO, String lang); String getDescription(String templateId, String elementId, String lang); Collection<ArchetypeElementVO> getArchetypeElementsVO(String idArchetype, String templateId); ArrayList<ClusterVO> getClusters(ArchetypeElementVO archetypeElementVO); }### Answer:
@Test(expectedExceptions = RuntimeException.class) public void should_not_find_archetype_element() { ArchetypeElements archetypeElements = new ArchetypeElements(mock(ArchetypeManager.class)); archetypeElements.getArchetypeElement(null, TEST_ARCHETYPE_ID + "/archetypeElementPath1"); } |
### Question:
DroolsGuideExportPlugin implements GuideExportPlugin { @Override public String getPluginName() { return "Drools"; } DroolsGuideExportPlugin(ArchetypeManager archetypeManager); @Override String getPluginName(); @Override byte[] compile(Guide guide); @Override String getSource(Guide guide); }### Answer:
@Test public void testGetPluginName() { assertThat(droolsGuideExportPlugin.getPluginName(), equalTo("Drools")); } |
### Question:
DroolsGuideExportPlugin implements GuideExportPlugin { @Override public byte[] compile(Guide guide) { return droolsExecutionManager.getDroolsRuleEngineService().compile(guide); } DroolsGuideExportPlugin(ArchetypeManager archetypeManager); @Override String getPluginName(); @Override byte[] compile(Guide guide); @Override String getSource(Guide guide); }### Answer:
@Test public void testCompile() { Guide guide = guides.getGuide("Stroke_risks.v2"); assertThat(droolsGuideExportPlugin.compile(guide), notNullValue()); } |
### Question:
DroolsGuideExportPlugin implements GuideExportPlugin { @Override public String getSource(Guide guide) { return new GDLDroolsConverter(guide, archetypeManager).convertToDrools(); } DroolsGuideExportPlugin(ArchetypeManager archetypeManager); @Override String getPluginName(); @Override byte[] compile(Guide guide); @Override String getSource(Guide guide); }### Answer:
@Test public void testGetSource() throws Exception { Guide guide = guides.getGuide("Stroke_risks.v2"); String source = droolsGuideExportPlugin.getSource(guide); assertThat(source, notNullValue()); } |
### Question:
Clusters { public ClusterVO getClusterVO(String templateId, String clusterId) { archetypeManager.loadArchetypesAndTemplatesIfNeeded(templateId, clusterId); Map<String, ClusterVO> clusterMap = getClusterMap(templateId); if (!clusterMap.containsKey(clusterId)) { String complexClusterId = findComplexClusterId(clusterId, clusterMap); if (complexClusterId == null) { return null; } else { clusterId = complexClusterId; } } return clusterMap.get(clusterId); } Clusters(ArchetypeManager archetypeManager); void init(); void loadClusters(
String archetypeId,
String templateId,
Collection<ClusterVO> clusterVOs); ClusterVO getClusterVO(String templateId, String clusterId); boolean isCluster(String templateId, String clusterId); Collection<ClusterVO> getSections(String templateId); String getText(ClusterVO clusterVO, String lang); String getText(String templateId, String elementId, String lang); String getDescription(ClusterVO clusterVO, String lang); String getDescription(String templateId, String elementId, String lang); }### Answer:
@Test public void should_not_find_cluster() { Clusters clusters = new Clusters(mock(ArchetypeManager.class)); ClusterVO clusterVO = clusters.getClusterVO(null, TEST_ARCHETYPE_ID + "/clusterPath1"); assertThat(clusterVO, is(nullValue())); } |
### Question:
OpenTracingHelper extends Helper { public void associateSpan(Object obj, Span span) { spanAssociations.put(obj, span); } OpenTracingHelper(Rule rule); Tracer getTracer(); void associateSpan(Object obj, Span span); Span retrieveSpan(Object obj); void finishedSpan(Object key, Span span); boolean isFinished(Object key); void setState(Object obj, int value); int getState(Object obj); boolean ignore(Object obj); }### Answer:
@Test public void testAssociateSpan() { OpenTracingHelper helper = new OpenTracingHelper(null); Object obj = new Object(); Span span = new MockTracer().buildSpan("Test").start(); helper.associateSpan(obj, span); assertEquals(span, helper.retrieveSpan(obj)); } |
### Question:
OpenTracingHelper extends Helper { public Tracer getTracer() { if (tracer == null) { initTracer(); } return tracer; } OpenTracingHelper(Rule rule); Tracer getTracer(); void associateSpan(Object obj, Span span); Span retrieveSpan(Object obj); void finishedSpan(Object key, Span span); boolean isFinished(Object key); void setState(Object obj, int value); int getState(Object obj); boolean ignore(Object obj); }### Answer:
@Test public void testGetTracerResolved() { OpenTracingHelper helper = new OpenTracingHelper(null); Tracer tracer = helper.getTracer(); assertNotNull(tracer); try { tracer.buildSpan("Test"); } catch (DummyTracer.DummyCalled e) { assertFalse(e.triggeringEnabled); return; } fail("DummyTracer did not initialize properly"); }
@Test public void testGetTracerWithRulesEnabled() { System.setProperty("io.opentracing.contrib.agent.allowInstrumentedTracer", "true"); try { OpenTracingHelper helper = new OpenTracingHelper(null); Tracer tracer = helper.getTracer(); assertNotNull(tracer); tracer.buildSpan("test2"); } catch(DummyTracer.DummyCalled e) { assertTrue(e.triggeringEnabled); return; } finally { System.clearProperty("io.opentracing.contrib.agent.allowInstrumentedTracer"); } fail("DummyTracer did not initialize properly"); }
@Test public void testGetTracerExisting() { GlobalTracer.register(new MockTracer()); OpenTracingHelper helper = new OpenTracingHelper(null); Tracer tracer = helper.getTracer(); assertNotNull(tracer); assertTrue(tracer.buildSpan("Test").start() instanceof MockSpan); } |
### Question:
BitReverse { public static byte bitRev8(byte b) { return BYTE_REV_TABLE[b & 0xFF]; } static byte bitRev8(byte b); static short bitRev16(short b); static int bitRev32(int b); }### Answer:
@Test public void bitRev8() throws Exception { assertThat(BitReverse.bitRev8((byte) 0x00), is((byte) 0x00)); assertThat(BitReverse.bitRev8((byte) 0xFF), is((byte) 0xFF)); assertThat(BitReverse.bitRev8((byte) 0x40), is((byte) 0x02)); assertThat(BitReverse.bitRev8((byte) 0x02), is((byte) 0x40)); assertThat(BitReverse.bitRev8((byte) 0x80), is((byte) 0x01)); assertThat(BitReverse.bitRev8((byte) 0x01), is((byte) 0x80)); assertThat(BitReverse.bitRev8((byte) 0xA0), is((byte) 0x05)); assertThat(BitReverse.bitRev8((byte) 0x18), is((byte) 0x18)); assertThat(BitReverse.bitRev8((byte) 0x1C), is((byte) 0x38)); assertThat(BitReverse.bitRev8((byte) 0x38), is((byte) 0x1C)); } |
### Question:
RegMap { @VisibleForTesting static long readValue(byte[] buff) { long res = 0; for (int i = 0; i < buff.length; i++) { res |= ((long) (buff[i] & 0xFF)) << ((buff.length - i - 1) * 8); } return res; } RegMap(int address, int reg_bits, I2cAdapter i2CAdapter); void read_regs(long reg, byte[] vals, int offset, int length); int read_reg(long reg); void write_reg(long reg, int val); void bulk_write(long reg, byte[] vals); void bulk_write(long reg, byte[] vals, int len); void update_bits(int reg, int mask, int val); }### Answer:
@Test public void readValueTest64bit() { long expected = 0x123456789ABCDEFFL; long actual = RegMap.readValue(new byte[] { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9A, (byte) 0xBC, (byte) 0xDE, (byte) 0xFF }); assertThat(actual, is(expected)); }
@Test public void readValueTest16bit() { long expected = 0x1234L; long actual = RegMap.readValue(new byte[] { (byte) 0x12, (byte) 0x34 }); assertThat(actual, is(expected)); } |
### Question:
RegMap { @VisibleForTesting static void writeValue(byte[] buff, long value) { for (int i = 0; i < buff.length; i++) { buff[i] = (byte) (value >> ((buff.length - i - 1) * 8)); } } RegMap(int address, int reg_bits, I2cAdapter i2CAdapter); void read_regs(long reg, byte[] vals, int offset, int length); int read_reg(long reg); void write_reg(long reg, int val); void bulk_write(long reg, byte[] vals); void bulk_write(long reg, byte[] vals, int len); void update_bits(int reg, int mask, int val); }### Answer:
@Test public void writeValueTest64bit() { byte[] expected = new byte[] { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9A, (byte) 0xBC, (byte) 0xDE, (byte) 0xFF }; byte[] actual; RegMap.writeValue(actual = new byte[8], 0x123456789ABCDEFFL); assertThat(actual, is(expected)); }
@Test public void writeValueTest16bit() { byte[] expected = new byte[] { (byte) 0x12, (byte) 0x34 }; byte[] actual; RegMap.writeValue(actual = new byte[2], 0x1234L); assertThat(actual, is(expected)); } |
### Question:
TsDumpFileUtils { public static File getFor(Context ctx, long freq, long bandwidth, Date date) { File root = ctx.getExternalFilesDir(null); String timestamp = DATE_FORMAT.format(date); String filename = String.format(DEFAULT_LOCALE, "mux_%d_%d_%s.ts", freq, bandwidth, timestamp); return new File(root, filename); } static File getFor(Context ctx, long freq, long bandwidth, Date date); static List<DvbDevice> getDevicesForAllRecordings(Context ctx); }### Answer:
@Test public void testNameCreation() { File actual = TsDumpFileUtils.getFor(context, 506_000_000L, 8_000_000L, date(2017, 1, 10, 13, 4, 24)); assertThat(actual, equalTo(new File(ROOT, "mux_506000000_8000000_20170110130424.ts"))); } |
### Question:
BitReverse { public static short bitRev16(short b) { return (short) (((bitRev8((byte) b) & 0xFF) << 8) | (bitRev8((byte) (b >> 8)) & 0xFF)); } static byte bitRev8(byte b); static short bitRev16(short b); static int bitRev32(int b); }### Answer:
@Test public void bitRev16() throws Exception { assertThat(BitReverse.bitRev16((short) 0x0001), is((short) 0x8000)); assertThat(BitReverse.bitRev16((short) 0x8000), is((short) 0x0001)); assertThat(BitReverse.bitRev16((short) 0xFF00), is((short) 0x00FF)); assertThat(BitReverse.bitRev16((short) 0xFFF0), is((short) 0x0FFF)); assertThat(BitReverse.bitRev16((short) 0x000F), is((short) 0xF000)); } |
### Question:
StackTraceSerializer { public static String serialize(Throwable t) { ByteArrayOutputStream buff = new ByteArrayOutputStream(); PrintStream ps = new PrintStream(buff); t.printStackTrace(ps); try { return buff.toString("UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } } static String serialize(Throwable t); }### Answer:
@Test public void testSerialize() throws Exception { String serialization = StackTraceSerializer.serialize(new IOException("Test message")); assertTrue(serialization.startsWith("java.io.IOException: Test message\n" + "\tat "+StackTraceSerializerTest.class.getName()+".")); } |
### Question:
BitReverse { public static int bitRev32(int b) { return ((bitRev16((short) b) & 0xFFFF) << 16) | (bitRev16((short) (b >> 16)) & 0xFFFF); } static byte bitRev8(byte b); static short bitRev16(short b); static int bitRev32(int b); }### Answer:
@Test public void bitRev32() throws Exception { assertThat(BitReverse.bitRev32(0x00000001), is(0x80000000)); assertThat(BitReverse.bitRev32(0x80000000), is(0x00000001)); assertThat(BitReverse.bitRev32(0x0F000000), is(0x000000F0)); assertThat(BitReverse.bitRev32(0x000000F0), is(0x0F000000)); assertThat(BitReverse.bitRev32(0xF0000000), is(0x0000000F)); assertThat(BitReverse.bitRev32(0x0000000F), is(0xF0000000)); assertThat(BitReverse.bitRev32(0xFF000000), is(0x000000FF)); assertThat(BitReverse.bitRev32(0x000000FF), is(0xFF000000)); assertThat(BitReverse.bitRev32(0xFFFFF0FF), is(0xFF0FFFFF)); assertThat(BitReverse.bitRev32(0xFF0FFFFF), is(0xFFFFF0FF)); assertThat(BitReverse.bitRev32(0xFFFFFFF0), is(0x0FFFFFFF)); assertThat(BitReverse.bitRev32(0x0FFFFFFF), is(0xFFFFFFF0)); } |
### Question:
DvbMath { static int fls(int x) { if (x == 0) return 0; int r = 32; if ((x & 0xffff0000L) == 0) { x <<= 16; r -= 16; } if ((x & 0xff000000L) == 0) { x <<= 8; r -= 8; } if ((x & 0xf0000000L) == 0) { x <<= 4; r -= 4; } if ((x & 0xc0000000L) == 0) { x <<= 2; r -= 2; } if ((x & 0x80000000L) == 0) { r -= 1; } return r; } static int intlog10(int value); static long divU64(long dividend, long divisor); static long divRoundClosest(long x, long divisor); }### Answer:
@Test public void fls() throws Exception { assertThat(DvbMath.fls(1), is(1)); assertThat(DvbMath.fls(0), is(0)); assertThat(DvbMath.fls(0x80000000), is(32)); } |
### Question:
DvbMath { static int intlog2(int value) { int msb = fls(value) - 1; int significand = value << (31 - msb); int logentry = (significand >> 23) & 0xff; int interpolation = ((significand & 0x7fffff) * ((LOG_TABLE[(logentry + 1) & 0xff] - LOG_TABLE[logentry]) & 0xffff)) >> 15; return (msb << 24) + (LOG_TABLE[logentry] << 8) + interpolation; } static int intlog10(int value); static long divU64(long dividend, long divisor); static long divRoundClosest(long x, long divisor); }### Answer:
@Test public void intlog2() throws Exception { assertThat(DvbMath.intlog2(8), is(3 << 24)); assertThat(DvbMath.intlog2(1024), is(10 << 24)); assertThat(DvbMath.intlog2(0x80000000), is(31 << 24)); } |
### Question:
DvbMath { public static int intlog10(int value) { return (int) ((intlog2(value) * 646456993L) >> 31); } static int intlog10(int value); static long divU64(long dividend, long divisor); static long divRoundClosest(long x, long divisor); }### Answer:
@Test public void intlog10() throws Exception { assertThat(DvbMath.intlog10(1_000), is(50331675)); } |
### Question:
FastIntFilter { public void setFilter(int ... ids) { synchronized (bitmap) { for (int aFilter : filter) setFilterOff(aFilter); this.filter = ids; for (int aFilter : filter) setFilterOn(aFilter); } } FastIntFilter(int size); void setFilter(int ... ids); boolean isFiltered(int id); }### Answer:
@Test public void testSimpleCase() { f.setFilter(0, 3, 8, 18, 19); confirmOnlyFiltered(0, 3, 8, 18, 19); }
@Test public void testWithReset() { f.setFilter(1, 7, 8, 17); confirmOnlyFiltered(1, 7, 8, 17); f.setFilter(0); confirmOnlyFiltered(0); f.setFilter(13, 19); confirmOnlyFiltered(13, 19); }
@Test public void testSlightlyOverSize() { f.setFilter(23); }
@Test(expected = ArrayIndexOutOfBoundsException.class) public void testTrulyOverSize() { f.setFilter(24); } |
### Question:
RxScreen extends Screen<V> { protected final void autoDispose(Disposable disposable) { disposables.add(disposable); } }### Answer:
@Test public void autoDispose() { Disposable disposable = Observable.just("a").subscribe(); rxScreen.autoDispose(disposable); rxScreen.onHide(null); assertThat(disposable.isDisposed()).isTrue(); } |
### Question:
RxScreen extends Screen<V> { protected final void autoUnsubscribe(Subscription subscription) { subscriptions.add(subscription); } }### Answer:
@Test public void autoUnsubscribe() { Subscription subscription = Observable.just("a").subscribe(); rxScreen.autoUnsubscribe(subscription); rxScreen.onHide(null); assertThat(subscription.isUnsubscribed()).isTrue(); } |
### Question:
Views { static void whenMeasured(final View view, final OnMeasured onMeasured) { int width = view.getWidth(); int height = view.getHeight(); if (width > 0 && height > 0) { onMeasured.onMeasured(); return; } view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() { @Override public boolean onPreDraw() { final ViewTreeObserver observer = view.getViewTreeObserver(); if (observer.isAlive()) { observer.removeOnPreDrawListener(this); } onMeasured.onMeasured(); return true; } }); } private Views(); }### Answer:
@Test public void whenMeasuredCallOnMeasured() { whenMeasured(view, new OnMeasured() { @Override public void onMeasured() { onMeasuredCalled = true; } }); activity.setContentView(view); assertThat(onMeasuredCalled).isTrue(); } |
### Question:
Screen extends LifecycleAwareComponent implements NavigableCompat, ActionBarModifier { @Nullable public final Activity getActivity() { return activity; } Screen(); @Nullable final V getView(); @Nullable final Activity getActivity(); @Nullable final LegacyNavigator getNavigator(); final Dialog getDialog(); @Override final void transitionStarted(); @Override final void transitionFinished(); boolean handleBack(); boolean quit(); @NotNull @Override String toString(); final void setView(@Nullable V view); final void setActivity(@Nullable Activity activity); }### Answer:
@Test public void createdActivity() { screen.create(context); assertThat(screen.getActivity()).isEqualTo(context); } |
### Question:
Screen extends LifecycleAwareComponent implements NavigableCompat, ActionBarModifier { protected final void whenTransitionFinished(TransitionFinishedListener listener) { if (isTransitioning) { transitionFinishedListeners.add(listener); } else { listener.onTransitionFinished(); } } Screen(); @Nullable final V getView(); @Nullable final Activity getActivity(); @Nullable final LegacyNavigator getNavigator(); final Dialog getDialog(); @Override final void transitionStarted(); @Override final void transitionFinished(); boolean handleBack(); boolean quit(); @NotNull @Override String toString(); final void setView(@Nullable V view); final void setActivity(@Nullable Activity activity); }### Answer:
@Test public void whenTransitionFinished() { final Screen.TransitionFinishedListener listener = mock(Screen.TransitionFinishedListener.class); screen.transitionStarted(); screen.whenTransitionFinished(listener); verify(listener, never()).onTransitionFinished(); screen.transitionFinished(); verify(listener).onTransitionFinished(); reset(listener); screen.transitionStarted(); screen.transitionFinished(); verify(listener, never()).onTransitionFinished(); } |
### Question:
ScreenGroup extends Screen<V> { public void addScreen(@NotNull S screen) { attachToLifecycle(screen, LifecycleState.Destroyed.INSTANCE); screens.add(screen); } ScreenGroup(); ScreenGroup(@NotNull List<S> screens); void addScreen(@NotNull S screen); void addScreens(@NotNull List<S> screens); }### Answer:
@Test public void addScreen() { screenGroup.resume(context); screenGroup.addScreen(screen3); assertThat(screenGroup.getScreens().size()).isEqualTo(3); }
@Test public void addScreen_emptyConstructor() { screenGroup = new ScreenGroup() { @Override protected ViewGroup createView(Context context) { return null; } }; screenGroup.addScreen(screen1); } |
### Question:
ScreenGroup extends Screen<V> { public void addScreens(@NotNull List<S> screens) { for (S screen : screens) { addScreen(screen); } } ScreenGroup(); ScreenGroup(@NotNull List<S> screens); void addScreen(@NotNull S screen); void addScreens(@NotNull List<S> screens); }### Answer:
@Test public void addScreens() { screenGroup = new ScreenGroup() { @Override protected ViewGroup createView(Context context) { return null; } }; screenGroup.addScreens(asList(screen1, screen2)); } |
### Question:
XmlUtils { public static XMLInputFactory createBasicInputFactory() { XMLInputFactory xmlFactory = XMLInputFactory.newInstance(); xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false); return xmlFactory; } static XMLInputFactory createBasicInputFactory(); }### Answer:
@Test public void testCreateBasicInputFactory() throws Exception { XMLInputFactory factory = XmlUtils.createBasicInputFactory(); factory.setXMLResolver(new XMLResolver() { @Override public Object resolveEntity(String publicID, String systemID, String baseURI, String namespace) throws XMLStreamException { Assert.assertFalse("DTD should not be resolved.", "http: return null; } }); XMLStreamReader reader = factory.createXMLStreamReader(new StringReader("<!DOCTYPE foo SYSTEM \"http: while(reader.hasNext()) { reader.next(); } } |
### Question:
ApmUIService { public AuthenticationInfo getAuthenticationInfo() { MyResultInfo result = new MyResultInfo(); int code = restService.get(result, "apmuiservices/configurationusers/authentication-info"); if(code == 200) { return new Gson().fromJson(result.getBodyAsString(), AuthenticationInfo.class); } else { errorService.showException(new RestException(result)); return null; } } ApmUIService(RestService restService, EntityService entityService, ErrorService errorService); Entity createDefectInRelease(String description, String summary, String severity, String detectedBy,
int releaseId, int sprintId, int teamId, int featureId, int workspaceId); Entity createRequirementInRelease(String description, String name, String priority, int storyPoints,
int releaseId, int sprintId, int teamId, int featureId, int workspaceId); AuthenticationInfo getAuthenticationInfo(); }### Answer:
@Test public void testGetAuthenticationInfo() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/apmuiservices/configurationusers/authentication-info", 200) .content("apmUIServiceTest_authenticationInfo.json"); AuthenticationInfo authenticationInfo = apmUIService.getAuthenticationInfo(); Assert.assertEquals(1, authenticationInfo.getAssignedWorkspaces().size()); Assert.assertEquals(1000, (int) authenticationInfo.getAssignedWorkspaces().iterator().next()); } |
### Question:
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public Element getState() { Element element = new Element(getClass().getSimpleName()); if(ref != null) { element.setAttribute("type", ref.type); element.setAttribute("id", String.valueOf(ref.id)); } return element; } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }### Answer:
@Test public void testGetState() { selectDefect(); Element state = activeItemService.getState(); Assert.assertEquals("ActiveItemService", state.getName()); Assert.assertEquals("defect", state.getAttributeValue("type")); Assert.assertEquals("1", state.getAttributeValue("id")); }
@Test public void testGetState_none() { selectNothing(); Element state = activeItemService.getState(); Assert.assertEquals("ActiveItemService", state.getName()); Assert.assertNull(state.getAttributeValue("type")); Assert.assertNull(state.getAttributeValue("id")); } |
### Question:
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public void loadState(Element state) { String type = state.getAttributeValue("type"); if(type != null) { ref = new EntityRef(type, Integer.valueOf(state.getAttributeValue("id"))); } } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }### Answer:
@Test public void testLoadState() { selectNothing(); Element state = new Element("ActiveItemService"); state.setAttribute("type", "defect"); state.setAttribute("id", "2"); activeItemService.loadState(state); checkActivateItem("defect", 2); } |
### Question:
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public synchronized void activate(Entity entity, boolean callTaskManager, boolean select) { if(entity != null) { ref = new EntityRef(entity); } else { ref = null; } fireOnActivated(); if(select && entity != null) { selectEntityDetail(entity); } if(callTaskManager && taskManagerIntegration != null) { taskManagerIntegration.activate(entity); } } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }### Answer:
@Test public void testActivate() { selectNothing(); handler.async(); activeItemService.addListener(new ActiveItemService.Listener() { @Override public void onActivated(final EntityRef ref) { activeItemService.removeListener(this); handler.done(new Runnable() { @Override public void run() { Assert.assertNotNull(ref); Assert.assertEquals(2, ref.id); Assert.assertEquals("requirement", ref.type); } }); } }); activeItemService.activate(new Entity("requirement", 2), false, false); checkActivateItem("requirement", 2); }
@Test public void testActivate_select() { handler.async(); getComponent(DetailUtil.class)._setLauncher(new DetailUtil.Launcher() { @Override public void loadDetail(Project project, final Entity entity, final boolean show, final boolean select) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("requirement", entity.getType()); Assert.assertEquals(4, entity.getId()); Assert.assertEquals(true, show); Assert.assertEquals(true, select); } }); } }); activeItemService.activate(new Entity("requirement", 4), false, true); } |
### Question:
ActiveItemService implements PersistentStateComponent<Element>, TaskManagerIntegration.Listener { public void selectEntityDetail(final Entity entity) { ApplicationUtil.invokeLaterIfNeeded(new Runnable() { public void run() { detailUtil.loadDetail(project, entity, true, true); } }); } ActiveItemService(Project project, DetailUtil detailUtil); synchronized void activate(Entity entity, boolean callTaskManager, boolean select); synchronized EntityRef getActiveItem(); void selectEntityDetail(final Entity entity); void addListener(Listener listener); void removeListener(Listener listener); Element getState(); void loadState(Element state); void taskEntityActivated(Entity entity); static Icon activeItemIcon; }### Answer:
@Test public void testSelectEntityDetail() throws Throwable { handler.async(); getComponent(DetailUtil.class)._setLauncher(new DetailUtil.Launcher() { @Override public void loadDetail(Project project, final Entity entity, final boolean show, final boolean select) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("requirement", entity.getType()); Assert.assertEquals(4, entity.getId()); Assert.assertEquals(true, show); Assert.assertEquals(true, select); } }); } }); activeItemService.selectEntityDetail(new Entity("requirement", 4)); } |
### Question:
TeamMemberService extends AbstractCachingEntityService<Entity> { public EntityList getTeamMembers(Entity team) { return getValue(team); } TeamMemberService(Project project, EntityService entityService); EntityList getTeamMembers(Entity team); void getTeamMembersAsync(Entity team, Callback<EntityList> callback); }### Answer:
@Test public void testGetTeamMembers() { EntityList list = teamMemberService.getTeamMembers(new Entity("team", 101)); checkMembers(list); teamMemberService.getTeamMembers(new Entity("team", 101)); } |
### Question:
TeamMemberService extends AbstractCachingEntityService<Entity> { public void getTeamMembersAsync(Entity team, Callback<EntityList> callback) { getValueAsync(team, callback); } TeamMemberService(Project project, EntityService entityService); EntityList getTeamMembers(Entity team); void getTeamMembersAsync(Entity team, Callback<EntityList> callback); }### Answer:
@Test public void testGetTeamMembersAsync() { handler.async(); teamMemberService.getTeamMembersAsync(new Entity("team", 101), new NonDispatchTestCallback<EntityList>(handler) { @Override public void evaluate(EntityList list) { checkMembers(list); } }); }
@Test public void testGetTeamMembersAsync_dispatch() { handler.async(); teamMemberService.getTeamMembersAsync(new Entity("team", 101), new DispatchTestCallback<EntityList>(handler) { @Override public void evaluate(EntityList list) { checkMembers(list); } }); } |
### Question:
AttachmentService { public void deleteAttachment(String name, EntityRef parent) { MyResultInfo result = new MyResultInfo(); if(restService.delete(result, "{0}s/{1}/attachments/{2}", parent.type, parent.id, EntityQuery.encode(name)) != HttpStatus.SC_OK) { errorService.showException(new RestException(result)); } else { EntityList list = EntityList.create(result.getBodyAsStream()); if(!list.isEmpty()) { entityService.fireEntityNotFound(new EntityRef(list.get(0)), true); } } } AttachmentService(RestService restService, EntityService entityService, ErrorService errorService); Entity getAttachmentEntity(Entity entity); Entity getAttachmentEntity(String name, EntityRef parent); String createAttachment(String filename, IndicatingInputStream is, long length, EntityRef parent); boolean updateAttachmentContent(String name, EntityRef parent, IndicatingInputStream is, long length, boolean silent); Entity updateAttachmentProperty(String name, EntityRef parent, String propertyName, String propertyValue, boolean silent); void deleteAttachment(String name, EntityRef parent); }### Answer:
@Test public void testDeleteAttachment() { handler.addRequest("DELETE", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 200) .content("attachmentServiceTest_attachment.xml"); handler.async(); addEntityListener(new EntityNotFound(handler, "attachment", 653, true)); attachmentService.deleteAttachment("logfile.txt", new EntityRef("defect", 1)); }
@Test public void testDeleteAttachment_failure() { handler.addRequest("DELETE", "/qcbin/rest/domains/domain/projects/project/defects/1/attachments/logfile.txt", 500) .responseBody("Failed"); attachmentService.deleteAttachment("logfile.txt", new EntityRef("defect", 1)); checkError("Failed"); } |
### Question:
WorkspaceService extends AbstractCachingEntityService<Void> { public void selectWorkspace(int id, String name) { if (!Integer.valueOf(id).equals(workspaceConfiguration.getWorkspaceId())) { workspaceConfiguration.setWorkspaceId(id); workspaceConfiguration.setWorkspaceName(name); restService.fireServerTypeEvent(); } } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }### Answer:
@Test public void testSelectWorkspace() throws Throwable { RestInvocations.sprintService_getReleases(handler, 1005); handler.async(); restService.addServerTypeListener(new OneTimeServerTypeListener(handler, restService) { @Override protected void connectedToEvent(ServerType serverType) { Assert.assertEquals(ServerType.AGM, serverType); } }); try { workspaceService.selectWorkspace(1005, "Red"); handler.consume(); Assert.assertEquals(1005, (int) workspaceConfiguration.getWorkspaceId()); Assert.assertEquals(workspaceConfiguration.getWorkspaceName(), "Red"); } finally { workspaceConfiguration.setWorkspaceId(1000); } } |
### Question:
WorkspaceService extends AbstractCachingEntityService<Void> { public Map<Integer, String> listWorkspaces() { return toWorkspaceMap(getValue(null)); } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }### Answer:
@Test public void testListWorkspaces() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); Map<Integer, String> map = workspaceService.listWorkspaces(); Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); }
@Test public void testListWorkspaces_caches() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); workspaceService.listWorkspaces(); Map<Integer, String> map = workspaceService.listWorkspaces(); Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); } |
### Question:
WorkspaceService extends AbstractCachingEntityService<Void> { public void listWorkspacesAsync(Callback<Map<Integer, String>> callback) { getValueAsync(null, translate(callback, new Transform<EntityList, Map<Integer, String>>() { @Override public Map<Integer, String> transform(EntityList entities) { return toWorkspaceMap(entities); } })); } WorkspaceService(Project project, EntityService entityService, RestService restService, WorkspaceConfiguration workspaceConfiguration); int getWorkspaceId(); String getWorkspaceName(); void selectWorkspace(int id, String name); Map<Integer, String> listWorkspaces(); void listWorkspacesAsync(Callback<Map<Integer, String>> callback); }### Answer:
@Test public void testListWorkspacesAsync() { handler.addRequest(false, "GET", "/qcbin/rest/domains/domain/projects/project/product-groups?fields=&query={}&order-by={}", 200) .content("workspaceServiceTest_workspaces.xml"); handler.async(); workspaceService.listWorkspacesAsync(new AbstractCachingService.Callback<Map<Integer, String>>() { @Override public void loaded(final Map<Integer, String> map) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(3, map.size()); Assert.assertEquals("All", map.get(-1)); Assert.assertEquals("Blue", map.get(1000)); Assert.assertEquals("Green", map.get(1001)); } }); } }); } |
### Question:
CustomizationService extends AbstractCachingService<Integer, APMCommonSettings, AbstractCachingService.Callback<APMCommonSettings>> { public String getNewDefectStatus(final AbstractCachingService.Callback<String> whenLoaded) { APMCommonSettings settings = getCachedValue(IDE_PREFERENCES); if(settings == null) { getValueAsync(IDE_PREFERENCES, translate(whenLoaded, new Transform<APMCommonSettings, String>() { @Override public String transform(APMCommonSettings settings) { return getNewDefectStatus(settings); } })); return null; } else { return getNewDefectStatus(settings); } } CustomizationService(Project project); String getNewDefectStatus(final AbstractCachingService.Callback<String> whenLoaded); }### Answer:
@Test public void testGetNewDefectStatus() { handler.async(); String status = customizationService.getNewDefectStatus(new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); Assert.assertNull(status); customizationService.getNewDefectStatus(new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); }
@Test public void testGetNewDefectStatus_dispatch() { handler.async(); String status = customizationService.getNewDefectStatus(new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); Assert.assertNull(status); customizationService.getNewDefectStatus(new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("New", data); Assert.assertEquals("New", customizationService.getNewDefectStatus(null)); } }); } |
### Question:
ThemeFeatureService extends AbstractCachingEntityService<ThemeFeatureService.Type> { public EntityList getFeatures() { return getValue(Type.feature); } ThemeFeatureService(Project project, EntityService entityService); EntityList getFeatures(); EntityList getFeatures(String filter); EntityList getThemes(); EntityList getThemes(String filter); }### Answer:
@Test public void testGetFeatures() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[71]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_features.xml"); EntityList list = themeFeatureService.getFeatures(); Assert.assertEquals(2, list.size()); Assert.assertEquals("Feature Due", list.get(0).getPropertyValue("name")); Assert.assertEquals("Feature Uno", list.get(1).getPropertyValue("name")); themeFeatureService.getFeatures(); }
@Test public void testGetFeatures_filter() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[71]; name[Uno]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_features2.xml"); EntityList list = themeFeatureService.getFeatures("Uno"); Assert.assertEquals(1, list.size()); Assert.assertEquals("Feature Uno", list.get(0).getPropertyValue("name")); } |
### Question:
ThemeFeatureService extends AbstractCachingEntityService<ThemeFeatureService.Type> { public EntityList getThemes() { return getValue(Type.theme); } ThemeFeatureService(Project project, EntityService entityService); EntityList getFeatures(); EntityList getFeatures(String filter); EntityList getThemes(); EntityList getThemes(String filter); }### Answer:
@Test public void testGetThemes() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[72]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_themes.xml"); EntityList list = themeFeatureService.getThemes(); Assert.assertEquals(2, list.size()); Assert.assertEquals("Theme Due", list.get(0).getPropertyValue("name")); Assert.assertEquals("Theme Uno", list.get(1).getPropertyValue("name")); themeFeatureService.getThemes(); }
@Test public void testGetThemes_filter() { handler.addRequest("GET", "/qcbin/rest/domains/domain/projects/project/requirements?fields=id,name,release-backlog-item.id,release-backlog-item.blocked,product-group-id&query={type-id[72]; name[Uno]; product-group-id[1000]}&order-by={name[ASC]}&page-size=1000", 200) .content("themeFeatureServiceTest_themes2.xml"); EntityList list = themeFeatureService.getThemes("Uno"); Assert.assertEquals(1, list.size()); Assert.assertEquals("Theme Uno", list.get(0).getPropertyValue("name")); } |
### Question:
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public RequirementTypeList getRequirementTypes() { return getValue(1); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }### Answer:
@Test public void testGetRequirementTypes() { RestInvocations.loadRequirementTypes(handler); RequirementTypeList types = requirementTypeService.getRequirementTypes(); checkTypes(types); requirementTypeService.getRequirementTypes(); } |
### Question:
MyResultInfo { public void copyFrom(ResultInfo info) { headers.putAll(info.getHeaders()); location = info.getLocation(); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }### Answer:
@Test public void testCopyFrom() throws IOException { ResultInfo result = ResultInfo.create(new ByteArrayOutputStream()); result.setLocation("location"); result.getHeaders().put("a", "b"); result.getHeaders().put("c", "d"); MyResultInfo info = new MyResultInfo(); info.copyFrom(result); Assert.assertEquals(result.getHeaders(), info.getHeaders()); Assert.assertEquals(result.getLocation(), info.getLocation()); } |
### Question:
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public RequirementTypeList tryRequirementTypes() { return getCachedValue(1); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }### Answer:
@Test public void testTryRequirementTypes() { RequirementTypeList types = requirementTypeService.tryRequirementTypes(); Assert.assertNull(types); RestInvocations.loadRequirementTypes(handler); requirementTypeService.getRequirementTypes(); types = requirementTypeService.tryRequirementTypes(); checkTypes(types); } |
### Question:
RequirementTypeService extends AbstractCachingService<Integer, RequirementTypeList, AbstractCachingService.Callback<RequirementTypeList>> { public void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback) { getValueAsync(1, callback); } RequirementTypeService(Project project); RequirementTypeList getRequirementTypes(); RequirementTypeList tryRequirementTypes(); void loadRequirementTypeListAsync(Callback<RequirementTypeList> callback); }### Answer:
@Test public void testLoadRequirementTypeList() throws InterruptedException { RestInvocations.loadRequirementTypes(handler); handler.async(); requirementTypeService.loadRequirementTypeListAsync(new NonDispatchTestCallback<RequirementTypeList>(handler) { @Override public void evaluate(RequirementTypeList types) { checkTypes(types); } }); }
@Test public void testLoadRequirementTypeList_dispatch() throws InterruptedException { RestInvocations.loadRequirementTypes(handler); handler.async(); requirementTypeService.loadRequirementTypeListAsync(new DispatchTestCallback<RequirementTypeList>(handler) { @Override public void evaluate(RequirementTypeList types) { checkTypes(types); } }); } |
### Question:
MyResultInfo { public String getBodyAsString() { return new String(copy.toByteArray()); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }### Answer:
@Test public void testGetBodyAsString() throws IOException { MyResultInfo info = new MyResultInfo(); ResultInfo result = ResultInfo.create(info.getOutputStream()); result.getBodyStream().write("foo".getBytes()); Assert.assertEquals("foo", info.getBodyAsString()); } |
### Question:
EntityReferenceTranslator implements Translator { public String getTargetType() { return targetType; } EntityReferenceTranslator(Project project, String targetType, SimpleCache cache); @Override String translate(String value, ValueCallback callback); String getTargetType(); }### Answer:
@Test public void testGetTargetType() { EntityReferenceTranslator translator = new EntityReferenceTranslator(getProject(), "defect", new SimpleCache()); Assert.assertEquals("defect", translator.getTargetType()); } |
### Question:
ExpressionResolver implements FilterResolver { @Override public String resolveDisplayValue(String expr, ValueCallback onValue) { Node node = ExpressionParser.parse(expr); String value; SingleValueCallBack callBack = new SingleValueCallBack(onValue); if(resolve(node, translator, callBack, node, new HashSet<Node>(Collections.singleton(node)))) { value = ExpressionBuilder.build(node); callBack.value(value); } else { value = TranslateService.LOADING_MESSAGE; callBack.initValue(value); } return value; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }### Answer:
@Test public void testResolveDisplayValueSync() { ExpressionResolver resolver = new ExpressionResolver(new TranslatorSync()); handler.async(); String value = resolver.resolveDisplayValue("A OR B", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("(a OR b)", value); } }); } }); Assert.assertEquals("(a OR b)", value); }
@Test public void testResolveDisplayValueAsync() { final LinkedList<String> expect = new LinkedList<String>(); ExpressionResolver resolver = new ExpressionResolver(new TranslatorAsync(expect)); expect.add("Loading..."); expect.add("(a OR b)"); handler.async(2); synchronized (expect) { String value = resolver.resolveDisplayValue("A OR B", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertFalse("Unexpected: " + value, expect.isEmpty()); Assert.assertEquals(expect.removeFirst(), value); } }); } }); Assert.assertEquals("Loading...", value); } } |
### Question:
ExpressionResolver implements FilterResolver { @Override public String toRESTQuery(String value) { return value; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }### Answer:
@Test public void testToRESTQuery() { ExpressionResolver resolver = new ExpressionResolver(new TranslatorSync()); Assert.assertEquals("A OR B", resolver.toRESTQuery("A OR B")); } |
### Question:
ExpressionResolver implements FilterResolver { public Translator getTranslator() { return translator; } ExpressionResolver(Translator translator); @Override String resolveDisplayValue(String expr, ValueCallback onValue); @Override String toRESTQuery(String value); Translator getTranslator(); }### Answer:
@Test public void testGetTranslator() { TranslatorSync translator = new TranslatorSync(); ExpressionResolver resolver = new ExpressionResolver(translator); Assert.assertEquals(translator, resolver.getTranslator()); } |
### Question:
MultipleItemsResolver implements FilterResolver { @Override public String resolveDisplayValue(String value, final ValueCallback onValue) { value = value.replace(NO_VALUE, NO_VALUE_DESC); onValue.value(value); return value; } @Override String resolveDisplayValue(String value, final ValueCallback onValue); @Override String toRESTQuery(String value); static final String NO_VALUE; static final String NO_VALUE_DESC; }### Answer:
@Test public void testResolveDisplayValue() { handler.async(); String value = resolver.resolveDisplayValue("A;B C;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("A;B C;(no value)", value); } }); } }); Assert.assertEquals("A;B C;(no value)", value); } |
### Question:
MultipleItemsResolver implements FilterResolver { @Override public String toRESTQuery(String value) { LinkedList<String> list = new LinkedList<String>(); for(String item: Arrays.asList(value.split(";"))) { if(NO_VALUE.equals(item)) { list.add(NO_VALUE); } else { list.add("\"" + item + "\""); } } return StringUtils.join(list, " OR "); } @Override String resolveDisplayValue(String value, final ValueCallback onValue); @Override String toRESTQuery(String value); static final String NO_VALUE; static final String NO_VALUE_DESC; }### Answer:
@Test public void testToRESTQuery() { String value = resolver.toRESTQuery("A;B C;\"\""); Assert.assertEquals("\"A\" OR \"B C\" OR \"\"", value); } |
### Question:
ExpressionParser { public static Node parse(String expr) { Lexer lexer = new Lexer(expr); return matchExpr(lexer); } static Node parse(String expr); }### Answer:
@Test public void testParseBasics() { ExpressionParser.parse("value"); ExpressionParser.parse("value AND value"); ExpressionParser.parse("value OR value"); ExpressionParser.parse("NOT value"); ExpressionParser.parse("(value)"); ExpressionParser.parse("'my value'"); ExpressionParser.parse("\"my value\""); ExpressionParser.parse("<value"); ExpressionParser.parse("<=value"); ExpressionParser.parse("<>value"); ExpressionParser.parse("=value"); ExpressionParser.parse(">value"); ExpressionParser.parse(">=value"); ExpressionParser.parse("(> A OR (<= \"B C\" AND NOT ='D E'))"); }
@Test public void testDontMatchOperatorPrefix() { ExpressionParser.parse("orisprefixnotoperator"); }
@Test public void testOperatorPriorityLikeQc() { Node node = ExpressionParser.parse("<a OR >=b AND c"); Assert.assertEquals("((< a OR >= b) AND c)", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a OR (>=b AND c)"); Assert.assertEquals("(< a OR (>= b AND c))", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a AND >=b OR c"); Assert.assertEquals("((< a AND >= b) OR c)", ExpressionBuilder.build(node)); node = ExpressionParser.parse("<a AND (>=b OR c)"); Assert.assertEquals("(< a AND (>= b OR c))", ExpressionBuilder.build(node)); node = ExpressionParser.parse("(a AND b AND c) OR (x AND y AND z)"); Assert.assertEquals("(((a AND b) AND c) OR ((x AND y) AND z))", ExpressionBuilder.build(node)); } |
### Question:
MyResultInfo { public InputStream getBodyAsStream() { return new ByteArrayInputStream(copy.toByteArray()); } MyResultInfo(); MyResultInfo(IndicatingOutputStream ios); OutputStream getOutputStream(); String getBodyAsString(); InputStream getBodyAsStream(); void copyFrom(ResultInfo info); String getLocation(); Map<String, String> getHeaders(); }### Answer:
@Test public void testGetBodyAsStream() throws IOException { MyResultInfo info = new MyResultInfo(); ResultInfo result = ResultInfo.create(info.getOutputStream()); result.getBodyStream().write("foo".getBytes()); Assert.assertEquals("foo", IOUtils.toString(info.getBodyAsStream())); } |
### Question:
IndicatingInputStream extends FileInputStream { public int read() throws IOException { cancel(); int i = super.read(); if(i != -1) { for(OutputStream observer: observers) { observer.write(i); } report(1); } return i; } IndicatingInputStream(File file, ProgressIndicator indicator); void addObserver(OutputStream observer); int read(); int read(byte[] bytes); int read(byte[] bytes, int ofs, int len); }### Answer:
@Test public void testReporting() throws IOException { final LinkedList<Double> fractions = new LinkedList<Double>(); fractions.add(0.25); fractions.add(0.75); fractions.add(0.80); fractions.add(1.0); handler.async(4); IndicatingInputStream iis = new IndicatingInputStream(file, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(fractions.removeFirst(), (Double)fraction); } }); } }); byte[] buf = new byte[10]; Assert.assertEquals(5, iis.read(buf, 0, 5)); Assert.assertEquals(10, iis.read(buf)); Assert.assertEquals('5', iis.read()); Assert.assertEquals(4, iis.read(buf)); } |
### Question:
TranslateService implements ServerTypeListener { public Translator getReferenceTranslator(String targetType) { return new EntityReferenceTranslator(project, targetType, cache); } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void testGetReferenceTranslator() { doTestGetReferenceTranslator(true); }
@Test public void testGetReferenceTranslator_caches() throws Throwable { doTestGetReferenceTranslator(true); handler.checkpoint(); Translator translator = translateService.getReferenceTranslator("defect"); String value = translator.translate("86", new ValueCallback() { @Override public void value(String value) { Assert.fail("Not expected"); } }); Assert.assertEquals("somewhat", value); } |
### Question:
IndicatingInputStream extends FileInputStream { private void cancel() throws IOException { if(indicator != null && indicator.isCanceled()) { throw new CanceledException(); } } IndicatingInputStream(File file, ProgressIndicator indicator); void addObserver(OutputStream observer); int read(); int read(byte[] bytes); int read(byte[] bytes, int ofs, int len); }### Answer:
@Test public void testCancel() throws IOException { IndicatingInputStream iis = new IndicatingInputStream(file, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { cancel(); } }); byte[] buf = new byte[5]; Assert.assertEquals(5, iis.read(buf)); try { iis.read(buf); Assert.fail("Should have failed"); } catch (CanceledException e) { } Assert.assertEquals("1234\n", new String(buf)); } |
### Question:
TranslateService implements ServerTypeListener { @Override public void connectedTo(ServerType serverType) { if(serverType.isConnected()) { cache.clear(); } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void testGetReferenceTranslator_invalidatesCache() throws Throwable { doTestGetReferenceTranslator(true); handler.checkpoint(); translateService.connectedTo(ServerType.AGM); doTestGetReferenceTranslator(false); } |
### Question:
TranslateService implements ServerTypeListener { public FilterResolver getFilterResolver(Field field) { if(Type.class.isAssignableFrom(field.getClazz())) { Type type = (Type)project.getComponent(field.getClazz()); FilterResolver filterResolver = type.getFilterResolver(); if(filterResolver != null) { return filterResolver; } } if(field.getReferencedType() != null) { return new ExpressionResolver(getReferenceTranslator(field.getReferencedType())); } if(field.getListId() != null) { return new MultipleItemsResolver(); } return null; } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void testGetFilterResolver_type() { Field field = new Field("duration", "Duration"); field.setClazz(BuildDurationType.class); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertTrue(resolver instanceof BuildDurationType); }
@Test public void testGetFilterResolver_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertNull(resolver); }
@Test public void testGetFilterResolver_list() { Field field = new Field("severity", "Severity"); field.setListId(299); FilterResolver resolver = translateService.getFilterResolver(field); Assert.assertTrue(resolver instanceof MultipleItemsResolver); } |
### Question:
TranslateService implements ServerTypeListener { public String convertQueryModelToView(Field field, String value, ValueCallback callback) { FilterResolver resolver = getFilterResolver(field); if(resolver != null) { return resolver.resolveDisplayValue(value, callback); } else { callback.value(value); return value; } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void testConvertQueryModelToView() { Field field = new Field("status", "Status"); field.setClazz(BuildStatusType.class); handler.async(); String value = translateService.convertQueryModelToView(field, "Success;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("Success;(no value)", value); } }); } }); Assert.assertEquals("Success;(no value)", value); }
@Test public void testConvertQueryModelToView_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); handler.async(); String value = translateService.convertQueryModelToView(field, "Success;\"\"", new ValueCallback() { @Override public void value(final String value) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals("Success;\"\"", value); } }); } }); Assert.assertEquals("Success;\"\"", value); } |
### Question:
IndicatingOutputStream extends FileOutputStream { public void write(int i) throws IOException { cancel(); super.write(i); for(OutputStream observer: observers) { observer.write(i); } report(1); } IndicatingOutputStream(File file, int size, ProgressIndicator indicator); void addObserver(OutputStream observer); void write(int i); void write(byte[] bytes); void write(byte[] bytes, int off, int len); }### Answer:
@Test public void testReporting() throws IOException { final LinkedList<Double> fractions = new LinkedList<Double>(); fractions.add(0.25); fractions.add(0.75); fractions.add(0.80); fractions.add(1.0); handler.async(4); IndicatingOutputStream ios = new IndicatingOutputStream(file, 20, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { handler.done(new Runnable() { @Override public void run() { Assert.assertEquals(fractions.removeFirst(), (Double) fraction); } }); } }); byte[] buf0 = "1234\n".getBytes(); byte[] buf1 = "123456789\n".getBytes(); byte[] buf2 = "678\n".getBytes(); ios.write(buf0); ios.write(buf1); ios.write('5'); ios.write(buf2); ios.close(); Assert.assertEquals("1234\n123456789\n5678\n", FileUtils.readFileToString(file)); } |
### Question:
TranslateService implements ServerTypeListener { public String convertQueryModelToREST(Field field, String value) { FilterResolver resolver = getFilterResolver(field); if(resolver != null) { return resolver.toRESTQuery(value); } else { return value; } } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void testConvertQueryModelToREST() { Field field = new Field("blocked", "Blocked"); field.setClazz(BacklogBlockedType.class); String value = translateService.convertQueryModelToREST(field, "blocked"); Assert.assertEquals("'**'", value); }
@Test public void testConvertQueryModelToREST_none() { Field field = new Field("name", "Name"); field.setClazz(String.class); String value = translateService.convertQueryModelToREST(field, "blocked"); Assert.assertEquals("blocked", value); } |
### Question:
TranslateService implements ServerTypeListener { public boolean isTranslated(Field field) { return getTranslator(field) != null; } TranslateService(Project project, RestService restService); boolean isTranslated(Field field); String convertQueryModelToREST(Field field, String value); String convertQueryModelToView(Field field, String value, ValueCallback callback); FilterResolver getFilterResolver(Field field); Translator getTranslator(Field field); Translator getReferenceTranslator(String targetType); String translateAsync(Field field, final String value, boolean syncCall, final ValueCallback onValue); String translateAsync(Translator translator, final String value, boolean syncCall, final ValueCallback onValue); @Override void connectedTo(ServerType serverType); static final String LOADING_MESSAGE; static final String NA_TOKEN; }### Answer:
@Test public void isTranslated() { Field field = new Field("duration", "Duration"); field.setClazz(BuildDurationType.class); Assert.assertTrue(translateService.isTranslated(field)); }
@Test public void isTranslated_negative() { Field field = new Field("name", "Name"); field.setClazz(String.class); Assert.assertFalse(translateService.isTranslated(field)); } |
### Question:
HpAlmTask extends Task { public boolean isInitialized() { return entity.isComplete() || (entity.isInitialized("name") && hasDateProperties(entity) && entity.isInitialized(getDescriptionField(entity.getType())) && (entity.isInitialized("dev-comments") || entity.isInitialized("comments"))); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testIsInitialized() { Entity entity = new Entity("defect", 1); entity.setProperty("name", "Name..."); entity.setProperty("description", "Description..."); entity.setProperty("dev-comments", "comments..."); entity.setProperty("last-modified", "2012-12-12 12:12:12"); entity.setProperty("creation-time", "2012-12-01"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertTrue(task.isInitialized()); }
@Test public void testIsInitialized_complete() { Entity entity = new Entity("defect", 1); entity.setComplete(true); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertTrue(task.isInitialized()); }
@Test public void testIsInitialized_negative() { List<String> required = Arrays.asList("name", "description", "dev-comments", "last-modified", "creation-time"); for(String prop: required) { Entity entity = new Entity("defect", 1); for(String key: required) { if(!key.equals(prop)) { entity.setProperty(key, key); } } HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertFalse(task.isInitialized()); } } |
### Question:
HpAlmTask extends Task { public String getId() { return new EntityRef(entity).toString(); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetId() { Entity entity = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("defect #1", task.getId()); } |
### Question:
HpAlmTask extends Task { public String getSummary() { return entity.getPropertyValue("name"); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetSummary() { Entity entity = new Entity("defect", 1); entity.setProperty("name", "My Name"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("My Name", task.getSummary()); } |
### Question:
HpAlmTask extends Task { public String getDescription() { return HTMLAreaField.toPlainText(entity.getPropertyValue(getDescriptionField(entity.getType())), false); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetDescription() { Entity entity = new Entity("defect", 1); entity.setProperty("description", "<html><body>This is <b>html</b>.</body></html>"); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals("This is html.", task.getDescription()); } |
### Question:
IndicatingOutputStream extends FileOutputStream { private void cancel() throws IOException { if(indicator != null && indicator.isCanceled()) { throw new CanceledException(); } } IndicatingOutputStream(File file, int size, ProgressIndicator indicator); void addObserver(OutputStream observer); void write(int i); void write(byte[] bytes); void write(byte[] bytes, int off, int len); }### Answer:
@Test public void testCancel() throws IOException { IndicatingOutputStream ios = new IndicatingOutputStream(file, 20, new ProgressIndicatorBase() { @Override public void setFraction(final double fraction) { cancel(); } }); ios.write("1234\n".getBytes()); try { ios.write("123456789\n".getBytes()); Assert.fail("Should have failed"); } catch (CanceledException e) { } Assert.assertEquals("1234\n", FileUtils.readFileToString(file)); } |
### Question:
PathUtils { public static String pathJoin(String separator, String ... parts) { StringBuilder builder = new StringBuilder(); if (parts.length == 0) return ""; if (parts.length == 1) return parts[0]; for (int i = 0; i < parts.length; i++) { String part = parts[i]; if (i == 0) { builder.append(org.apache.commons.lang.StringUtils.removeEnd(part, separator)).append(separator); } else if (i == parts.length - 1) { builder.append(org.apache.commons.lang.StringUtils.removeStart(part, separator)); } else { builder.append(org.apache.commons.lang.StringUtils.removeStart(org.apache.commons.lang.StringUtils.removeEnd(part, separator), separator)).append(separator); } } return builder.toString(); } static String pathJoin(String separator, String ... parts); }### Answer:
@Test public void testPathJoin() throws Exception { assertThat(pathJoin("/", "aaa", "bbb"), is("aaa/bbb")); assertThat(pathJoin("/", "a", "b"), is("a/b")); assertThat(pathJoin("/", "a/", "/b"), is("a/b")); assertThat(pathJoin("/", "a/", "b/"), is("a/b/")); assertThat(pathJoin("/"), is("")); assertThat(pathJoin("/", "a"), is("a")); assertThat(pathJoin("/", "/a/"), is("/a/")); } |
### Question:
HpAlmTask extends Task { public Comment[] getComments() { return parseComments(entity.getPropertyValue(entity.isInitialized("dev-comments")? "dev-comments": "comments")); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetComments() { Entity entity = new Entity("defect", 1); String html = "<html><body>\n" + "<strong> Joe Joe, Fri Sep 07 2012:</strong><br>\nComment1\n" + "<strong>________________________________________</strong><br>\n" + "<strong> Jim Jim, Fri Sep 07 2012:</strong><br>\nComment2\n" + "<b>________________________________________</b><br>\n" + "<strong> John John, Fri Sep 07 2012:</strong><br>\nComment3\n" + "</body></html>"; entity.setProperty("dev-comments", html); HpAlmTask task = new HpAlmTask(getProject(), entity); Assert.assertEquals(3, task.getComments().length); Assert.assertEquals("Joe Joe", task.getComments()[0].getAuthor()); Assert.assertEquals("Jim Jim", task.getComments()[1].getAuthor()); Assert.assertEquals("John John", task.getComments()[2].getAuthor()); Entity requirement = new Entity("requirement", 1); requirement.setProperty("comments", html); task = new HpAlmTask(getProject(), requirement); Assert.assertEquals(3, task.getComments().length); } |
### Question:
HpAlmTask extends Task { public TaskType getType() { if("defect".equals(entity.getType())) { return TaskType.BUG; } else { return TaskType.FEATURE; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetType() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals(TaskType.BUG, task.getType()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertEquals(TaskType.FEATURE, task2.getType()); } |
### Question:
HpAlmTask extends Task { public Date getUpdated() { return parseDate(entity.getPropertyValue("last-modified")); } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetUpdated() { Entity defect = new Entity("defect", 1); defect.setProperty("last-modified", "2012-12-12 12:12:12"); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(task.getUpdated())); } |
### Question:
HpAlmTask extends Task { public Date getCreated() { try { Date date = CommentField.dateFormat.parse(entity.getPropertyValue("creation-time")); if("requirement".equals(entity.getType())) { return new Date(date.getTime() + timeFormat.parse(entity.getPropertyValue("req-time")).getTime() + TimeZone.getDefault().getRawOffset()); } return date; } catch(ParseException e) { return getUpdated(); } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetCreated() { Entity defect = new Entity("defect", 1); defect.setProperty("creation-time", "2012-12-12"); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertEquals("2012-12-12 00:00:00 +0100", HpAlmCommentTest.format.format(task.getCreated())); }
@Test public void testGetCreated_requirement() { Entity requirement = new Entity("requirement", 1); requirement.setProperty("creation-time", "2012-12-12"); requirement.setProperty("req-time", "12:12:12"); HpAlmTask task = new HpAlmTask(getProject(), requirement); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(task.getCreated())); } |
### Question:
HpAlmTask extends Task { public boolean isClosed() { if("defect".equals(entity.getType())) { return "Closed".equals(entity.getPropertyValue("status")); } else { return false; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testIsClosed() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); defect.setProperty("status", "Closed"); Assert.assertTrue(task.isClosed()); defect.setProperty("status", "Open"); Assert.assertFalse(task.isClosed()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertFalse(task2.isClosed()); } |
### Question:
HpAlmTask extends Task { public boolean isIssue() { return getType() == TaskType.BUG; } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testIsIssue() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); Assert.assertTrue(task.isIssue()); Entity requirement = new Entity("requirement", 1); HpAlmTask task2 = new HpAlmTask(getProject(), requirement); Assert.assertFalse(task2.isIssue()); } |
### Question:
HpAlmTask extends Task { public String getIssueUrl() { if(openInBrowserAvailable) { return _getIssueUrl(); } else { return null; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetIssueUrl() { Entity defect = new Entity("defect", 1); HpAlmTask task = new HpAlmTask(getProject(), defect); String url = task._getIssueUrl(); Assert.assertEquals("td: Entity requirement = new Entity("requirement", 2); HpAlmTask task2 = new HpAlmTask(getProject(), requirement ); String url2 = task2._getIssueUrl(); Assert.assertEquals("td: } |
### Question:
HpAlmTask extends Task { public static Date parseDate(String dateStr) { try { return dateTimeFormat.parse(dateStr); } catch (ParseException e) { return new Date(); } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testParseDate() { Date date = HpAlmTask.parseDate("2012-12-12 12:12:12"); Assert.assertEquals("2012-12-12 12:12:12 +0100", HpAlmCommentTest.format.format(date)); } |
### Question:
HpAlmTask extends Task { public static String getDescriptionField(String entityType) { if("defect".equals(entityType)) { return "description"; } else { return "req-comment"; } } HpAlmTask(Project project, Entity entity); boolean isInitialized(); String getId(); String getSummary(); String getDescription(); Comment[] getComments(); Icon getIcon(); TaskType getType(); Date getUpdated(); Date getCreated(); boolean isClosed(); String getCustomIcon(); boolean isIssue(); String getIssueUrl(); static Date parseDate(String dateStr); static String getDescriptionField(String entityType); }### Answer:
@Test public void testGetDescriptionField() { Assert.assertEquals("description", HpAlmTask.getDescriptionField("defect")); Assert.assertEquals("req-comment", HpAlmTask.getDescriptionField("requirement")); } |
### Question:
EntityLabelService extends AbstractCachingService<Integer, Map<String, String>, AbstractCachingService.Callback<Map<String, String>>> { public void loadEntityLabelAsync(final String entityType, Callback<String> callback) { getValueAsync(ENTITIES, translate(callback, new Transform<Map<String, String>, String>() { @Override public String transform(Map<String, String> labelMap) { if(labelMap.containsKey(entityType)) { return labelMap.get(entityType); } else { return entityType; } } })); } EntityLabelService(Project project, RestService restService); void loadEntityLabelAsync(final String entityType, Callback<String> callback); }### Answer:
@Test public void testLoadEntityLabelAsync() { handler.async(2); entityLabelService.loadEntityLabelAsync("defect", new NonDispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("Defect", data); } }); entityLabelService.loadEntityLabelAsync("defect", new DispatchTestCallback<String>(handler) { @Override protected void evaluate(String data) { Assert.assertEquals("Defect", data); } }); } |
### Question:
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public String extractId(String taskName) { return taskName; } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }### Answer:
@Test public void testExtractId() { HpAlmRepository repository = new HpAlmRepository(); Assert.assertEquals("defect #123", repository.extractId("defect #123")); } |
### Question:
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public HpAlmRepository clone() { HpAlmRepository ret = new HpAlmRepository(getUrl(), id); ret.requirement = requirement; ret.defect = defect; return ret; } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }### Answer:
@Test public void testClone() { HpAlmRepository repository = new HpAlmRepository(getProject().getName(), 1); HpAlmRepository clone = repository.clone(); Assert.assertEquals(repository.getId(), clone.getId()); Assert.assertEquals(repository.getUrl(), clone.getUrl()); Assert.assertEquals(repository.getDefect(), clone.getDefect()); Assert.assertEquals(repository.getRequirement(), clone.getRequirement()); } |
### Question:
HpAlmRepository extends TaskRepository implements Comparable<HpAlmRepository> { public int compareTo(HpAlmRepository other) { if(id < other.id) { return -1; } else if(id > other.id) { return 1; } else { return 0; } } HpAlmRepository(); HpAlmRepository(String url, long id); void setId(long id); @Tag("defect") TaskConfig getDefect(); void setDefect(TaskConfig defect); @Tag("requirement") TaskConfig getRequirement(); void setRequirement(TaskConfig requirement); @Attribute("id") long getId(); String getPresentableName(); boolean isConfigured(); Task[] getIssues(String query, int max, long since); @Override void setPreferredOpenTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredOpenTaskState(); @Override void setPreferredCloseTaskState(@Nullable CustomTaskState customTaskState); @Nullable @Override CustomTaskState getPreferredCloseTaskState(); Task findTask(String taskName); String extractId(String taskName); HpAlmRepository clone(); boolean equals(Object o); int hashCode(); int compareTo(HpAlmRepository other); }### Answer:
@Test public void testCompareTo() { HpAlmRepository repository1 = new HpAlmRepository(getProject().getName(), 1); HpAlmRepository repository2 = new HpAlmRepository(getProject().getName(), 2); Assert.assertEquals(-1, repository1.compareTo(repository2)); Assert.assertEquals(1, repository2.compareTo(repository1)); Assert.assertEquals(0, repository1.compareTo(repository1)); } |
### Question:
ProjectUserService extends AbstractCachingService<Integer, UserList, AbstractCachingService.Callback<UserList>> { public User getUser(String username) { for(User user: getUserList()) { if(user.getUsername().equals(username)) { return user; } } 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 testGetUser() { RestInvocations.loadProjectUsers(handler); User tester = projectUserService.getUser("tester"); Assert.assertEquals("tester", tester.getUsername()); Assert.assertEquals("Integration Test", tester.getFullName()); projectUserService.getUser("tester"); }
@Test public void testGetUser_nonExisting() { RestInvocations.loadProjectUsers(handler); Assert.assertNull(projectUserService.getUser("nonExisting")); } |
### Question:
SubversionRevisionFactory implements RevisionFactory { @Override public boolean matches(VcsRoot vcsRoot, String location, String alias) { SvnVcs svnVcs = (SvnVcs) vcsRoot.getVcs(); String url = svnVcs.getInfo(vcsRoot.getPath()).getRepositoryRootURL().toString(); return url.equals(location) || url.equals(alias); } @Override VcsRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }### Answer:
@Test public void testMatches() throws SVNException { Info info = Mockito.mock(Info.class); Mockito.when(info.getRepositoryRootURL()).thenReturn(SVNURL.parseURIDecoded("http: SvnVcs spy = Mockito.spy(svnVcs); LightVirtualFile file = new LightVirtualFile(); Mockito.doReturn(info).when(spy).getInfo(file); Assert.assertFalse(subversionRevisionFactory.matches(new VcsRoot(spy, file), "location", "alias")); Assert.assertTrue(subversionRevisionFactory.matches(new VcsRoot(spy, file), "http: Assert.assertTrue(subversionRevisionFactory.matches(new VcsRoot(spy, file), "location", "http: } |
### Question:
SubversionRevisionFactory implements RevisionFactory { @Override public VcsRevisionNumber create(String revision) { try { return new SvnRevisionNumber(SVNRevision.create(Long.valueOf(revision))); } catch (NumberFormatException e) { return null; } } @Override VcsRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }### Answer:
@Test public void testCreate() { VcsRevisionNumber revisionNumber = subversionRevisionFactory.create("1234"); Assert.assertTrue(revisionNumber instanceof SvnRevisionNumber); Assert.assertEquals(1234, ((SvnRevisionNumber) revisionNumber).getLongRevisionNumber()); } |
### Question:
GitRevisionFactory implements RevisionFactory { @Override public boolean matches(VcsRoot vcsRoot, String location, String alias) { return false; } @Override GitRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }### Answer:
@Test public void testMatches() { Assert.assertFalse(gitRevisionFactory.matches(new VcsRoot(gitVcs, new LightVirtualFile()), "location", "alias")); } |
### Question:
GitRevisionFactory implements RevisionFactory { @Override public GitRevisionNumber create(String revision) { return new GitRevisionNumber(revision.replaceFirst(" .*$", "")); } @Override GitRevisionNumber create(String revision); @Override boolean matches(VcsRoot vcsRoot, String location, String alias); @Override String getType(); }### Answer:
@Test public void testCreate() { VcsRevisionNumber revisionNumber = gitRevisionFactory.create("2a7314b614b70b1d007236cbe2bf0b0d3028693d master"); Assert.assertTrue(revisionNumber instanceof GitRevisionNumber); Assert.assertEquals("2a7314b614b70b1d007236cbe2bf0b0d3028693d", ((GitRevisionNumber) revisionNumber).getRev()); } |
### Question:
SpellCheckTokenizer { public SpellCheckTokenizer(String text) { this.text = text; wordIterator = BreakIterator.getWordInstance(); wordIterator.setText(text); wordIterator.first(); } SpellCheckTokenizer(String text); boolean hasMoreTokens(); Token nextToken(); }### Answer:
@Test public void testSpellCheckTokenizer() { check("Gives words except 12345 or punctuation, and like.\n", new SpellCheckTokenizer.Token("Gives", 0), new SpellCheckTokenizer.Token("words", 6), new SpellCheckTokenizer.Token("except", 12), new SpellCheckTokenizer.Token("or", 25), new SpellCheckTokenizer.Token("punctuation", 28), new SpellCheckTokenizer.Token("and", 41), new SpellCheckTokenizer.Token("like", 45)); } |
### Question:
NavigationListener implements HyperlinkListener { public void hyperlinkUpdate(HyperlinkEvent hyperlinkEvent) { if(hyperlinkEvent.getEventType() == HyperlinkEvent.EventType.ACTIVATED) { for(Recognizer recognizer: NavigationDecorator.recognizers) { if(recognizer.navigate(project, hyperlinkEvent.getDescription())) { break; } } } } NavigationListener(Project project); void hyperlinkUpdate(HyperlinkEvent hyperlinkEvent); }### 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: } }); } }); new NavigationListener(getProject()).hyperlinkUpdate(new HyperlinkEvent(this, HyperlinkEvent.EventType.ACTIVATED, null, "web:http: } |
### Question:
NavigationDecorator { public static String explode(Project project, String plain) { return explode(project, plain, false); } static String explode(Project project, String plain); static String explodeHtml(Project project, String html); static List<Recognizer> recognizers; }### Answer:
@Test public void testExplode() throws InterruptedException { String value = NavigationDecorator.explode(getProject(), "Go to http: Assert.assertEquals( "Go to <a href=\"web:http: } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.