Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
PageIndicators extends FrameLayout { void bindViewPager(@NonNull ViewPager viewPager) { viewPager.addOnPageChangeListener(pageChangeListener); viewPager.addOnAdapterChangeListener(adapterChangeListener); bindPagerAdapter(viewPager.getAdapter()); } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void bindViewPager() { TestViewPager viewPager = new TestViewPager(getApplicationContext()); indicators.bindViewPager(viewPager); viewPager.assertHasListeners(); viewPager.getAdapter().assertHasObservers(true); }
PageIndicators extends FrameLayout { void unbindViewPager(@NonNull ViewPager viewPager) { unbindPagerAdapter(viewPager.getAdapter()); viewPager.removeOnAdapterChangeListener(adapterChangeListener); viewPager.removeOnPageChangeListener(pageChangeListener); } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void unbindViewPager() { TestViewPager viewPager = new TestViewPager(getApplicationContext()); indicators.bindViewPager(viewPager); indicators.unbindViewPager(viewPager); viewPager.assertHasNoListeners(); viewPager.getAdapter().assertHasObservers(false); }
PageIndicators extends FrameLayout { void bindPagerAdapter(@Nullable PagerAdapter adapter) { if (adapter != null) { adapter.registerDataSetObserver(dataSetObserver); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void bindPagerAdapter() { TestPagerAdapter adapter = new TestPagerAdapter(); indicators.bindPagerAdapter(adapter); adapter.assertHasObservers(true); }
PageIndicators extends FrameLayout { void unbindPagerAdapter(@Nullable PagerAdapter adapter) { if (adapter != null) { adapter.unregisterDataSetObserver(dataSetObserver); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void unbindPagerAdapter() { TestPagerAdapter adapter = new TestPagerAdapter(); indicators.bindPagerAdapter(adapter); indicators.unbindPagerAdapter(adapter); adapter.assertHasObservers(false); }
PageIndicators extends FrameLayout { void setupPage(PageObserver observer) { int page = 0; if (viewPager != null) { page = viewPager.getCurrentItem(); } observer.onPageChanged(this, page); } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void setupPage() { TestViewPager viewPager = new TestViewPager(getApplicationContext()); indicators.setViewPager(viewPager); indicators.setupPage(pageObserverView); pageObserverView.assertChange(indicators, viewPager.getCurrentItem()); }
PageIndicators extends FrameLayout { void setupPageCount(PageCountObserver observer) { int pageCount = 0; if (viewPager != null) { PagerAdapter adapter = viewPager.getAdapter(); if (adapter != null) { pageCount = adapter.getCount(); } } observer.onPageCountChanged(this, pageCount); } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void setupPageCount() { TestViewPager viewPager = new TestViewPager(getApplicationContext()); indicators.setViewPager(viewPager); indicators.setupPageCount(pageObserverView); pageObserverView.assertChange(indicators, viewPager.getAdapter().getCount()); }
PageNumberView extends TextView implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @Override public void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count) { if (this.pageCount != count) { this.pageCount = count; updateText(); } } PageNumberView(Context context); PageNumberView(Context context, AttributeSet attrs); PageNumberView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageNumberView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); void setFormatLocalized(boolean formatLocalized); boolean getFormatLocalized(); void setTemplate(@Nullable String template); String getTemplate(); @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); }
@Test public void onPageCountChanged() { PageIndicators indicators = new PageIndicators(getApplicationContext()); pageNumberView.setTemplate("%d-%d"); pageNumberView.onPageChanged(indicators, 1); pageNumberView.onPageCountChanged(indicators, 2); pageNumberView.onPageCountChanged(indicators, 3); assertThat(pageNumberView.getText().toString(), is("2-3")); }
PageIndicators extends FrameLayout { @CallSuper public void registerObserver(@NonNull Observer observer) { observers.registerObserver(observer); if (observer instanceof PageObserver) { setupPage((PageObserver) observer); } if (observer instanceof PageCountObserver) { setupPageCount((PageCountObserver) observer); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void registerObserver() { TestViewPager viewPager = new TestViewPager(getApplicationContext()); indicators.setViewPager(viewPager); indicators.registerObserver(pageObserverView); assertThat(indicators.observers.pageObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageCountObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageStateObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageScrollObservers, hasItem(pageObserverView)); pageObserverView.assertChange(indicators, viewPager.getCurrentItem()); pageObserverView.assertChange(indicators, viewPager.getAdapter().getCount()); }
PageIndicators extends FrameLayout { @CallSuper public void unregisterObserver(@NonNull Observer observer) { observers.unregisterObserver(observer); } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void unregisterObserver() { indicators.registerObserver(pageObserverView); indicators.unregisterObserver(pageObserverView); assertThat(indicators.observers.pageObservers, empty()); assertThat(indicators.observers.pageCountObservers, empty()); assertThat(indicators.observers.pageStateObservers, empty()); assertThat(indicators.observers.pageScrollObservers, empty()); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { void registerObserver(PageIndicators.Observer observer) { if (observer != null) { if (observer instanceof PageIndicators.PageObserver) { pageObservers.add((PageIndicators.PageObserver) observer); } if (observer instanceof PageIndicators.PageCountObserver) { pageCountObservers.add((PageIndicators.PageCountObserver) observer); } if (observer instanceof PageIndicators.PageStateObserver) { pageStateObservers.add((PageIndicators.PageStateObserver) observer); } if (observer instanceof PageIndicators.PageScrollObserver) { pageScrollObservers.add((PageIndicators.PageScrollObserver) observer); } } } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void registerObserver() { observers.registerObserver(observer); assertThat(observers.pageObservers, hasItem(observer)); assertThat(observers.pageCountObservers, hasItem(observer)); assertThat(observers.pageStateObservers, hasItem(observer)); assertThat(observers.pageScrollObservers, hasItem(observer)); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { @SuppressWarnings("SuspiciousMethodCalls") void unregisterObserver(PageIndicators.Observer observer) { if (observer != null) { pageObservers.remove(observer); pageCountObservers.remove(observer); pageStateObservers.remove(observer); pageScrollObservers.remove(observer); } } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void unregisterObserver() { observers.registerObserver(observer); observers.unregisterObserver(observer); assertThat(observers.pageObservers, empty()); assertThat(observers.pageCountObservers, empty()); assertThat(observers.pageStateObservers, empty()); assertThat(observers.pageScrollObservers, empty()); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { void unregisterAllObservers() { pageObservers.clear(); pageCountObservers.clear(); pageStateObservers.clear(); pageScrollObservers.clear(); } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void unregisterAllObservers() { observers.registerObserver(observer); observers.registerObserver(new TestObserver()); observers.unregisterAllObservers(); assertThat(observers.pageObservers, empty()); assertThat(observers.pageCountObservers, empty()); assertThat(observers.pageStateObservers, empty()); assertThat(observers.pageScrollObservers, empty()); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { @Override public void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page) { for (PageIndicators.PageObserver observer : pageObservers) { observer.onPageChanged(indicators, page); } } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void onPageChanged() { TestObserver observer = new TestObserver(); observers.registerObserver(observer.pageObserver()); observers.registerObserver(this.observer); PageIndicators indicators = new PageIndicators(null); observers.onPageChanged(indicators, 42); observers.onPageChanged(indicators, 99); observer.assertChange(indicators, 42); observer.assertChange(indicators, 99); this.observer.assertChange(indicators, 42); this.observer.assertChange(indicators, 99); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { @Override public void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count) { for (PageIndicators.PageCountObserver observer : pageCountObservers) { observer.onPageCountChanged(indicators, count); } } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void onPageCountChanged() { TestObserver observer = new TestObserver(); observers.registerObserver(observer.pageCountObserver()); observers.registerObserver(this.observer); PageIndicators indicators = new PageIndicators(null); observers.onPageCountChanged(indicators, 42); observers.onPageCountChanged(indicators, 99); observer.assertChange(indicators, 42); observer.assertChange(indicators, 99); this.observer.assertChange(indicators, 42); this.observer.assertChange(indicators, 99); }
Observers implements PageIndicators.PageObserver, PageIndicators.PageCountObserver, PageIndicators.PageStateObserver, PageIndicators.PageScrollObserver { @Override public void onPageStateChanged(@NonNull PageIndicators indicators, @State int state) { for (PageIndicators.PageStateObserver observer : pageStateObservers) { observer.onPageStateChanged(indicators, state); } } @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); @Override void onPageStateChanged(@NonNull PageIndicators indicators, @State int state); @Override void onPageScrolled(@NonNull PageIndicators indicators, @IntRange(from = 0) int page, @FloatRange(from = 0, to = 1, toInclusive = false) float pageOffset); }
@Test public void onPageStateChanged() { TestObserver observer = new TestObserver(); observers.registerObserver(observer.pageStateObserver()); observers.registerObserver(this.observer); PageIndicators indicators = new PageIndicators(null); observers.onPageStateChanged(indicators, ViewPager.SCROLL_STATE_IDLE); observers.onPageStateChanged(indicators, ViewPager.SCROLL_STATE_DRAGGING); observers.onPageStateChanged(indicators, ViewPager.SCROLL_STATE_SETTLING); observer.assertChange(indicators, ViewPager.SCROLL_STATE_IDLE); observer.assertChange(indicators, ViewPager.SCROLL_STATE_DRAGGING); observer.assertChange(indicators, ViewPager.SCROLL_STATE_SETTLING); this.observer.assertChange(indicators, ViewPager.SCROLL_STATE_IDLE); this.observer.assertChange(indicators, ViewPager.SCROLL_STATE_DRAGGING); this.observer.assertChange(indicators, ViewPager.SCROLL_STATE_SETTLING); }
PageIndicatorView extends LinearLayout implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @Override @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) public Drawable getDividerDrawable() { Drawable divider = super.getDividerDrawable(); if (divider instanceof SpaceDrawable) { return null; } return divider; } PageIndicatorView(Context context); PageIndicatorView(Context context, AttributeSet attrs); @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) Drawable getDividerDrawable(); void setFillViewport(boolean fillViewport); boolean getFillViewport(); void setIndicator(@DrawableRes int resId); void setIndicator(@Nullable Drawable drawable); Drawable getIndicator(); void setIndicatorSpacing(@Dimension int spacing); @Dimension int getIndicatorSpacing(); void setIndicatorWidth(@IndicatorSize int width); @IndicatorSize int getIndicatorWidth(); void setIndicatorHeight(@IndicatorSize int height); @IndicatorSize int getIndicatorHeight(); @CallSuper @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @CallSuper @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); int getPage(); int getPageCount(); static final int INTRINSIC_SIZE; }
@Test public void getDividerDrawable_ignore_SpaceDrawable() { pageIndicatorView.setDividerDrawable(new SpaceDrawable(5)); assertThat(pageIndicatorView.getDividerDrawable(), nullValue()); } @Test public void getDividerDrawable_delegate_non_SpaceDrawable() { Drawable drawable = new ShapeDrawable(); pageIndicatorView.setDividerDrawable(drawable); assertThat(pageIndicatorView.getDividerDrawable(), is(drawable)); }
PageIndicatorView extends LinearLayout implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @CallSuper @Override public void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page) { if (this.page != page) { updatePageSelection(this.page, false); this.page = page; updatePageSelection(page, true); } } PageIndicatorView(Context context); PageIndicatorView(Context context, AttributeSet attrs); @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) Drawable getDividerDrawable(); void setFillViewport(boolean fillViewport); boolean getFillViewport(); void setIndicator(@DrawableRes int resId); void setIndicator(@Nullable Drawable drawable); Drawable getIndicator(); void setIndicatorSpacing(@Dimension int spacing); @Dimension int getIndicatorSpacing(); void setIndicatorWidth(@IndicatorSize int width); @IndicatorSize int getIndicatorWidth(); void setIndicatorHeight(@IndicatorSize int height); @IndicatorSize int getIndicatorHeight(); @CallSuper @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @CallSuper @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); int getPage(); int getPageCount(); static final int INTRINSIC_SIZE; }
@Test public void onPageChanged() { PageIndicators indicators = new PageIndicators(getApplicationContext()); pageIndicatorView.onPageCountChanged(indicators, 3); pageIndicatorView.onPageChanged(indicators, 1); pageIndicatorView.onPageChanged(indicators, 2); assertThat(pageIndicatorView.indicators[0].isSelected(), is(false)); assertThat(pageIndicatorView.indicators[1].isSelected(), is(false)); assertThat(pageIndicatorView.indicators[2].isSelected(), is(true)); }
PageIndicatorView extends LinearLayout implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @CallSuper @Override public void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count) { if (this.indicators.length != count) { removeAllViews(); View[] indicatorViews = new View[count]; for (int i = 0; i < count; i++) { indicatorViews[i] = new View(getContext()); addView(indicatorViews[i]); setIndicatorDrawable(indicatorViews[i], drawable, width, height); } this.indicators = indicatorViews; updatePageSelection(this.page, true); } } PageIndicatorView(Context context); PageIndicatorView(Context context, AttributeSet attrs); @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) Drawable getDividerDrawable(); void setFillViewport(boolean fillViewport); boolean getFillViewport(); void setIndicator(@DrawableRes int resId); void setIndicator(@Nullable Drawable drawable); Drawable getIndicator(); void setIndicatorSpacing(@Dimension int spacing); @Dimension int getIndicatorSpacing(); void setIndicatorWidth(@IndicatorSize int width); @IndicatorSize int getIndicatorWidth(); void setIndicatorHeight(@IndicatorSize int height); @IndicatorSize int getIndicatorHeight(); @CallSuper @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @CallSuper @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); int getPage(); int getPageCount(); static final int INTRINSIC_SIZE; }
@Test public void onPageCountChanged() { PageIndicators indicators = new PageIndicators(getApplicationContext()); pageIndicatorView.onPageChanged(indicators, 1); pageIndicatorView.onPageCountChanged(indicators, 2); pageIndicatorView.onPageCountChanged(indicators, 3); assertThat(pageIndicatorView.indicators.length, is(3)); assertThat(pageIndicatorView.indicators[1].isSelected(), is(true)); }
PageIndicatorView extends LinearLayout implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @VisibleForTesting static void setIndicatorDrawable(View view, Drawable drawable, int width, int height) { ViewGroup.LayoutParams params = view.getLayoutParams(); if (drawable != null) { Drawable.ConstantState state = drawable.getConstantState(); if (state != null) { drawable = state.newDrawable(); } params.width = getIndicatorSize(width, drawable.getIntrinsicWidth()); params.height = getIndicatorSize(height, drawable.getIntrinsicHeight()); } else { params.width = params.height = 0; } if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { view.setBackgroundDrawable(drawable); } else { view.setBackground(drawable); } } PageIndicatorView(Context context); PageIndicatorView(Context context, AttributeSet attrs); @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicatorView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) Drawable getDividerDrawable(); void setFillViewport(boolean fillViewport); boolean getFillViewport(); void setIndicator(@DrawableRes int resId); void setIndicator(@Nullable Drawable drawable); Drawable getIndicator(); void setIndicatorSpacing(@Dimension int spacing); @Dimension int getIndicatorSpacing(); void setIndicatorWidth(@IndicatorSize int width); @IndicatorSize int getIndicatorWidth(); void setIndicatorHeight(@IndicatorSize int height); @IndicatorSize int getIndicatorHeight(); @CallSuper @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @CallSuper @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); int getPage(); int getPageCount(); static final int INTRINSIC_SIZE; }
@Test public void setIndicatorDrawable_to_null() { View view = new View(getApplicationContext()); view.setLayoutParams(new ViewGroup.LayoutParams(-1, -1)); PageIndicatorView.setIndicatorDrawable(view, null, 1, 2); assertThat(view.getBackground(), nullValue()); assertThat(view.getLayoutParams().width, is(0)); assertThat(view.getLayoutParams().height, is(0)); } @Test public void setIndicatorDrawable_to_drawable() { View view = new View(getApplicationContext()); view.setLayoutParams(new ViewGroup.LayoutParams(-1, -1)); Drawable drawable = new SpaceDrawable(2); PageIndicatorView.setIndicatorDrawable(view, drawable, -1, 1); assertThat(view.getBackground(), is(drawable)); assertThat(view.getLayoutParams().width, is(2)); assertThat(view.getLayoutParams().height, is(1)); } @Test public void setIndicatorDrawable_to_new_drawable() { View view = new View(getApplicationContext()); view.setLayoutParams(new ViewGroup.LayoutParams(-1, -1)); TestDrawable drawable = new TestDrawable(new SpaceDrawable(2)); PageIndicatorView.setIndicatorDrawable(view, drawable, -1, 1); assertThat(view.getBackground(), is(drawable.drawable)); assertThat(view.getLayoutParams().width, is(2)); assertThat(view.getLayoutParams().height, is(1)); }
SpaceDrawable extends Drawable { @Override public void draw(@NonNull Canvas canvas) { } SpaceDrawable(int spacing); @Override int getIntrinsicWidth(); @Override int getIntrinsicHeight(); @Override void draw(@NonNull Canvas canvas); @Override void setAlpha(int alpha); @Override void setColorFilter(ColorFilter colorFilter); @Override int getOpacity(); }
@Test public void draw() { TestCanvas canvas = new TestCanvas(); drawable.draw(canvas); canvas.assertEmpty(); }
PriorityComparator implements Comparator<Object> { static <T> Iterable<T> prioritize(Iterable<T> iterable) { if (!PRIORITY_AVAILABLE) return iterable; ArrayList<T> list = new ArrayList<T>(); for (T value : iterable) list.add(value); Collections.sort(list, INSTANCE); return list; } private PriorityComparator(); @Override int compare(Object value1, Object value2); }
@Test public void testPrioritize() { assertThat(PriorityComparator.prioritize( asList(two, minus5, noPriority, zero, minus3, inheritedOne, zero, two)), contains(zero, zero, inheritedOne, two, two, noPriority, minus3, minus5)); }
TracerResolver { public static Tracer resolveTracer() { return resolveTracer(null); } static Tracer resolveTracer(); static Tracer resolveTracer(ClassLoader classloader); @Deprecated static void reload(); }
@Test public void testResolveFromFactoryHasHigherPriorityThanResolver() throws IOException { writeServiceFile(TracerFactory.class, Mocks.Prio0_TracerFactory.class); writeServiceFile(TracerResolver.class, Mocks.Prio1_TracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.ResolvedTracerFromFactory.class))); } @Test public void testResolverDisabled() throws IOException { try { System.setProperty("tracerresolver.disabled", "true"); writeServiceFile(TracerResolver.class, Mocks.MockTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(nullValue())); } finally { System.clearProperty("tracerresolver.disabled"); } } @Test public void testNothingRegistered() { assertThat(TracerResolver.resolveTracer(), is(nullValue())); } @Test public void testResolveTracer() throws IOException { writeServiceFile(TracerResolver.class, Mocks.MockTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.ResolvedTracer.class))); } @Test public void testResolveFallback() throws IOException { writeServiceFile(Tracer.class, Mocks.FallbackTracer.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.FallbackTracer.class))); } @Test public void testResolverBeatsFallback() throws IOException { writeServiceFile(Tracer.class, Mocks.FallbackTracer.class); writeServiceFile(TracerResolver.class, Mocks.MockTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.ResolvedTracer.class))); } @Test public void testFallbackWhenResolvingNull() throws IOException { writeServiceFile(Tracer.class, Mocks.FallbackTracer.class); writeServiceFile(TracerResolver.class, Mocks.NullTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.FallbackTracer.class))); } @Test public void testResolvingNullWithoutFallback() throws IOException { writeServiceFile(TracerResolver.class, Mocks.NullTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(nullValue())); } @Test public void testSkipResolverThrowingException() throws IOException { writeServiceFile(TracerResolver.class, Mocks.HighPriorityThrowingResolver.class, Mocks.MockTracerResolver.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.ResolvedTracer.class))); } @Test public void testResolveWithExistingGlobalTracer() throws IOException { writeServiceFile(TracerResolver.class, Mocks.MockTracerResolver.class, Mocks.NullTracerResolver.class); writeServiceFile(Tracer.class, Mocks.FallbackTracer.class); GlobalTracer.register(new MockTracer()); assertThat(TracerResolver.resolveTracer(), is(sameInstance(GlobalTracer.get()))); } @Test public void testResolveFromFactory() throws IOException { writeServiceFile(TracerFactory.class, Mocks.Prio0_TracerFactory.class); assertThat(TracerResolver.resolveTracer(), is(instanceOf(Mocks.ResolvedTracerFromFactory.class))); }
FileLister { public List<File> files() throws IOException { if (!sourceDirectory.exists()) { return ImmutableList.of(); } String includesStr = StringUtils.join(includes.iterator(), ","); String excludesStr = StringUtils.join(excludes.iterator(), ","); return FileUtils.getFiles(sourceDirectory, includesStr, excludesStr); } FileLister(File sourceDirectory, List<String> includes, List<String> excludes); List<File> files(); }
@Test public void testAllFiles() throws Exception { List<File> files = files(list("*.txt"), list()); assertFilesAre(files, "a.txt", "b.txt"); } @Test public void testExcludes() throws Exception { List<File> files = files(list("*.txt"), list("b.txt")); assertFilesAre(files, "a.txt"); } @Test public void testNoIncludesMeansNoFiles() throws Exception { List<File> files = files(list(), list()); assertFilesAre(files); } @Test public void testNonExistentDirectory() throws IOException { File doesnotexist = new File(tmpf.getRoot(), "doesnotexist"); FileLister fileLister = new FileLister(doesnotexist, list("*.txt"), list()); assertFilesAre(fileLister.files()); } @Test public void testRecursiveIncludes() throws Exception { List<File> files = files(list("**/*.txt"), list()); assertFilesAre(files, "a.txt", "b.txt", "subdir/c.txt"); } @Test public void testRecursiveIncludesAndExcludes() throws Exception { List<File> files = files(list("**c.txt")); assertFilesAre(files, "a.txt", "b.txt"); }
JSLintMojo extends AbstractMojo { public void setOptions(Map<String, String> options) { this.options.clear(); this.options.putAll(options); } void execute(); void setDefaultSourceFolder(File defaultSourceFolder); void setEncoding(String encoding); void setExcludes(List<String> excludes); void setFailOnError(boolean b); void setIncludes(List<String> includes); void setJslint(File jslintSource); void setOptions(Map<String, String> options); void setOutputFolder(File outputFolder); void setSkip(boolean skip); void setSourceFolders(List<File> sourceFolders); }
@Test public void testOptions() throws Exception { useGoodSource(); mojo.setOptions(ImmutableMap.of("sloppy", "false")); executeMojoExpectingFailure(); assertTrue(true); }
JSLintMojo extends AbstractMojo { @VisibleForTesting Map<String, String> getOptions() { return options; } void execute(); void setDefaultSourceFolder(File defaultSourceFolder); void setEncoding(String encoding); void setExcludes(List<String> excludes); void setFailOnError(boolean b); void setIncludes(List<String> includes); void setJslint(File jslintSource); void setOptions(Map<String, String> options); void setOutputFolder(File outputFolder); void setSkip(boolean skip); void setSourceFolders(List<File> sourceFolders); }
@Test public void testOptionsFromPom() { Map<String, String> options = mojo.getOptions(); assertThat(options.size(), is(2)); assertThat(options, hasEntry("es5", "true")); assertThat(options, hasEntry("sloppy", "true")); }
JUnitXmlResultFormatter implements ResultFormatter { public void setFile(File file) { this.file = file; } void begin(); void end(); void output(JSLintResult result); void setFile(File file); void setStdout(OutputStream defaultOutputStream); }
@Test public void testFileSetReallyIsFile() throws Exception { thrown.expect(BuildException.class); thrown.expectMessage("must be a directory"); JSLintResult result = aResult("foo.js"); formatter.setFile(folder.newFile("foo")); formatResult(result); } @Test public void testNormality() { formatter.setFile(folder.getRoot()); formatResult(aResult("foo.js")); File expected = new File(folder.getRoot(), "TEST-foo.js.xml"); assertTrue(expected.exists()); } @Test public void testReadOnlyFileBlowsUp() throws IOException { thrown.expect(BuildException.class); thrown.expectMessage(FileNotFoundException.class.getName()); File output = folder.newFile("TEST-foo.js.xml"); assertTrue(output.setReadOnly()); formatter.setFile(folder.getRoot()); formatResult(aResult("foo.js")); } @Test public void testNonAlphaNumericFilename() { formatter.setFile(folder.getRoot()); formatResult(aResult("a&b.js")); File expected = new File(folder.getRoot(), "TEST-a_b.js.xml"); assertTrue(expected.exists()); }
JSLint { public JSLintResult lint(String systemId, Reader reader) throws IOException { return lint(systemId, Util.readerToString(reader)); } JSLint(ContextFactory contextFactory, Function lintFunc); void addOption(Option o); void addOption(Option o, String arg); String getEdition(); JSLintResult lint(String systemId, Reader reader); JSLintResult lint(String systemId, String javaScript); String report(String javaScript); String report(String javaScript, boolean errorsOnly); void resetOptions(); }
@Test public void testAccurateColumnNumbers() { List<Issue> issues = lint("var foo = 1").getIssues(); assertIssues(issues, EXPECTED_SEMICOLON); assertThat(issues.get(0).getCharacter(), is(12)); } @Test public void testAccurateLineNumbers() { List<Issue> issues = lint("var foo = 1").getIssues(); assertIssues(issues, EXPECTED_SEMICOLON); assertThat(issues.get(0).getLine(), is(1)); } @Test public void testDataGlobals() throws Exception { JSLintResult result = lint("var foo = 12;"); assertThat(result.getIssues(), empty()); assertThat(result.getGlobals(), contains("foo")); } @Test public void testDataJsonness() throws Exception { JSLintResult result = lint("{\"a\":100}"); assertThat(result.getIssues(), empty()); assertTrue(result.isJson()); } @Test public void testEmptySource() throws Exception { JSLintResult result = lint(""); assertThat(result.getIssues(), empty()); } @Test public void testGlobalName() throws Exception { String src = "\nname = \"fred\";"; JSLintResult result = lint(src); assertThat(result.getIssues(), empty()); } @Test public void testLintReader() throws Exception { Reader reader = new StringReader("var foo = 1"); List<Issue> issues = lint(reader).getIssues(); assertIssues(issues, EXPECTED_SEMICOLON); } @Test public void testNoProblems() throws IOException { JSLintResult result = lint("var foo = 1;"); assertThat(result.getIssues(), empty()); } @Test public void testNullSource() throws Exception { JSLintResult result = lint((String) null); assertThat(result.getIssues(), empty()); } @Test public void testOneProblem() throws IOException { List<Issue> problems = lint("var foo = 1").getIssues(); assertIssues(problems, EXPECTED_SEMICOLON); } @Test public void testProperties() { JSLintResult result = lint("var obj = {\"a\": 1, \"b\": 42, 3: \"c\"};"); assertIssues(result.getIssues()); Set<String> properties = result.getProperties(); assertThat(properties, containsInAnyOrder("a", "b", "3")); } @Test public void testReportInResult() throws Exception { String html = lint("var foo = 42").getReport(); assertThat(html, containsString("<cite><address>")); assertThat(html, containsString(EXPECTED_SEMICOLON)); } @Test public void testUnableToContinue() throws Exception { List<Issue> issues = lint("\"").getIssues(); assertIssues(issues, "Unclosed string.", "Stopping. (100% scanned)."); }
JSLint { public String getEdition() { return (String) lintFunc.get("edition", lintFunc); } JSLint(ContextFactory contextFactory, Function lintFunc); void addOption(Option o); void addOption(Option o, String arg); String getEdition(); JSLintResult lint(String systemId, Reader reader); JSLintResult lint(String systemId, String javaScript); String report(String javaScript); String report(String javaScript, boolean errorsOnly); void resetOptions(); }
@Test public void testGetEdition() throws Exception { String edition = lint.getEdition(); assertThat(edition, is(notNullValue())); String dateRe = "^\\d\\d\\d\\d-\\d\\d-\\d\\d$"; assertTrue(edition + " matches " + dateRe, edition.matches(dateRe)); }
JSLint { public String report(String javaScript) { return report(javaScript, false); } JSLint(ContextFactory contextFactory, Function lintFunc); void addOption(Option o); void addOption(Option o, String arg); String getEdition(); JSLintResult lint(String systemId, Reader reader); JSLintResult lint(String systemId, String javaScript); String report(String javaScript); String report(String javaScript, boolean errorsOnly); void resetOptions(); }
@Test public void testReportErrorsOnly() throws Exception { String html = lint.report("var foo = 42", true); assertThat(html, containsString("<cite><address>")); assertThat(html, containsString(EXPECTED_SEMICOLON)); } @Test public void testReportFull() throws Exception { String html = lint.report("var foo = 42;"); assertThat(html, containsString("<dt>global</dt><dd>foo</dd>")); }
JSLint { public void resetOptions() { options.clear(); } JSLint(ContextFactory contextFactory, Function lintFunc); void addOption(Option o); void addOption(Option o, String arg); String getEdition(); JSLintResult lint(String systemId, Reader reader); JSLintResult lint(String systemId, String javaScript); String report(String javaScript); String report(String javaScript, boolean errorsOnly); void resetOptions(); }
@Test public void testResetOptions() throws Exception { String eval_js = "eval('1');"; lint.addOption(Option.EVIL); lint.resetOptions(); JSLintResult result = lint(eval_js); assertIssues(result.getIssues(), "eval is evil."); }
JSLintXmlFormatter extends XmlFormatter implements JSLintResultFormatter { public String format(JSLintResult result) { StringBuilder sb = new StringBuilder("<file"); sb.append(attr("name", result.getName())); sb.append(">" + NEWLINE); List<Issue> issues = result.getIssues(); for (Issue issue : issues) { sb.append("<issue"); sb.append(attr("line", Integer.toString(issue.getLine()))); sb.append(attr("char", Integer.toString(issue.getCharacter()))); sb.append(attr("reason", issue.getReason())); sb.append(attr("evidence", issue.getEvidence())); sb.append("/>" + NEWLINE); } sb.append("</file>"); return sb.toString(); } String format(JSLintResult result); }
@Test public void testNoOutput() throws Exception { JSLintResult result = new JSLintResult.ResultBuilder("good.js").build(); String expected = "<file name='good.js'/>"; String actual = form.format(result); XMLAssert.assertXMLEqual(expected, actual); XMLAssert.assertXMLValid(getValidatorFor(actual)); } @Test public void testOneIssue() throws Exception { String name = "bad.js"; Issue issue = new Issue.IssueBuilder(name, 1, 1, "too many goats teleported").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).addIssue(issue).build(); String expected = "<file name='bad.js'>" + "<issue line='1' char='1' reason='too many goats teleported' evidence='' />" + "</file>"; String actual = form.format(result); XMLAssert.assertXMLEqual(expected, actual); XMLAssert.assertXMLValid(getValidatorFor(actual)); }
CheckstyleXmlFormatter extends XmlFormatter implements JSLintResultFormatter { public String format(JSLintResult result) { StringBuilder sb = new StringBuilder("<file"); sb.append(attr("name", result.getName())); sb.append(">\n"); for (Issue issue : result.getIssues()) { sb.append("<error"); sb.append(attr("line", Integer.toString(issue.getLine()))); sb.append(attr("column", Integer.toString(issue.getCharacter()))); sb.append(attr("severity", "warning")); sb.append(attr("message", issue.getReason())); sb.append(attr("source", JSLint.class.getName())); sb.append("/>\n"); } sb.append("</file>"); return sb.toString(); } String format(JSLintResult result); }
@Test public void shouldHaveNoProblems() throws Exception { JSLintResult result = new JSLintResult.ResultBuilder("hello.js").duration(0).build(); String expected = "<file name=\"hello.js\" />"; XMLAssert.assertXMLEqual(expected, form.format(result)); } @Test public void shouldHaveOneProblem() throws Exception { String name = "bad.js"; Issue issue = new Issue.IssueBuilder(name, 1, 1, "this is not a daffodil").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).addIssue(issue).build(); String expected = "<file name=\"bad.js\">" + "<error line='1' column='1' severity='warning' message='this is not a daffodil'" + " source='com.googlecode.jslint4java.JSLint' />" + "</file>"; XMLAssert.assertXMLEqual(expected, form.format(result)); }
JUnitXmlFormatter extends XmlFormatter implements JSLintResultFormatter { public String format(JSLintResult result) { StringBuilder sb = new StringBuilder("<testsuite"); List<Issue> issues = result.getIssues(); String testFailures = issues.isEmpty() ? "0" : "1"; sb.append(attr("failures", testFailures)); sb.append(attr("time", formatTimeAsSeconds(result.getDuration()))); sb.append(attr("skipped", "0")); sb.append(attr("errors", testFailures)); sb.append(attr("tests", "1")); sb.append(attr("name", result.getName())); sb.append(">"); sb.append("<testcase"); sb.append(attr("time", formatTimeAsSeconds(result.getDuration()))); sb.append(attr("classname", TEST_CLASSNAME)); sb.append(attr("name", result.getName())); sb.append(">"); if (!issues.isEmpty()) { sb.append("<failure"); String msg = String.format("Found %d problem%s", issues.size(), s(issues.size())); sb.append(attr("message", msg)); sb.append(attr("type", AssertionError.class.getName())); sb.append(">"); for (Issue issue : issues) { sb.append(escape(issue.toString())); sb.append(System.getProperty("line.separator")); } sb.append("</failure>"); } sb.append("</testcase>"); sb.append("</testsuite>"); return sb.toString(); } String format(JSLintResult result); }
@Test public void testEscaping() throws Exception { String expected = "<testsuite failures=\"1\" time=\"0.000\" errors=\"1\" skipped=\"0\" " + "tests=\"1\" name=\"&quot;a&amp;b&apos;.js\">" + "<testcase time=\"0.000\" classname=\"com.googlecode.jslint4java\" " + "name=\"&quot;a&amp;b&apos;.js\">" + "<failure message=\"Found 1 problem\" type=\"java.lang.AssertionError\">" + "\"a&amp;b'.js:1:1:I&lt;&amp;&gt;Like&lt;angle&gt;&gt;\"brackets'\n" + "</failure>" + "</testcase>" + "</testsuite>"; String name = "\"a&b\'.js"; Issue issue = new Issue.IssueBuilder(name, 1, 1, "I<&>Like<angle>>\"brackets\'").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).duration(0).addIssue(issue) .build(); XMLAssert.assertXMLEqual(expected, form.format(result)); } @Test public void testNoProblems() throws Exception { String expected = "<testsuite failures=\"0\" time=\"0.000\" errors=\"0\" skipped=\"0\" " + "tests=\"1\" name=\"hello.js\">" + "<testcase time=\"0.000\" classname=\"com.googlecode.jslint4java\" name=\"hello.js\" />" + "</testsuite>"; JSLintResult result = new JSLintResult.ResultBuilder("hello.js").duration(0).build(); XMLAssert.assertXMLEqual(expected, form.format(result)); } @Test public void testOneProblem() throws Exception { String expected = "<testsuite failures=\"1\" time=\"0.000\" errors=\"1\" skipped=\"0\" " + "tests=\"1\" name=\"hello.js\">" + "<testcase time=\"0.000\" classname=\"com.googlecode.jslint4java\" name=\"hello.js\">" + "<failure message=\"Found 1 problem\" type=\"java.lang.AssertionError\">" + "hello.js:1:1:too many aardvarks\n" + "</failure>" + "</testcase>" + "</testsuite>"; String name = "hello.js"; Issue issue = new Issue.IssueBuilder(name, 1, 1, "too many aardvarks").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).duration(0).addIssue(issue) .build(); XMLAssert.assertXMLEqual(expected, form.format(result)); } @Test public void testTwoProblems() throws Exception { String expected = "<testsuite failures=\"1\" time=\"0.000\" errors=\"1\" skipped=\"0\" " + "tests=\"1\" name=\"hello.js\">" + "<testcase time=\"0.000\" classname=\"com.googlecode.jslint4java\" name=\"hello.js\">" + "<failure message=\"Found 2 problems\" type=\"java.lang.AssertionError\">" + "hello.js:1:1:too many aardvarks\n" + "hello.js:1:2:too few aardvarks\n" + "</failure>" + "</testcase>" + "</testsuite>"; String name = "hello.js"; Issue issue1 = new Issue.IssueBuilder(name, 1, 1, "too many aardvarks").build(); Issue issue2 = new Issue.IssueBuilder(name, 1, 2, "too few aardvarks").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).duration(0).addIssue(issue1) .addIssue(issue2).build(); XMLAssert.assertXMLEqual(expected, form.format(result)); }
XmlFormatter { protected String escape(String str) { if (str == null) return ""; return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"); } String footer(); String header(); }
@Test public void testEscapeNull() throws Exception { assertThat(xf.escape(null), is("")); } @Test public void testEscape() throws Exception { assertThat(xf.escape("echo '<usage>' 2>&1"), is("echo '&lt;usage&gt;' 2&gt;&amp;1")); }
XmlFormatter { protected String attr(String key, String value) { if (key == null) throw new IllegalArgumentException("key cannot be null"); if (value == null) { value = ""; } StringBuilder sb = new StringBuilder(' '); sb.append(' '); sb.append(escapeAttr(key)); sb.append("='"); sb.append(escapeAttr(value)); sb.append("'"); return sb.toString(); } String footer(); String header(); }
@Test public void testAttrKeyIsNull() throws Exception { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("key cannot be null"); xf.attr(null, "foo"); } @Test public void testAttrValueIsNull() throws Exception { assertThat(xf.attr("foo", null), is(" foo=''")); } @Test public void testAttr() throws Exception { assertThat(xf.attr("foo", "bar"), is(" foo='bar'")); } @Test public void testAttrEscape() throws Exception { assertThat(xf.attr("foo", "\"'<&>"), is(" foo='&quot;&apos;&lt;&amp;&gt;'")); }
PlainFormatter implements JSLintResultFormatter { public String format(JSLintResult result) { StringBuilder sb = new StringBuilder(); for (Issue issue : result.getIssues()) { sb.append(outputOneIssue(issue)); } return sb.toString(); } String footer(); String format(JSLintResult result); String header(); }
@Test public void shouldCopeWithCharacterZero() throws Exception { String nl = System.getProperty("line.separator"); String name = "foo/bar.js"; Issue issue = new IssueBuilder(name, 0, 0, "oops").evidence("BANG").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).addIssue(issue).build(); StringBuilder sb = new StringBuilder(name); sb.append(":0:0: oops").append(nl); sb.append("BANG").append(nl); sb.append("^").append(nl); assertThat(rf.format(result), is(sb.toString())); } @Test public void testExpectedOutputNoIssues() { JSLintResult result = new JSLintResult.ResultBuilder("foo/bar.js").build(); String out = rf.format(result); assertThat(out, is("")); } @Test public void testExpectedOutputOneIssue() { String nl = System.getProperty("line.separator"); String name = "foo/bar.js"; Issue issue = new IssueBuilder(name, 1, 2, "no clucking").evidence("cluck()").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).addIssue(issue).build(); StringBuilder sb = new StringBuilder(name); sb.append(":1:2: no clucking").append(nl); sb.append("cluck()").append(nl); sb.append(" ^").append(nl); assertThat(rf.format(result), is(sb.toString())); } @Test public void testNoEvidence() throws Exception { String nl = System.getProperty("line.separator"); String name = "foo/bar.js"; Issue issue = new IssueBuilder(name, 1, 1, "fatality").build(); JSLintResult result = new JSLintResult.ResultBuilder(name).addIssue(issue).build(); StringBuilder sb = new StringBuilder(name); sb.append(":1:1: fatality"); sb.append(nl); assertThat(rf.format(result), is(sb.toString())); }
PlainFormatter implements JSLintResultFormatter { public String footer() { return null; } String footer(); String format(JSLintResult result); String header(); }
@Test public void shouldEmitNullFooter() { assertThat(rf.footer(), is(nullValue())); }
PlainFormatter implements JSLintResultFormatter { public String header() { return null; } String footer(); String format(JSLintResult result); String header(); }
@Test public void shouldEmitNullHeader() { assertThat(rf.header(), is(nullValue())); }
ReportFormatter extends XmlFormatter implements JSLintResultFormatter { @Override public String footer() { return "</body></html>"; } @Override String footer(); String format(JSLintResult result); @Override String header(); }
@Test public void shouldHaveHtmlFooter() { assertThat(form.footer(), is("</body></html>")); }
ReportFormatter extends XmlFormatter implements JSLintResultFormatter { @Override public String header() { return "<html><head></head><body>"; } @Override String footer(); String format(JSLintResult result); @Override String header(); }
@Test public void shouldHaveHtmlHeader() { assertThat(form.header(), is("<html><head></head><body>")); }
ReportFormatter extends XmlFormatter implements JSLintResultFormatter { public String format(JSLintResult result) { String name = result.getName(); StringBuilder sb = new StringBuilder(); sb.append("<div class='file'>"); sb.append("<h1"); sb.append(attr("id", name)); sb.append(">"); sb.append(escape(name)); sb.append("</h1>"); sb.append(result.getReport()); sb.append("</div>"); sb.append("</div>"); return sb.toString(); } @Override String footer(); String format(JSLintResult result); @Override String header(); }
@Test public void testEscaping() throws Exception { JSLintResult result = mockResult("'a<b&c>d\".js"); String expected = "<h1 id='&apos;a&lt;b&amp;c&gt;d&quot;.js'>'a&lt;b&amp;c&gt;d\".js</h1>"; assertThat(form.format(result).contains(expected), is(true)); } @Test public void testOutput() throws Exception { JSLintResult result = mockResult("foo.js"); String expected = "<div class='file'>" + "<h1 id='foo.js'>foo.js</h1>" + "<div>undefined cat: schrodinger</div>" + "</div>"; XMLUnit.compareXML(expected, form.format(result)); }
OptionParser { public <T> T parse(Class<T> clazz, String value) { try { Method method = clazz.getMethod("valueOf", String.class); @SuppressWarnings("unchecked") T rv = (T) method.invoke(null, value); return rv; } catch (NoSuchMethodException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } catch (InvocationTargetException e) { Throwable cause = e.getCause(); if (cause instanceof RuntimeException) { throw (RuntimeException) cause; } else { throw new RuntimeException(cause); } } } T parse(Class<T> clazz, String value); }
@Test public void testNoSuchMethod() throws Exception { thrown.expect(RuntimeException.class); thrown.expectCause(CoreMatchers.<Throwable>instanceOf(NoSuchMethodException.class)); thrown.expectMessage("System.valueOf"); optionParser.parse(System.class, "foo"); } @Test public void testParseBoolean() throws Exception { assertThat(optionParser.parse(Boolean.class, "true"), is(Boolean.TRUE)); } @Test public void testParseInteger() throws Exception { assertThat(optionParser.parse(Integer.class, "2"), is(2)); } @Test public void testParseIntegerFailure() throws Exception { thrown.expect(NumberFormatException.class); optionParser.parse(Integer.class, "foo"); } @Test public void testRuntimeExceptionWrapping() throws Exception { thrown.expect(RuntimeException.class); thrown.expectCause(CoreMatchers.<Throwable>instanceOf(IOException.class)); thrown.expectMessage("IOException: burble"); optionParser.parse(Foo.class, "foo"); }
Issue { @Override public String toString() { return getSystemId() + ":" + getLine() + ":" + getCharacter() + ":" + getReason(); } private Issue(IssueBuilder ib); int getCharacter(); String getEvidence(); int getLine(); String getRaw(); String getReason(); String getSystemId(); @Override String toString(); }
@Test public void testToString() { Issue issue = new IssueBuilder("foo.js", 1, 1, "you broke it").build(); assertThat(issue.toString(), is("foo.js:1:1:you broke it")); }
Util { static boolean booleanValue(String name, Scriptable scope) { Object val = scope.get(name, scope); if (val == UniqueTag.NOT_FOUND) { return false; } else { return Context.toBoolean(val); } } private Util(); }
@Test public void testBooleanTrue() throws Exception { cx.evaluateString(scope, "var ok = true;", "-", 1, null); assertThat(Util.booleanValue("ok", scope), is(true)); } @Test public void testBooleanFalse() throws Exception { cx.evaluateString(scope, "var ok = false;", "-", 1, null); assertThat(Util.booleanValue("ok", scope), is(false)); } @Test public void testBooleanUndefined() throws Exception { cx.evaluateString(scope, "var ok;", "-", 1, null); assertThat(Util.booleanValue("ok", scope), is(false)); }
Util { static int intValue(String name, Scriptable scope) { if (scope == null) { return 0; } Object o = scope.get(name, scope); return o == Scriptable.NOT_FOUND ? 0 : (int) Context.toNumber(o); } private Util(); }
@Test public void testIntValueFromJava() throws Exception { scope.put("foo", scope, 42); assertThat(Util.intValue("foo", scope), is(42)); } @Test public void testIntValueFromJavaScript() throws Exception { cx.evaluateString(scope, "var foo = 42", "-", 1, null); assertThat(Util.intValue("foo", scope), is(42)); } @Test public void testIntValueNullScope() throws Exception { assertThat(Util.intValue("foo", null), is(0)); } @Test public void testIntValueOfUndefined() { cx.evaluateString(scope, "var foo;", "-", 1, null); assertThat(Util.intValue("foo", scope), is(0)); }
JSLintMojo extends AbstractMojo { public void execute() throws MojoExecutionException, MojoFailureException { if (skip) { getLog().info("skipping JSLint"); return; } JSLint jsLint = applyJSlintSource(); applyDefaults(); applyOptions(jsLint); List<File> files = getFilesToProcess(); int failures = 0; ReportWriter reporter = makeReportWriter(); try { reporter.open(); for (File file : files) { JSLintResult result = lintFile(jsLint, file); failures += result.getIssues().size(); logIssues(result, reporter); } } finally { reporter.close(); } if (failures > 0) { String message = "JSLint found " + failures + " problems in " + files.size() + " files"; if (failOnError) { throw new MojoFailureException(message); } else { getLog().info(message); } } } void execute(); void setDefaultSourceFolder(File defaultSourceFolder); void setEncoding(String encoding); void setExcludes(List<String> excludes); void setFailOnError(boolean b); void setIncludes(List<String> includes); void setJslint(File jslintSource); void setOptions(Map<String, String> options); void setOutputFolder(File outputFolder); void setSkip(boolean skip); void setSourceFolders(List<File> sourceFolders); }
@Test public void testBasics() throws Exception { useGoodSource(); mojo.execute(); } @Test public void testLogToFileContents() throws Exception { useGoodSource(); mojo.execute(); File report = assertFileExists("jslint.xml"); Matcher m = Pattern.compile("<file\\s").matcher(readFile(report)); assertTrue("found first <file", m.find()); assertTrue("found second <file", m.find()); assertFalse("no more <file", m.find()); } @Test public void testLogToFileOnSuccess() throws Exception { useGoodSource(); mojo.execute(); assertFileExists("jslint.xml"); }
Util { static Object javaToJS(Object o, Scriptable scope) { Class<?> cls = o.getClass(); if (cls.isArray()) { return new NativeArray((Object[]) o); } else { return Context.javaToJS(o, scope); } } private Util(); }
@Test public void testJavaToJS_JSArrays() { String[] ary = new String[] { "a", "b" }; Object result = Util.javaToJS(ary, scope); assertThat(result, instanceOf(NativeArray.class)); NativeArray nAry = (NativeArray) result; assertThat(nAry.getLength(), is(2L)); assertThat(nAry.get(0, nAry), is((Object)"a")); assertThat(nAry.get(1, nAry), is((Object)"b")); }
Util { static <T> List<T> listValue(String name, Scriptable scope, Converter<T> c) { Object val = scope.get(name, scope); if (val == UniqueTag.NOT_FOUND || val instanceof Undefined) { return new ArrayList<T>(); } Scriptable ary = (Scriptable) val; int count = intValue("length", ary); List<T> list = new ArrayList<T>(count); for (int i = 0; i < count; i++) { list.add(c.convert(ary.get(i, ary))); } return list; } private Util(); }
@Test public void testListValueOfObject() throws Exception { cx.evaluateString(scope, "var l = [{'a':1}, {'a':2}];", "-", 1, null); Util.Converter<Foo> c = new Converter<Foo>() { public Foo convert(Object obj) { Scriptable scope = (Scriptable) obj; return new Foo((int)Context.toNumber(scope.get("a", scope))); } }; List<Foo> l = Util.listValue("l", scope, c); assertThat(l, contains(new Foo(1), new Foo(2))); } @Test public void testListValueWithNull() throws Exception { List<Void> l = Util.listValue("foo", scope, new Converter<Void>() { public Void convert(Object obj) { return null; } }); assertThat(l, empty()); }
Util { static <T> List<T> listValueOfType(String name, Class<T> class1, Scriptable scope) { return listValue(name, scope, new Converter<T>() { public T convert(Object obj) { @SuppressWarnings("unchecked") T value = (T) obj; return value; } }); } private Util(); }
@Test public void testListValueOfTypeInteger() throws Exception { cx.evaluateString(scope, "var l = [9,8,7];", "-", 1, null); List<Integer> l = Util.listValueOfType("l", Integer.class, scope); assertThat(l, contains(9, 8, 7)); } @Test public void testListValueOfTypeString() throws Exception { cx.evaluateString(scope, "var l = ['a','b','c'];", "-", 1, null); List<String> l = Util.listValueOfType("l", String.class, scope); assertThat(l, contains("a", "b", "c")); } @Test public void testListValueOfNull() throws Exception { cx.evaluateString(scope, "var l = [null];", "-", 1, null); List<String> l = Util.listValueOfType("l", String.class, scope); assertThat(l, contains(nullValue())); } @Test public void testListValueOfUndefined() throws Exception { cx.evaluateString(scope, "var undef;", "-", 1, null); List<String> l = Util.listValueOfType("undef", String.class, scope); assertThat(l, empty()); }
Util { static String readerToString(Reader reader) throws IOException { StringBuffer sb = new StringBuffer(); int c; while ((c = reader.read()) != -1) { sb.append((char) c); } return sb.toString(); } private Util(); }
@Test public void testReaderToString() throws Exception { StringReader reader = CharStreams.newReaderSupplier("foo bar").getInput(); assertThat(Util.readerToString(reader), is("foo bar")); }
Util { static String stringValue(String name, Scriptable scope) { if (scope == null) { return null; } Object o = scope.get(name, scope); return o instanceof String ? (String) o : null; } private Util(); }
@Test public void testStringValueFromJava() throws Exception { scope.put("foo", scope, "bar"); assertThat(Util.stringValue("foo", scope), is("bar")); } @Test public void testStringValueFromJavaScript() throws Exception { cx.evaluateString(scope, "var foo = 'bar'", "-", 1, null); assertThat(Util.stringValue("foo", scope), is("bar")); } @Test public void testStringValueNullScope() throws Exception { assertThat(Util.stringValue("foo", null), is(nullValue())); } @Test public void testStringValueOfUndefined() { cx.evaluateString(scope, "var foo;", "-", 1, null); assertThat(Util.stringValue("foo", scope), is(nullValue())); }
JSLintMojo extends AbstractMojo { @VisibleForTesting String getEncoding() { return encoding; } void execute(); void setDefaultSourceFolder(File defaultSourceFolder); void setEncoding(String encoding); void setExcludes(List<String> excludes); void setFailOnError(boolean b); void setIncludes(List<String> includes); void setJslint(File jslintSource); void setOptions(Map<String, String> options); void setOutputFolder(File outputFolder); void setSkip(boolean skip); void setSourceFolders(List<File> sourceFolders); }
@Test public void testDefaultEncoding() { assertEquals("UTF-8", mojo.getEncoding()); }
UnicodeBomInputStream extends InputStream { public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } UnicodeBomInputStream(final InputStream inputStream); final BOM getBOM(); final synchronized UnicodeBomInputStream skipBOM(); @Override int read(); @Override int read(final byte b[]); @Override int read(final byte b[], final int off, final int len); @Override long skip(final long n); @Override int available(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override synchronized void reset(); @Override boolean markSupported(); }
@Test public void basicSanityFromResourceReader() throws Exception { UnicodeBomInputStream is2 = new UnicodeBomInputStream(getBomJs()); is2.skipBOM(); String s = CharStreams.toString(new InputStreamReader(is2, Charsets.UTF_8)); String nl = System.getProperty("line.separator"); assertThat(s, is(" } @Test public void canLintWithBom() throws Exception { UnicodeBomInputStream is2 = new UnicodeBomInputStream(getBomJs()); is2.skipBOM(); InputStreamReader isr = new InputStreamReader(is2, Charsets.UTF_8); JSLint jsLint = new JSLintBuilder().fromDefault(); jsLint.addOption(Option.PREDEF, "alert"); JSLintResult result = jsLint.lint("bom.js", isr); assertThat(result.getIssues(), empty()); }
JSLintBuilder { public JSLint fromClasspathResource(String resource) throws IOException { return fromClasspathResource(resource, UTF8); } JSLint fromClasspathResource(String resource); JSLint fromClasspathResource(String resource, Charset encoding); JSLint fromDefault(); JSLint fromFile(File f); JSLint fromFile(File f, Charset encoding); @NeedsContext JSLint fromReader(Reader reader, String name); JSLintBuilder timeout(long maxTimeInSeconds); JSLintBuilder timeout(long maxTime, TimeUnit timeUnit); }
@Test public void testFromClasspathResource() throws Exception { assertJSLintOK(builder.fromClasspathResource(STUB_JSLINT)); }
JSLintBuilder { public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } JSLint fromClasspathResource(String resource); JSLint fromClasspathResource(String resource, Charset encoding); JSLint fromDefault(); JSLint fromFile(File f); JSLint fromFile(File f, Charset encoding); @NeedsContext JSLint fromReader(Reader reader, String name); JSLintBuilder timeout(long maxTimeInSeconds); JSLintBuilder timeout(long maxTime, TimeUnit timeUnit); }
@Test public void testFromDefault() throws Exception { assertJSLintOK(builder.fromDefault()); } @Test public void canBuildMultipleLintersFromSameInstance() throws Exception { assertJSLintOK(builder.fromDefault()); assertJSLintOK(builder.fromDefault()); }
JSLintBuilder { public JSLint fromFile(File f) throws IOException { return fromFile(f, UTF8); } JSLint fromClasspathResource(String resource); JSLint fromClasspathResource(String resource, Charset encoding); JSLint fromDefault(); JSLint fromFile(File f); JSLint fromFile(File f, Charset encoding); @NeedsContext JSLint fromReader(Reader reader, String name); JSLintBuilder timeout(long maxTimeInSeconds); JSLintBuilder timeout(long maxTime, TimeUnit timeUnit); }
@Test public void testFromFile() throws Exception { File f = new File(getStubJslint().toURI()); assertJSLintOK(builder.fromFile(f)); }
JSLintBuilder { @NeedsContext public JSLint fromReader(Reader reader, String name) throws IOException { try { Context cx = contextFactory.enterContext(); ScriptableObject scope = cx.initStandardObjects(); cx.evaluateReader(scope, reader, name, 1, null); Function lintFunc = (Function) scope.get("JSLINT", scope); return new JSLint(contextFactory, lintFunc); } finally { Context.exit(); } } JSLint fromClasspathResource(String resource); JSLint fromClasspathResource(String resource, Charset encoding); JSLint fromDefault(); JSLint fromFile(File f); JSLint fromFile(File f, Charset encoding); @NeedsContext JSLint fromReader(Reader reader, String name); JSLintBuilder timeout(long maxTimeInSeconds); JSLintBuilder timeout(long maxTime, TimeUnit timeUnit); }
@Test public void testFromReader() throws Exception { InputStreamReader input = Resources.newReaderSupplier(getStubJslint(), Charsets.UTF_8) .getInput(); assertJSLintOK(builder.fromReader(input, "stubjslint.js")); }
StringArray { public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } private StringArray(); static String[] valueOf(String str); }
@Test public void testValueOf() { String[] ary = StringArray.valueOf("a,b"); assertThat(ary, arrayContaining("a", "b")); }
CharsetConverter implements IStringConverter<Charset> { public Charset convert(String value) { try { return Charset.forName(value); } catch (IllegalCharsetNameException e) { throw new ParameterException("unknown encoding '" + value + "'"); } catch (UnsupportedCharsetException e) { throw new ParameterException("unknown encoding '" + value + "'"); } } Charset convert(String value); }
@Test public void testConvert() throws Exception { assertThat(cc.convert("UTF-8"), is(Charsets.UTF_8)); } @Test public void testIllegalCharsetName() throws Exception { thrown.expect(ParameterException.class); thrown.expectMessage("unknown encoding"); cc.convert("!@#$%^&*("); } @Test public void testUnknownCharset() throws Exception { assumeThat(Charset.isSupported(UNKNOWN_CHARSET_NAME), is(false)); thrown.expect(ParameterException.class); thrown.expectMessage("unknown encoding"); cc.convert(UNKNOWN_CHARSET_NAME); }
Main { private void version() { if (lint == null) { lint = lintBuilder.fromDefault(); } info("using jslint version " + lint.getEdition()); throw new DieException(null, 0); } static void main(String[] args); }
@Test public void testVersion() throws Exception { kaboom.expect(DieException.class); kaboom.expect(hasProperty("code", equalTo(0))); String edition = new JSLintBuilder().fromDefault().getEdition(); try { runLint("--version"); fail("should have thrown DieException"); } catch (DieException e) { List<String> expectedStdout = ImmutableList.of("using jslint version " + edition); assertLintOutput(e.getCode(), 0, expectedStdout, NO_OUTPUT); throw e; } }
JSFunction { @Override public String toString() { return String.format("function %s()", getName()); } private JSFunction(Builder builder); List<String> getClosure(); List<String> getException(); List<String> getGlobal(); List<String> getLabel(); int getLast(); int getLine(); String getName(); List<String> getOuter(); List<String> getParams(); List<String> getUnused(); List<String> getVars(); @Override String toString(); }
@Test public void testToString() { JSFunction f = new JSFunction.Builder("fred", 1).build(); assertThat(f.toString(), is("function fred()")); }
ConditionEvents implements Iterable<ConditionEvent> { @PublicAPI(usage = ACCESS) public boolean isEmpty() { return getAllowed().isEmpty() && getViolating().isEmpty(); } @PublicAPI(usage = ACCESS) ConditionEvents(); @PublicAPI(usage = ACCESS) void add(ConditionEvent event); @PublicAPI(usage = ACCESS) void setInformationAboutNumberOfViolations(String informationAboutNumberOfViolations); @PublicAPI(usage = ACCESS) Collection<ConditionEvent> getViolating(); @PublicAPI(usage = ACCESS) Collection<ConditionEvent> getAllowed(); @PublicAPI(usage = ACCESS) boolean containViolation(); @PublicAPI(usage = ACCESS) boolean isEmpty(); @Deprecated @PublicAPI(usage = ACCESS) List<String> getFailureDescriptionLines(); @PublicAPI(usage = ACCESS) FailureMessages getFailureMessages(); @PublicAPI(usage = ACCESS, state = EXPERIMENTAL) void handleViolations(ViolationHandler<?> violationHandler); @Override @PublicAPI(usage = ACCESS) Iterator<ConditionEvent> iterator(); @Override String toString(); }
@Test @UseDataProvider("eventsWithEmpty") public void isEmpty(ConditionEvents events, boolean expectedEmpty) { assertThat(events.isEmpty()).as("events are empty").isEqualTo(expectedEmpty); }
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); }
@Test public void direct_dependencies_from_self_by_inheritance() { JavaClass javaClass = importClassWithContext(AExtendingSuperAImplementingInterfaceForA.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(extendsDependency() .from(AExtendingSuperAImplementingInterfaceForA.class) .to(SuperA.class) .inLineNumber(0)) .areAtLeastOne(implementsDependency() .from(AExtendingSuperAImplementingInterfaceForA.class) .to(InterfaceForA.class) .inLineNumber(0)); } @Test public void direct_dependencies_from_self_by_member_declarations() { JavaClass javaClass = importClasses(AhavingMembersOfTypeB.class, B.class).get(AhavingMembersOfTypeB.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(fieldTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeastOne(methodReturnTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeastOne(methodThrowsDeclarationDependency() .from(AhavingMembersOfTypeB.class) .to(B.BException.class) .inLineNumber(0)) .areAtLeast(2, parameterTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeastOne(methodChecksInstanceOfDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(7)) .areAtLeastOne(methodChecksInstanceOfDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(25)); } @Test public void direct_dependencies_from_self_by_annotation() { JavaClass javaClass = importClasses(ClassWithAnnotationDependencies.class) .get(ClassWithAnnotationDependencies.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnClass.class) .inLineNumber(0)) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnField.class) .inLineNumber(0)) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnConstructor.class) .inLineNumber(0)) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnMethod.class) .inLineNumber(0)) .areAtLeastOne(annotationMemberOfTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(WithType.class) .inLineNumber(0)) .areAtLeastOne(annotationMemberOfTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(B.class) .inLineNumber(0)) ; } @Test public void direct_dependencies_from_self_finds_correct_set_of_target_types() { JavaClass javaClass = importPackagesOf(getClass()).get(ClassWithAnnotationDependencies.class); Set<JavaClass> targets = FluentIterable.from(javaClass.getDirectDependenciesFromSelf()) .transform(toGuava(GET_TARGET_CLASS)).toSet(); assertThatTypes(targets).matchInAnyOrder( B.class, AhavingMembersOfTypeB.class, Object.class, String.class, List.class, Serializable.class, SomeSuperClass.class, WithType.class, WithNestedAnnotations.class, OnClass.class, OnMethod.class, OnConstructor.class, OnField.class, MetaAnnotated.class, WithEnum.class, WithPrimitive.class, SomeEnumAsAnnotationParameter.class, SomeEnumAsAnnotationArrayParameter.class, SomeEnumAsNestedAnnotationParameter.class, SomeEnumAsDefaultParameter.class); } @Test public void has_no_dependencies_to_primitives() { JavaClass javaClass = importClassWithContext(AllPrimitiveDependencies.class); assertThat(javaClass.getDirectDependenciesFromSelf()).doNotHave(anyDependency().toPrimitives()); } @Test public void direct_dependencies_from_self_by_accesses() { JavaClass javaClass = importClasses(AAccessingB.class, B.class).get(AAccessingB.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(callDependency() .from(AAccessingB.class) .to(B.class, CONSTRUCTOR_NAME) .inLineNumber(5)) .areAtLeastOne(setFieldDependency() .from(AAccessingB.class) .to(B.class, "field") .inLineNumber(6)) .areAtLeastOne(callDependency() .from(AAccessingB.class) .to(B.class, "call") .inLineNumber(7)); }
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); }
@Test public void direct_dependencies_to_self_by_accesses() { JavaClass javaClass = importClassesWithContext(AAccessingB.class, B.class).get(B.class); assertThat(javaClass.getDirectDependenciesToSelf()) .hasSize(3) .areAtLeastOne(callDependency() .from(AAccessingB.class) .to(B.class, CONSTRUCTOR_NAME) .inLineNumber(5)) .areAtLeastOne(setFieldDependency() .from(AAccessingB.class) .to(B.class, "field") .inLineNumber(6)) .areAtLeastOne(callDependency() .from(AAccessingB.class) .to(B.class, "call") .inLineNumber(7)); } @Test public void direct_dependencies_to_self_by_inheritance() { JavaClass superClass = importClassesWithContext(SuperA.class, AExtendingSuperAImplementingInterfaceForA.class).get(SuperA.class); assertThat(superClass.getDirectDependenciesToSelf()) .areAtLeastOne(extendsDependency() .from(AExtendingSuperAImplementingInterfaceForA.class) .to(SuperA.class) .inLineNumber(0)); JavaClass interfaceClass = importClassesWithContext(InterfaceForA.class, AExtendingSuperAImplementingInterfaceForA.class).get(InterfaceForA.class); assertThat(interfaceClass.getDirectDependenciesToSelf()) .areAtLeastOne(implementsDependency() .from(AExtendingSuperAImplementingInterfaceForA.class) .to(InterfaceForA.class) .inLineNumber(0)); } @Test public void direct_dependencies_to_self_by_member_declarations() { JavaClass javaClass = importClassesWithContext(AhavingMembersOfTypeB.class, B.class).get(B.class); assertThat(javaClass.getDirectDependenciesToSelf()) .areAtLeastOne(fieldTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeastOne(methodReturnTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeast(2, parameterTypeDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(0)) .areAtLeastOne(methodChecksInstanceOfDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(7)) .areAtLeastOne(methodChecksInstanceOfDependency() .from(AhavingMembersOfTypeB.class) .to(B.class) .inLineNumber(25)); JavaClass exceptionClass = importClassesWithContext(AhavingMembersOfTypeB.class, B.BException.class) .get(B.BException.class); assertThat(exceptionClass.getDirectDependenciesToSelf()) .areAtLeastOne(methodThrowsDeclarationDependency() .from(AhavingMembersOfTypeB.class) .to(B.BException.class) .inLineNumber(0)); } @Test public void direct_dependencies_to_self_by_annotation() { JavaClasses javaClasses = importPackagesOf(getClass()); assertThat(javaClasses.get(OnClass.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnClass.class) .inLineNumber(0)); assertThat(javaClasses.get(OnField.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnField.class) .inLineNumber(0)); assertThat(javaClasses.get(OnMethod.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnMethod.class) .inLineNumber(0)); assertThat(javaClasses.get(OnConstructor.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(OnConstructor.class) .inLineNumber(0)); assertThat(javaClasses.get(WithType.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationMemberOfTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(WithType.class) .inLineNumber(0)); assertThat(javaClasses.get(B.class).getDirectDependenciesToSelf()) .areAtLeastOne(annotationMemberOfTypeDependency() .from(ClassWithAnnotationDependencies.class) .to(B.class) .inLineNumber(0)); }
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); }
@Test public void function_getSimpleName() { assertThat(JavaClass.Functions.GET_SIMPLE_NAME.apply(importClassWithContext(List.class))) .as("result of GET_SIMPLE_NAME(clazz)") .isEqualTo(List.class.getSimpleName()); } @Test public void predicate_simpleName() { assertThat(simpleName(Parent.class.getSimpleName())) .accepts(importClassWithContext(Parent.class)) .rejects(importClassWithContext(SuperClassWithFieldAndMethod.class)); assertThat(simpleName("Simple")).hasDescription("simple name 'Simple'"); }
ContainAnyCondition extends ArchCondition<Collection<? extends T>> { @Override public void check(Collection<? extends T> collection, ConditionEvents events) { ConditionEvents subEvents = new ConditionEvents(); for (T element : collection) { condition.check(element, subEvents); } if (!subEvents.isEmpty()) { events.add(new AnyConditionEvent(collection, subEvents)); } } ContainAnyCondition(ArchCondition<T> condition); @Override void check(Collection<? extends T> collection, ConditionEvents events); @Override String toString(); }
@Test public void if_there_are_no_input_events_no_ContainsAnyEvent_is_added() { ConditionEvents events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(emptyList(), events); assertThat(events.isEmpty()).as("events are empty").isTrue(); } @Test public void satisfied_works_and_description_contains_mismatches() { ConditionEvents events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(TWO_NONSERIALIZABLE_OBJECTS, events); assertThat(events).containViolations(messageForTwoTimes(isSerializableMessageFor(Object.class))); events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(ONE_SERIALIZABLE_AND_ONE_NON_SERIALIZABLE_OBJECT, events); assertThat(events).containNoViolation(); } @Test public void inverting_works() throws Exception { ConditionEvents events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(ONE_SERIALIZABLE_AND_ONE_NON_SERIALIZABLE_OBJECT, events); assertThat(events).containNoViolation(); assertThat(events.getAllowed()).as("Exactly one allowed event occurred").hasSize(1); assertThat(getInverted(events)).containViolations(isSerializableMessageFor(SerializableObject.class)); }
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); }
@Test public void predicate_simpleNameStartingWith() { JavaClass input = importClassWithContext(Parent.class); assertThat(simpleNameStartingWith("P")).accepts(input); assertThat(simpleNameStartingWith("Pa")).accepts(input); assertThat(simpleNameStartingWith("PA")).rejects(input); assertThat(simpleNameStartingWith(".P")).rejects(input); assertThat(simpleNameStartingWith("")).accepts(input); assertThat(simpleNameStartingWith("wrong")).rejects(input); assertThat(simpleNameStartingWith(input.getName())).rejects(input); assertThat(simpleNameStartingWith(input.getName().substring(0, 2))).rejects(input); assertThat(simpleNameStartingWith("Prefix")).hasDescription("simple name starting with 'Prefix'"); } @Test public void predicate_simpleNameContaining() { JavaClass input = importClassWithContext(Parent.class); assertThat(simpleNameContaining("Parent")).accepts(input); assertThat(simpleNameContaining("Par")).accepts(input); assertThat(simpleNameContaining("a")).accepts(input); assertThat(simpleNameContaining("b")).rejects(input); assertThat(simpleNameContaining("A")).rejects(input); assertThat(simpleNameContaining("ent")).accepts(input); assertThat(simpleNameContaining("Pent")).rejects(input); assertThat(simpleNameContaining("aren")).accepts(input); assertThat(simpleNameContaining("")).accepts(input); assertThat(simpleNameContaining(input.getName())).rejects(input); assertThat(simpleNameContaining(" ")).rejects(input); assertThat(simpleNameContaining(".")).rejects(input); assertThat(simpleNameContaining(".Parent")).rejects(input); assertThat(simpleNameContaining("Infix")).hasDescription("simple name containing 'Infix'"); } @Test public void predicate_simpleNameEndingWith() { JavaClass input = importClassWithContext(Parent.class); assertThat(simpleNameEndingWith("Parent")).accepts(input); assertThat(simpleNameEndingWith("ent")).accepts(input); assertThat(simpleNameEndingWith("")).accepts(input); assertThat(simpleNameEndingWith(input.getName())).rejects(input); assertThat(simpleNameEndingWith(" ")).rejects(input); assertThat(simpleNameEndingWith(".")).rejects(input); assertThat(simpleNameEndingWith(".Parent")).rejects(input); assertThat(simpleNameEndingWith("Suffix")).hasDescription("simple name ending with 'Suffix'"); } @Test public void predicate_implement_descriptions() { assertThat(implement(List.class)) .hasDescription("implement " + List.class.getName()); assertThat(implement(List.class.getName())) .hasDescription("implement " + List.class.getName()); assertThat(implement(DescribedPredicate.<JavaClass>alwaysTrue().as("custom"))) .hasDescription("implement custom"); } @Test public void predicate_equivalentTo() { JavaClass javaClass = importClasses(SuperClassWithFieldAndMethod.class, Parent.class).get(SuperClassWithFieldAndMethod.class); assertThat(equivalentTo(SuperClassWithFieldAndMethod.class)) .accepts(javaClass); assertThat(equivalentTo(Parent.class)) .rejects(javaClass) .hasDescription("equivalent to " + Parent.class.getName()); } @Test public void predicate_belong_to() { JavaClasses classes = new ClassFileImporter().importPackagesOf(getClass()); JavaClass outerAnonymous = getOnlyClassSettingField(classes, ClassWithNamedAndAnonymousInnerClasses.name_of_fieldIndicatingOuterAnonymousInnerClass); JavaClass nestedAnonymous = getOnlyClassSettingField(classes, ClassWithNamedAndAnonymousInnerClasses.name_of_fieldIndicatingNestedAnonymousInnerClass); assertThat(belongToAnyOf(Object.class, ClassWithNamedAndAnonymousInnerClasses.class)) .hasDescription(String.format("belong to any of [%s, %s]", Object.class.getName(), ClassWithNamedAndAnonymousInnerClasses.class.getName())) .accepts(classes.get(ClassWithNamedAndAnonymousInnerClasses.class)) .accepts(classes.get(ClassWithNamedAndAnonymousInnerClasses.NamedInnerClass.class)) .accepts(classes.get(ClassWithNamedAndAnonymousInnerClasses.NamedInnerClass.NestedNamedInnerClass.class)) .accepts(outerAnonymous) .accepts(nestedAnonymous) .rejects(classes.get(getClass())); }
AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } AccessTarget(JavaClass owner, String name, String fullName); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @Override int hashCode(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaMember> resolve(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); }
@Test public void isAnnotatedWith_type_on_resolved_target() { JavaCall<?> call = simulateCall().from(Origin.class, "call").to(Target.class, "called"); assertThat(call.getTarget().isAnnotatedWith(QueriedAnnotation.class)) .as("target is annotated with @" + QueriedAnnotation.class.getSimpleName()) .isTrue(); assertThat(call.getTarget().isAnnotatedWith(Deprecated.class)) .as("target is annotated with @" + Deprecated.class.getSimpleName()) .isFalse(); } @Test public void isAnnotatedWith_predicate_on_resolved_target() { JavaCall<?> call = simulateCall().from(Origin.class, "call").to(Target.class, "called"); assertThat(call.getTarget().isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("target is annotated with anything") .isTrue(); assertThat(call.getTarget().isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("target is annotated with nothing") .isFalse(); }
AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType) { return isMetaAnnotatedWith(annotationType.getName()); } AccessTarget(JavaClass owner, String name, String fullName); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @Override int hashCode(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaMember> resolve(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); }
@Test public void isMetaAnnotatedWith_type_on_resolved_target() { JavaClasses classes = importClassesWithContext(Origin.class, Target.class, QueriedAnnotation.class); JavaCall<?> call = simulateCall().from(classes.get(Origin.class), "call").to(classes.get(Target.class).getMethod("called")); assertThat(call.getTarget().isMetaAnnotatedWith(QueriedAnnotation.class)) .as("target is meta-annotated with @" + QueriedAnnotation.class.getSimpleName()) .isFalse(); assertThat(call.getTarget().isMetaAnnotatedWith(Retention.class)) .as("target is meta-annotated with @" + Retention.class.getSimpleName()) .isTrue(); } @Test public void isMetaAnnotatedWith_predicate_on_resolved_target() { JavaClasses classes = importClassesWithContext(Origin.class, Target.class, QueriedAnnotation.class); JavaCall<?> call = simulateCall().from(classes.get(Origin.class), "call").to(classes.get(Target.class).getMethod("called")); assertThat(call.getTarget().isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("target is meta-annotated with anything") .isTrue(); assertThat(call.getTarget().isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("target is meta-annotated with nothing") .isFalse(); }
ArchConditions { @PublicAPI(usage = ACCESS) public static ArchCondition<JavaClass> onlyHaveDependentsWhere(DescribedPredicate<? super Dependency> predicate) { String description = "only have dependents where " + predicate.getDescription(); return new AllDependenciesCondition(description, predicate, GET_DIRECT_DEPENDENCIES_TO_SELF); } private ArchConditions(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessFieldsThat(final DescribedPredicate<? super JavaField> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethod(Class<?> owner, String methodName, Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethod(String ownerName, String methodName, String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethodWhere(final DescribedPredicate<? super JavaMethodCall> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallMethodsThat(final DescribedPredicate<? super JavaMethod> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructor(Class<?> owner, Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructor(String ownerName, String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructorWhere(final DescribedPredicate<? super JavaConstructorCall> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallConstructorsThat(final DescribedPredicate<? super JavaConstructor> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallCodeUnitsThat(final DescribedPredicate<? super JavaCodeUnit> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessMembersThat(final DescribedPredicate<? super JavaMember> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> dependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyDependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyBeAccessedByClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThatResideIn(String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThatResideInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyBeAccessedByAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentsInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentsWhere(DescribedPredicate<? super Dependency> predicate); @PublicAPI(usage = ACCESS) static AllDependenciesCondition onlyHaveDependenciesInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static AllDependenciesCondition onlyHaveDependenciesWhere(DescribedPredicate<? super Dependency> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<T> never(ArchCondition<T> condition); @PublicAPI(usage = ACCESS) static ArchCondition<T> not(ArchCondition<T> condition); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> be(final Class<?> clazz); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBe(final Class<?> clazz); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> be(final String className); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBe(final String className); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveName(final String name); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> notHaveName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullName(String fullName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> notHaveFullName(String fullName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveFullyQualifiedName(final String name); @Internal static DescribedPredicate<HasName> fullyQualifiedName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notHaveFullyQualifiedName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleName(final String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notHaveSimpleName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameStartingWith(final String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameContaining(final String infix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotContaining(final String infix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameEndingWith(final String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameMatching(final String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullNameMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullNameNotMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameContaining(String infix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotContaining(String infix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideInAPackage(final String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideOutsideOfPackage(String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideOutsideOfPackages(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> haveModifier( final JavaModifier modifier); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notHaveModifier( final JavaModifier modifier); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePublic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePublic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beProtected(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeProtected(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePackagePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePackagePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beStatic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeStatic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beFinal(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeFinal(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveOnlyFinalFields(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveOnlyPrivateConstructors(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( final DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( final DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(Class<?> interfaceType); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(Class<?> interfaceType); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(String interfaceTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(String interfaceTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beInterfaces(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeInterfaces(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beEnums(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeEnums(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beTopLevelClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeTopLevelClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beNestedClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeNestedClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beMemberClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeMemberClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beInnerClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeInnerClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAnonymousClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAnonymousClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beLocalClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeLocalClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> containNumberOfElements(DescribedPredicate<? super Integer> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredIn(Class<?> owner); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> notBeDeclaredIn(Class<?> owner); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredIn(String ownerTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> notBeDeclaredIn(String ownerTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredInClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(DescribedPredicate<? super List<JavaClass>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(DescribedPredicate<? super JavaClass> predicate); }
@Test public void only_have_dependents_where() { JavaClasses classes = importClasses(CallingClass.class, SomeClass.class); JavaClass accessedClass = classes.get(SomeClass.class); assertThat(onlyHaveDependentsWhere(DescribedPredicate.<Dependency>alwaysFalse())) .checking(accessedClass) .haveAtLeastOneViolationMessageMatching(String.format(".*%s.*%s.*", quote(CallingClass.class.getName()), quote(SomeClass.class.getName()))); assertThat(onlyHaveDependentsWhere(DescribedPredicate.<Dependency>alwaysTrue().as("custom"))) .hasDescription("only have dependents where custom") .checking(accessedClass) .containNoViolation(); }
AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public JavaClass getOwner() { return owner; } AccessTarget(JavaClass owner, String name, String fullName); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @Override int hashCode(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaMember> resolve(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); }
@Test public void no_throws_clause_is_resolved() { CodeUnitCallTarget target = getTarget("withoutThrowsDeclaration"); ThrowsClause<CodeUnitCallTarget> throwsClause = target.getThrowsClause(); assertThat(throwsClause).as("throws clause").isEmpty(); assertThat(throwsClause.getTypes()).isEmpty(); assertThat(throwsClause.getOwner()).isEqualTo(target); assertThatType(throwsClause.getDeclaringClass()).matches(Target.class); }
AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } AccessTarget(JavaClass owner, String name, String fullName); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @Override int hashCode(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaMember> resolve(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); }
@Test public void predicate_declaredIn() { JavaCall<?> call = simulateCall().from(Origin.class, "call").to(Target.class, "called"); assertThat(declaredIn(Target.class)) .accepts(call.getTarget()) .hasDescription("declared in " + Target.class.getName()); assertThat(declaredIn(Target.class.getName())) .accepts(call.getTarget()) .hasDescription("declared in " + Target.class.getName()); assertThat(declaredIn(equivalentTo(Target.class).as("custom"))) .accepts(call.getTarget()) .hasDescription("declared in custom"); assertThat(declaredIn(Origin.class)) .rejects(call.getTarget()); assertThat(declaredIn(Origin.class.getName())) .rejects(call.getTarget()); assertThat(declaredIn(equivalentTo(Origin.class))) .rejects(call.getTarget()); }
JavaMember implements HasName.AndFullName, HasDescriptor, HasAnnotations<JavaMember>, HasModifiers, HasOwner<JavaClass>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> type) { return isAnnotatedWith(type.getName()); } JavaMember(JavaMemberBuilder<?, ?> builder); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<? extends JavaMember>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<? extends JavaMember> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<? extends JavaAnnotation<? extends JavaMember>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @Internal String getDescriptor(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) abstract Member reflect(); @Override String toString(); }
@Test public void isAnnotatedWith_type() { assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Deprecated.class)) .as("field is annotated with @Deprecated").isTrue(); assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Retention.class)) .as("field is annotated with @Retention").isFalse(); } @Test public void isAnnotatedWith_predicate() { assertThat(importField(SomeClass.class, "someField") .isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("predicate matches").isTrue(); assertThat(importField(SomeClass.class, "someField") .isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("predicate matches").isFalse(); }
JavaMember implements HasName.AndFullName, HasDescriptor, HasAnnotations<JavaMember>, HasModifiers, HasOwner<JavaClass>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> type) { return isMetaAnnotatedWith(type.getName()); } JavaMember(JavaMemberBuilder<?, ?> builder); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<? extends JavaMember>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<? extends JavaMember> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<? extends JavaAnnotation<? extends JavaMember>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @Internal String getDescriptor(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) abstract Member reflect(); @Override String toString(); }
@Test public void isMetaAnnotatedWith_type() { JavaClass clazz = importClassesWithContext(SomeClass.class, Deprecated.class).get(SomeClass.class); assertThat(clazz.getField("someField").isMetaAnnotatedWith(Deprecated.class)) .as("field is meta-annotated with @Deprecated").isFalse(); assertThat(clazz.getField("someField").isMetaAnnotatedWith(Retention.class)) .as("field is meta-annotated with @Retention").isTrue(); } @Test public void isMetaAnnotatedWith_predicate() { JavaClass clazz = importClassesWithContext(SomeClass.class, Deprecated.class).get(SomeClass.class); assertThat(clazz.getField("someField") .isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("predicate matches").isTrue(); assertThat(clazz.getField("someField") .isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("predicate matches").isFalse(); }
JavaMember implements HasName.AndFullName, HasDescriptor, HasAnnotations<JavaMember>, HasModifiers, HasOwner<JavaClass>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } JavaMember(JavaMemberBuilder<?, ?> builder); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<? extends JavaMember>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<? extends JavaMember> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<? extends JavaAnnotation<? extends JavaMember>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @Internal String getDescriptor(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) abstract Member reflect(); @Override String toString(); }
@Test public void predicate_declaredIn() { JavaField field = importField(SomeClass.class, "someField"); assertThat(declaredIn(SomeClass.class)) .accepts(field) .hasDescription("declared in " + SomeClass.class.getName()); assertThat(declaredIn(SomeClass.class.getName())) .accepts(field) .hasDescription("declared in " + SomeClass.class.getName()); assertThat(declaredIn(equivalentTo(SomeClass.class).as("custom"))) .accepts(field) .hasDescription("declared in custom"); assertThat(declaredIn(getClass())).rejects(field); assertThat(declaredIn(getClass().getName())).rejects(field); assertThat(declaredIn(equivalentTo(getClass()))).rejects(field); }
ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public boolean containsType(Class<?> type) { return containsType(type.getName()); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void containsType() { JavaMethod method = importMethod(SomeClass.class, "method"); assertAllTrue(contains(method, SQLDataException.class)); assertAllFalse(contains(method, Exception.class)); }
ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public int size() { return throwsDeclarations.size(); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void size() { assertThat(importMethod(SomeClass.class, "method").getThrowsClause().size()) .as("size of throws clause").isEqualTo(2); }
ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public JavaClassList getTypes() { return new JavaClassList(FluentIterable.from(throwsDeclarations).transform(toGuava(GET_RAW_TYPE)).toList()); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void getTypes() { JavaMethod method = importMethod(SomeClass.class, "method"); assertThatTypes(method.getThrowsClause().getTypes()).matchInAnyOrder(IOException.class, SQLDataException.class); }
ArchConditions { @PublicAPI(usage = ACCESS) public static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type) { return declareThrowableOfType(equivalentTo(type).as(type.getName())); } private ArchConditions(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessField(final Class<?> owner, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessField(final String ownerName, final String fieldName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessFieldsThat(final DescribedPredicate<? super JavaField> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethod(Class<?> owner, String methodName, Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethod(String ownerName, String methodName, String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callMethodWhere(final DescribedPredicate<? super JavaMethodCall> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallMethodsThat(final DescribedPredicate<? super JavaMethod> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructor(Class<?> owner, Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructor(String ownerName, String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callConstructorWhere(final DescribedPredicate<? super JavaConstructorCall> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallConstructorsThat(final DescribedPredicate<? super JavaConstructor> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyCallCodeUnitsThat(final DescribedPredicate<? super JavaCodeUnit> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessMembersThat(final DescribedPredicate<? super JavaMember> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyAccessClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> dependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyDependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyBeAccessedByClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThatResideIn(String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> accessClassesThatResideInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyBeAccessedByAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentsInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> onlyHaveDependentsWhere(DescribedPredicate<? super Dependency> predicate); @PublicAPI(usage = ACCESS) static AllDependenciesCondition onlyHaveDependenciesInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static AllDependenciesCondition onlyHaveDependenciesWhere(DescribedPredicate<? super Dependency> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<T> never(ArchCondition<T> condition); @PublicAPI(usage = ACCESS) static ArchCondition<T> not(ArchCondition<T> condition); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> be(final Class<?> clazz); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBe(final Class<?> clazz); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> be(final String className); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBe(final String className); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveName(final String name); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> notHaveName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullName(String fullName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> notHaveFullName(String fullName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveFullyQualifiedName(final String name); @Internal static DescribedPredicate<HasName> fullyQualifiedName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notHaveFullyQualifiedName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleName(final String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notHaveSimpleName(String name); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameStartingWith(final String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameContaining(final String infix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotContaining(final String infix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameEndingWith(final String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveSimpleNameNotEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameMatching(final String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullNameMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_FULL_NAME> haveFullNameNotMatching(String regex); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotStartingWith(String prefix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameContaining(String infix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotContaining(String infix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_NAME> haveNameNotEndingWith(String suffix); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideInAPackage(final String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideInAnyPackage(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideOutsideOfPackage(String packageIdentifier); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> resideOutsideOfPackages(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> haveModifier( final JavaModifier modifier); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notHaveModifier( final JavaModifier modifier); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePublic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePublic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beProtected(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeProtected(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePackagePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePackagePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> bePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBePrivate(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beStatic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeStatic(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> beFinal(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_MODIFIERS> notBeFinal(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveOnlyFinalFields(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> haveOnlyPrivateConstructors(); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beAnnotatedWith( final DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeAnnotatedWith( DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( Class<? extends Annotation> type); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> beMetaAnnotatedWith( final DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<HAS_ANNOTATIONS> notBeMetaAnnotatedWith( DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(Class<?> interfaceType); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(Class<?> interfaceType); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(String interfaceTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(String interfaceTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> implement(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notImplement(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableTo(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beInterfaces(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeInterfaces(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beEnums(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeEnums(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beTopLevelClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeTopLevelClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beNestedClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeNestedClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beMemberClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeMemberClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beInnerClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeInnerClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beAnonymousClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeAnonymousClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> beLocalClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> notBeLocalClasses(); @PublicAPI(usage = ACCESS) static ArchCondition<JavaClass> containNumberOfElements(DescribedPredicate<? super Integer> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredIn(Class<?> owner); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> notBeDeclaredIn(Class<?> owner); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredIn(String ownerTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> notBeDeclaredIn(String ownerTypeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaMember> beDeclaredInClassesThat(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaField> haveRawType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(Class<?>... parameterTypes); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(String... parameterTypeNames); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawParameterTypes(DescribedPredicate<? super List<JavaClass>> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(Class<?> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> haveRawReturnType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(String typeName); @PublicAPI(usage = ACCESS) static ArchCondition<JavaCodeUnit> declareThrowableOfType(DescribedPredicate<? super JavaClass> predicate); }
@Test public void declare_throwable_of_type() { class Failure { @SuppressWarnings("unused") void method() { } } assertThat(declareThrowableOfType(SQLException.class)) .hasDescription("declare throwable of type " + SQLException.class.getName()) .checking(importMethod(Failure.class, "method")) .haveOneViolationMessageContaining("Method", "method()", "does not declare throwable of type " + SQLException.class.getName()); }
JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public JavaClasses that(DescribedPredicate<? super JavaClass> predicate) { Map<String, JavaClass> matchingElements = Guava.Maps.filterValues(classes, predicate); String newDescription = String.format("%s that %s", description, predicate.getDescription()); return new JavaClasses(defaultPackage, matchingElements, newDescription); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void restriction_on_classes_should_filter_the_elements() { JavaClasses onlySomeClass = ALL_CLASSES.that(haveTheNameOf(SomeClass.class)); assertThat(onlySomeClass).containsExactly(SOME_CLASS); }
JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public boolean contain(Class<?> reflectedType) { return contain(reflectedType.getName()); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void contain_type() { assertThat(ALL_CLASSES.contain(getClass())).isFalse(); assertThat(ALL_CLASSES.contain(SomeOtherClass.class)).isTrue(); }
JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public JavaClass get(Class<?> reflectedType) { return get(reflectedType.getName()); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void get_returns_correct_JavaClass() { assertThat(ALL_CLASSES.get(SomeOtherClass.class)).isEqualTo(SOME_OTHER_CLASS); assertThat(ALL_CLASSES.get(SomeOtherClass.class.getName())).isEqualTo(SOME_OTHER_CLASS); }
JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { static JavaClasses of(Iterable<JavaClass> classes) { Map<String, JavaClass> mapping = new HashMap<>(); for (JavaClass clazz : classes) { mapping.put(clazz.getName(), clazz); } JavaPackage defaultPackage = !Iterables.isEmpty(classes) ? getRoot(classes.iterator().next().getPackage()) : JavaPackage.from(classes); return new JavaClasses(defaultPackage, mapping); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void javaClasses_of_iterable() { ImmutableSet<JavaClass> iterable = ImmutableSet.of(importClassWithContext(JavaClassesTest.class), importClassWithContext(JavaClass.class)); JavaClasses classes = JavaClasses.of(iterable); assertThat(ImmutableSet.copyOf(classes)).isEqualTo(iterable); }
Source { @PublicAPI(usage = ACCESS) public Optional<String> getFileName() { return fileName; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void source_file_name() throws URISyntaxException { Source source = new Source(urlOf(Object.class).toURI(), Optional.of("SomeClass.java"), false); assertThat(source.getFileName()).as("source file name").contains("SomeClass.java"); source = new Source(urlOf(Object.class).toURI(), Optional.<String>absent(), false); assertThat(source.getFileName()).as("source file name").isAbsent(); }
Source { @Override public int hashCode() { return Objects.hash(uri, md5sum); } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test @UseDataProvider("equalMd5Sums") public void positive_equals_hashcode_of_md5sums(Md5sum first, Md5sum second) { assertThat(first).isEqualTo(second); assertThat(first.hashCode()).isEqualTo(second.hashCode()); }
Source { @PublicAPI(usage = ACCESS) public Md5sum getMd5sum() { return md5sum; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void compensates_error_on_md5_calculation() throws Exception { Source source = newSource(new URI("bummer")); assertThat(source.getMd5sum()).isEqualTo(Md5sum.UNDETERMINED); }
Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getDescription() { return description; } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }
@Test public void Dependency_from_origin_and_target() { JavaClass origin = importClassWithContext(getClass()); JavaClass target = importClassWithContext(DependencyClass.class); Dependency dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Class <" + origin.getName() + "> extends class <" + target.getName() + ">"); target = importClassWithContext(DependencyInterface.class); dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Class <" + origin.getName() + "> implements interface <" + target.getName() + ">"); origin = importClassWithContext(DependencySubInterface.class); dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Interface <" + origin.getName() + "> extends interface <" + target.getName() + ">"); }
Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceofCheck.getLineNumber()); } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }
@Test @UseDataProvider("with_instanceof_check_members") public void Dependency_from_instanceof_check_in_code_unit(JavaCodeUnit memberWithInstanceofCheck, int expectedLineNumber) { InstanceofCheck instanceofCheck = getOnlyElement(memberWithInstanceofCheck.getInstanceofChecks()); Dependency dependency = Dependency.tryCreateFromInstanceofCheck(instanceofCheck).get(); Assertions.assertThatDependency(dependency) .matches(ClassWithDependencyOnInstanceofCheck.class, InstanceOfCheckTarget.class) .hasDescription(memberWithInstanceofCheck.getFullName(), "checks instanceof", InstanceOfCheckTarget.class.getName()) .inLocation(ClassWithDependencyOnInstanceofCheck.class, expectedLineNumber); }
Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description) { this.originClass = originClass; this.targetClass = targetClass; this.lineNumber = lineNumber; this.description = description; this.sourceCodeLocation = SourceCodeLocation.of(originClass, lineNumber); } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }
@Test public void dependency_predicates_descriptions() { assertThat(dependency(Origin.class, Target.class)) .hasSameDescriptionAs(dependency(Origin.class.getName(), Target.class.getName())) .hasDescription("dependency " + Origin.class.getName() + " -> " + Target.class.getName()); assertThat(dependency(predicateWithDescription("first"), predicateWithDescription("second"))) .hasDescription("dependency first -> second"); }
Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } }
@Test public void test_classes() { JavaClasses input = importClasses(Object.class, String.class); DescribedIterable<JavaClass> output = Transformers.classes().transform(input); assertThat(output).containsOnlyElementsOf(input); }
JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } JavaTypeVariable(String name, JavaClass erasure); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) List<JavaType> getBounds(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); }
@Test public void type_variable_name() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<SOME_NAME> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithUnboundTypeParameter.class).getTypeParameters().get(0); assertThat(type.getName()).isEqualTo("SOME_NAME"); }
JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) List<JavaType> getBounds(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); }
@Test public void erased_unbound_type_variable_is_java_lang_Object() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<T> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithUnboundTypeParameter.class).getTypeParameters().get(0); assertThatType(type.toErasure()).matches(Object.class); } @Test public void erased_type_variable_bound_by_single_class_is_this_class() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleClassBound<T extends Serializable> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithSingleClassBound.class).getTypeParameters().get(0); assertThatType(type.toErasure()).matches(Serializable.class); } @Test public void erased_type_variable_bound_by_single_generic_class_is_the_erasure_of_this_class() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleGenericClassBound<T extends List<String>> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithSingleGenericClassBound.class).getTypeParameters().get(0); assertThatType(type.toErasure()).matches(List.class); } @Test public void erased_type_variable_bound_by_multiple_generic_classes_and_interfaces_is_the_erasure_of_the_leftmost_bound() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithMultipleGenericClassAndInterfaceBounds<T extends HashMap<String, String> & Iterable<String> & Serializable> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithMultipleGenericClassAndInterfaceBounds.class).getTypeParameters().get(0); assertThatType(type.toErasure()).matches(HashMap.class); } @Test public void erased_type_variable_bound_by_concrete_array_type_is_array_type() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleGenericArrayBound<T extends List<Object[]>, U extends List<String[][]>, V extends List<List<?>[][][]>> { } List<JavaTypeVariable> typeParameters = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithSingleGenericArrayBound.class).getTypeParameters(); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(0)).toErasure()).matches(Object[].class); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(1)).toErasure()).matches(String[][].class); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(2)).toErasure()).matches(List[][][].class); } @Test public void erased_type_variable_bound_by_generic_array_type_is_array_with_erasure_component_type() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithGenericArrayBounds<A, B extends String, C extends List<?>, T extends List<A[]>, U extends List<B[][]>, V extends List<C[][][]>> { } List<JavaTypeVariable> typeParameters = new ClassFileImporter().importClass(ClassWithBoundTypeParameterWithGenericArrayBounds.class).getTypeParameters(); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(3)).toErasure()).matches(Object[].class); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(4)).toErasure()).matches(String[][].class); assertThatType(getTypeArgumentOfFirstBound(typeParameters.get(5)).toErasure()).matches(List[][][].class); }
JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaTypeVariable(String name, JavaClass erasure); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) List<JavaType> getBounds(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); }
@Test public void toString_unbounded() { @SuppressWarnings("unused") class Unbounded<NAME> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(Unbounded.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME") .doesNotContain("extends"); } @Test public void toString_upper_bounded_by_single_bound() { @SuppressWarnings("unused") class BoundedBySingleBound<NAME extends String> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(BoundedBySingleBound.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME extends java.lang.String"); } @Test public void toString_upper_bounded_by_multiple_bounds() { @SuppressWarnings("unused") class BoundedByMultipleBounds<NAME extends String & Serializable> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(BoundedByMultipleBounds.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME extends java.lang.String & java.io.Serializable"); }
AbstractClassesTransformer implements ClassesTransformer<T> { @Override public final DescribedIterable<T> transform(JavaClasses collection) { return DescribedIterable.From.iterable(doTransform(collection), description); } protected AbstractClassesTransformer(String description); @Override final DescribedIterable<T> transform(JavaClasses collection); abstract Iterable<T> doTransform(JavaClasses collection); @Override final ClassesTransformer<T> that(final DescribedPredicate<? super T> predicate); @Override final String getDescription(); @Override final ClassesTransformer<T> as(String description); @Override String toString(); }
@Test public void transform_javaclasses() { AbstractClassesTransformer<String> transformer = toNameTransformer(); JavaClasses classes = importClassesWithContext(AbstractClassesTransformer.class, AbstractClassesTransformerTest.class); DescribedIterable<String> transformed = transformer.transform(classes); assertThat(transformed).containsOnly(AbstractClassesTransformer.class.getName(), AbstractClassesTransformerTest.class.getName()); }
PluginLoader { public T load() { return supplier.get(); } private PluginLoader(Class<T> pluginType, Map<JavaVersion, String> versionToPlugins, T fallback); static Creator<T> forType(Class<T> pluginType); T load(); }
@Test public void loads_correct_plugin_for_version() { System.setProperty("java.version", "1.7.0_55"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBeforeJava9); System.setProperty("java.version", "1.8.0_122"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBeforeJava9); System.setProperty("java.version", "9"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "9.0.1"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "11-ea"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "13"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "14"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeAfterJava13); }
ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResourceName); @PublicAPI(usage = ACCESS) static ArchConfiguration get(); @PublicAPI(usage = ACCESS) void reset(); @PublicAPI(usage = ACCESS) boolean resolveMissingDependenciesFromClassPath(); @PublicAPI(usage = ACCESS) void setResolveMissingDependenciesFromClassPath(boolean newValue); @PublicAPI(usage = ACCESS) boolean md5InClassSourcesEnabled(); @PublicAPI(usage = ACCESS) void setMd5InClassSourcesEnabled(boolean enabled); @PublicAPI(usage = ACCESS) Optional<String> getClassResolver(); @PublicAPI(usage = ACCESS) void setClassResolver(Class<? extends ClassResolver> classResolver); @PublicAPI(usage = ACCESS) void unsetClassResolver(); @PublicAPI(usage = ACCESS) List<String> getClassResolverArguments(); @PublicAPI(usage = ACCESS) void setClassResolverArguments(String... args); @PublicAPI(usage = ACCESS) void setExtensionProperties(String extensionIdentifier, Properties properties); @PublicAPI(usage = ACCESS) Properties getExtensionProperties(String extensionIdentifier); @PublicAPI(usage = ACCESS) ExtensionProperties configureExtension(String extensionIdentifier); @PublicAPI(usage = ACCESS) Properties getSubProperties(String propertyPrefix); @PublicAPI(usage = ACCESS) boolean containsProperty(String propertyName); @PublicAPI(usage = ACCESS) String getProperty(String propertyName); @PublicAPI(usage = ACCESS) void setProperty(String propertyName, String value); @PublicAPI(usage = ACCESS) String getPropertyOrDefault(String propertyName, String defaultValue); @Internal // {@value ...} does not work on non constants outside of the package static final String ARCHUNIT_PROPERTIES_RESOURCE_NAME; @Internal // {@value ...} does not work on non constants outside of the package static final String RESOLVE_MISSING_DEPENDENCIES_FROM_CLASS_PATH; @Internal static final String ENABLE_MD5_IN_CLASS_SOURCES; }
@Test public void if_no_extension_properties_are_found_empty_properties_are_returned() { ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); assertThat(configuration.getExtensionProperties("not-there")).isEmpty(); } @Test public void creates_extension_properties_from_prefix() { writeProperties( "extension.test-extension.enabled", true, "extension.test-extension.some-prop", "some value", "extension.test-extension.other_prop", 88, "extension.other-extension.enabled", false, "extension.other-extension.other-prop", "other value" ); ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); Properties properties = configuration.getExtensionProperties("test-extension"); assertThat(properties).containsOnly( entry("enabled", "true"), entry("some-prop", "some value"), entry("other_prop", "88")); properties = configuration.getExtensionProperties("other-extension"); assertThat(properties).containsOnly( entry("enabled", "false"), entry("other-prop", "other value")); }
ArchConfiguration { @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } private ArchConfiguration(); private ArchConfiguration(String propertiesResourceName); @PublicAPI(usage = ACCESS) static ArchConfiguration get(); @PublicAPI(usage = ACCESS) void reset(); @PublicAPI(usage = ACCESS) boolean resolveMissingDependenciesFromClassPath(); @PublicAPI(usage = ACCESS) void setResolveMissingDependenciesFromClassPath(boolean newValue); @PublicAPI(usage = ACCESS) boolean md5InClassSourcesEnabled(); @PublicAPI(usage = ACCESS) void setMd5InClassSourcesEnabled(boolean enabled); @PublicAPI(usage = ACCESS) Optional<String> getClassResolver(); @PublicAPI(usage = ACCESS) void setClassResolver(Class<? extends ClassResolver> classResolver); @PublicAPI(usage = ACCESS) void unsetClassResolver(); @PublicAPI(usage = ACCESS) List<String> getClassResolverArguments(); @PublicAPI(usage = ACCESS) void setClassResolverArguments(String... args); @PublicAPI(usage = ACCESS) void setExtensionProperties(String extensionIdentifier, Properties properties); @PublicAPI(usage = ACCESS) Properties getExtensionProperties(String extensionIdentifier); @PublicAPI(usage = ACCESS) ExtensionProperties configureExtension(String extensionIdentifier); @PublicAPI(usage = ACCESS) Properties getSubProperties(String propertyPrefix); @PublicAPI(usage = ACCESS) boolean containsProperty(String propertyName); @PublicAPI(usage = ACCESS) String getProperty(String propertyName); @PublicAPI(usage = ACCESS) void setProperty(String propertyName, String value); @PublicAPI(usage = ACCESS) String getPropertyOrDefault(String propertyName, String defaultValue); @Internal // {@value ...} does not work on non constants outside of the package static final String ARCHUNIT_PROPERTIES_RESOURCE_NAME; @Internal // {@value ...} does not work on non constants outside of the package static final String RESOLVE_MISSING_DEPENDENCIES_FROM_CLASS_PATH; @Internal static final String ENABLE_MD5_IN_CLASS_SOURCES; }
@Test public void returns_property_if_property_is_set() { writeProperties("configured.property", "explicitlySet"); ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); assertThat(configuration.getPropertyOrDefault("configured.property", "default")).isEqualTo("explicitlySet"); } @Test public void returns_default_if_property_is_unset() { writeProperties(); ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); assertThat(configuration.getPropertyOrDefault("unconfigured.property", "default")).isEqualTo("default"); }
DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysTrue() { return (DescribedPredicate<T>) ALWAYS_TRUE; } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); }
@Test public void alwaysTrue_works() { assertThat(alwaysTrue()).accepts(new Object()).hasDescription("always true"); }
DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysFalse() { return (DescribedPredicate<T>) ALWAYS_FALSE; } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); }
@Test public void alwaysFalse_works() { assertThat(alwaysFalse()).rejects(new Object()).hasDescription("always false"); }
DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); }
@Test public void equalTo_works() { assertThat(equalTo(5)) .rejects(4) .hasDescription("equal to '5'") .accepts(5) .rejects(6); Object object = new Object(); assertThat(equalTo(object)).accepts(object); } @Test @UseDataProvider("not_scenarios") public void not_works(NotScenario scenario) { assertThat(scenario.apply(equalTo(5))) .accepts(4) .hasDescription(scenario.expectedPrefix + " equal to '5'") .rejects(5) .accepts(6); Object object = new Object(); assertThat(scenario.apply(equalTo(object))).rejects(object); }