// Test for reduceErrs, reduceErr reduces collection
// of errors into a single maximal error with in the list.
func TestReduceErrs(t *testing.T) {
	canceledErrs := make([]error, 0, 5)
	for i := range 5 {
		canceledErrs = append(canceledErrs, fmt.Errorf("error %d: %w", i, context.Canceled))
	}
	// List all of all test cases to validate various cases of reduce errors.
	testCases := []struct {
		errs        []error
		ignoredErrs []error

      }
      // if the length of the toString() result was > maxLength for some reason, truncate that
      seq = string;
    }

    return new StringBuilder(maxLength)
        .append(seq, 0, truncationLength)
        .append(truncationIndicator)
        .toString();
  }

  /**
   * Indicates whether the contents of the given character sequences {@code s1} and {@code s2} are

      StringBuilder escapedInput = new StringBuilder();
      for (char c : input.toCharArray()) {
        if (c >= 0x20 && c <= 0x7E) {
          escapedInput.append(c);
        } else {
          escapedInput.append(String.format("\\u%04x", (int) c));
        }
      }
      fail("FLOATING_POINT_PATTERN should have matched valid input <" + escapedInput + ">");
    }
  }

Here, the `shutdown` event handler function will write a text line `"Application shutdown"` to a file `log.txt`.

/// info

In the `open()` function, the `mode="a"` means "append", so, the line will be added after whatever is on that file, without overwriting the previous contents.

///

/// tip

functionality. Syntax is `mc support inspect ALIAS/path/to/files`. This can for example be used to collect `xl.meta` from objects that are misbehaving. To collect `xl.meta` from a specific object, for example placed at `ALIAS/bucket/path/to/file.txt` append `/xl.meta`, for instance `mc support inspect ALIAS/bucket/path/to/file.txt/xl.meta`. All files can be collected, so this can also be used to retrieve `part.*` files, etc.

Wildcards can be used, for example `mc support inspect ALIAS/bucket/path/**/xl.meta`...

		},
		{
			err:     errIgnored,
			ignored: true,
		},
		{
			err:     errFaultyDisk,
			ignored: true,
		},
	}
	for i, testCase := range testCases {
		if ok := IsErrIgnored(testCase.err, append(baseIgnoredErrs, errIgnored)...); ok != testCase.ignored {
			t.Errorf("Test: %d, Expected %t, got %t", i+1, testCase.ignored, ok)
		}
	}
}

// Test queries()
func TestQueries(t *testing.T) {

     */
    int FILE_READ_DATA = 0x00000001; // 1
    /**
     * Permission to write data to a file or add files to a directory
     */
    int FILE_WRITE_DATA = 0x00000002; // 2
    /**
     * Permission to append data to a file or add subdirectories
     */
    int FILE_APPEND_DATA = 0x00000004; // 3
    /**
     * Permission to read extended attributes
     */
    int FILE_READ_EA = 0x00000008; // 4
    /**

    // access mask encoding
    /** File read data access right */
    int FILE_READ_DATA = 0x00000001; // 1
    /** File write data access right */
    int FILE_WRITE_DATA = 0x00000002; // 2
    /** File append data access right */
    int FILE_APPEND_DATA = 0x00000004; // 3
    /** File read extended attributes access right */
    int FILE_READ_EA = 0x00000008; // 4
    /** File write extended attributes access right */

            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;
    }

    /**
     * Appends a filter to the existing filter chain.
     *
     * @param filter the filter to append
     * @param chain the existing filter chain
     * @return a new filter chain with the filter appended
     */
    protected FilterChain appendFilterChain(final Filter filter, final FilterChain chain) {

| get                 | yes       |
| put                 | yes       |
| ls                  | yes       |
| mkdir               | yes       |
| rmdir               | yes       |
| delete              | yes       |
| append              | no        |
| rename              | no        |

MinIO supports following FTP/SFTP based protocols to access and manage data.