.desc("Stop at first failure in reactorized builds")
                    .get());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")
                    .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                    .get());
            options.addOption(Option.builder(FAIL_NEVER)

            // Assert message indicates which validation failed
            if (expectDirSlashMsg) {
                assertTrue(ex.getMessage().contains("directory must end with '/'"),
                        "Expected trailing slash message, was: " + ex.getMessage());
            } else {
                assertTrue(ex.getMessage().contains("invalid") || ex.getMessage().contains("invalid:"),

}

// Between represents the RHS of a BETWEEN expression
type Between struct {
	Not   bool     `parser:" @\"NOT\"? "`
	Start *Operand `parser:" \"BETWEEN\" @@ "`
	End   *Operand `parser:" \"AND\" @@ "`
}

// In represents the RHS of an IN expression. The RHS can be a list-literal
// (i.e. enclosed in parentheses like `IN (1,2,4)`) or it could be a JSON path

                    return name.length();
                }

                @Override
                public CharSequence subSequence(final int start, final int end) {
                    return name.subSequence(start, end);
                }

            };
        }

        /**
         * @return CharSequence
         */
        public static CharSequence aaa() {

        int actualResumeKey = SMBUtil.readInt4(buffer, 6);
        assertEquals(newResumeKey, actualResumeKey);

        // Check filename is updated (it's at the end after flags)
        String actualFilename = readString(buffer, 12, written - 12);
        assertEquals(newFilename, actualFilename);
    }

    @Test
    void testWriteSetupWireFormat() {

     *
     * @param element the object to be added
     */
    public void addFirst(final E element) {
        header.next.addBefore(element);
    }

    /**
     * Adds an element at the end.
     *
     * @param element the object to be added
     */
    public void addLast(final E element) {
        header.addBefore(element);
    }

    /**

        final URL u = locator.getURL();

        FileEntry[] entries;

        if (u.getPath().lastIndexOf('/') != u.getPath().length() - 1) {
            throw new SmbException(u.toString() + " directory must end with '/'");
        }

        if (locator.getType() != SmbConstants.TYPE_SERVER) {
            throw new SmbException("The requested list operations is invalid: " + u.toString());
        }

    /**
     * Skip n bytes of data on this stream. This operation will not result
     * in any IO with the server. Unlink <code>InputStream</code> value less than
     * the one provided will not be returned if it exceeds the end of the file
     * (if this is a problem let us know).
     */
    @Override
    public long skip(final long n) throws IOException {
        if (n > 0) {
            fp += n;
            return n;
        }

	scannerMetricHealAbandonedVersion

	// START Trace metrics:
	scannerMetricStartTrace
	scannerMetricScanObject // Scan object. All operations included.
	scannerMetricHealAbandonedObject

	// END realtime metrics:
	scannerMetricLastRealtime

	// Trace only metrics:
	scannerMetricScanFolder      // Scan a folder on disk, recursively.
	scannerMetricScanCycle       // Full cycle, cluster global

         * Not clean up global Gradle processes (i.e. classpath in ~/.gradle/...).
         */
        KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS,
        /**
         * Run at the end of each build. Kill potentially leaked processes in the current build.
         * Only kill local Gradle processes (classpath in checkout directory).
         * Not clean up global Gradle processes (i.e. classpath in ~/.gradle/...).