func SetCompressionConfig(s config.Config, cfg Config) {
	if !cfg.Enabled {
		// No need to save disabled settings in new config.
		return
	}
	s[config.CompressionSubSys][config.Default] = config.KVS{
		config.KV{
			Key:   config.Enable,
			Value: config.EnableOn,
		},
		config.KV{
			Key:   Extensions,
			Value: strings.Join(cfg.Extensions, config.ValueSeparator),
		},
		config.KV{

        // Verify interactions happen exactly once during construction
        verify(cfg, times(1)).getBufferCacheSize();
        verify(cfg, times(1)).getMaximumBufferSize();
        verifyNoMoreInteractions(cfg);

        // When cache is empty, getBuffer allocates a new buffer with configured size
        byte[] buf = impl.getBuffer();
        assertNotNull(buf, "getBuffer should never return null");

 */

package jcifs.netbios;

import jcifs.Configuration;

class NodeStatusRequest extends NameServicePacket {

    NodeStatusRequest(final Configuration cfg, final Name name) {
        super(cfg);
        this.questionName = name;
        this.questionType = NBSTAT;
        this.isRecurDesired = false;
        this.isBroadcast = false;
    }

    @Override

        super(AvPair.MsvAvSingleHost, raw);
    }

    /**
     * Constructs an AvSingleHost using configuration settings
     *
     * @param cfg the configuration containing machine ID
     */
    public AvSingleHost(final Configuration cfg) {
        this(new byte[8], cfg.getMachineId());
    }

    /**
     * Constructs an AvSingleHost with custom data and machine ID
     *

			Description:    "Cluster replication is enabled on this site, versioning cannot be suspended on bucket.",
			HTTPStatusCode: http.StatusBadRequest,
		}, r.URL)
		return
	}

	if rcfg, _ := globalBucketObjectLockSys.Get(bucket); rcfg.LockEnabled && (v.Suspended() || v.PrefixesExcluded()) {
		writeErrorResponse(ctx, w, APIError{
			Code:           "InvalidBucketState",

const (
	defaultTarget = "1"
)

// NewConfig - initialize lambda config.
func NewConfig() Config {
	// Make sure to initialize lambda targets
	cfg := Config{
		Webhook: make(map[string]target.WebhookArgs),
	}
	cfg.Webhook[defaultTarget] = target.WebhookArgs{}
	return cfg

    private Smb2LogoffResponse newResponse() {
        Configuration cfg = Mockito.mock(Configuration.class);
        return new Smb2LogoffResponse(cfg);
    }

    @Test
    @DisplayName("Constructor accepts a Configuration and creates instance")
    void constructor_happyPath() {
        // Arrange
        Configuration cfg = Mockito.mock(Configuration.class);

        // Act

     */
    public void exportCsv(final Writer writer) {
        final CsvConfig cfg = new CsvConfig(',', '"', '"');
        cfg.setEscapeDisabled(false);
        cfg.setQuoteDisabled(false);
        @SuppressWarnings("resource")
        final CsvWriter csvWriter = new CsvWriter(writer, cfg);
        try {
            final List<String> list = new ArrayList<>();
            list.add("BadWord");

	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	var cfg madmin.TierConfig
	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(reqBytes, &cfg); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	var ignoreInUse bool

				}
				afterV = ""
			}

			for _, version := range fiVersions {
				if !version.VersionPurgeStatus().Empty() {
					continue
				}
				versioned := vcfg != nil && vcfg.Versioned(entry.name)
				versions = append(versions, version.ToObjectInfo(bucket, entry.name, versioned))
			}

			continue
		}

		if entry.isDir() {
			if delimiter == "" {
				continue