private static boolean isSystemStackFrame(String className) {
        return className.startsWith("jdk.internal.") ||
            className.startsWith("sun.") ||
            className.startsWith("com.sun.") ||
            className.startsWith("org.codehaus.groovy.") ||
            className.startsWith("org.gradle.internal.metaobject.") ||
            className.startsWith("org.gradle.kotlin.dsl.execution.");
    }

            assertThat(packageName, is(notNullValue()));
            assertThat(shortClassName, is(notNullValue()));
            assertThat(packageName,
                    packageName.startsWith("junit") || packageName.startsWith("org.junit") || packageName.startsWith("org.hamcrest"),
                    is(true));
            count++;
        });
        assertTrue(count > 0);
    }

    /**
     * @throws Exception
     */

        withWorkaroundsFor("task-project") {
            task.javaClass.name.run {
                startsWith("com.android.build.gradle.tasks.ShaderCompile")
                    || startsWith("com.android.build.gradle.tasks.MapSourceSetPathsTask")
                    || startsWith("com.android.build.gradle.tasks.MergeResources")
            }
        }

    fun canAccessConventions(from: String, area: String) =

        String lower = permission.toLowerCase(Locale.ROOT);
        final String aclPrefix;
        if (lower.startsWith(allowPrefix)) {
            lower = lower.substring(allowPrefix.length());
            permission = permission.substring(allowPrefix.length());
            aclPrefix = StringUtil.EMPTY;
        } else if (lower.startsWith(denyPrefix)) {
            lower = lower.substring(denyPrefix.length());

                }
                System.out.println(path);
                assertThat(path, is(notNullValue()));
                assertThat(path, path.startsWith("junit") || path.startsWith("org/junit") || path.startsWith("org/hamcrest")
                        || path.startsWith("META-INF/") || path.equals("LICENSE-junit.txt"), is(true));
                assertThat(is, is(notNullValue()));
                count++;
            } finally {

        s.startsWith("snippet-configuration-cache-") ||
            s.startsWith("snippet-test-kit-") ||
            s.startsWith("snippet-java-") ||
            s.startsWith("snippet-maven-") ||
            s.startsWith("snippet-plugins-") ||
            s.startsWith("snippet-tasks-") ||
            s.startsWith("snippet-files-");
    private static final Predicate<String> SNIPPETS_BUCKET_3 = s ->

        if (s.startsWith("#")) {
            return StringUtil.EMPTY;
        }
        if (s.startsWith(CONTAINS)) {
            final String v = s.substring(CONTAINS.length());
            final StringBuilder buf = new StringBuilder(100);
            return ".*" + appendFileterPath(buf, escape(v)) + ".*";
        }
        if (s.startsWith(REGEXP_IGNORE_CASE)) {

            final String key = entry.getKey();
            if (key.startsWith(CONFIG_PREFIX)) {
                configConfigMap.put(key.substring(CONFIG_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(CLIENT_PREFIX)) {
                clientConfigMap.put(key.substring(CLIENT_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(XPATH_PREFIX)) {

        Activation activation = profile.getActivation();

        String jdk = activation.getJdk();

        // null case is covered by canDetermineActivation(), so we can do a straight startsWith() here.
        if (jdk.startsWith("[") || jdk.startsWith("(")) {
            try {
                return matchJdkVersionRange(jdk);
            } catch (InvalidVersionSpecificationException e) {
                throw new ProfileActivationException(

        then:
        def e = thrown(AssertionError)
        e.message.trim().startsWith('Expected: a collection containing "none"')

        when:
        failure.assertHasLineNumber(23)

        then:
        def e2 = thrown(AssertionError)
        e2.message.trim().startsWith('Expected: a collection containing "23"')
    }

    def "cannot assert that failure location is present when missing"() {