testHandleLeaksCallback();
	}
	return 0;
}

void testHandleLeaks()
{
	HANDLE h;
	h = CreateThread(NULL, 0, &testHandleLeaksFunc, 0, 0, NULL);
	WaitForSingleObject(h, INFINITE);
	CloseHandle(h);

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !linux && !windows

package os

		return syscall.EINVAL
	}

	// no need for a finalizer anymore
	runtime.SetFinalizer(p, nil)
	return nil
}

func (p *Process) closeHandle() {
	syscall.CloseHandle(syscall.Handle(p.handle))
}

func findProcess(pid int) (p *Process, err error) {
	const da = syscall.STANDARD_RIGHTS_READ |
		syscall.PROCESS_QUERY_INFORMATION | syscall.SYNCHRONIZE

		nthread = MaxThread;
	for(i=0; i<nthread; i++)
		thread_id[i] = _beginthreadex(0, 0, addThread, &max, 0, 0);
	for(i=0; i<nthread; i++) {
		WaitForSingleObject((HANDLE)thread_id[i], INFINITE);
		CloseHandle((HANDLE)thread_id[i]);
	}
}

__stdcall
static unsigned int
goDummyCallbackThread(void* p)
{
	int i, max;

	max = *(int*)p;
	for(i=0; i<max; i++)
		goDummy();
	return 0;
}

int

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package os

import (
	"syscall"
)

func (p *Process) closeHandle() {
	syscall.Close(int(p.handle))

	snap, err := createModuleSnapshot()
	if err != nil {
		// pprof expects a map entry, so fake one, when we haven't added anything yet.
		b.addMappingEntry(0, 0, 0, "", "", true)
		return
	}
	defer func() { _ = syscall.CloseHandle(snap) }()

	var module windows.ModuleEntry32
	module.Size = uint32(windows.SizeofModuleEntry32)
	err = windows.Module32First(snap, &module)
	if err != nil {

		t.Fatalf("Open failed: %v", err)
	}
	syscall.CloseHandle(h)
	h, err = syscall.Open(dir, syscall.O_RDONLY|syscall.O_TRUNC, 0)
	if err == nil {
		t.Error("Open should have failed")
	} else {
		syscall.CloseHandle(h)
	}
	h, err = syscall.Open(dir, syscall.O_RDONLY|syscall.O_CREAT, 0)
	if err == nil {
		t.Error("Open should have failed")
	} else {
		syscall.CloseHandle(h)
	}
}

func TestComputerName(t *testing.T) {

	addr, err := syscall.MapViewOfFile(
		mapObj,        // handle
		access,        // access
		0,             // offsetHigh
		0,             // offsetLow
		uintptr(size), // length
	)
	if err != nil {
		syscall.CloseHandle(mapObj)
		return nil, err
	}

	region := unsafe.Slice((*byte)(unsafe.Pointer(addr)), size)
	return &sharedMem{
		f:             f,
		region:        region,
		removeOnClose: removeOnClose,

	if err != nil {
		t.Fatal(err)
	}
	fd := poll.FD{Sysfd: s, IsStream: true, ZeroReadIsEOF: true}
	_, err = fd.Init("tcp", true)
	if err != nil {
		syscall.CloseHandle(s)
		t.Fatal(err)
	}
	defer fd.Close()

	const SIO_TCP_INFO = syscall.IOC_INOUT | syscall.IOC_VENDOR | 39
	inbuf := uint32(0)
	var outbuf _TCP_INFO_v0
	cbbr := uint32(0)

L16:
L17:__declspec(dllexport)
L18:void ThreadRaiseNoExcept(void)
L19:{
L20:    HANDLE thread = CreateThread(0, 0, ThreadRaiser,  0, 0, 0);
L21:    if (0 != thread)
L22:    {
L23:        WaitForSingleObject(thread, INFINITE);
L24:        CloseHandle(thread);
L25:    }
L26:}
...