pkg syscall (openbsd-amd64), const CCR0_FLUSH ideal-int
pkg syscall (openbsd-amd64), const CPUID_CFLUSH = 524288
pkg syscall (openbsd-amd64), const CPUID_CFLUSH ideal-int
pkg syscall (openbsd-amd64), const EFER_LMA = 1024
pkg syscall (openbsd-amd64), const EFER_LMA ideal-int
pkg syscall (openbsd-amd64), const EFER_LME = 256
pkg syscall (openbsd-amd64), const EFER_LME ideal-int
pkg syscall (openbsd-amd64), const EFER_NXE = 2048

    int dialectIndex;
    SmbTransport.ServerData server;

    SmbComNegotiateResponse(final SmbTransport.ServerData server) {
        this.server = server;
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

  }

  data class Request(
    val network: Network?,
    val domain: String,
    val nsType: Int,
    val flags: Int,
    val callback: DnsResolver.Callback<List<InetAddress>>,
  )

  @Implementation
  fun query(
    network: Network?,
    domain: String,
    nsType: Int,
    flags: Int,
    executor: Executor,
    cancellationSignal: CancellationSignal?,

    private static class TestProcess extends Process {
        private final int exitValue;

        public TestProcess(int exitValue) {
            this.exitValue = exitValue;
        }

        @Override
        public int waitFor() throws InterruptedException {
            return exitValue;
        }

        @Override
        public int exitValue() {
            return exitValue;
        }

            @Override
            public void setIntHeader(String name, int value) {
            }

            @Override
            public void addIntHeader(String name, int value) {
            }

            @Override
            public void setStatus(int sc) {
            }

            @Override
            public int getStatus() {
                return 0;
            }

func (stats *HTTPAPIStats) Get(api string) int {
	if stats == nil {
		return 0
	}

	stats.RLock()
	defer stats.RUnlock()

	val, ok := stats.apiStats[api]
	if ok {
		return val
	}

	return 0
}

// Load returns the recorded stats.
func (stats *HTTPAPIStats) Load(toLower bool) map[string]int {
	if stats == nil {
		return map[string]int{}
	}

	stats.RLock()

                    || PRIORITY_ELEMENT.equals(qName)) {
                buf = new StringBuilder();
            }
        }

        @Override
        public void characters(final char[] ch, final int offset, final int length) {
            if (buf != null) {
                buf.append(new String(ch, offset, length));
            }
        }

        @Override

                        }
                    }
                }

                final int max = Math.min(dc_list.length, LOOKUP_RESP_LIMIT);
                for (int j = 0; j < max; j++) {
                    final int i = dc_list_counter++ % max;
                    if (dc_list[i] != null) {
                        try {
                            return interrogate(dc_list[i]);

    void testGetEntries_largeNumberOfRoots() throws Exception {
        // Create array with many entries
        int count = 100;
        netdfs.DfsEnumArray200 largeArray = new netdfs.DfsEnumArray200();
        largeArray.count = count;
        largeArray.s = new netdfs.DfsInfo200[count];

        for (int i = 0; i < count; i++) {
            netdfs.DfsInfo200 entry = new netdfs.DfsInfo200();

import io.restassured.RestAssured;
import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;

public abstract class CrudTestBase extends ITBase {

    protected static final int NUM = 20;
    protected static final int SEARCH_ALL_NUM = 1000;

    private static final Logger logger = LogManager.getLogger(CrudTestBase.class);

    // ================
    // Abstract Methods
    // ================