Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: CollectionUtils { public static <L> ArrayList<L> filter(List<L> list, Predicate<L> predicate) { ArrayList<L> result = new ArrayList<L>(); for (L element : list) { if (predicate.apply(element)) { result.add(element); } } return result; } private CollectionUtils(); static ArrayList<L> filter(List<L> list, Predicate<L> predicate); static ArrayList<T> map(List<G> input, Function1<T, G> function); static Set<T> map(Set<G> input, Function1<T, G> function); static boolean isNullOrEmpty(Collection<?> input); static List<Integer> asList(int... ids); static Set<T> asSet(T... items); }### Answer: @Test public void filter() { final List<String> strings = Arrays.asList("a", "aa", "aa", "aaa", "aaa", "aaaa"); Assert.assertEquals( Arrays.asList("aaa", "aaa", "aaaa"), CollectionUtils.filter(strings, str -> str.length() > 2) ); }
### Question: CollectionUtils { public static boolean isNullOrEmpty(Collection<?> input) { return input == null \|\| input.isEmpty(); } private CollectionUtils(); static ArrayList<L> filter(List<L> list, Predicate<L> predicate); static ArrayList<T> map(List<G> input, Function1<T, G> function); static Set<T> map(Set<G> input, Function1<T, G> function); static boolean isNullOrEmpty(Collection<?> input); static List<Integer> asList(int... ids); static Set<T> asSet(T... items); }### Answer: @Test public void isNullOrEmpty() { final List<String> strings = Arrays.asList("a", "aa", "aaa", "aaaa"); Assert.assertFalse(CollectionUtils.isNullOrEmpty(strings)); Assert.assertTrue(CollectionUtils.isNullOrEmpty(null)); Assert.assertTrue(CollectionUtils.isNullOrEmpty(Collections.emptyList())); }
### Question: CollectionUtils { public static List<Integer> asList(int... ids) { final List<Integer> result = new ArrayList<>(ids.length); for (int id : ids) { result.add(id); } return result; } private CollectionUtils(); static ArrayList<L> filter(List<L> list, Predicate<L> predicate); static ArrayList<T> map(List<G> input, Function1<T, G> function); static Set<T> map(Set<G> input, Function1<T, G> function); static boolean isNullOrEmpty(Collection<?> input); static List<Integer> asList(int... ids); static Set<T> asSet(T... items); }### Answer: @Test public void asList() throws Exception { final int[] ints = IntStream.range(0, 5).toArray(); final List<Integer> expected = IntStream.range(0, 5).boxed().collect(Collectors.toList()); Assert.assertEquals(expected, CollectionUtils.asList(ints)); }
### Question: CollectionUtils { public static <T> Set<T> asSet(T... items) { final HashSet<T> result = new HashSet<>(items.length); result.addAll(Arrays.asList(items)); return Collections.unmodifiableSet(result); } private CollectionUtils(); static ArrayList<L> filter(List<L> list, Predicate<L> predicate); static ArrayList<T> map(List<G> input, Function1<T, G> function); static Set<T> map(Set<G> input, Function1<T, G> function); static boolean isNullOrEmpty(Collection<?> input); static List<Integer> asList(int... ids); static Set<T> asSet(T... items); }### Answer: @Test public void asSet() throws Exception { final Set<Integer> expected = IntStream.range(0, 5).boxed().collect(Collectors.toSet()); Assert.assertEquals(expected, CollectionUtils.asSet(0, 1, 2, 3, 4)); }
### Question: KVJsonSerializer { @VisibleForTesting @NonNull JSONObject createCategoryObject(KVCategory category) throws JSONException { final JSONObject categoryJsonObject = new JSONObject(); categoryJsonObject.put(NAME_KEY, category.getName()); final JSONArray entriesJsonArray = new JSONArray(); for (KVSaver.KVEntry entry : category.entries()) { final JSONObject entryJsonObject = new JSONObject(); entryJsonObject.put(NAME_KEY, entry.getName()); entryJsonObject.put(VALUE_KEY, entry.getValue()); entriesJsonArray.put(entryJsonObject); } categoryJsonObject.put(ENTRIES_KEY, entriesJsonArray); return categoryJsonObject; } }### Answer: @Test public void createCategoryObject() throws Exception { final KVSaver.KVCategory testCategory = new KVSaver.KVCategory("cat", Arrays.asList( new KVSaver.KVEntry("k1", "v1"), new KVSaver.KVEntry("k2", "v2") )); final JSONObject category = serializer.createCategoryObject(testCategory); assertEquals("cat", category.getString(NAME_KEY)); final JSONArray entries = category.getJSONArray(ENTRIES_KEY); assertEquals(2, entries.length()); assertEquals("k1", entries.getJSONObject(0).getString(NAME_KEY)); assertEquals("v1", entries.getJSONObject(0).getString(VALUE_KEY)); assertEquals("k2", entries.getJSONObject(1).getString(NAME_KEY)); assertEquals("v2", entries.getJSONObject(1).getString(VALUE_KEY)); }
### Question: KVJsonSerializer { @VisibleForTesting @NonNull JSONArray createCategoriesArray(List<KVCategory> categories) throws JSONException { final JSONArray categoriesJsonArray = new JSONArray(); for (KVCategory category : categories) { if (category.isEmpty()) { continue; } final JSONObject categoryJsonObject = createCategoryObject(category); categoriesJsonArray.put(categoryJsonObject); } return categoriesJsonArray; } }### Answer: @Test public void createCategoriesArray_returns_empty_array_for_empty_collection() throws Exception { final JSONArray array = serializer.createCategoriesArray(Collections.emptyList()); assertEquals(0, array.length()); } @Test public void createCategoriesArray_returns_correct_json_object() throws Exception { final List<KVSaver.KVCategory> testCategories = Arrays.asList( new KVSaver.KVCategory("cat", Collections.singletonList( new KVSaver.KVEntry("k1", "v1"))), new KVSaver.KVCategory("cat", Collections.emptyList()) ); final JSONArray categories = serializer.createCategoriesArray(testCategories); assertEquals(1, categories.length()); assertEquals("cat", categories.getJSONObject(0).getString(NAME_KEY)); }
### Question: KVSaver extends Observable implements Saver { List<KVCategory> getData() { final List<KVCategory> categories = new ArrayList<>(); synchronized (items) { for (Map.Entry<String, Map<String, String>> categoryEntry : items.entrySet()) { final String categoryName = categoryEntry.getKey(); final List<KVEntry> entries = new ArrayList<>(); for (Map.Entry<String, String> keyValEntry : categoryEntry.getValue().entrySet()) { final String key = keyValEntry.getKey(); final String value = keyValEntry.getValue(); entries.add(new KVEntry(key, value)); } categories.add(new KVCategory(categoryName, entries)); } } return categories; } @Override void save(String category, String key, String value); @Override void remove(String category, String key); @Override void remove(String category); }### Answer: @Test public void get_data_when_empty_returns_empty_collection() { assertTrue("collection should be empty", saver.getData().isEmpty()); }
### Question: KVSaver extends Observable implements Saver { @Override public void save(String category, String key, String value) { synchronized (items) { Map<String, String> keyValues = items.get(category); if (keyValues == null) { keyValues = new LinkedHashMap<>(); items.put(category, keyValues); } keyValues.put(key, value); } setChanged(); notifyObservers(); } @Override void save(String category, String key, String value); @Override void remove(String category, String key); @Override void remove(String category); }### Answer: @Test public void save_notifies_about_change() { final Observer observable = Mockito.mock(Observer.class); saver.addObserver(observable); saver.save("cat", "key1", "val1"); Mockito.verify(observable).update(Mockito.eq(saver), Mockito.any()); } @Test public void update_notifies_about_change() { final Observer observable = Mockito.mock(Observer.class); saver.save("cat", "key1", "val1"); saver.addObserver(observable); saver.save("cat", "key1", "val2"); Mockito.verify(observable).update(Mockito.eq(saver), Mockito.any()); }
### Question: SelectedPageStorage { @Nullable String getSelectedPage() { return preferences.getString(KEY_SELECTED_PAGE_ID, null); } SelectedPageStorage(SharedPreferences preferences); }### Answer: @Test public void getSelectedPage_returns_null_if_nothing_stored() { assertNull(pageStorage.getSelectedPage()); }
### Question: ExpandedView extends FrameLayout { public void displayPages(List<Page> pages, Page selected, boolean animated) { setVisibility(VISIBLE); setupIcons(pages, selected, animated); setupPage(selected); title.setText(selected.getTitle()); } ExpandedView(@NonNull Context context); ExpandedView(@NonNull Context context, ExpandedViewCallback callback); ExpandedView(@NonNull Context context, @Nullable AttributeSet attrs); ExpandedView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr); void displayPages(List<Page> pages, Page selected, boolean animated); void setSelected(Page selected); void setCallback(ExpandedViewCallback callback); void destroyContentAnimated(@Nullable Runnable runnable); void destroyContent(); @Override boolean dispatchKeyEvent(KeyEvent event); static final int BACGROUND_TRANSPARENT_COLOR_RES; }### Answer: @Test public void displayPages() throws Exception { View pageView1 = mock(View.class, withSettings().extraInterfaces(PageView.class)); View pageView2 = mock(View.class, withSettings().extraInterfaces(PageView.class)); List<Page> pages = ImmutableList.of( new Page("page1", R.drawable.ic_share, "page1", (context, overlayCallback) -> pageView1), new Page("page2", R.drawable.ic_share, "page2", (context, overlayCallback) -> pageView2) ); Page selectedPage = pages.get(0); view.displayPages(pages, selectedPage, false); ViewGroup iconHolder = view.findViewById(R.id.tab_icons_holder); assertEquals(pages.size() + 1, iconHolder.getChildCount()); for (int i = 0; i < iconHolder.getChildCount(); i++) { View child = iconHolder.getChildAt(i); assertTrue(child.isSelected() == ObjectUtil.equals(child.getTag(), selectedPage.getId())); } ViewGroup container = view.findViewById(R.id.content); assertEquals(1, container.getChildCount()); assertEquals(View.VISIBLE, view.getVisibility()); }
### Question: ExpandedView extends FrameLayout { public void destroyContent() { animator.cancel(); setVisibility(INVISIBLE); content = null; contentContainer.removeAllViews(); disposable.dispose(); } ExpandedView(@NonNull Context context); ExpandedView(@NonNull Context context, ExpandedViewCallback callback); ExpandedView(@NonNull Context context, @Nullable AttributeSet attrs); ExpandedView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr); void displayPages(List<Page> pages, Page selected, boolean animated); void setSelected(Page selected); void setCallback(ExpandedViewCallback callback); void destroyContentAnimated(@Nullable Runnable runnable); void destroyContent(); @Override boolean dispatchKeyEvent(KeyEvent event); static final int BACGROUND_TRANSPARENT_COLOR_RES; }### Answer: @Test public void destroyContent() throws Exception { view.destroyContent(); assertEquals(View.INVISIBLE, view.getVisibility()); ViewGroup container = view.findViewById(R.id.content); assertEquals(0, container.getChildCount()); }
### Question: PhialButton extends View { @VisibleForTesting static int getIconSize(int maxSize, int intrinsicSize) { if (intrinsicSize == -1 \|\| intrinsicSize > maxSize) { return maxSize; } return intrinsicSize; } PhialButton(Context context); PhialButton(Context context, @Nullable AttributeSet attrs); PhialButton(Context context, @Nullable AttributeSet attrs, int defStyleAttr); void setIcon(Drawable drawable); void setIcon(Bitmap bitmap); Drawable getIcon(); void setIcon(@DrawableRes int iconId); void setSuggestedSize(int size); void setShadowSize(int size); @ColorInt int getBackgroundColor(); @ColorInt int getIconColor(); int getShadowColor(); int getShadowSize(); int getSuggestedSize(); }### Answer: @Test public void getIconSize_returns_correct_size() { assertEquals(10, PhialButton.getIconSize(10, -1)); assertEquals(10, PhialButton.getIconSize(10, 20)); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @Override public void onActivityStarted(Activity activity) { if (!isExpanded) { view.showButton(activity, false); } } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void onActivityStarted_adds_button() { presenter.onActivityStarted(activity); verify(view).showButton(eq(activity), eq(false)); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @Override public void onActivityStopped(Activity activity) { if (!isExpanded) { view.removeButton(activity); } } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void onActivityStopped_removes_button() { presenter.onActivityStopped(activity); verify(view).removeButton(eq(activity)); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @Override public void onActivityResumed(Activity activity) { curActivity = activity; if (isExpanded) { final List<Page> visiblePages = calcVisiblePages(); if (!visiblePages.isEmpty()) { view.showExpandedView(activity, visiblePages, findSelected(visiblePages), false); return; } isExpanded = false; view.freeExpandedContent(); notifier.fireDebugWindowHide(); view.showButton(activity, false); } } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void onActivityResumed_does_noting_if_not_expanded() { verifyNoMoreInteractions(view); presenter.onActivityResumed(activity); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @Override public void onActivityPaused(Activity activity) { if (ObjectUtil.equals(activity, curActivity)) { if (isExpanded) { view.removeExpandedView(curActivity); } curActivity = null; } } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void onActivityPaused_does_noting_if_not_expanded() { verifyNoMoreInteractions(view); presenter.onActivityPaused(activity); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @VisibleForTesting @NonNull List<Page> calcVisiblePages() { final List<Page> visiblePages = new ArrayList<>(allPages.size()); for (Page page : allPages) { final boolean shouldShowPage = screenTracker.matchesAny(page.getTargetScreens()); if (shouldShowPage) { visiblePages.add(page); } } return visiblePages; } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void calcVisiblePages() throws Exception { addPages(2); when(screenTracker.matchesAny(any())).thenReturn(true, false); assertEquals(Collections.singletonList(pages.get(0)), presenter.calcVisiblePages()); }
### Question: OverlayPresenter extends SimpleActivityLifecycleCallbacks implements ScreenTracker.ScreenListener { @VisibleForTesting @NonNull Page findSelected(List<Page> visible) { final String selectedPageId = selectedPageStorage.getSelectedPage(); for (Page page : visible) { if (ObjectUtil.equals(selectedPageId, page.getId())) { return page; } } return visible.get(0); } OverlayPresenter( OverlayView view, List<Page> allPages, SelectedPageStorage selectedPageStorage, ScreenTracker screenTracker, PhialNotifier notifier); @Override void onActivityStarted(Activity activity); @Override void onActivityStopped(Activity activity); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onScreenChanged(Screen screen); @Nullable View findViewById(int id); void destroy(); }### Answer: @Test public void findSelected() { addPages(2); mockStoreToSelect(pages.get(1)); assertEquals(pages.get(1), presenter.findSelected(pages)); }
### Question: OverlayView implements ExpandedView.ExpandedViewCallback { void showExpandedView(Activity activity, List<Page> pages, Page selected, boolean animated) { expandedView.displayPages(pages, selected, animated); activity.getWindowManager().addView(expandedView, wrap(EXPANDED_VIEW_PARAMS)); } OverlayView(Context context, DragHelper dragHelper, ExpandedView expandedView); @Override void finish(); @Nullable @Override View findViewById(int id); @Override void onPageSelected(Page page); }### Answer: @Test public void showExpandedView() { final List<Page> pages = IntStream.range(0, 5).mapToObj(this::createPage).collect(Collectors.toList()); view.showExpandedView(activity, pages, pages.get(1), false); verify(windowManager).addView(eq(expandedView), any()); verify(expandedView).displayPages(eq(pages), eq(pages.get(1)), eq(false)); }
### Question: OverlayView implements ExpandedView.ExpandedViewCallback { void updateExpandedView(List<Page> pages, Page selected) { expandedView.displayPages(pages, selected, false); } OverlayView(Context context, DragHelper dragHelper, ExpandedView expandedView); @Override void finish(); @Nullable @Override View findViewById(int id); @Override void onPageSelected(Page page); }### Answer: @Test public void updateExpandedView() { final List<Page> pages = IntStream.range(0, 5).mapToObj(this::createPage).collect(Collectors.toList()); view.updateExpandedView(pages, pages.get(1)); verify(expandedView).displayPages(eq(pages), eq(pages.get(1)), eq(false)); }
### Question: OverlayView implements ExpandedView.ExpandedViewCallback { void removeExpandedView(Activity activity) { activity.getWindowManager().removeView(expandedView); } OverlayView(Context context, DragHelper dragHelper, ExpandedView expandedView); @Override void finish(); @Nullable @Override View findViewById(int id); @Override void onPageSelected(Page page); }### Answer: @Test public void removeExpandedView() { view.removeExpandedView(activity); verify(windowManager).removeView(eq(expandedView)); }
### Question: OverlayView implements ExpandedView.ExpandedViewCallback { void setSelectedPage(Page page) { expandedView.setSelected(page); } OverlayView(Context context, DragHelper dragHelper, ExpandedView expandedView); @Override void finish(); @Nullable @Override View findViewById(int id); @Override void onPageSelected(Page page); }### Answer: @Test public void setSelectedPage() { final Page page = createPage(1); view.setSelectedPage(page); verify(expandedView).setSelected(eq(page)); }
### Question: ScreenTracker extends SimpleActivityLifecycleCallbacks implements PhialScopeNotifier.OnScopeChangedListener { @Override public void onActivityResumed(Activity activity) { currentScreen.setActivity(activity); fireOnScreenChanged(); } void addListener(ScreenListener listener); void removeListener(ScreenListener listener); Screen getCurrentScreen(); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onEnterScope(String scopeName, View view); @Override void onExitScope(String scopeName); boolean matchesAny(Set<TargetScreen> targetScreen); View findTarget(int id); }### Answer: @Test public void onActivityResumed() throws Exception { ScreenListener listener = mock(ScreenListener.class); screenTracker.addListener(listener); Activity activity = mock(Activity.class); screenTracker.onActivityResumed(activity); ArgumentCaptor<Screen> screenCaptor = ArgumentCaptor.forClass(Screen.class); verify(listener).onScreenChanged(screenCaptor.capture()); Screen screen = screenCaptor.getValue(); assertEquals(activity, screen.getActivity()); }
### Question: ConfigManager { void saveOption(String name, List<String> values) { if (!hasSameSizeAsConfig(values)) { throw new IllegalArgumentException("unexpected size of options!. Should be " + fillConfig.getTargetIds().size() + "; But was " + values.size() ); } final List<String> optionNames = store.read(ORDER); if (!optionNames.contains(name)) { List<String> newOptions = new ArrayList<>(optionNames); newOptions.add(name); store.save(ORDER, newOptions); } store.save(KEY_PREFIX + name, values); } ConfigManager(FillConfig fillConfig, Store store); }### Answer: @Test public void saveOption_add_options_in_store() throws Exception { when(store.read(eq(ConfigManager.ORDER))).thenReturn(Collections.singletonList("old")); configManager.saveOption("new", Arrays.asList("1", "2")); InOrder inOrder = Mockito.inOrder(store); inOrder.verify(store).save(eq(ConfigManager.ORDER), eq(Arrays.asList("old", "new"))); inOrder.verify(store).save(eq(ConfigManager.KEY_PREFIX + "new"), eq(Arrays.asList("1", "2"))); } @Test public void saveOption_updates_option_in_store() throws Exception { when(store.read(eq(ConfigManager.ORDER))).thenReturn(Collections.singletonList("old")); configManager.saveOption("old", Arrays.asList("1", "2")); verify(store).save(eq(ConfigManager.KEY_PREFIX + "old"), eq(Arrays.asList("1", "2"))); verify(store).save(anyString(), any()); } @Test(expected = Exception.class) public void saveOption_throws_on_bad_size() throws Exception { when(store.read(eq(ConfigManager.ORDER))).thenReturn(Collections.emptyList()); configManager.saveOption("test", Collections.singletonList("1")); }
### Question: ScreenTracker extends SimpleActivityLifecycleCallbacks implements PhialScopeNotifier.OnScopeChangedListener { @Override public void onActivityPaused(Activity activity) { if (ObjectUtil.equals(activity, currentScreen.getActivity())) { currentScreen.clearActivity(); fireOnScreenChanged(); } } void addListener(ScreenListener listener); void removeListener(ScreenListener listener); Screen getCurrentScreen(); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onEnterScope(String scopeName, View view); @Override void onExitScope(String scopeName); boolean matchesAny(Set<TargetScreen> targetScreen); View findTarget(int id); }### Answer: @Test public void onActivityPaused() throws Exception { ScreenListener listener = mock(ScreenListener.class); screenTracker.addListener(listener); Activity activity = mock(Activity.class); screenTracker.onActivityResumed(activity); screenTracker.onActivityPaused(activity); ArgumentCaptor<Screen> screenCaptor = ArgumentCaptor.forClass(Screen.class); verify(listener, times(2)).onScreenChanged(screenCaptor.capture()); Screen screen = screenCaptor.getValue(); assertNull(screen.getActivity()); }
### Question: ScreenTracker extends SimpleActivityLifecycleCallbacks implements PhialScopeNotifier.OnScopeChangedListener { @Override public void onEnterScope(String scopeName, View view) { currentScreen.enterScope(scopeName, view); fireOnScreenChanged(); } void addListener(ScreenListener listener); void removeListener(ScreenListener listener); Screen getCurrentScreen(); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onEnterScope(String scopeName, View view); @Override void onExitScope(String scopeName); boolean matchesAny(Set<TargetScreen> targetScreen); View findTarget(int id); }### Answer: @Test public void onEnterScope() throws Exception { ScreenListener listener = mock(ScreenListener.class); screenTracker.addListener(listener); screenTracker.onEnterScope("scope", mock(View.class)); verify(listener).onScreenChanged(any()); }
### Question: ScreenTracker extends SimpleActivityLifecycleCallbacks implements PhialScopeNotifier.OnScopeChangedListener { @Override public void onExitScope(String scopeName) { currentScreen.exitScope(scopeName); fireOnScreenChanged(); } void addListener(ScreenListener listener); void removeListener(ScreenListener listener); Screen getCurrentScreen(); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onEnterScope(String scopeName, View view); @Override void onExitScope(String scopeName); boolean matchesAny(Set<TargetScreen> targetScreen); View findTarget(int id); }### Answer: @Test public void onExitScope() throws Exception { ScreenListener listener = mock(ScreenListener.class); screenTracker.addListener(listener); screenTracker.onExitScope("scope"); verify(listener).onScreenChanged(any()); }
### Question: ScreenTracker extends SimpleActivityLifecycleCallbacks implements PhialScopeNotifier.OnScopeChangedListener { void destroy() { listeners.clear(); currentScreen.clearActivity(); } void addListener(ScreenListener listener); void removeListener(ScreenListener listener); Screen getCurrentScreen(); @Override void onActivityResumed(Activity activity); @Override void onActivityPaused(Activity activity); @Override void onEnterScope(String scopeName, View view); @Override void onExitScope(String scopeName); boolean matchesAny(Set<TargetScreen> targetScreen); View findTarget(int id); }### Answer: @Test public void destroy() throws Exception { screenTracker.destroy(); assertNull(screenTracker.getCurrentScreen().getActivity()); }
### Question: Screen { public boolean matchesAny(Collection<TargetScreen> screens) { if (CollectionUtils.isNullOrEmpty(screens)) { return true; } for (TargetScreen targetScreen : screens) { if (matches(targetScreen)) { return true; } } return false; } Screen(Activity activity, String scopeName); boolean matches(TargetScreen screen); boolean matchesAny(Collection<TargetScreen> screens); @Nullable View findTarget(int id); }### Answer: @Test public void matchesAny() throws Exception { Collection<TargetScreen> targetScreens = ImmutableList.of( TargetScreen.forScope("scope0"), TargetScreen.forScope("scope1") ); screen.setActivity(Robolectric.buildActivity(ActivityA.class).get()); screen.enterScope("scope1", null); assertTrue(screen.matchesAny(targetScreens)); }
### Question: Screen { @Nullable public View findTarget(int id) { View resultView = null; for (WeakReference<View> weakRefView : scopes.values()) { View scopeView = weakRefView.get(); if (scopeView != null) { resultView = scopeView.findViewById(id); } if (resultView != null) { return resultView; } } if (activity != null) { resultView = activity.findViewById(id); } return resultView; } Screen(Activity activity, String scopeName); boolean matches(TargetScreen screen); boolean matchesAny(Collection<TargetScreen> screens); @Nullable View findTarget(int id); }### Answer: @Test public void findTarget() { screen.setActivity(mock(Activity.class)); assertNull(screen.findTarget(1)); }
### Question: ConfigManager { List<Integer> getTargetIds() { return fillConfig.getTargetIds(); } ConfigManager(FillConfig fillConfig, Store store); }### Answer: @Test public void getTargetIds() throws Exception { assertEquals(config.getTargetIds(), configManager.getTargetIds()); }
### Question: AutoFillerBuilder { public AutoFillerBuilder fill(int... ids) { Precondition.notEmpty(ids, "ids should not be empty"); this.targetIds = CollectionUtils.asList(ids); return this; } AutoFillerBuilder(TargetScreen targetScreen); AutoFillerBuilder fill(int... ids); FillConfig withOptions(FillOption... options); FillConfig withoutOptions(); }### Answer: @Test(expected = Exception.class) public void empty_fill_rises_exception() { builder.fill(); }
### Question: AutoFillerBuilder { public FillConfig withOptions(FillOption... options) { this.options = Arrays.asList(options); return this.build(); } AutoFillerBuilder(TargetScreen targetScreen); AutoFillerBuilder fill(int... ids); FillConfig withOptions(FillOption... options); FillConfig withoutOptions(); }### Answer: @Test(expected = Exception.class) public void withOptions_without_calling_fill_rises_exception() { builder.withOptions(Mockito.mock(FillOption.class)); }
### Question: StripPrefixFilter extends HttpInboundSyncFilter { @Override public boolean shouldFilter(HttpRequestMessage msg) { for (String target: prefixPatterns) { if (msg.getPath().matches(target)) { return true; } } return false; } StripPrefixFilter(List<String> prefixPatterns); @Override HttpRequestMessage apply(HttpRequestMessage input); @Override int filterOrder(); @Override boolean shouldFilter(HttpRequestMessage msg); }### Answer: @Test public void testShouldFilter() { StripPrefixFilter filter = new StripPrefixFilter(Arrays.asList("/path1/.*")); assertThat(filter.shouldFilter(sampleHttpMessage("/path1/testRemaining?query1=val1"))).isTrue(); assertThat(filter.shouldFilter(sampleHttpMessage("/path2/testRemaining?query1=val1"))).isFalse(); }
### Question: SagaInstanceFactory { public <SagaData> SagaInstance create(Saga<SagaData> saga, SagaData data) { SagaManager<SagaData> sagaManager = (SagaManager<SagaData>)sagaManagers.get(saga); if (sagaManager == null) throw new RuntimeException(("No SagaManager for " + saga)); return sagaManager.create(data); } SagaInstanceFactory(SagaManagerFactory sagaManagerFactory, Collection<Saga<?>> sagas); SagaInstance create(Saga<SagaData> saga, SagaData data); }### Answer: @Test public void shouldCreateSagaInstance() { when(sagaManager.create(sagaData1)).thenReturn(expectedSi1); when(sagaManager.create(sagaData2)).thenReturn(expectedSi2); SagaInstance si1 = sagaInstanceFactory.create(saga, sagaData1); assertEquals(expectedSi1, si1); verify(sagaManagerFactory, times(1)).make(saga); SagaInstance si2 = sagaInstanceFactory.create(saga, sagaData2); assertEquals(expectedSi2, si2); verify(sagaManagerFactory, times(1)).make(saga); }
### Question: Money { public boolean isGreaterThanOrEqual(Money other) { return amount.compareTo(other.amount) >= 0; } private Money(); Money(BigDecimal amount); Money(String s); Money(int i); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); Money add(Money delta); boolean isGreaterThanOrEqual(Money other); String asString(); Money multiply(int x); Long asLong(); static Money ZERO; }### Answer: @Test public void shouldCompare() { assertTrue(m2.isGreaterThanOrEqual(m2)); assertTrue(m2.isGreaterThanOrEqual(m1)); assertFalse(m1.isGreaterThanOrEqual(m2)); }
### Question: Money { public Money add(Money delta) { return new Money(amount.add(delta.amount)); } private Money(); Money(BigDecimal amount); Money(String s); Money(int i); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); Money add(Money delta); boolean isGreaterThanOrEqual(Money other); String asString(); Money multiply(int x); Long asLong(); static Money ZERO; }### Answer: @Test public void shouldAdd() { assertEquals(new Money(M1_AMOUNT + M2_AMOUNT), m1.add(m2)); }
### Question: Money { public Money multiply(int x) { return new Money(amount.multiply(new BigDecimal(x))); } private Money(); Money(BigDecimal amount); Money(String s); Money(int i); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); Money add(Money delta); boolean isGreaterThanOrEqual(Money other); String asString(); Money multiply(int x); Long asLong(); static Money ZERO; }### Answer: @Test public void shouldMultiply() { int multiplier = 12; assertEquals(new Money(M2_AMOUNT * multiplier), m2.multiply(multiplier)); }
### Question: ConsumerController { @RequestMapping(method= RequestMethod.GET, path="/{consumerId}") public ResponseEntity<GetConsumerResponse> get(@PathVariable long consumerId) { return consumerService.findById(consumerId) .map(consumer -> new ResponseEntity<>(new GetConsumerResponse(consumer.getName()), HttpStatus.OK)) .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND)); } ConsumerController(ConsumerService consumerService); @RequestMapping(method= RequestMethod.POST) CreateConsumerResponse create(@RequestBody CreateConsumerRequest request); @RequestMapping(method= RequestMethod.GET, path="/{consumerId}") ResponseEntity<GetConsumerResponse> get(@PathVariable long consumerId); }### Answer: @Test public void shouldGetConsumer() throws IOException { Mockito.when(consumerService.findById(1)).thenReturn(Optional.of(consumer)); given(). standaloneSetup(configureControllers(consumerController)). when(). get("/consumers/1"). then(). statusCode(200) ; }
### Question: OrderHistoryController { @RequestMapping(path = "/{orderId}", method = RequestMethod.GET) public ResponseEntity<GetOrderResponse> getOrder(@PathVariable String orderId) { return orderHistoryDao.findOrder(orderId) .map(order -> new ResponseEntity<>(makeGetOrderResponse(order), HttpStatus.OK)) .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND)); } OrderHistoryController(OrderHistoryDao orderHistoryDao); @RequestMapping(method = RequestMethod.GET) ResponseEntity<GetOrdersResponse> getOrders(@RequestParam(name = "consumerId") String consumerId); @RequestMapping(path = "/{orderId}", method = RequestMethod.GET) ResponseEntity<GetOrderResponse> getOrder(@PathVariable String orderId); }### Answer: @Test public void testGetOrder() { when(orderHistoryDao.findOrder("1")).thenReturn(Optional.of(new Order("1", null, null, null, null, 101L, "Ajanta"))); given(). standaloneSetup(configureControllers(orderHistoryController)). when(). get("/orders/1"). then(). statusCode(200). body("restaurantName", equalTo("Ajanta")) ; }
### Question: DeliveryService { public void createDelivery(long orderId, long restaurantId, Address deliveryAddress) { Restaurant restaurant = restaurantRepository.findById(restaurantId).get(); deliveryRepository.save(Delivery.create(orderId, restaurantId, restaurant.getAddress(), deliveryAddress)); } DeliveryService(RestaurantRepository restaurantRepository, DeliveryRepository deliveryRepository, CourierRepository courierRepository); void createRestaurant(long restaurantId, String restaurantName, Address address); void createDelivery(long orderId, long restaurantId, Address deliveryAddress); void scheduleDelivery(long orderId, LocalDateTime readyBy); void cancelDelivery(long orderId); @Transactional void updateAvailability(long courierId, boolean available); @Transactional Optional<DeliveryStatus> getDeliveryInfo(long deliveryId); }### Answer: @Test public void shouldCreateDelivery() { when(restaurantRepository.findById(RESTAURANT_ID)).thenReturn(Optional.of(restaurant)); when(restaurant.getAddress()).thenReturn(DeliveryServiceTestData.PICKUP_ADDRESS); deliveryService.createDelivery(ORDER_ID, RESTAURANT_ID, DeliveryServiceTestData.DELIVERY_ADDRESS); ArgumentCaptor<Delivery> arg = ArgumentCaptor.forClass(Delivery.class); verify(deliveryRepository).save(arg.capture()); Delivery delivery = arg.getValue(); assertNotNull(delivery); assertEquals(ORDER_ID, delivery.getId()); assertEquals(DeliveryState.PENDING, delivery.getState()); assertEquals(RESTAURANT_ID, delivery.getRestaurantId()); assertEquals(DeliveryServiceTestData.PICKUP_ADDRESS, delivery.getPickupAddress()); assertEquals(DeliveryServiceTestData.DELIVERY_ADDRESS, delivery.getDeliveryAddress()); }
### Question: Order { public OrderState getState() { return state; } private Order(); Order(long consumerId, long restaurantId, DeliveryInformation deliveryInformation, List<OrderLineItem> orderLineItems); static ResultWithDomainEvents<Order, OrderDomainEvent> createOrder(long consumerId, Restaurant restaurant, DeliveryInformation deliveryInformation, List<OrderLineItem> orderLineItems); Long getId(); void setId(Long id); DeliveryInformation getDeliveryInformation(); Money getOrderTotal(); List<OrderDomainEvent> cancel(); List<OrderDomainEvent> undoPendingCancel(); List<OrderDomainEvent> noteCancelled(); List<OrderDomainEvent> noteApproved(); List<OrderDomainEvent> noteRejected(); List<OrderDomainEvent> noteReversingAuthorization(); ResultWithDomainEvents<LineItemQuantityChange, OrderDomainEvent> revise(OrderRevision orderRevision); List<OrderDomainEvent> rejectRevision(); List<OrderDomainEvent> confirmRevision(OrderRevision orderRevision); Long getVersion(); List<OrderLineItem> getLineItems(); OrderState getState(); long getRestaurantId(); Long getConsumerId(); }### Answer: @Test public void shouldCreateOrder() { assertEquals(singletonList(new OrderCreatedEvent(CHICKEN_VINDALOO_ORDER_DETAILS, OrderDetailsMother.DELIVERY_ADDRESS, RestaurantMother.AJANTA_RESTAURANT_NAME)), createResult.events); assertEquals(OrderState.APPROVAL_PENDING, order.getState()); }
### Question: Order { public Money getOrderTotal() { return orderLineItems.orderTotal(); } private Order(); Order(long consumerId, long restaurantId, DeliveryInformation deliveryInformation, List<OrderLineItem> orderLineItems); static ResultWithDomainEvents<Order, OrderDomainEvent> createOrder(long consumerId, Restaurant restaurant, DeliveryInformation deliveryInformation, List<OrderLineItem> orderLineItems); Long getId(); void setId(Long id); DeliveryInformation getDeliveryInformation(); Money getOrderTotal(); List<OrderDomainEvent> cancel(); List<OrderDomainEvent> undoPendingCancel(); List<OrderDomainEvent> noteCancelled(); List<OrderDomainEvent> noteApproved(); List<OrderDomainEvent> noteRejected(); List<OrderDomainEvent> noteReversingAuthorization(); ResultWithDomainEvents<LineItemQuantityChange, OrderDomainEvent> revise(OrderRevision orderRevision); List<OrderDomainEvent> rejectRevision(); List<OrderDomainEvent> confirmRevision(OrderRevision orderRevision); Long getVersion(); List<OrderLineItem> getLineItems(); OrderState getState(); long getRestaurantId(); Long getConsumerId(); }### Answer: @Test public void shouldCalculateTotal() { assertEquals(CHICKEN_VINDALOO_PRICE.multiply(CHICKEN_VINDALOO_QUANTITY), order.getOrderTotal()); }
### Question: Delta { @Nonnull public static Version inferNextVersion(@Nonnull final Version version, @Nonnull final CompatibilityType compatibilityType) { if (version == null) { throw new IllegalArgumentException("null version"); } if (compatibilityType == null) { throw new IllegalArgumentException("null compatibilityType"); } switch (compatibilityType) { case BACKWARD_COMPATIBLE_IMPLEMENTER: return version.next(Version.Element.PATCH); case BACKWARD_COMPATIBLE_USER: return version.next(Version.Element.MINOR); case NON_BACKWARD_COMPATIBLE: return version.next(Version.Element.MAJOR); default: throw new IllegalArgumentException("Unknown type <"+compatibilityType+">"); } } Delta(@Nonnull final Set<? extends Difference> differences); @Nonnull final Set<Difference> getDifferences(); @Nonnull final CompatibilityType computeCompatibilityType(); @Nonnull static Version inferNextVersion(@Nonnull final Version version, @Nonnull final CompatibilityType compatibilityType); @Nonnull final Version infer(@Nonnull final Version previous); final boolean validate(@Nonnull final Version previous, @Nonnull final Version current); }### Answer: @Test public void inferVersion() { final int major = 1; final int minor = 2; final int patch = 3; final Version version = new Version(major, minor, patch); assertEquals(version.next(MAJOR), inferNextVersion(version, NON_BACKWARD_COMPATIBLE)); assertEquals(version.next(MINOR), inferNextVersion(version, BACKWARD_COMPATIBLE_USER)); assertEquals(version.next(PATCH), inferNextVersion(version, BACKWARD_COMPATIBLE_IMPLEMENTER)); } @Test(expected=IllegalArgumentException.class) public void shouldInferWithNullVersionFail() { inferNextVersion(null, BACKWARD_COMPATIBLE_IMPLEMENTER); } @Test(expected=IllegalArgumentException.class) public void shouldInferWithNullCompatibilityTypeFail() { inferNextVersion(new Version(1, 0, 0), null); }
### Question: ExtensibleFirefoxDriver extends FirefoxDriver { public void uninstallAddon(AddonUninstallRequest request) throws IOException { addonSupport.uninstallAddon(request); } ExtensibleFirefoxDriver(GeckoDriverService service, FirefoxOptions options); void installAddon(AddonInstallRequest request); void uninstallAddon(AddonUninstallRequest request); static ArtifactInfo getArtifactInfo(); static ArtifactInfo getParentArtifactInfo(); }### Answer: @Test public void uninstallAddon() throws Exception { File sampleExtensionZipFile = buildSampleExtension(); AddonInstallRequest installRequest = AddonInstallRequest.fromFile(sampleExtensionZipFile, AddonPersistence.TEMPORARY); BehaviorVerifier<Void> verifier = (driver, baseUri) -> { AddonUninstallRequest uninstallRequest = AddonUninstallRequest.fromId(SAMPLE_EXTENSION_ID); driver.uninstallAddon(uninstallRequest); driver.get(baseUri.toString()); try { new WebDriverWait(driver, 3).until(ExpectedConditions.presenceOfElementLocated(By.id("injected"))); fail("extension still installed it seems"); } catch (org.openqa.selenium.TimeoutException ignore) { } return (Void) null; }; testInstallAddon(installRequest, verifier); }
### Question: EmptyHashFileGenerator implements HashFileGenerator { @Override public Optional<String> hash(final Optional<URL> url) throws IOException { return Optional.absent(); } @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(Collection<URL> urls); }### Answer: @Test public void defaultHashOneNotNull() throws Exception { Assert.assertNotNull("should not be null", emptyHashFileGenerator.hash(null)); } @Test public void defaultHashOneAbsent() throws Exception { Assert.assertFalse("should be absent", emptyHashFileGenerator.hash(null).isPresent()); } @Test public void defaultHashOneAbsentWithValue() throws Exception { Assert.assertFalse("should be absent", emptyHashFileGenerator.hash(Optional.of(new URL("file: }
### Question: EmptyHashFileGenerator implements HashFileGenerator { @Override public Optional<String> hashMulti(Collection<URL> urls) throws IOException { return Optional.absent(); } @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(Collection<URL> urls); }### Answer: @Test public void defaultHashMultiNotNull() throws Exception { Assert.assertNotNull("should not be null", emptyHashFileGenerator.hashMulti(null)); } @Test public void defaultHashMultiAbsent() throws Exception { Assert.assertFalse("should be absent", emptyHashFileGenerator.hashMulti(null).isPresent()); } @Test public void defaultHashMultiEmptyNotNull() throws Exception { Assert.assertNotNull("should not be null", emptyHashFileGenerator.hashMulti(Collections.EMPTY_LIST)); } @Test public void defaultHashMultiEmptyNotNullAbsentWithValue() throws Exception { Assert.assertNotNull("should not be null", emptyHashFileGenerator.hashMulti(Lists.newArrayList(new URL("file: } @Test public void defaultHashMultiEmptyAbsent() throws Exception { Assert.assertFalse("should be absent", emptyHashFileGenerator.hashMulti(Collections.EMPTY_LIST).isPresent()); }
### Question: EmptyModelAdjuster implements ModelAdjuster { @Override public @Nullable Object adjust(@Nullable Object obj) { return obj; } @Override @Nullable Object adjust(@Nullable Object obj); }### Answer: @Test public void nullReturnsNull() throws Exception { Assert.assertNull("null returns null", emptyModelAdjuster.adjust(null)); } @Test public void sameObject() throws Exception { final Object obj = new Object(); Assert.assertEquals("return the same object", obj, emptyModelAdjuster.adjust(obj)); }
### Question: SpringModelAdjuster implements ModelAdjuster { public String getModelKey() { return modelKey; } @Override @Nullable Object adjust(@Nullable final Object obj); void setModelKey(final String modelKey); String getModelKey(); }### Answer: @Test public void defaultModelKey() throws Exception { Assert.assertEquals("model key should be 'model'", "model", springModelAdjuster.getModelKey()); }
### Question: SpringModelAdjuster implements ModelAdjuster { public void setModelKey(final String modelKey) { this.modelKey = modelKey; } @Override @Nullable Object adjust(@Nullable final Object obj); void setModelKey(final String modelKey); String getModelKey(); }### Answer: @Test public void setModelKey() throws Exception { springModelAdjuster.setModelKey("newModelKey"); Assert.assertEquals("model key should be 'newModelKey'", "newModelKey", springModelAdjuster.getModelKey()); }
### Question: SpringModelAdjuster implements ModelAdjuster { @Override public @Nullable Object adjust(@Nullable final Object obj) { if (obj instanceof Model) { final Model model = (Model) obj; return model.asMap().get("model"); } if (obj instanceof Map) { final Map map = (Map) obj; return map.get("model"); } return obj; } @Override @Nullable Object adjust(@Nullable final Object obj); void setModelKey(final String modelKey); String getModelKey(); }### Answer: @Test public void adjustMap() throws Exception { final Object modelObject = new Object(); final Map<String,Object> map = new HashMap(); map.put("model", modelObject); Assert.assertEquals("should return modelObject", modelObject, springModelAdjuster.adjust(map)); } @Test public void adjustMapFail() throws Exception { final Object modelObject = new Object(); final Map<String,Object> map = new HashMap(); map.put("model2", modelObject); Assert.assertNull("should return null", springModelAdjuster.adjust(map)); } @Test public void adjustSpringModel() throws Exception { final Object modelObject = new Object(); final Model model = new ExtendedModelMap(); model.addAttribute("model", modelObject); Assert.assertEquals("should return modelObject", modelObject, springModelAdjuster.adjust(model)); } @Test public void adjustPassThrough() throws Exception { final Object modelObject = new Object(); Assert.assertEquals("should return modelObject", modelObject, springModelAdjuster.adjust(modelObject)); }
### Question: DefaultToSoyDataConverter implements ToSoyDataConverter { @Override public Optional<SoyMapData> toSoyMap(final Object model) throws Exception { if (model == null) { return Optional.absent(); } return Optional.fromNullable(objectToSoyDataMap(model)); } DefaultToSoyDataConverter(); void setIgnorablePropertiesMatcher( Matcher<PropertyDescriptor> ignorablePropertiesMatcher); @Override Optional<SoyMapData> toSoyMap(final Object model); }### Answer: @Test public void testToSoyMapWhenNoModel() throws Exception { Optional<SoyMapData> soyData = objectToSoyDataConverter.toSoyMap(null); assertFalse(soyData.isPresent()); } @Test public void testToSoyMapWhenModelIsPresent() throws Exception { Map<String, String> model = new HashMap<String, String>(); model.put(key, keyValue); Optional<SoyMapData> soyData = objectToSoyDataConverter.toSoyMap(model); assertTrue(soyData.isPresent()); SoyMapData data = soyData.get(); assertEquals(keyValue, data.get(key).stringValue()); }
### Question: DefaultToSoyDataConverter implements ToSoyDataConverter { @SuppressWarnings("unchecked") protected Map<String, ?> toSoyCompatibleMap(final Object obj) throws Exception { Object ret = toSoyCompatibleObjects(obj); if (!(ret instanceof Map)) { throw new IllegalArgumentException("Input should be a Map or POJO."); } return (Map<String, ?>) ret; } DefaultToSoyDataConverter(); void setIgnorablePropertiesMatcher( Matcher<PropertyDescriptor> ignorablePropertiesMatcher); @Override Optional<SoyMapData> toSoyMap(final Object model); }### Answer: @Test(expected = IllegalArgumentException.class) public void testToSoyCompatibleMapWhenNotMap() throws Exception { String test = "won't work"; objectToSoyDataConverter.toSoyCompatibleMap(test); }
### Question: DefaultToSoyDataConverter implements ToSoyDataConverter { protected SoyMapData objectToSoyDataMap(Object obj) throws Exception { if (obj == null) { return new SoyMapData(); } if (obj instanceof SoyMapData) { return (SoyMapData) obj; } return new SoyMapData(toSoyCompatibleMap(obj)); } DefaultToSoyDataConverter(); void setIgnorablePropertiesMatcher( Matcher<PropertyDescriptor> ignorablePropertiesMatcher); @Override Optional<SoyMapData> toSoyMap(final Object model); }### Answer: @Test public void testObjectToSoyDataMapWhenObjectIsNull() throws Exception { SoyMapData testObject = objectToSoyDataConverter .objectToSoyDataMap(null); assertTrue(testObject instanceof SoyMapData); } @Test public void testObjectToSoyDataMapWhenObjectIsSoyMapData() throws Exception { SoyMapData testInput = new SoyMapData(); testInput.putSingle(key, SoyData.createFromExistingData(keyValue)); SoyMapData testObject = objectToSoyDataConverter .objectToSoyDataMap(testInput); assertTrue(testObject instanceof SoyMapData); assertEquals(keyValue, ((SoyMapData) testObject).get(key).stringValue()); } @Test public void testObjectToSoyDataMapWhenObjectIsMap() throws Exception { Map<String, String> testInput = new HashMap<String, String>(); testInput.put(key, keyValue); SoyMapData testObject = objectToSoyDataConverter .objectToSoyDataMap(testInput); assertTrue(testObject instanceof SoyMapData); assertEquals(keyValue, ((SoyMapData) testObject).get(key).stringValue()); }
### Question: EmptyLocaleProvider implements LocaleProvider { @Override public Optional<Locale> resolveLocale(final HttpServletRequest request) { return Optional.absent(); } @Override Optional<Locale> resolveLocale(final HttpServletRequest request); }### Answer: @Test public void testShouldNotReturnNull() throws Exception { Assert.assertNotNull(emptyLocaleProvider.resolveLocale(null)); } @Test public void testDefaultAbsent() throws Exception { Assert.assertFalse("locale should be absent", emptyLocaleProvider.resolveLocale(null).isPresent()); }
### Question: DefaultLocaleProvider implements LocaleProvider { @Override public Optional<Locale> resolveLocale(final HttpServletRequest request) { return Optional.fromNullable(locale); } DefaultLocaleProvider(Locale locale); DefaultLocaleProvider(); @Override Optional<Locale> resolveLocale(final HttpServletRequest request); void setLocale(final Locale locale); }### Answer: @Test public void testShouldNotReturnNull() throws Exception { Assert.assertTrue("should return value", defaultLocaleProvider.resolveLocale(null).isPresent()); } @Test public void shouldReturnUsDefault() throws Exception { Assert.assertEquals("should return absent", Locale.US, defaultLocaleProvider.resolveLocale(request).get()); }
### Question: AcceptHeaderLocaleProvider implements LocaleProvider { public Optional<Locale> resolveLocale(final HttpServletRequest request) { return Optional.fromNullable(request.getLocale()); } Optional<Locale> resolveLocale(final HttpServletRequest request); }### Answer: @Test public void shouldThrowNPE() throws Exception { try { acceptHeaderLocaleProvider.resolveLocale(null); fail("npe should be thrown"); } catch (Exception ex) { } } @Test public void shouldReturnLocale() throws Exception { when(request.getLocale()).thenReturn(Locale.GERMAN); final Optional<Locale> localeOptional = acceptHeaderLocaleProvider.resolveLocale(request); Assert.assertTrue("locale should be present", localeOptional.isPresent()); Assert.assertEquals("locale should be German", Locale.GERMAN, localeOptional.get()); }
### Question: DefaultTemplateRenderer implements TemplateRenderer { public boolean isHotReloadMode() { return hotReloadMode; } @Override void render(final RenderRequest renderRequest); void setToSoyDataConverter(final ToSoyDataConverter toSoyDataConverter); void setHotReloadMode(boolean hotReloadMode); boolean isHotReloadMode(); boolean isHotReloadModeOff(); }### Answer: @Test public void testDefaultDebug() throws Exception { Assert.assertFalse("debug is off by default", defaultTemplateRenderer.isHotReloadMode()); }
### Question: ConfigurableAuthManager implements AuthManager { @Override public boolean isAllowed(final String url) { return allowedTemplates.contains(url); } ConfigurableAuthManager(List<String> allowedTemplates); ConfigurableAuthManager(); void setAllowedTemplates(final List<String> allowedTemplates); @Override boolean isAllowed(final String url); }### Answer: @Test public void testDefault() throws Exception { Assert.assertFalse("should not allow by default", configurableAuthManager.isAllowed("template")); }
### Question: EmptyTemplateRenderer implements TemplateRenderer { @Override public void render(final RenderRequest renderRequest) throws Exception { } @Override void render(final RenderRequest renderRequest); }### Answer: @Test public void testName() throws Exception { emptyTemplateRenderer.render(renderRequest); Mockito.verifyZeroInteractions(renderRequest); }
### Question: DefaultTofuCompiler implements TofuCompiler { public boolean isHotReloadMode() { return hotReloadMode; } @Override SoyTofu compile(@Nullable final Collection<URL> urls); @Override final Optional<String> compileToJsSrc(@Nullable final URL url, @Nullable final SoyMsgBundle soyMsgBundle); @Override Collection<String> compileToJsSrc(Collection<URL> templates, @Nullable SoyMsgBundle soyMsgBundle); void setHotReloadMode(final boolean hotReloadMode); void setCompileTimeGlobalModelResolver(final CompileTimeGlobalModelResolver compileTimeGlobalModelResolver); void setSoyJsSrcOptions(final SoyJsSrcOptions soyJsSrcOptions); boolean isHotReloadMode(); boolean isHotReloadModeOff(); SoyJsSrcOptions getSoyJsSrcOptions(); SoyTofuOptions getSoyTofuOptions(); void setSoyTofuOptions(SoyTofuOptions soyTofuOptions); }### Answer: @Test public void debugDefault() throws Exception { Assert.assertFalse("debug should be off", defaultTofuCompiler.isHotReloadMode()); }
### Question: DefaultTofuCompiler implements TofuCompiler { public SoyJsSrcOptions getSoyJsSrcOptions() { return soyJsSrcOptions; } @Override SoyTofu compile(@Nullable final Collection<URL> urls); @Override final Optional<String> compileToJsSrc(@Nullable final URL url, @Nullable final SoyMsgBundle soyMsgBundle); @Override Collection<String> compileToJsSrc(Collection<URL> templates, @Nullable SoyMsgBundle soyMsgBundle); void setHotReloadMode(final boolean hotReloadMode); void setCompileTimeGlobalModelResolver(final CompileTimeGlobalModelResolver compileTimeGlobalModelResolver); void setSoyJsSrcOptions(final SoyJsSrcOptions soyJsSrcOptions); boolean isHotReloadMode(); boolean isHotReloadModeOff(); SoyJsSrcOptions getSoyJsSrcOptions(); SoyTofuOptions getSoyTofuOptions(); void setSoyTofuOptions(SoyTofuOptions soyTofuOptions); }### Answer: @Test public void testSoyJsSrcOptionsNotNull() throws Exception { Assert.assertNotNull(defaultTofuCompiler.getSoyJsSrcOptions()); }
### Question: PermissableAuthManager implements AuthManager { @Override public boolean isAllowed(String url) { return true; } @Override boolean isAllowed(String url); }### Answer: @Test public void testDefault() throws Exception { Assert.assertTrue("should allow all", permissableAuthManager.isAllowed("template")); }
### Question: RequestParametersDataResolver implements RuntimeDataResolver { @Override public void resolveData(final HttpServletRequest request, final HttpServletResponse response, final Map<String, ? extends Object> model, final SoyMapData root) { for (final Enumeration e = request.getParameterNames(); e.hasMoreElements();) { final String paramName = (String) e.nextElement(); final String parameter = request.getParameter(paramName); if (parameter != null) { root.put("_request.parameter." + paramName, parameter); } } } @Override void resolveData(final HttpServletRequest request, final HttpServletResponse response, final Map<String, ? extends Object> model, final SoyMapData root); String getPrefix(); void setPrefix(String prefix); }### Answer: @Test public void resolveRequestParameters() throws Exception { final SoyMapData soyMapData = new SoyMapData(); final Vector<String> names = new Vector<String>(); names.add("name1"); names.add("name2"); final Vector<String> values = new Vector<String>(); values.add("value1"); values.add("value2"); final HttpServletRequest request = mock(HttpServletRequest.class); final HttpServletResponse response = mock(HttpServletResponse.class); final Enumeration e = mock(Enumeration.class); when(e.hasMoreElements()).thenReturn(false); when(request.getParameterNames()).thenReturn(names.elements()); when(request.getHeaderNames()).thenReturn(e); when(request.getParameter("name1")).thenReturn(values.get(0)); when(request.getParameter("name2")).thenReturn(values.get(1)); when(request.getCookies()).thenReturn(new Cookie[]{}); requestParametersResolver.resolveData(request, response, null, soyMapData); Assert.assertEquals("should not be value1", "value1", soyMapData.get("_request.parameter.name1").stringValue()); Assert.assertEquals("should not be value2", "value2", soyMapData.get("_request.parameter.name2").stringValue()); }
### Question: RequestHeadersDataResolver implements RuntimeDataResolver { @Override public void resolveData(final HttpServletRequest request, final HttpServletResponse response, Map<String, ? extends Object> model, final SoyMapData root) { for (final Enumeration e = request.getHeaderNames(); e.hasMoreElements();) { final String headerName = (String) e.nextElement(); final String requestHeader = request.getHeader(headerName); if (requestHeader != null) { root.put(prefix + headerName, requestHeader); } } } @Override void resolveData(final HttpServletRequest request, final HttpServletResponse response, Map<String, ? extends Object> model, final SoyMapData root); void setPrefix(String prefix); String getPrefix(); }### Answer: @Test public void testResolverHeaders() throws Exception { final SoyMapData soyMapData = new SoyMapData(); final Vector<String> names = new Vector<String>(); names.add("name1"); names.add("name2"); final Vector<String> values = new Vector<String>(); values.add("value1"); values.add("value2"); final HttpServletRequest request = mock(HttpServletRequest.class); final HttpServletResponse response = mock(HttpServletResponse.class); final Enumeration e = mock(Enumeration.class); when(e.hasMoreElements()).thenReturn(false); when(request.getParameterNames()).thenReturn(e); when(request.getHeaderNames()).thenReturn(names.elements()); when(request.getHeader("name1")).thenReturn(values.get(0)); when(request.getHeader("name2")).thenReturn(values.get(1)); when(request.getCookies()).thenReturn(new Cookie[]{}); requestHeadersResolver.resolveData(request, response, Maps.<String, Object>newHashMap(), soyMapData); Assert.assertEquals("should not be value1", "value1", soyMapData.get("_request.header.name1").stringValue()); Assert.assertEquals("should not be value2", "value2", soyMapData.get("_request.header.name2").stringValue()); }
### Question: EmptyCompileTimeGlobalModelResolver implements CompileTimeGlobalModelResolver { public Optional<SoyMapData> resolveData() { return Optional.absent(); } Optional<SoyMapData> resolveData(); }### Answer: @Test public void notNull() throws Exception { Assert.assertNotNull("not null", defaultCompileTimeGlobalModelResolver.resolveData()); } @Test public void absent() throws Exception { Assert.assertFalse("should be absent", defaultCompileTimeGlobalModelResolver.resolveData().isPresent()); }
### Question: DefaultCompileTimeGlobalModelResolver implements CompileTimeGlobalModelResolver { @Override public Optional<SoyMapData> resolveData() { if (data == null \|\| data.isEmpty()) { return Optional.absent(); } return Optional.of(new SoyMapData(data)); } @Override Optional<SoyMapData> resolveData(); void setData(final Map data); void setProperties(final Properties properties); }### Answer: @Test public void defaultNotNull() throws Exception { Assert.assertNotNull("by default not null", defaultCompileTimeGlobalModelResolver.resolveData()); } @Test public void defaultAbsent() throws Exception { Assert.assertFalse("by default there is no data - returns absent", defaultCompileTimeGlobalModelResolver.resolveData().isPresent()); }
### Question: MD5HashFileGenerator implements HashFileGenerator, InitializingBean { public boolean isHotReloadMode() { return hotReloadMode; } void afterPropertiesSet(); @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(final Collection<URL> urls); static String getMD5Checksum(final InputStream is); void setHotReloadMode(boolean hotReloadMode); void setCacheMaxSize(int cacheMaxSize); void setExpireAfterWrite(int expireAfterWrite); void setExpireAfterWriteUnit(String expireAfterWriteUnit); boolean isHotReloadMode(); int getCacheMaxSize(); int getExpireAfterWrite(); String getExpireAfterWriteUnit(); }### Answer: @Test public void testDebugByDefault() throws Exception { Assert.assertFalse("debug should be off by default", hashFileGenerator.isHotReloadMode()); }
### Question: DefaultCompileTimeGlobalModelResolver implements CompileTimeGlobalModelResolver { public void setProperties(final Properties properties) { data = new HashMap(); for (final String propertyName : properties.stringPropertyNames()) { data.put(propertyName, properties.getProperty(propertyName)); } } @Override Optional<SoyMapData> resolveData(); void setData(final Map data); void setProperties(final Properties properties); }### Answer: @Test public void setProperties() throws Exception { final Properties properties = new Properties(); properties.setProperty("key1", "value1"); properties.setProperty("key2", "value2"); properties.setProperty("key3", "value3"); defaultCompileTimeGlobalModelResolver.setProperties(properties); Assert.assertEquals("after setting data - returns value1", "value1", defaultCompileTimeGlobalModelResolver.resolveData().get().get("key1").stringValue()); Assert.assertEquals("after setting data - returns value2", "value2", defaultCompileTimeGlobalModelResolver.resolveData().get().get("key2").stringValue()); Assert.assertEquals("after setting data - returns value3", "value3", defaultCompileTimeGlobalModelResolver.resolveData().get().get("key3").stringValue()); }
### Question: ClasspathTemplateFilesResolver implements TemplateFilesResolver, InitializingBean { public boolean isHotReloadMode() { return hotReloadMode; } @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(String templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); String getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); }### Answer: @Test public void defaultDebugFlag() throws Exception { Assert.assertFalse("debug flag should be off", templateFilesResolver.isHotReloadMode()); }
### Question: ClasspathTemplateFilesResolver implements TemplateFilesResolver, InitializingBean { public boolean isRecursive() { return recursive; } @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(String templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); String getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); }### Answer: @Test public void defaultRecursive() throws Exception { Assert.assertTrue("recursive template file resolution should be on", templateFilesResolver.isRecursive()); }
### Question: ClasspathTemplateFilesResolver implements TemplateFilesResolver, InitializingBean { public void setRecursive(boolean recursive) { this.recursive = recursive; } @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(String templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); String getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); }### Answer: @Test public void setRecursive() throws Exception { templateFilesResolver.setRecursive(false); Assert.assertFalse("recursive template file resolution should be off", templateFilesResolver.isRecursive()); }
### Question: ClasspathTemplateFilesResolver implements TemplateFilesResolver, InitializingBean { public String getTemplatesLocation() { return templatesLocation; } @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(String templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); String getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); }### Answer: @Test public void defaultTemplateLocation() throws Exception { Assert.assertNull("template file location should be null", new DefaultTemplateFilesResolver().getTemplatesLocation()); }
### Question: MD5HashFileGenerator implements HashFileGenerator, InitializingBean { public String getExpireAfterWriteUnit() { return expireAfterWriteUnit; } void afterPropertiesSet(); @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(final Collection<URL> urls); static String getMD5Checksum(final InputStream is); void setHotReloadMode(boolean hotReloadMode); void setCacheMaxSize(int cacheMaxSize); void setExpireAfterWrite(int expireAfterWrite); void setExpireAfterWriteUnit(String expireAfterWriteUnit); boolean isHotReloadMode(); int getCacheMaxSize(); int getExpireAfterWrite(); String getExpireAfterWriteUnit(); }### Answer: @Test public void testDefaultWriteExpireUnit() throws Exception { Assert.assertEquals("default write expire unit should be", "DAYS", hashFileGenerator.getExpireAfterWriteUnit()); }
### Question: DefaultTemplateFilesResolver implements TemplateFilesResolver, ServletContextAware, InitializingBean { public boolean isHotReloadMode() { return hotReloadMode; } DefaultTemplateFilesResolver(); @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(Resource templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); Resource getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); @Override void setServletContext(ServletContext servletContext); }### Answer: @Test public void defaultDebugFlag() throws Exception { Assert.assertFalse("debug flag should be off", defaultTemplateFilesResolver.isHotReloadMode()); }
### Question: DefaultTemplateFilesResolver implements TemplateFilesResolver, ServletContextAware, InitializingBean { public boolean isRecursive() { return recursive; } DefaultTemplateFilesResolver(); @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(Resource templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); Resource getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); @Override void setServletContext(ServletContext servletContext); }### Answer: @Test public void defaultRecursive() throws Exception { Assert.assertTrue("recursive template file resolution should be on", defaultTemplateFilesResolver.isRecursive()); }
### Question: DefaultTemplateFilesResolver implements TemplateFilesResolver, ServletContextAware, InitializingBean { public void setRecursive(boolean recursive) { this.recursive = recursive; } DefaultTemplateFilesResolver(); @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(Resource templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); Resource getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); @Override void setServletContext(ServletContext servletContext); }### Answer: @Test public void setRecursive() throws Exception { defaultTemplateFilesResolver.setRecursive(false); Assert.assertFalse("recursive template file resolution should be off", defaultTemplateFilesResolver.isRecursive()); }
### Question: DefaultTemplateFilesResolver implements TemplateFilesResolver, ServletContextAware, InitializingBean { public Resource getTemplatesLocation() { return templatesLocation; } DefaultTemplateFilesResolver(); @Override void afterPropertiesSet(); @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final @Nullable String templateFileName); void setTemplatesLocation(Resource templatesLocation); void setRecursive(boolean recursive); void setHotReloadMode(boolean hotReloadMode); Resource getTemplatesLocation(); boolean isRecursive(); boolean isHotReloadMode(); String getFilesExtension(); void setFilesExtension(String filesExtension); @Override void setServletContext(ServletContext servletContext); }### Answer: @Test public void defaultTemplateLocation() throws Exception { Assert.assertNull("template file location should be null", defaultTemplateFilesResolver.getTemplatesLocation()); }
### Question: EmptyTemplateFilesResolver implements TemplateFilesResolver { @Override public Collection<URL> resolve() throws IOException { return Collections.emptyList(); } @Override Collection<URL> resolve(); @Override Optional<URL> resolve(final String templateName); }### Answer: @Test public void nonNull() throws Exception { Assert.assertNotNull("should not be null", emptyTemplateFilesResolver.resolve()); } @Test public void testResolveMany() throws Exception { Assert.assertTrue("should be empty", emptyTemplateFilesResolver.resolve().isEmpty()); } @Test public void testResolveOne() throws Exception { Assert.assertFalse("should be absent", emptyTemplateFilesResolver.resolve("template").isPresent()); }
### Question: MD5HashFileGenerator implements HashFileGenerator, InitializingBean { public int getExpireAfterWrite() { return expireAfterWrite; } void afterPropertiesSet(); @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(final Collection<URL> urls); static String getMD5Checksum(final InputStream is); void setHotReloadMode(boolean hotReloadMode); void setCacheMaxSize(int cacheMaxSize); void setExpireAfterWrite(int expireAfterWrite); void setExpireAfterWriteUnit(String expireAfterWriteUnit); boolean isHotReloadMode(); int getCacheMaxSize(); int getExpireAfterWrite(); String getExpireAfterWriteUnit(); }### Answer: @Test public void testDefaultExpireTime() throws Exception { Assert.assertEquals("default expire in days is 1 day", 1, hashFileGenerator.getExpireAfterWrite()); }
### Question: DefaultSoyMsgBundleResolver implements SoyMsgBundleResolver { public boolean isHotReloadMode() { return hotReloadMode; } Optional<SoyMsgBundle> resolve(final Optional<Locale> locale); void setMessagesPath(final String messagesPath); void setHotReloadMode(final boolean hotReloadMode); void setFallbackToEnglish(boolean fallbackToEnglish); String getMessagesPath(); boolean isHotReloadMode(); boolean isFallbackToEnglish(); }### Answer: @Test public void defaultDebug() throws Exception { Assert.assertFalse("debug should be off", defaultSoyMsgBundleResolver.isHotReloadMode()); }
### Question: DefaultSoyMsgBundleResolver implements SoyMsgBundleResolver { public String getMessagesPath() { return messagesPath; } Optional<SoyMsgBundle> resolve(final Optional<Locale> locale); void setMessagesPath(final String messagesPath); void setHotReloadMode(final boolean hotReloadMode); void setFallbackToEnglish(boolean fallbackToEnglish); String getMessagesPath(); boolean isHotReloadMode(); boolean isFallbackToEnglish(); }### Answer: @Test public void defaultMessagesPath() throws Exception { Assert.assertEquals("default messages path", "messages", defaultSoyMsgBundleResolver.getMessagesPath()); }
### Question: DefaultSoyMsgBundleResolver implements SoyMsgBundleResolver { public boolean isFallbackToEnglish() { return fallbackToEnglish; } Optional<SoyMsgBundle> resolve(final Optional<Locale> locale); void setMessagesPath(final String messagesPath); void setHotReloadMode(final boolean hotReloadMode); void setFallbackToEnglish(boolean fallbackToEnglish); String getMessagesPath(); boolean isHotReloadMode(); boolean isFallbackToEnglish(); }### Answer: @Test public void defaultFallbackToEnglish() throws Exception { Assert.assertTrue("fallBack to English should be on", defaultSoyMsgBundleResolver.isFallbackToEnglish()); }
### Question: DefaultSoyMsgBundleResolver implements SoyMsgBundleResolver { public Optional<SoyMsgBundle> resolve(final Optional<Locale> locale) throws IOException { if (!locale.isPresent()) { return Optional.absent(); } synchronized (msgBundles) { SoyMsgBundle soyMsgBundle = null; if (isHotReloadModeOff()) { soyMsgBundle = msgBundles.get(locale.get()); } if (soyMsgBundle == null) { soyMsgBundle = createSoyMsgBundle(locale.get()); if (soyMsgBundle == null) { soyMsgBundle = createSoyMsgBundle(new Locale(locale.get().getLanguage())); } if (soyMsgBundle == null && fallbackToEnglish) { soyMsgBundle = createSoyMsgBundle(Locale.ENGLISH); } if (soyMsgBundle == null) { return Optional.absent(); } if (isHotReloadModeOff()) { msgBundles.put(locale.get(), soyMsgBundle); } } return Optional.fromNullable(soyMsgBundle); } } Optional<SoyMsgBundle> resolve(final Optional<Locale> locale); void setMessagesPath(final String messagesPath); void setHotReloadMode(final boolean hotReloadMode); void setFallbackToEnglish(boolean fallbackToEnglish); String getMessagesPath(); boolean isHotReloadMode(); boolean isFallbackToEnglish(); }### Answer: @Test public void resolveWithNoLocale() throws Exception { Assert.assertFalse("value should be absent", defaultSoyMsgBundleResolver.resolve(Optional.<Locale>absent()).isPresent()); } @Test public void resolveDefaultMessagePathValuePresent() throws Exception { final Optional<SoyMsgBundle> soyMsgBundleOptional = defaultSoyMsgBundleResolver.resolve(Optional.of(Locale.ENGLISH)); Assert.assertTrue("value should be present", soyMsgBundleOptional.isPresent()); } @Test public void resolveDefaultMessagePathNotNull() throws Exception { final Optional<SoyMsgBundle> soyMsgBundleOptional = defaultSoyMsgBundleResolver.resolve(Optional.of(Locale.ENGLISH)); Assert.assertNotNull("value should be present", soyMsgBundleOptional.get()); }
### Question: EmptySoyMsgBundleResolver implements SoyMsgBundleResolver { @Override public Optional<SoyMsgBundle> resolve(final Optional<Locale> locale) throws IOException { return Optional.absent(); } @Override Optional<SoyMsgBundle> resolve(final Optional<Locale> locale); }### Answer: @Test public void defaultNull() throws Exception { Assert.assertFalse(emptySoyMsgBundleResolver.resolve(null).isPresent()); } @Test public void defaultAbsent() throws Exception { Assert.assertFalse(emptySoyMsgBundleResolver.resolve(Optional.<Locale>absent()).isPresent()); } @Test public void localePassedIn() throws Exception { Assert.assertFalse(emptySoyMsgBundleResolver.resolve(Optional.of(Locale.GERMANY)).isPresent()); }
### Question: MD5HashFileGenerator implements HashFileGenerator, InitializingBean { public int getCacheMaxSize() { return cacheMaxSize; } void afterPropertiesSet(); @Override Optional<String> hash(final Optional<URL> url); @Override Optional<String> hashMulti(final Collection<URL> urls); static String getMD5Checksum(final InputStream is); void setHotReloadMode(boolean hotReloadMode); void setCacheMaxSize(int cacheMaxSize); void setExpireAfterWrite(int expireAfterWrite); void setExpireAfterWriteUnit(String expireAfterWriteUnit); boolean isHotReloadMode(); int getCacheMaxSize(); int getExpireAfterWrite(); String getExpireAfterWriteUnit(); }### Answer: @Test public void testDefaultMaxEntries() throws Exception { Assert.assertEquals("default cache size is 10000", 10000, hashFileGenerator.getCacheMaxSize()); }
### Question: Value implements Cloneable { @Nonnull public final T get() { return value; } protected Value(@Nonnull final T value); @Nonnull abstract Class<T> type(); @Nonnull final T get(); @Nonnull final W map( @Nonnull final Function<? super T, ? extends W> mapper); @SuppressWarnings({"CloneDoesntCallSuperClone", "unchecked"}) @Override final V clone(); @Override final String toString(); }### Answer: @Test public void shouldInternStringValues() { final String value = new String(new char[]{'a', 'b'}); assertThat(StringTestyValue.of(value).get(), is( sameInstance(StringTestyValue.of("ab").get()))); }
### Question: XProperties extends OrderedProperties { @Nonnull public static XProperties from(@Nonnull @NonNull final String absolutePath) throws IOException { final Resource resource = new PathMatchingResourcePatternResolver() .getResource(absolutePath); try (final InputStream in = resource.getInputStream()) { final XProperties xprops = new XProperties(); xprops.included.add(resource.getURI()); xprops.load(in); return xprops; } } XProperties(); XProperties(@Nonnull final Map<String, String> initial); @Nonnull static XProperties from(@Nonnull @NonNull final String absolutePath); void register(@Nonnull final String prefix, @Nonnull final Conversion<?, ? extends Exception> factory); @Override synchronized void load(@Nonnull final Reader reader); @Override synchronized void load(final InputStream inStream); @Nullable @Override String getProperty(final String key); @Nullable @Override synchronized Object get(final Object key); @Nullable T getObject(@Nonnull final String key); @Nullable @SuppressWarnings("unchecked") T getObjectOrDefault(@Nonnull final String key, @Nullable final T defaultValue); }### Answer: @Test public void shouldNoticeRecursiveInclude() throws IOException { thrown.expect(RecursiveIncludeException.class); thrown.expectMessage(containsString(format("%s/tweedle-dee.properties", pathPrefix))); XProperties.from(format("%s/tweedle-dee.properties", pathPrefix)); }
### Question: StackTraceFocuser implements Function<E, E> { @Nonnull public static Predicate<StackTraceElement> ignoreClassName(@Nonnull final Pattern className) { return frame -> className.matcher(frame.getClassName()).find(); } StackTraceFocuser(@Nonnull final Iterable<Predicate<StackTraceElement>> ignores); @SafeVarargs StackTraceFocuser(@Nonnull final Predicate<StackTraceElement> first, final Predicate<StackTraceElement>... rest); @Nonnull static StackTraceFocuser<E> ignoreClassNames( @Nonnull final List<Pattern> classNameIgnores); @Nonnull static StackTraceFocuser<E> ignoreJavaClasses(); @Override E apply(final E e); @Nonnull static Predicate<StackTraceElement> ignoreClassName(@Nonnull final Pattern className); @Nonnull static Predicate<StackTraceElement> ignoreMethodName(@Nonnull final Pattern methodName); @Nonnull static Predicate<StackTraceElement> ignoreFileName(@Nonnull final Pattern fileName); @Nonnull static Predicate<StackTraceElement> ignoreLineNumber(@Nonnull final Pattern lineNumber); }### Answer: @Test public void shouldIgnoreWithCustomClassName() { final Throwable x = new Throwable(); final StackTraceElement nonWindfola = new StackTraceElement("lotro.Bilbo", "smokes", "Bilbo.java", 5); x.setStackTrace(new StackTraceElement[]{ new StackTraceElement("windfola.Frodo", "lives", "Frodo.java", 3), nonWindfola}); assertFramesRemaining(x, new StackTraceFocuser<>(ignoreClassName(compile("^windfola\\."))), nonWindfola); }
### Question: StackTraceFocuser implements Function<E, E> { @Nonnull public static Predicate<StackTraceElement> ignoreMethodName(@Nonnull final Pattern methodName) { return frame -> methodName.matcher(frame.getMethodName()).find(); } StackTraceFocuser(@Nonnull final Iterable<Predicate<StackTraceElement>> ignores); @SafeVarargs StackTraceFocuser(@Nonnull final Predicate<StackTraceElement> first, final Predicate<StackTraceElement>... rest); @Nonnull static StackTraceFocuser<E> ignoreClassNames( @Nonnull final List<Pattern> classNameIgnores); @Nonnull static StackTraceFocuser<E> ignoreJavaClasses(); @Override E apply(final E e); @Nonnull static Predicate<StackTraceElement> ignoreClassName(@Nonnull final Pattern className); @Nonnull static Predicate<StackTraceElement> ignoreMethodName(@Nonnull final Pattern methodName); @Nonnull static Predicate<StackTraceElement> ignoreFileName(@Nonnull final Pattern fileName); @Nonnull static Predicate<StackTraceElement> ignoreLineNumber(@Nonnull final Pattern lineNumber); }### Answer: @Test public void shouldIgnoreWithCustomMethodName() { final Throwable x = new Throwable(); final StackTraceElement nonLives = new StackTraceElement("lotro.Bilbo", "smokes", "Bilbo.java", 5); x.setStackTrace(new StackTraceElement[]{ new StackTraceElement("windfola.Frodo", "lives", "Frodo.java", 3), nonLives}); assertFramesRemaining(x, new StackTraceFocuser<>(ignoreMethodName(compile("lives"))), nonLives); }
### Question: StackTraceFocuser implements Function<E, E> { @Nonnull public static Predicate<StackTraceElement> ignoreFileName(@Nonnull final Pattern fileName) { return frame -> fileName.matcher(frame.getFileName()).find(); } StackTraceFocuser(@Nonnull final Iterable<Predicate<StackTraceElement>> ignores); @SafeVarargs StackTraceFocuser(@Nonnull final Predicate<StackTraceElement> first, final Predicate<StackTraceElement>... rest); @Nonnull static StackTraceFocuser<E> ignoreClassNames( @Nonnull final List<Pattern> classNameIgnores); @Nonnull static StackTraceFocuser<E> ignoreJavaClasses(); @Override E apply(final E e); @Nonnull static Predicate<StackTraceElement> ignoreClassName(@Nonnull final Pattern className); @Nonnull static Predicate<StackTraceElement> ignoreMethodName(@Nonnull final Pattern methodName); @Nonnull static Predicate<StackTraceElement> ignoreFileName(@Nonnull final Pattern fileName); @Nonnull static Predicate<StackTraceElement> ignoreLineNumber(@Nonnull final Pattern lineNumber); }### Answer: @Test public void shouldIgnoreWithCustomFileName() { final Throwable x = new Throwable(); final StackTraceElement nonFrodo = new StackTraceElement("lotro.Bilbo", "smokes", "Bilbo.java", 5); x.setStackTrace(new StackTraceElement[]{ new StackTraceElement("windfola.Frodo", "lives", "Frodo.java", 3), nonFrodo}); assertFramesRemaining(x, new StackTraceFocuser<>(ignoreFileName(compile("Frodo\\.java"))), nonFrodo); }
### Question: StackTraceFocuser implements Function<E, E> { @Nonnull public static Predicate<StackTraceElement> ignoreLineNumber(@Nonnull final Pattern lineNumber) { return frame -> lineNumber.matcher(String.valueOf(frame.getLineNumber())).find(); } StackTraceFocuser(@Nonnull final Iterable<Predicate<StackTraceElement>> ignores); @SafeVarargs StackTraceFocuser(@Nonnull final Predicate<StackTraceElement> first, final Predicate<StackTraceElement>... rest); @Nonnull static StackTraceFocuser<E> ignoreClassNames( @Nonnull final List<Pattern> classNameIgnores); @Nonnull static StackTraceFocuser<E> ignoreJavaClasses(); @Override E apply(final E e); @Nonnull static Predicate<StackTraceElement> ignoreClassName(@Nonnull final Pattern className); @Nonnull static Predicate<StackTraceElement> ignoreMethodName(@Nonnull final Pattern methodName); @Nonnull static Predicate<StackTraceElement> ignoreFileName(@Nonnull final Pattern fileName); @Nonnull static Predicate<StackTraceElement> ignoreLineNumber(@Nonnull final Pattern lineNumber); }### Answer: @Test public void shouldIgnoreWithCustomLineNumber() { final Throwable x = new Throwable(); final StackTraceElement nonThree = new StackTraceElement("lotro.Bilbo", "smokes", "Bilbo.java", 5); x.setStackTrace(new StackTraceElement[]{ new StackTraceElement("windfola.Frodo", "lives", "Frodo.java", 3), nonThree}); assertFramesRemaining(x, new StackTraceFocuser<>(ignoreLineNumber(compile("3"))), nonThree); }
### Question: LinkedIterable implements Iterable<T> { @Nonnull public static <T> Iterable<T> over(@Nullable final T head, @Nonnull final Predicate<T> terminate, @Nonnull final Function<T, T> traverse) { return new LinkedIterable<>(head, terminate, traverse); } private LinkedIterable(final T head, final Predicate<T> terminate, final Function<T, T> traverse); @Nonnull static Iterable<T> over(@Nullable final T head, @Nonnull final Predicate<T> terminate, @Nonnull final Function<T, T> traverse); @Nonnull static Iterable<T> over(@Nonnull final Predicate<T> terminate, @Nonnull final Function<T, T> traverse); @Override Iterator<T> iterator(); @Override Spliterator<T> spliterator(); static final int SPLITERATOR_CHARACTERISTICS; }### Answer: @Test public void shouldHaveNone() { assertThat(over(Objects::isNull, identity()), is(emptyIterable())); } @Test public void shouldHaveOne() { assertThat(over(this, Objects::isNull, t -> null), is(contains(this))); } @Test public void shouldHaveMany() { final Predicate<Integer> terminate = t -> 3 == t; final Function<Integer, Integer> traverse = t -> t + 1; assertThat(over(0, terminate, traverse), contains(0, 1, 2)); }
### Question: XProperties extends OrderedProperties { @Override public synchronized void load(@Nonnull final Reader reader) throws IOException { final ResourcePatternResolver loader = new PathMatchingResourcePatternResolver(); try (final CharArrayWriter writer = new CharArrayWriter()) { try (final BufferedReader lines = new BufferedReader(reader)) { for (String line = lines.readLine(); null != line; line = lines.readLine()) { writer.append(line).append('\n'); final Matcher matcher = include.matcher(line); if (matcher.matches()) for (final String x : comma .split(substitutor.replace(matcher.group(1)))) for (final Resource resource : loader .getResources(x)) { final URI uri = resource.getURI(); if (!included.add(uri)) throw new RecursiveIncludeException(uri, included); try (final InputStream in = resource .getInputStream()) { load(in); } } } } super.load(new CharArrayReader(writer.toCharArray())); } included.clear(); } XProperties(); XProperties(@Nonnull final Map<String, String> initial); @Nonnull static XProperties from(@Nonnull @NonNull final String absolutePath); void register(@Nonnull final String prefix, @Nonnull final Conversion<?, ? extends Exception> factory); @Override synchronized void load(@Nonnull final Reader reader); @Override synchronized void load(final InputStream inStream); @Nullable @Override String getProperty(final String key); @Nullable @Override synchronized Object get(final Object key); @Nullable T getObject(@Nonnull final String key); @Nullable @SuppressWarnings("unchecked") T getObjectOrDefault(@Nonnull final String key, @Nullable final T defaultValue); }### Answer: @Test public void shouldThrowOnBadInclude() throws IOException { thrown.expect(FileNotFoundException.class); thrown.expectMessage(containsString("no-such-location")); xprops.load(new StringReader("#include no-such-location")); }
### Question: Converter { @Nonnull public <T> T convert(@Nonnull final Class<T> type, @Nonnull final String value) throws Exception { return convert(TypeToken.of(wrap(type)), value); } void register(@Nonnull final Class<T> type, @Nonnull final Conversion<T, ?> factory); void register(@Nonnull final TypeToken<T> type, @Nonnull final Conversion<T, ?> factory); void registerDate(@Nonnull final String pattern); @Nonnull T convert(@Nonnull final Class<T> type, @Nonnull final String value); @SuppressWarnings("unchecked") @Nonnull T convert(@Nonnull final TypeToken<T> type, @Nonnull final String value); @Nonnull Set<TypeToken<?>> registered(); }### Answer: @Test public void shouldConvertString() throws Exception { assertThat("bob", is(equalTo(converter.convert(String.class, "bob")))); } @Test public void shouldConvertRegistered() throws Exception { assertThat(Paths.get("/dev/null"), is(equalTo(converter.convert(Path.class, "/dev/null")))); } @Test public void shouldConvertWithValueOf() throws Exception { assertThat(3, is(equalTo(converter.convert(Integer.class, "3")))); } @Test public void shouldConvertWithOf() throws Exception { assertThat(UTC, is(equalTo(converter.convert(ZoneOffset.class, "Z")))); } @Test public void shouldConvertWithNew() throws Exception { assertThat(new File("/dev/null"), is(equalTo(converter.convert(File.class, "/dev/null")))); } @Test public void shouldConvertToResourceList() throws Exception { final String path = format("classpath:/%s.class", getClass().getName().replace('.', '/')); final List<Resource> resources = asList( new PathMatchingResourcePatternResolver().getResources(path)); assertThat(resources, is(equalTo(converter.convert(new TypeToken<List<Resource>>() { }, path)))); } @Test(expected = UnsupportedConversion.class) public void shouldThrowWhenUnsupported() throws Exception { converter.convert(Package.class, getClass().getPackage().getName()); }
### Question: Converter { public <T> void register(@Nonnull final Class<T> type, @Nonnull final Conversion<T, ?> factory) throws DuplicateConversion { register(TypeToken.of(type), factory); } void register(@Nonnull final Class<T> type, @Nonnull final Conversion<T, ?> factory); void register(@Nonnull final TypeToken<T> type, @Nonnull final Conversion<T, ?> factory); void registerDate(@Nonnull final String pattern); @Nonnull T convert(@Nonnull final Class<T> type, @Nonnull final String value); @SuppressWarnings("unchecked") @Nonnull T convert(@Nonnull final TypeToken<T> type, @Nonnull final String value); @Nonnull Set<TypeToken<?>> registered(); }### Answer: @Test(expected = DuplicateConversion.class) public void shouldThrowWhenDuplicate() { converter.register(Path.class, Paths::get); }
### Question: XProperties extends OrderedProperties { @Nullable @Override public synchronized Object get(final Object key) { final Object value = super.get(key); if (null == value \|\| !(value instanceof String)) return value; return substitutor.replace((String) value); } XProperties(); XProperties(@Nonnull final Map<String, String> initial); @Nonnull static XProperties from(@Nonnull @NonNull final String absolutePath); void register(@Nonnull final String prefix, @Nonnull final Conversion<?, ? extends Exception> factory); @Override synchronized void load(@Nonnull final Reader reader); @Override synchronized void load(final InputStream inStream); @Nullable @Override String getProperty(final String key); @Nullable @Override synchronized Object get(final Object key); @Nullable T getObject(@Nonnull final String key); @Nullable @SuppressWarnings("unchecked") T getObjectOrDefault(@Nonnull final String key, @Nullable final T defaultValue); }### Answer: @Test public void shouldReplaceGet() { xprops.setProperty("foo", "found"); xprops.setProperty("bar", "${foo}"); assertThat(xprops.get("bar"), is(equalTo((Object) "found"))); }
### Question: Gateway3DSecureActivity extends AppCompatActivity { String getExtraTitle() { Bundle extras = getIntent().getExtras(); if (extras != null) { return extras.getString(EXTRA_TITLE); } return null; } static final String EXTRA_HTML; static final String EXTRA_TITLE; static final String EXTRA_ACS_RESULT; }### Answer: @Test public void testGetExtraTitleReturnsNullIfMissing() { Intent testIntent = new Intent(); doReturn(testIntent).when(activity).getIntent(); String title = activity.getExtraTitle(); assertNull(title); } @Test public void testGetExtraTitleReturnsValueIfExists() { String expectedTitle = "My Title"; Intent testIntent = new Intent(); testIntent.putExtra(Gateway3DSecureActivity.EXTRA_TITLE, expectedTitle); doReturn(testIntent).when(activity).getIntent(); String title = activity.getExtraTitle(); assertEquals(expectedTitle, title); }
### Question: Gateway { public Gateway setMerchantId(String merchantId) { if (merchantId == null) { throw new IllegalArgumentException("Merchant ID may not be null"); } this.merchantId = merchantId; return this; } Gateway(); String getMerchantId(); Gateway setMerchantId(String merchantId); Region getRegion(); Gateway setRegion(Region region); void updateSession(String sessionId, String apiVersion, GatewayMap payload, GatewayCallback callback); Single<GatewayMap> updateSession(String sessionId, String apiVersion, GatewayMap payload); static void start3DSecureActivity(Activity activity, String html); static void start3DSecureActivity(Activity activity, String html, String title); static boolean handle3DSecureResult(int requestCode, int resultCode, Intent data, Gateway3DSecureCallback callback); static void requestGooglePayData(PaymentsClient paymentsClient, PaymentDataRequest request, Activity activity); static boolean handleGooglePayResult(int requestCode, int resultCode, Intent data, GatewayGooglePayCallback callback); }### Answer: @Test public void testSetMerchantIdThrowsExceptionIfNull() throws Exception { try { gateway.setMerchantId(null); fail("Null merchant ID should throw illegal argument exception"); } catch (Exception e) { assertTrue(e instanceof IllegalArgumentException); } } @Test public void setMerchantIdWorksAsExpected() throws Exception { gateway.setMerchantId("MERCHANT_ID"); assertEquals(gateway.merchantId, "MERCHANT_ID"); }
### Question: Gateway { public Gateway setRegion(Region region) { if (region == null) { throw new IllegalArgumentException("Region may not be null"); } this.region = region; return this; } Gateway(); String getMerchantId(); Gateway setMerchantId(String merchantId); Region getRegion(); Gateway setRegion(Region region); void updateSession(String sessionId, String apiVersion, GatewayMap payload, GatewayCallback callback); Single<GatewayMap> updateSession(String sessionId, String apiVersion, GatewayMap payload); static void start3DSecureActivity(Activity activity, String html); static void start3DSecureActivity(Activity activity, String html, String title); static boolean handle3DSecureResult(int requestCode, int resultCode, Intent data, Gateway3DSecureCallback callback); static void requestGooglePayData(PaymentsClient paymentsClient, PaymentDataRequest request, Activity activity); static boolean handleGooglePayResult(int requestCode, int resultCode, Intent data, GatewayGooglePayCallback callback); }### Answer: @Test public void testSetRegionThrowsExceptionIfNull() throws Exception { try { gateway.setRegion(null); fail("Null region should throw illegal argument exception"); } catch (Exception e) { assertTrue(e instanceof IllegalArgumentException); } } @Test public void testSetRegionWorksAsIntended() throws Exception { gateway.setRegion(Gateway.Region.ASIA_PACIFIC); assertEquals(Gateway.Region.ASIA_PACIFIC, gateway.region); }

Subsets and Splits

No community queries yet

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