*/
    public CIFSContext getContext() {
        return context;
    }

    /**
     * Check if directory notifications are enabled in configuration
     *
     * @param config configuration
     * @return true if notifications are enabled
     */
    private boolean isDirectoryNotificationsEnabled(Configuration config) {
        return config.isDirectoryNotificationsEnabled();
    }

        FessJsonResourceProvider testProvider = new FessJsonResourceProvider();

        // Verify nulls suppression is enabled
        assertTrue("Nulls should be suppressed", testProvider.isNullsSuppressed());

        // Verify pretty print is enabled
        assertFalse("Pretty print should not be suppressed", testProvider.isPrettyPrintSuppressed());

        // Verify mapping option configuration

	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	if globalSiteReplicationSys.isEnabled() && !v.Enabled() {
		writeErrorResponse(ctx, w, APIError{
			Code:           "InvalidBucketState",
			Description:    "Cluster replication is enabled on this site, versioning cannot be suspended on bucket.",
			HTTPStatusCode: http.StatusBadRequest,
		}, r.URL)
		return
	}

	if err != nil {
		t.Fatalf("Unable to format drives for erasure, %s", err)
	}

	ep := PoolEndpoints{Endpoints: endpoints}

	parity, err := ecDrivesNoConfig(16)
	if err != nil {
		t.Fatalf("Unexpected error during EC drive config: %v", err)
	}
	if _, err := newErasureSets(ctx, ep, storageDisks, format, parity, 0); err != nil {
		t.Fatalf("Unable to initialize erasure")
	}
}

                    quietPeriod = 90
                    triggerRules = triggerExcludes
                    branchFilter = determineBranchFilter(effectiveTriggerBranches)
                    enabled = enableTriggers
                }
            } else if (stage.trigger != Trigger.NEVER) {
                val effectiveTriggerBranches = mutableListOf(model.branch.branchName)

                if (model.branch.isMaster) {

// license that can be found in the LICENSE file.

//go:build boringcrypto

package main

import (
	"fmt"
	"os"
)

func init() {
	fmt.Printf("SKIP with boringcrypto enabled\n")
	os.Exit(0)

    void requestSecurityMode() {
        // Not enforced, server does not require -> enabled only
        Smb2NegotiateResponse first = mock(Smb2NegotiateResponse.class);
        when(first.isSigningRequired()).thenReturn(false);
        assertEquals(Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED, transport.getRequestSecurityMode(first));

        // Enforced -> required+enabled

        // Test protected constructor with suppression enabled
        String message = "Test with suppression";
        TestFessSystemException exception = new TestFessSystemException(message, true, true);

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());

        // Test that suppression is enabled
        RuntimeException suppressed = new RuntimeException("Suppressed exception");

 * to a remote host. Newer TLS options are quite useful:
 *
 *  * Server Name Indication (SNI) enables one IP address to negotiate secure connections for
 *    multiple domain names.
 *
 *  * Application Layer Protocol Negotiation (ALPN) enables the HTTPS port (443) to be used to
 *    negotiate HTTP/2.
 *

OkHttp Brotli Implementation
============================

This module is an implementation of [Brotli][1] compression.
It enables Brotli support in addition to tranparent Gzip support,
provided Accept-Encoding is not set previously.  Modern web servers
must choose to return Brotli responses.  n.b. It is not used for
sending requests.

```java
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(BrotliInterceptor.INSTANCE)
  .build();