},
        "japanese_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}ja/stopwords.txt"
        },
        "korean_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}ko/stopwords.txt"
        },
        "latvian_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}lv/stopwords.txt"

                // Do nothing
            }

            @Override
            public void stop() {
                stopCallCount.incrementAndGet();
            }
        };

        // Execute stop multiple times
        dataStore.stop();
        dataStore.stop();
        dataStore.stop();

        assertEquals(3, stopCallCount.get());
    }

docker volume prune -f || true
docker volume rm $(docker volume ls -q -f dangling=true) || true

# Stop two nodes, one of each pool, to check that all S3 calls work while quorum is still there
[ "${MODE}" == "pools" ] && docker-compose -f minio-${MODE}.yaml stop minio2
[ "${MODE}" == "pools" ] && docker-compose -f minio-${MODE}.yaml stop minio6

# Pause one node, to check that all S3 calls work while one node goes wrong

    assertSame(stopwatch, stopwatch.stop());
    assertFalse(stopwatch.isRunning());
  }

  public void testStop_new() {
    assertThrows(IllegalStateException.class, stopwatch::stop);
    assertFalse(stopwatch.isRunning());
  }

  public void testStop_alreadyStopped() {
    stopwatch.start();
    stopwatch.stop();
    assertThrows(IllegalStateException.class, stopwatch::stop);
    assertFalse(stopwatch.isRunning());
  }

import org.lastaflute.web.validation.Required;

/**
 * The download form for stop words dictionary.
 * This form is used for downloading stop words dictionary files from the admin interface.
 *
 */
public class DownloadForm {

    /**
     * Dictionary ID for identifying the stop words dictionary to download.
     */
    @Required
    public String dictId;

    /**

 */
package org.codelibs.fess.app.web.api.admin.dict.stopwords;

import org.codelibs.fess.app.web.api.admin.dict.BaseSearchDictBody;

/**
 * Search request body for stop words dictionary administration.
 * Extends BaseSearchDictBody with stop words dictionary-specific search parameters.
 */
public class SearchBody extends BaseSearchDictBody {

    /**
     * Default constructor for SearchBody.
     */

                    result = true;
                    // don't stop processing in case a future segment explicitly excludes this repo
                }
                // check for external:http:*
                else if (EXTERNAL_HTTP_WILDCARD.equals(repo) && isExternalHttpRepo(originalRepository)) {
                    result = true;
                    // don't stop processing in case a future segment explicitly excludes this repo

	mc idp ldap policy attach old-minio readwrite --group=CN=project.c,ou=groups,ou=swengg,dc=min,dc=io

	mc idp ldap policy entities old-minio

	mc admin cluster iam export old-minio
	set +x

	mc admin service stop old-minio
}

import_iam_content_in_new_minio() {
	echo "Importing IAM content in new minio instance."
	# Assume current minio binary exists.
	MINIO_CI_CD=1 ./minio server /tmp/data/{1...4} &
	sleep 5

	set -x

func ExampleScanner_earlyStop() {
	onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
		i := bytes.IndexByte(data, ',')
		if i == -1 {
			if !atEOF {
				return 0, nil, nil
			}
			// If we have reached the end, return the last token.
			return 0, data, bufio.ErrFinalToken
		}
		// If the token is "STOP", stop the scanning and ignore the rest.

   * to stop requests. You could poll for lifecycle changes in a work loop:
   *
   * <pre>
   *   public void run() {
   *     while ({@link #isRunning()}) {
   *       // perform a unit of work
   *     }
   *   }
   * </pre>
   *
   * <p>...or you could respond to stop requests by implementing {@link #triggerShutdown()}, which