// Check for overflows.
	// https://github.com/minio/minio/issues/8035
	// XFS can show wrong values at times error out
	// in such scenarios.
	if info.Free > info.Total {
		return info, fmt.Errorf("detected free space (%d) > total drive space (%d), fs corruption at (%s). please run 'fsck'", info.Free, info.Total, path)
	}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor

      // H T T P / 1 . 1   2 0 0   T e m p o r a r y   R e d i r e c t
      // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0

      // Parse protocol like "HTTP/1.1" followed by a space.
      val codeStart: Int
      val protocol: Protocol
      if (statusLine.startsWith("HTTP/1.")) {
        if (statusLine.length < 9 || statusLine[8] != ' ') {

		return l, true
	}
	return 0, false
}

// grow grows the buffer to guarantee space for n more bytes.
// It returns the index where bytes should be written.
// If the buffer can't grow it will panic with ErrTooLarge.
func (b *Buffer) grow(n int) int {
	m := b.Len()
	// If buffer is empty, reset to recover space.
	if m == 0 && b.off != 0 {
		b.Reset()
	}
	// Try to grow by means of a reslice.

                "1000, 500, 8, 4096", // 4K sectors
                "1000, 500, 16, 4096", // Large sectors and allocation
                "1000, 0, 8, 512", // No free space
                "1000, 1000, 8, 512" // All space free
        })
        void shouldDecodeVariousSectorConfigurations(long alloc, long free, int sectPerAlloc, int bytesPerSect)
                throws SMBProtocolDecodingException {

        assertEquals(512, info.bytesPerSect);
        assertEquals(1000L * 100 * 512, info.getCapacity(), "Capacity calculation should be correct");
        assertEquals(500L * 100 * 512, info.getFree(), "Free space calculation should be correct");
    }

    /**
     * Tests the readDataWireFormat method with the SMB_QUERY_FS_SIZE_INFO information level.
     */
    @Test
    void testReadDataWireFormat_SmbQueryFSSizeInfo() {

    assertUnescaped(e, '(');
    assertUnescaped(e, ')');
    assertUnescaped(e, '~');
    assertUnescaped(e, ':');
    assertUnescaped(e, '@');

    // Don't use plus for spaces
    assertEscaping(e, "%20", ' ');

    assertThat(e.escape("safe with spaces")).isEqualTo("safe%20with%20spaces");
    assertThat(e.escape("******@****.***")).isEqualTo("******@****.***");
  }

  private UrlEscaperTesting() {}

licensing terms of the Project Developments that will always supersede such
Code of Conduct.

## Scope

This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail

            encodeSet = FORM_ENCODE_SET,
            // Plus is encoded as `%2B`, space is encoded as plus.
            plusIsSpace = false,
            charset = charset,
          )
        values +=
          value.canonicalizeWithCharset(
            encodeSet = FORM_ENCODE_SET,
            // Plus is encoded as `%2B`, space is encoded as plus.
            plusIsSpace = false,
            charset = charset,

* Dann gibt sie die **Response** zurück.

/// note | Technische Details

Wenn Sie Abhängigkeiten mit `yield` haben, wird der Exit-Code *nach* der Middleware ausgeführt.

Wenn es Hintergrundtasks gab (dies wird später im [Hintergrundtasks](background-tasks.md)-Abschnitt behandelt), werden sie *nach* allen Middlewares ausgeführt.

///

## Eine Middleware erstellen { #create-a-middleware }

The content of each of these strings can have any format, but should not contain spaces.

These scopes represent "permissions".

In OpenAPI (e.g. the API docs), you can define "security schemes".

When one of these security schemes uses OAuth2, you can also declare and use scopes.

Each "scope" is just a string (without spaces).