target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testStringValueFromJavaScript() throws Exception { cx.evaluateString(scope, "var foo = 'bar'", "-", 1, null); assertThat(Util.stringValue("foo", scope), is("bar")); } | 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; } | 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; } } | 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(); } | 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(); } | 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 testDefaultEncoding() { assertEquals("UTF-8", mojo.getEncoding()); } | @VisibleForTesting String getEncoding() { return encoding; } | JSLintMojo extends AbstractMojo { @VisibleForTesting String getEncoding() { return encoding; } } | JSLintMojo extends AbstractMojo { @VisibleForTesting String getEncoding() { return encoding; } } | 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... | 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... |
@Test public void testStringValueNullScope() throws Exception { assertThat(Util.stringValue("foo", null), is(nullValue())); } | 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; } | 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; } } | 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(); } | 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(); } | 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 testStringValueOfUndefined() { cx.evaluateString(scope, "var foo;", "-", 1, null); assertThat(Util.stringValue("foo", scope), is(nullValue())); } | 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; } | 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; } } | 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(); } | 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(); } | 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 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(" } | public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } | UnicodeBomInputStream extends InputStream { public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } } | UnicodeBomInputStream extends InputStream { public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } UnicodeBomInputStream(final InputStream inputStream); } | 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()... | 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()... |
@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 = j... | public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } | UnicodeBomInputStream extends InputStream { public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } } | UnicodeBomInputStream extends InputStream { public final synchronized UnicodeBomInputStream skipBOM() throws IOException { if (!skipped) { skip(bom.bytes.length); skipped = true; } return this; } UnicodeBomInputStream(final InputStream inputStream); } | 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()... | 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()... |
@Test public void testFromClasspathResource() throws Exception { assertJSLintOK(builder.fromClasspathResource(STUB_JSLINT)); } | public JSLint fromClasspathResource(String resource) throws IOException { return fromClasspathResource(resource, UTF8); } | JSLintBuilder { public JSLint fromClasspathResource(String resource) throws IOException { return fromClasspathResource(resource, UTF8); } } | JSLintBuilder { public JSLint fromClasspathResource(String resource) throws IOException { return fromClasspathResource(resource, UTF8); } } | 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... | 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... |
@Test public void testFromDefault() throws Exception { assertJSLintOK(builder.fromDefault()); } | public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } | JSLintBuilder { public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } } | JSLintBuilder { public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } } | 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); JSLi... | 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); JSLi... |
@Test public void testFromFile() throws Exception { File f = new File(getStubJslint().toURI()); assertJSLintOK(builder.fromFile(f)); } | public JSLint fromFile(File f) throws IOException { return fromFile(f, UTF8); } | JSLintBuilder { public JSLint fromFile(File f) throws IOException { return fromFile(f, UTF8); } } | JSLintBuilder { public JSLint fromFile(File f) throws IOException { return fromFile(f, UTF8); } } | 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 ... | 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 ... |
@Test public void testFromReader() throws Exception { InputStreamReader input = Resources.newReaderSupplier(getStubJslint(), Charsets.UTF_8) .getInput(); assertJSLintOK(builder.fromReader(input, "stubjslint.js")); } | @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(conte... | 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 ... | 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 ... | 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 ... | 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 ... |
@Test public void canBuildMultipleLintersFromSameInstance() throws Exception { assertJSLintOK(builder.fromDefault()); assertJSLintOK(builder.fromDefault()); } | public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } | JSLintBuilder { public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } } | JSLintBuilder { public JSLint fromDefault() { try { return fromClasspathResource(JSLINT_FILE); } catch (IOException e) { throw new RuntimeException(e); } } } | 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); JSLi... | 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); JSLi... |
@Test public void testValueOf() { String[] ary = StringArray.valueOf("a,b"); assertThat(ary, arrayContaining("a", "b")); } | public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } | StringArray { public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } } | StringArray { public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } private StringArray(); } | StringArray { public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } private StringArray(); static String[] valueOf(String str); } | StringArray { public static String[] valueOf(String str) { return str.split("\\s*,\\s*"); } private StringArray(); static String[] valueOf(String str); } |
@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... | 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 { repo... | 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 reporte... | 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 reporte... | 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 reporte... | 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 reporte... |
@Test public void testConvert() throws Exception { assertThat(cc.convert("UTF-8"), is(Charsets.UTF_8)); } | 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 + "'"); } } | 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 ... | 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 ... | 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 ... | 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 ... |
@Test public void testIllegalCharsetName() throws Exception { thrown.expect(ParameterException.class); thrown.expectMessage("unknown encoding"); cc.convert("!@#$%^&*("); } | 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 + "'"); } } | 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 ... | 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 ... | 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 ... | 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 ... |
@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); } | 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 + "'"); } } | 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 ... | 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 ... | 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 ... | 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 ... |
@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> expectedStdo... | private void version() { if (lint == null) { lint = lintBuilder.fromDefault(); } info("using jslint version " + lint.getEdition()); throw new DieException(null, 0); } | Main { private void version() { if (lint == null) { lint = lintBuilder.fromDefault(); } info("using jslint version " + lint.getEdition()); throw new DieException(null, 0); } } | Main { private void version() { if (lint == null) { lint = lintBuilder.fromDefault(); } info("using jslint version " + lint.getEdition()); throw new DieException(null, 0); } } | 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); } | 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 testToString() { JSFunction f = new JSFunction.Builder("fred", 1).build(); assertThat(f.toString(), is("function fred()")); } | @Override public String toString() { return String.format("function %s()", getName()); } | JSFunction { @Override public String toString() { return String.format("function %s()", getName()); } } | JSFunction { @Override public String toString() { return String.format("function %s()", getName()); } private JSFunction(Builder builder); } | 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(); ... | 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(); ... |
@Test public void testLogToFileOnSuccess() throws Exception { useGoodSource(); mojo.execute(); assertFileExists("jslint.xml"); } | 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 { repo... | 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 reporte... | 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 reporte... | 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 reporte... | 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 reporte... |
@Test @UseDataProvider("eventsWithEmpty") public void isEmpty(ConditionEvents events, boolean expectedEmpty) { assertThat(events.isEmpty()).as("events are empty").isEqualTo(expectedEmpty); } | @PublicAPI(usage = ACCESS) public boolean isEmpty() { return getAllowed().isEmpty() && getViolating().isEmpty(); } | ConditionEvents implements Iterable<ConditionEvent> { @PublicAPI(usage = ACCESS) public boolean isEmpty() { return getAllowed().isEmpty() && getViolating().isEmpty(); } } | ConditionEvents implements Iterable<ConditionEvent> { @PublicAPI(usage = ACCESS) public boolean isEmpty() { return getAllowed().isEmpty() && getViolating().isEmpty(); } @PublicAPI(usage = ACCESS) ConditionEvents(); } | 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 setInformatio... | 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 setInformatio... |
@Test public void direct_dependencies_from_self_by_inheritance() { JavaClass javaClass = importClassWithContext(AExtendingSuperAImplementingInterfaceForA.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(extendsDependency() .from(AExtendingSuperAImplementingInterfaceForA.class) .to(SuperA.cla... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... |
@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... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... |
@Test public void direct_dependencies_from_self_by_annotation() { JavaClass javaClass = importClasses(ClassWithAnnotationDependencies.class) .get(ClassWithAnnotationDependencies.class); assertThat(javaClass.getDirectDependenciesFromSelf()) .areAtLeastOne(annotationTypeDependency() .from(ClassWithAnnotationDependencies.... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... |
@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(); asse... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesFromSelf() { return javaClassDependencies.getDirectDependenciesFromClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage ... |
@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))... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... |
@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(AExtendingSuperAImplementingInt... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... |
@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) .inLineNumb... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... |
@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)); as... | @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<Dependency> getDirectDependenciesToSelf() { return javaClassDependencies.getDirectDependenciesToClass(); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = AC... |
@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()); } | @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } JavaClass(JavaClassBuilder builder); } | 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(); @Overrid... | 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(); @Overrid... |
@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'"); } | @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public String getSimpleName() { return descriptor.getSimpleClassName(); } JavaClass(JavaClassBuilder builder); } | 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(); @Overrid... | 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(); @Overrid... |
@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(); } | @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 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(n... | 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(n... | 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(n... | 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(n... |
@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")... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@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")).reje... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@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.getNa... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@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"))) ... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@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) .hasDes... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@Test public void predicate_belong_to() { JavaClasses classes = new ClassFileImporter().importPackagesOf(getClass()); JavaClass outerAnonymous = getOnlyClassSettingField(classes, ClassWithNamedAndAnonymousInnerClasses.name_of_fieldIndicatingOuterAnonymousInnerClass); JavaClass nestedAnonymous = getOnlyClassSettingField... | @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } } | JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return descriptor.getFullyQualifiedClassName(); } JavaClass(JavaClassBuilder builder); } | 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... | 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... |
@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(c... | @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } } | 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); } | 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 ... | 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 ... |
@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... | @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } } | 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); } | 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 ... | 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 ... |
@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().... | @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType) { return isMetaAnnotatedWith(annotationType.getName()); } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType) { return isMetaAnnotatedWith(annotationType.getName()); } } | 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); } | 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); @O... | 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); @O... |
@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.getTarg... | @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType) { return isMetaAnnotatedWith(annotationType.getName()); } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType) { return isMetaAnnotatedWith(annotationType.getName()); } } | 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); } | 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); @O... | 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); @O... |
@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) .haveAtLeastOneViolationMessageMat... | @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); } | 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_DEPENDENC... | 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_DEPENDENC... | 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_DEPENDENC... | 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_DEPENDENC... |
@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.g... | @Override @PublicAPI(usage = ACCESS) public JavaClass getOwner() { return owner; } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public JavaClass getOwner() { return owner; } } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public JavaClass getOwner() { return owner; } AccessTarget(JavaClass owner, String name, String fullName); } | 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) J... | 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) J... |
@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.getTa... | @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } } | AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } AccessTarget(JavaClass owner, String name, String fullName); } | 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) JavaCl... | 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) JavaCl... |
@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... | @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> type) { return isAnnotatedWith(type.getName()); } | 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 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(JavaMember... | 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(JavaMember... | 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(JavaMember... |
@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<?>>always... | @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> type) { return isAnnotatedWith(type.getName()); } | 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 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(JavaMember... | 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(JavaMember... | 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(JavaMember... |
@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... | @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> type) { return isMetaAnnotatedWith(type.getName()); } | 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 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(Ja... | 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(Ja... | 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(Ja... |
@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.get... | @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> type) { return isMetaAnnotatedWith(type.getName()); } | 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 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(Ja... | 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(Ja... | 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(Ja... |
@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 " + ... | @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } | JavaMember implements
HasName.AndFullName, HasDescriptor, HasAnnotations<JavaMember>, HasModifiers, HasOwner<JavaClass>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } } | JavaMember implements
HasName.AndFullName, HasDescriptor, HasAnnotations<JavaMember>, HasModifiers, HasOwner<JavaClass>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } JavaMember(JavaMemberBuilder<?, ?> builder); } | 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<? e... | 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<? e... |
@Test public void containsType() { JavaMethod method = importMethod(SomeClass.class, "method"); assertAllTrue(contains(method, SQLDataException.class)); assertAllFalse(contains(method, Exception.class)); } | @PublicAPI(usage = ACCESS) public boolean containsType(Class<?> type) { return containsType(type.getName()); } | ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public boolean containsType(Class<?> type) { return containsType(type.getName()); } } | 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); } | 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<... | 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<... |
@Test public void size() { assertThat(importMethod(SomeClass.class, "method").getThrowsClause().size()) .as("size of throws clause").isEqualTo(2); } | @PublicAPI(usage = ACCESS) public int size() { return throwsDeclarations.size(); } | ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public int size() { return throwsDeclarations.size(); } } | ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public int size() { return throwsDeclarations.size(); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); } | 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 =... | 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 =... |
@Test public void getTypes() { JavaMethod method = importMethod(SomeClass.class, "method"); assertThatTypes(method.getThrowsClause().getTypes()).matchInAnyOrder(IOException.class, SQLDataException.class); } | @PublicAPI(usage = ACCESS) public JavaClassList getTypes() { return new JavaClassList(FluentIterable.from(throwsDeclarations).transform(toGuava(GET_RAW_TYPE)).toList()); } | 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()); } } | 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> thrownT... | 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> thrownT... | 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> thrownT... |
@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")) .haveOneViolationMessageCon... | @PublicAPI(usage = ACCESS) public static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type) { return declareThrowableOfType(equivalentTo(type).as(type.getName())); } | ArchConditions { @PublicAPI(usage = ACCESS) public static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type) { return declareThrowableOfType(equivalentTo(type).as(type.getName())); } } | ArchConditions { @PublicAPI(usage = ACCESS) public static ArchCondition<JavaCodeUnit> declareThrowableOfType(Class<? extends Throwable> type) { return declareThrowableOfType(equivalentTo(type).as(type.getName())); } private ArchConditions(); } | 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 Cla... | 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 Cla... |
@Test public void restriction_on_classes_should_filter_the_elements() { JavaClasses onlySomeClass = ALL_CLASSES.that(haveTheNameOf(SomeClass.class)); assertThat(onlySomeClass).containsExactly(SOME_CLASS); } | @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... | 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); ... | 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); ... | 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); ... | 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); ... |
@Test public void contain_type() { assertThat(ALL_CLASSES.contain(getClass())).isFalse(); assertThat(ALL_CLASSES.contain(SomeOtherClass.class)).isTrue(); } | @PublicAPI(usage = ACCESS) public boolean contain(Class<?> reflectedType) { return contain(reflectedType.getName()); } | JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public boolean contain(Class<?> reflectedType) { return contain(reflectedType.getName()); } } | 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... | 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... | 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... |
@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); } | @PublicAPI(usage = ACCESS) public JavaClass get(Class<?> reflectedType) { return get(reflectedType.getName()); } | JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public JavaClass get(Class<?> reflectedType) { return get(reflectedType.getName()); } } | 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> clas... | 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> clas... | 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> clas... |
@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); } | 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 n... | 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 d... | 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 d... | 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 d... | 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 d... |
@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(), ... | @PublicAPI(usage = ACCESS) public Optional<String> getFileName() { return fileName; } | Source { @PublicAPI(usage = ACCESS) public Optional<String> getFileName() { return fileName; } } | Source { @PublicAPI(usage = ACCESS) public Optional<String> getFileName() { return fileName; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); } | 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(); ... | 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(); ... |
@Test @UseDataProvider("equalMd5Sums") public void positive_equals_hashcode_of_md5sums(Md5sum first, Md5sum second) { assertThat(first).isEqualTo(second); assertThat(first.hashCode()).isEqualTo(second.hashCode()); } | @Override public int hashCode() { return Objects.hash(uri, md5sum); } | Source { @Override public int hashCode() { return Objects.hash(uri, md5sum); } } | Source { @Override public int hashCode() { return Objects.hash(uri, md5sum); } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); } | 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 ha... | 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 ha... |
@Test public void compensates_error_on_md5_calculation() throws Exception { Source source = newSource(new URI("bummer")); assertThat(source.getMd5sum()).isEqualTo(Md5sum.UNDETERMINED); } | @PublicAPI(usage = ACCESS) public Md5sum getMd5sum() { return md5sum; } | Source { @PublicAPI(usage = ACCESS) public Md5sum getMd5sum() { return md5sum; } } | Source { @PublicAPI(usage = ACCESS) public Md5sum getMd5sum() { return md5sum; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); } | 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 ... | 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 ... |
@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 <" + origi... | @Override @PublicAPI(usage = ACCESS) public String getDescription() { return description; } | Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getDescription() { return description; } } | 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); } | 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 ge... | 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 ge... |
@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.tryCre... | static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceofCheck.getLineNumber()); } | Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceof... | Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceof... | Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceof... | Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceof... |
@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(predicateWithDesc... | 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); } | 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.... | 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.... | 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.... | 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.... |
@Test public void test_classes() { JavaClasses input = importClasses(Object.class, String.class); DescribedIterable<JavaClass> output = Transformers.classes().transform(input); assertThat(output).containsOnlyElementsOf(input); } | static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } | Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } } | Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } } | Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } } | Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } } |
@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"); } | @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } JavaTypeVariable(String name, JavaClass erasure); } | 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 ... | 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 ... |
@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... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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).getTypeParameter... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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(ClassWithBoundTypeParameterWithSingleGene... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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> { } JavaTypeVariab... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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 ClassFileImp... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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<JavaTypeVa... | @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaTypeVariable(String name, JavaClass erasure); } | 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 @PublicAP... | 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 @PublicAP... |
@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") .doesNot... | @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaTypeVariable(String name, JavaClass erasure); } | 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(u... | 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(u... |
@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(JavaTypeV... | @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaTypeVariable(String name, JavaClass erasure); } | 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(u... | 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(u... |
@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.toStrin... | @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } } | JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaTypeVariable(String name, JavaClass erasure); } | 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(u... | 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(u... |
@Test public void transform_javaclasses() { AbstractClassesTransformer<String> transformer = toNameTransformer(); JavaClasses classes = importClassesWithContext(AbstractClassesTransformer.class, AbstractClassesTransformerTest.class); DescribedIterable<String> transformed = transformer.transform(classes); assertThat(tra... | @Override public final DescribedIterable<T> transform(JavaClasses collection) { return DescribedIterable.From.iterable(doTransform(collection), description); } | AbstractClassesTransformer implements ClassesTransformer<T> { @Override public final DescribedIterable<T> transform(JavaClasses collection) { return DescribedIterable.From.iterable(doTransform(collection), description); } } | AbstractClassesTransformer implements ClassesTransformer<T> { @Override public final DescribedIterable<T> transform(JavaClasses collection) { return DescribedIterable.From.iterable(doTransform(collection), description); } protected AbstractClassesTransformer(String description); } | 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> tr... | 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> tr... |
@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.setProp... | public T load() { return supplier.get(); } | PluginLoader { public T load() { return supplier.get(); } } | PluginLoader { public T load() { return supplier.get(); } private PluginLoader(Class<T> pluginType, Map<JavaVersion, String> versionToPlugins, T fallback); } | 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(); } | 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 if_no_extension_properties_are_found_empty_properties_are_returned() { ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); assertThat(configuration.getExtensionProperties("not-there")).isEmpty(); } | @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } } | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... |
@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" ); Ar... | @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } } | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... | ArchConfiguration { @PublicAPI(usage = ACCESS) public Properties getExtensionProperties(String extensionIdentifier) { String propertyPrefix = getFullExtensionPropertyPrefix(extensionIdentifier); return getSubProperties(propertyPrefix); } private ArchConfiguration(); private ArchConfiguration(String propertiesResource... |
@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"); } | @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } | ArchConfiguration { @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } } | ArchConfiguration { @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } private ArchConfiguration(); private ArchConfiguration(String propertiesResourceName); } | 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 ArchConfig... | 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 ArchConfig... |
@Test public void returns_default_if_property_is_unset() { writeProperties(); ArchConfiguration configuration = testConfiguration(PROPERTIES_FILE_NAME); assertThat(configuration.getPropertyOrDefault("unconfigured.property", "default")).isEqualTo("default"); } | @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } | ArchConfiguration { @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } } | ArchConfiguration { @PublicAPI(usage = ACCESS) public String getPropertyOrDefault(String propertyName, String defaultValue) { return properties.getProperty(propertyName, defaultValue); } private ArchConfiguration(); private ArchConfiguration(String propertiesResourceName); } | 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 ArchConfig... | 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 ArchConfig... |
@Test public void alwaysTrue_works() { assertThat(alwaysTrue()).accepts(new Object()).hasDescription("always true"); } | @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysTrue() { return (DescribedPredicate<T>) ALWAYS_TRUE; } | DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysTrue() { return (DescribedPredicate<T>) ALWAYS_TRUE; } } | DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysTrue() { return (DescribedPredicate<T>) ALWAYS_TRUE; } DescribedPredicate(String description, Object... params); } | 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... param... | 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... param... |
@Test public void alwaysFalse_works() { assertThat(alwaysFalse()).rejects(new Object()).hasDescription("always false"); } | @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysFalse() { return (DescribedPredicate<T>) ALWAYS_FALSE; } | DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysFalse() { return (DescribedPredicate<T>) ALWAYS_FALSE; } } | DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysFalse() { return (DescribedPredicate<T>) ALWAYS_FALSE; } DescribedPredicate(String description, Object... params); } | 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... par... | 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... par... |
@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); } | public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } DescribedPredicate(String description, Object... params); } | 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>... | 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>... |
@Test public void lessThan_works() { assertThat(lessThan(4)) .accepts(3) .hasDescription("less than '4'") .rejects(4) .rejects(5); assertThat(lessThan(Foo.SECOND)) .accepts(Foo.FIRST) .rejects(Foo.SECOND) .rejects(Foo.THIRD); } | public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params);... | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params);... |
@Test public void greaterThan_works() { assertThat(greaterThan(5)) .accepts(6) .hasDescription("greater than '5'") .rejects(5) .rejects(4); assertThat(greaterThan(Foo.SECOND)) .rejects(Foo.FIRST) .rejects(Foo.SECOND) .accepts(Foo.THIRD); } | public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... pa... | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... pa... |
@Test public void extensions_are_configured() throws IOException { TestExtension extensionOne = new TestExtension("one"); TestExtension extensionTwo = new TestExtension("two"); when(extensionLoader.getAll()).thenReturn(ImmutableSet.<ArchUnitExtension>of(extensionOne, extensionTwo)); ArchConfiguration.get().setExtension... | public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); void dispatch(EvaluatedRule evaluatedRule); } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); void dispatch(EvaluatedRule evaluatedRule); } |
@Test public void lessThanOrEqualTo_works() { assertThat(lessThanOrEqualTo(5)) .accepts(4) .hasDescription("less than or equal to '5'") .accepts(5) .rejects(6); assertThat(lessThanOrEqualTo(Foo.SECOND)) .accepts(Foo.FIRST) .accepts(Foo.SECOND) .rejects(Foo.THIRD); } | public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, ... | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, ... |
@Test public void greaterThanOrEqualTo_works() { assertThat(greaterThanOrEqualTo(5)) .accepts(6) .hasDescription("greater than or equal to '5'") .accepts(5) .rejects(4); assertThat(greaterThanOrEqualTo(Foo.SECOND)) .rejects(Foo.FIRST) .accepts(Foo.SECOND) .accepts(Foo.THIRD); } | public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String descrip... | DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String descrip... |
@Test public void describe_works() { Predicate<Integer> isEven = new Predicate<Integer>() { @Override public boolean apply(Integer input) { return input % 2 == 0; } }; assertThat(describe("is even", isEven)) .accepts(8) .hasDescription("is even") .accepts(4) .rejects(5); } | public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate... | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate... |
@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); } | public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } } | DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> equalTo(final T object) { return new EqualToPredicate<>(object); } DescribedPredicate(String description, Object... params); } | 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>... | 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>... |
@Test public void empty_works() { assertThat(empty()) .hasDescription("empty") .accepts(Collections.emptyList()) .accepts(Collections.emptySet()) .rejects(ImmutableList.of(1)) .rejects(Collections.singleton("")); } | public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } | DescribedPredicate implements Predicate<T> { public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } } | DescribedPredicate implements Predicate<T> { public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } DescribedPredicate(String description, Object... params); } | DescribedPredicate implements Predicate<T> { public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final Described... | DescribedPredicate implements Predicate<T> { public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final Described... |
@Test @DataProvider(value = { "some.arbitrary.pkg | some.arbitrary.pkg | true", "some.arbitrary.pkg | some.thing.different | false", "some..pkg | some.arbitrary.pkg | true", "some..middle..pkg | some.arbitrary.middle.more.pkg | true", "*..pkg | some.arbitrary.pkg | true", "some..* | some.arbitrary.pkg | true", "*..pkg ... | @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } | PackageMatcher { @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } } | PackageMatcher { @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } private PackageMatcher(String packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static... | PackageMatcher { @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static... |
@Test public void should_reject_more_than_two_dots_in_a_row() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier may not contain more than two '.' in a row"); PackageMatcher.of("some...pkg"); } | @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... |
@Test public void should_reject_more_than_one_star_in_a_row() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier may not contain more than one '*' in a row"); PackageMatcher.of("some**package"); } | @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... |
@Test public void should_reject_capturing_with_two_dots() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier does not support capturing via (..), use (**) instead"); PackageMatcher.of("some.(..).package"); } | @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... |
@Test public void should_reject_illegal_characters() { String illegalPackageIdentifier = "some" + PackageMatcher.TWO_STAR_REGEX_MARKER + "package"; thrown.expect(IllegalArgumentException.class); thrown.expectMessage(String.format( "Package Identifier '%s' may only consist of valid java identifier parts or the symbols '... | @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); } | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... | PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean mat... |
@Test public void evaluated_rules_are_dispatched_after_extension_has_been_configured() { TestExtension extension = enabled(new TestExtension("test") { @Override public void handle(EvaluatedRule evaluatedRule) { assertPropertiesAreConfigured(); super.handle(evaluatedRule); } private void assertPropertiesAreConfigured() ... | public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); void dispatch(EvaluatedRule evaluatedRule); } | ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); void dispatch(EvaluatedRule evaluatedRule); } |
@Test public void matches_any_package() { assertThat(PackageMatchers.of("..match..", "..other..")) .accepts("foo.match.bar") .accepts("foo.other.bar") .accepts("foo.match.other.bar") .rejects("foo.bar") .rejects("matc.hother"); } | @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(String... ... | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(String... ... |
@Test public void description() { assertThat(PackageMatchers.of("..foo..", "..bar..")) .hasDescription("matches any of ['..foo..', '..bar..']"); } | @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); } | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(String... ... | PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(String... ... |
@Test public void after() { Integer result = plus(7).after(parseInteger()).apply("11"); assertThat(result).as("Adding 7 after parseInt('11')").isEqualTo(18); } | public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } | ChainableFunction implements Function<F, T> { public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } } | ChainableFunction implements Function<F, T> { public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } } | ChainableFunction implements Function<F, T> { public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } ChainableFunction<E, T> after(final Fun... | ChainableFunction implements Function<F, T> { public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } ChainableFunction<E, T> after(final Fun... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.