| `minio_cluster_health_capacity_raw_total_bytes`    | Total cluster raw storage capacity in bytes. <br><br>Type: gauge    |        |
| `minio_cluster_health_capacity_raw_free_bytes`     | Total cluster raw storage free in bytes. <br><br>Type: gauge        |        |

        // Then
        assertEquals(3, lanmanCompatibility, "Should delegate LanMan compatibility");
        assertTrue(allowNTLMFallback, "Should delegate NTLM fallback setting");
        assertFalse(useRawNTLM, "Should delegate raw NTLM setting");
        assertTrue(disablePlainTextPasswords, "Should delegate plain text password setting");
        assertEquals("GUEST", guestUsername, "Should delegate guest username");

      TestMultimapGenerator<K, V, M> generator) {
    return new MultimapTestSuiteBuilder<K, V, M>().usingGenerator(generator);
  }

  // Class parameters must be raw.
  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    return ImmutableList.<Class<? extends AbstractTester>>of(
        MultimapAsMapGetTester.class,

    return new ParameterizedTypeImpl(
        ClassOwnership.JVM_BEHAVIOR.getOwnerType(rawType), rawType, arguments);
  }

  /** Decides what owner type to use for constructing {@link ParameterizedType} from a raw class. */
  private enum ClassOwnership {
    OWNED_BY_ENCLOSING_CLASS {
      @Override
      @Nullable Class<?> getOwnerType(Class<?> rawType) {
        return rawType.getEnclosingClass();
      }
    },

    /**
     * Strings are Unicode flag.
     */
    int FLAGS2_UNICODE = 0x8000;

    /**
     * No capabilities.
     */
    int CAP_NONE = 0x0000;
    /**
     * Raw mode transfers are supported capability.
     */
    int CAP_RAW_MODE = 0x0001;
    /**
     * Multiplex mode is supported capability.
     */
    int CAP_MPX_MODE = 0x0002;
    /**

![Distributed MinIO, n nodes with m drives each](https://github.com/minio/minio/blob/master/docs/screenshots/Architecture-diagram_distributed_nm.png?raw=true)

### GNU/Linux and macOS

```sh
export MINIO_ROOT_USER=<ACCESS_KEY>
export MINIO_ROOT_PASSWORD=<SECRET_KEY>
minio server http://host{1...n}/export{1...m}
```

        @Test
        @DisplayName("Test verify failed state")
        void testVerifyFailedState() {
            assertFalse(testBlock.isVerifyFailed());
        }

        @Test
        @DisplayName("Test raw payload handling")
        void testRawPayloadHandling() {
            byte[] payload = new byte[] { 1, 2, 3, 4, 5 };

            assertNull(testBlock.getRawPayload());

    }
  }

  internal fun useAsSocket() {
    javaNetSocket.soTimeout = 0
    noNewExchanges()
  }

  override fun route(): Route = route

  override fun cancel() {
    // Close the raw socket so we don't end up doing synchronous I/O.
    rawSocket.closeQuietly()
  }

  override fun socket(): JavaNetSocket = javaNetSocket

  /** Returns true if this connection is ready to host new streams. */

#### Check the `openapi.json` { #check-the-openapi-json }

If you are curious about how the raw OpenAPI schema looks like, FastAPI automatically generates a JSON (schema) with the descriptions of all your API.

			}
		}()
		o.ID = ""
	}

	if contextCanceled(ctx) {
		return entries, ctx.Err()
	}
	// Do listing in-place.
	// Create output for our results.
	// Create filter for results.
	o.debugln("Raw List", o)
	filterCh := make(chan metaCacheEntry, o.Limit)
	listCtx, cancelList := context.WithCancel(ctx)
	filteredResults := o.gatherResults(listCtx, filterCh)
	var wg sync.WaitGroup
	wg.Add(1)
	var listErr error