}

        // If file ends inside an example, still check that block
        if (inExample) {
            flagIfReversed(file, errors, currentSnippets);
        }
    }

    /**
     * Only flags when the first two detectable snippets in the block are GROOVY then KOTLIN.
     * Ignores blocks with fewer than two detectable snippets.
     */

     */
    public void setFileInformationClass(final byte fileInformationClass) {
        this.fileInformationClass = fileInformationClass;
    }

    /**
     * Sets the query flags for the directory enumeration
     *
     * @param queryFlags
     *            the queryFlags to set
     */
    public void setQueryFlags(final byte queryFlags) {
        this.queryFlags = queryFlags;
    }

     */
    public void setRemainingBytes(final int remainingBytes) {
        this.remainingBytes = remainingBytes;
    }

    /**
     * Sets the write operation flags.
     *
     * @param writeFlags the writeFlags to set
     */
    public void setWriteFlags(final int writeFlags) {
        this.writeFlags = writeFlags;
    }

    /**

    /**
     * Creation time of the crawling information.
     */
    public String createdTime;

    /**
     * Clears all pagination state and crawling information fields.
     * Resets all counts, page flags, and crawling-specific fields to their default values.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;

                             * like writeandx will choke if session
                             * closes in between
                             */
    }

    /**
     * Sets the write mode flags for this request.
     *
     * @param writeMode
     *            the writeMode to set
     */
    public final void setWriteMode(final int writeMode) {
        this.writeMode = writeMode;
    }

    assertThat(input)
        .matches(
            Pattern.compile(
                Doubles.FLOATING_POINT_PATTERN.pattern(), Doubles.FLOATING_POINT_PATTERN.flags()));
  }

  @GwtIncompatible // Doubles.tryParse
  public void testTryParseHex() {
    for (String signChar : ImmutableList.of("", "+", "-")) {
      for (String hexPrefix : ImmutableList.of("0x", "0X")) {

public class SmbCopyUtilTest {

    // --- Tests for openCopyTargetFile ---

    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("openCopyTargetFile sets correct access flags depending on alsoRead")
    void openCopyTargetFile_accessMask_respectsAlsoRead(boolean alsoRead) throws Exception {
        // Arrange
        SmbFile dest = mock(SmbFile.class);

Example:

```sh
minio server /data{1...4}
```

The command takes no flags

```sh
mc support diagnostics myminio/
```

The output printed will be of the form

```sh
● Admin Info ... ✔ 
● CPU ... ✔ 
● Disk Hardware ... ✔ 
● Os Info ... ✔ 
● Mem Info ... ✔ 

    /**
     * Gets the IOCTL control code from the response.
     *
     * @return the ctlCode
     */
    public int getCtlCode() {
        return this.ctlCode;
    }

    /**
     * Gets the IOCTL flags from the response.
     *
     * @return the ioctlFlags
     */
    public int getIoctlFlags() {
        return this.ioctlFlags;
    }

    /**
     * Gets the file identifier from the response.
     *

## Building and Testing

The most reliable way to build and test Guava is:

```shell
./mvnw clean install
```

If you want to run a single test, you'll need to pass multiple flags because
Guava is a multi-module project. For performance reasons, you may also wish to
skip generating Javadoc. For example:

```shell