});

        assertThrows(CIFSException.class, () -> {
            compressionService.decompress(null, CompressionService.COMPRESSION_LZ77);
        });
    }

    @Test
    @DisplayName("Test invalid offset/length handling")
    public void testInvalidOffsetLength() {
        assertThrows(CIFSException.class, () -> {
            compressionService.compress(testData, -1, testData.length, CompressionService.COMPRESSION_LZ77);

     *
     * @throws NullPointerException if {@code key}, {@code values}, or any element in {@code values}
     *     is null. The builder is left in an invalid state.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> putAll(K key, Iterable<? extends V> values) {
      if (key == null) {

		// Test case - 3
		// In case of garbage request body ErrMalformedXML is returned.
		{badRequest, globalMinioDefaultRegion, ErrMalformedXML},
		// Test case - 4
		// In case of invalid XML request body ErrMalformedXML is returned.
		{malformedReq, globalMinioDefaultRegion, ErrMalformedXML},
	}

	for i, testCase := range testCases {
		config.SetRegion(globalServerConfig, testCase.serverConfigRegion)

		if err = json.Unmarshal(data, cfg); err != nil {
			// Unable to parse old JSON simply re-initialize a new one.
			return newServerCfg()
		}
	}

	if !globalCredViaEnv && cfg.Credential.IsValid() {
		// Preserve older credential if we do not have
		// root credentials set via environment variable.
		globalActiveCred = cfg.Credential
	}

     * The config type is identified by the first character of the config ID.
     *
     * @param configId the configuration ID to analyze
     * @return the ConfigType (WEB, FILE, or DATA) or null if the config ID is invalid or doesn't match any known type
     */
    public ConfigType getConfigType(final String configId) {
        if (configId == null || configId.length() < 2) {
            return null;
        }

                    } else if (response.getContentException() != null) {
                        logger.warn("Invalid request for {}.", path, response.getContentException());
                    } else {
                        logger.warn("Invalid request for {}. The response is {}", path, response.getContentAsString());
                    }
                }
            } catch (final Exception e) {

| `minio_s3_requests_rejected_header_total`     | Total number S3 requests rejected for invalid header.    |
| `minio_s3_requests_rejected_invalid_total`    | Total number S3 invalid requests.                        |
| `minio_s3_requests_rejected_timestamp_total`  | Total number S3 requests rejected for invalid timestamp. |
| `minio_s3_requests_total`                     | Total number S3 requests.                                |

        void testGetOEMBytesWithUnsupportedEncoding() {
            // Given
            Configuration mockConfig = mock(Configuration.class);
            when(mockConfig.getOemEncoding()).thenReturn("INVALID-ENCODING");

            // When & Then
            RuntimeCIFSException exception = assertThrows(RuntimeCIFSException.class, () -> {
                Strings.getOEMBytes(TEST_STRING, mockConfig);
            });

        if (StringUtil.isNotBlank(value)) {
            try {
                readInterval = Long.parseLong(value);
            } catch (final NumberFormatException e) {
                logger.warn("Invalid read interval: {}", value);
            }
        }
        return readInterval;
    }

    /**
     * Sleep for the specified interval.
     * @param interval The interval.
     */

        case 0x0A:
            return "Subfolders only";
        case 0x01:
            return "This folder and files";
        case 0x09:
            return "Files only";
        }
        return "Invalid";
    }

    @Override
    public int getAccessMask() {
        return this.access;
    }

    @Override
    public SID getSID() {
        return this.sid;
    }

    @Override