cli.BoolFlag{
		Name:   "compat",
		Usage:  "enable strict S3 compatibility by turning off certain performance optimizations",
		Hidden: true,
	},
	// This flag is hidden and to be used only during certain performance testing.
	cli.BoolFlag{
		Name:   "no-compat",
		Usage:  "disable strict S3 compatibility by turning on certain performance optimizations",
		Hidden: true,
	},
}

// Help template for minio.

    * DualStack:
    * => IPv4 BackendPool name == clusterName
    * => IPv6 BackendPool name == <clusterName>-IPv6
    * This result into:
    * - clusters moving from IPv4 to duakstack will require no changes
    * - clusters moving from IPv6 (while not seen in the wild, we can not rule out their existence) to dualstack will require deleting backend pools (the reconciler will take care of creating correct backendpools)

   * number of elements and whose elements may change over time.
   *
   * <p>This test might fail in GWT because the GWT emulations might count on the input collection
   * not to change during the copy. It is safe to do so in GWT because javascript is
   * single-threaded.
   */
  @GwtIncompatible // GWT is single threaded
  public void testCopyOf_threadSafe() {
    /*

     * @param cred the authentication credentials to use for the session
     * @throws SmbException if an SMB protocol error occurs
     * @throws GeneralSecurityException if a security error occurs during authentication
     */
    public SmbComSessionSetupAndX(final CIFSContext tc, final SmbComNegotiateResponse negotiated, final ServerMessageBlock andx,
            final Object cred) throws SmbException, GeneralSecurityException {

     * @param file the actual file containing the dictionary content
     * @throws DictionaryException if the file was updated by another process,
     *         if the file doesn't exist, or if there's an error during storage
     */
    public void store(final DictionaryFile<? extends DictionaryItem> dictFile, final File file) {
        getDictionaryFile(dictFile.getId()).ifPresent(currentFile -> {

			if err != nil && tc.expectedParsingErr != nil && err.Error() != tc.expectedParsingErr.Error() {
				t.Fatalf("%d: Expected '%v' during parsing but got '%v'", i+1, tc.expectedParsingErr, err)
			}
			if err == nil && tc.expectedParsingErr != nil {
				t.Fatalf("%d: Expected '%v' during parsing but got '%v'", i+1, tc.expectedParsingErr, err)
			}
			if tc.expectedParsingErr != nil {
				// We already expect a parsing error,

     * When enabled, thumbnails are generated for supported file types.
     */
    @Size(max = 10)
    public String thumbnail;

    /**
     * Types of crawling failures to ignore during crawling operations.
     * Specified failure types will not be logged or counted as errors.
     */
    @Size(max = 1000)
    public String ignoreFailureType;

    /**

        DirFileEntryEnumIterator1 it = new DirFileEntryEnumIterator1(tree, parent, "*", null, 0);
        assertFalse(it.hasNext(), "Iterator should be empty when server reports no such file");

        // FindClose2 is sent during cleanup
        verify(tree, times(1)).send(isA(SmbComFindClose2.class), any());
        verify(tree, atLeastOnce()).release();
    }

    @ParameterizedTest
    @ValueSource(strings = { "", " ", "*", "?" })

        verify(transport).disconnect(true, true);
    }

    // Happy path: ensureConnected returns true/false
    @ParameterizedTest
    @DisplayName("ensureConnected indicates if it connected during call")
    @ValueSource(booleans = { true, false })
    void ensureConnected_returns(boolean connectedDuringCall) throws Exception {
        when(transport.ensureConnected()).thenReturn(connectedDuringCall);

     * Continues executing tasks from {@link #queue} until it is empty.
     *
     * <p>The thread's interrupt bit is cleared before execution of each task.
     *
     * <p>If the Thread in use is interrupted before or during execution of the tasks in {@link
     * #queue}, the Executor will complete its tasks, and then restore the interruption. This means
     * that once the Thread returns to the Executor that this Executor composes, the interruption