name = pipeName;
        pipeData = data;
        pipeDataOff = off;
        pipeDataLen = len;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_CALL_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0xFFFF;
        maxSetupCount = (byte) 0x00;
        setupCount = 2;
    }

    @Override

type currentScannerCycle struct {
	current        uint64
	next           uint64
	started        time.Time
	cycleCompleted []time.Time
}

// clone returns a clone.
func (z currentScannerCycle) clone() currentScannerCycle {
	z.cycleCompleted = append(make([]time.Time, 0, len(z.cycleCompleted)), z.cycleCompleted...)
	return z

        }

        applyTestDefaults(
            model,
            this,
            "docs:docsTest docs:checkSamples",
            os = os,
            arch = os.defaultArch,
            timeout = if (os == Os.WINDOWS) 90 else 60,
            extraParameters =
                listOf(
                    buildScanTagParam(docsTestType.docsTestName),
                    parallelizationMethod.extraBuildParameters,

                        if (!params.contains(RequestParam.NO_TIMEOUT)) {
                            resp.wait(timeout);
                            timeout = resp.getExpiration() - System.currentTimeMillis();
                            if (timeout <= 0) {
                                throw new TransportException(this + " timedout waiting for response to " + req);
                            }

class TransWaitNamedPipe extends SmbComTransaction {

    TransWaitNamedPipe(final String pipeName) {
        name = pipeName;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_WAIT_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0;
        maxSetupCount = (byte) 0x00;
        setupCount = 2;
    }

    @Override

net.ipv4.tcp_mtu_probing=1
net.ipv4.tcp_base_mss=1280

# Disable ipv6
net.ipv6.conf.all.disable_ipv6=1
net.ipv6.conf.default.disable_ipv6=1
net.ipv6.conf.lo.disable_ipv6=1

[bootloader]
# Avoid firing timers for all CPUs at the same time. This is irrelevant for
# full nohz systems

	},
	cli.DurationFlag{
		Name:   "shutdown-timeout",
		Value:  time.Second * 30,
		Usage:  "shutdown timeout to gracefully shutdown server (DEPRECATED)",
		EnvVar: "MINIO_SHUTDOWN_TIMEOUT",
		Hidden: true,
	},

	cli.DurationFlag{
		Name:   "idle-timeout",
		Value:  xhttp.DefaultIdleTimeout,
		Usage:  "idle timeout is the maximum amount of time to wait for the next request when keep-alive are enabled",

            verify(mockBuffer, times(2)).enc_ndr_small(0); // minor version and ptype (both are 0)
            verify(mockBuffer).enc_ndr_small(DcerpcConstants.RPC_C_PF_BROADCAST); // flags
            verify(mockBuffer).enc_ndr_long(0x00000010); // Little-endian / ASCII / IEEE
            verify(mockBuffer).enc_ndr_short(message.length);
            verify(mockBuffer, times(1)).enc_ndr_short(0); // auth_value length

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension

@Flaky // STDOUT logging enabled for test
@Timeout(30)
@Tag("Slow")
@Burst
class EventListenerTest(
  val listenerInstalledOn: ListenerInstalledOn = ListenerInstalledOn.Client,
) {
  @RegisterExtension

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;