FATAL // Connection or session must be terminated
    }

    /**
     * Error categories
     */
    public enum Category {
        AUTHENTICATION, AUTHORIZATION, NETWORK, PROTOCOL, RESOURCE, CONFIGURATION, ENCRYPTION, TIMEOUT, IO, UNKNOWN
    }

    private final int errorCode;
    private final Severity severity;
    private final Category category;
    private final Map<String, Object> context;

        double noneRatio = compressionService.estimateCompressionRatio(testData, CompressionService.COMPRESSION_NONE);
        assertEquals(1.0, noneRatio, 0.001);
    }

    @Test
    @DisplayName("Test configuration limits")
    public void testConfigurationLimits() {
        assertTrue(compressionService.getMinCompressionSize() > 0);

func (tDays TransitionDays) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	return e.EncodeElement(int(tDays), startElement)
}

// Transition - transition actions for a rule in lifecycle configuration.
type Transition struct {
	XMLName      xml.Name       `xml:"Transition"`
	Days         TransitionDays `xml:"Days,omitempty"`
	Date         TransitionDate `xml:"Date,omitempty"`

            .get(30, TimeUnit.SECONDS);
    } catch (Exception e) {
        throw new IOException("Multi-channel read failed", e);
    }
}
```

## 6. Configuration

### 6.1 Configuration Properties
```java
// In PropertyConfiguration.java
public static final String USE_MULTI_CHANNEL = "jcifs.smb.client.useMultiChannel";

		SecretKey: secretKey,
	}
}

// Initialize KMS global variable after valiadating and loading the configuration.
// It depends on KMS env variables and global cli flags.
func handleKMSConfig() {
	present, err := kms.IsPresent()
	if err != nil {
		logger.Fatal(err, "Invalid KMS configuration specified")
	}
	if !present {
		return
	}

	KMS, err := kms.Connect(GlobalContext, &kms.ConnectionOptions{

import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.fscc.FileBothDirectoryInfo;
import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.ServerMessageBlock2Response;

 * Parameters can be stored as any Object type and retrieved with type conversion
 * support for common types like String.</p>
 *
 * <p>This class is commonly used to pass configuration parameters to data store
 * implementations during crawling operations, allowing for flexible parameter
 * handling without tight coupling to specific parameter schemas.</p>
 */
public class DataStoreParams {

    /**

     */
    public void setPageNumberList(final List<Integer> pageNumberList) {
        this.pageNumberList = pageNumberList;
    }

    /**
     * Gets the default page size from the Fess configuration.
     *
     * @return the default page size configured in the system
     */
    protected int getDefaultPageSize() {
        return ComponentUtil.getFessConfig().getPagingPageSizeAsInteger();
    }

                        .id(getExecutionId(existing, goal))
                        .priority(i - mojos.size())
                        .phase(phase)
                        .goals(List.of(goal))
                        .configuration(mojo.getConfiguration())
                        .location("", location)
                        .location("id", location)
                        .location("phase", location)

	}

	// Not an XML
	badRequest := &http.Request{
		Body:          io.NopCloser(bytes.NewReader([]byte("garbage"))),
		ContentLength: int64(len("garbage")),
	}

	// generates the input request with XML bucket configuration set to the request body.
	createExpectedRequest := func(req *http.Request, location string) *http.Request {
		createBucketConfig := createBucketLocationConfiguration{}
		createBucketConfig.Location = location