.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/windows/syscall_windows_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package windows_test
   6
   7 import (
   8         "debug/pe"
   9         "errors"
  10         "fmt"
  11         "io/ioutil"
  12         "os"
  13         "path/filepath"
  14         "runtime"
  15         "strconv"
  16         "strings"
  17         "syscall"
  18         "testing"
  19         "unsafe"
  20
  21         "golang.org/x/sys/windows"
  22 )
  23
  24 func TestWin32finddata(t *testing.T) {
  25         dir, err := ioutil.TempDir("", "go-build")
  26         if err != nil {
  27                 t.Fatalf("failed to create temp directory: %v", err)
  28         }
  29         defer os.RemoveAll(dir)
  30
  31         path := filepath.Join(dir, "long_name.and_extension")
  32         f, err := os.Create(path)
  33         if err != nil {
  34                 t.Fatalf("failed to create %v: %v", path, err)
  35         }
  36         f.Close()
  37
  38         type X struct {
  39                 fd  windows.Win32finddata
  40                 got byte
  41                 pad [10]byte // to protect ourselves
  42
  43         }
  44         var want byte = 2 // it is unlikely to have this character in the filename
  45         x := X{got: want}
  46
  47         pathp, _ := windows.UTF16PtrFromString(path)
  48         h, err := windows.FindFirstFile(pathp, &(x.fd))
  49         if err != nil {
  50                 t.Fatalf("FindFirstFile failed: %v", err)
  51         }
  52         err = windows.FindClose(h)
  53         if err != nil {
  54                 t.Fatalf("FindClose failed: %v", err)
  55         }
  56
  57         if x.got != want {
  58                 t.Fatalf("memory corruption: want=%d got=%d", want, x.got)
  59         }
  60 }
  61
  62 func TestFormatMessage(t *testing.T) {
  63         dll := windows.MustLoadDLL("netevent.dll")
  64
  65         const TITLE_SC_MESSAGE_BOX uint32 = 0xC0001B75
  66         const flags uint32 = syscall.FORMAT_MESSAGE_FROM_HMODULE | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS
  67         buf := make([]uint16, 300)
  68         _, err := windows.FormatMessage(flags, uintptr(dll.Handle), TITLE_SC_MESSAGE_BOX, 0, buf, nil)
  69         if err != nil {
  70                 t.Fatalf("FormatMessage for handle=%x and errno=%x failed: %v", dll.Handle, TITLE_SC_MESSAGE_BOX, err)
  71         }
  72 }
  73
  74 func abort(funcname string, err error) {
  75         panic(funcname + " failed: " + err.Error())
  76 }
  77
  78 func ExampleLoadLibrary() {
  79         h, err := windows.LoadLibrary("kernel32.dll")
  80         if err != nil {
  81                 abort("LoadLibrary", err)
  82         }
  83         defer windows.FreeLibrary(h)
  84         proc, err := windows.GetProcAddress(h, "GetVersion")
  85         if err != nil {
  86                 abort("GetProcAddress", err)
  87         }
  88         r, _, _ := syscall.Syscall(uintptr(proc), 0, 0, 0, 0)
  89         major := byte(r)
  90         minor := uint8(r >> 8)
  91         build := uint16(r >> 16)
  92         print("windows version ", major, ".", minor, " (Build ", build, ")\n")
  93 }
  94
  95 func TestTOKEN_ALL_ACCESS(t *testing.T) {
  96         if windows.TOKEN_ALL_ACCESS != 0xF01FF {
  97                 t.Errorf("TOKEN_ALL_ACCESS = %x, want 0xF01FF", windows.TOKEN_ALL_ACCESS)
  98         }
  99 }
 100
 101 func TestCreateWellKnownSid(t *testing.T) {
 102         sid, err := windows.CreateWellKnownSid(windows.WinBuiltinAdministratorsSid)
 103         if err != nil {
 104                 t.Fatalf("Unable to create well known sid for administrators: %v", err)
 105         }
 106         if got, want := sid.String(), "S-1-5-32-544"; got != want {
 107                 t.Fatalf("Builtin Administrators SID = %s, want %s", got, want)
 108         }
 109 }
 110
 111 func TestPseudoTokens(t *testing.T) {
 112         version, err := windows.GetVersion()
 113         if err != nil {
 114                 t.Fatal(err)
 115         }
 116         if ((version&0xffff)>>8)|((version&0xff)<<8) < 0x0602 {
 117                 return
 118         }
 119
 120         realProcessToken, err := windows.OpenCurrentProcessToken()
 121         if err != nil {
 122                 t.Fatal(err)
 123         }
 124         defer realProcessToken.Close()
 125         realProcessUser, err := realProcessToken.GetTokenUser()
 126         if err != nil {
 127                 t.Fatal(err)
 128         }
 129
 130         pseudoProcessToken := windows.GetCurrentProcessToken()
 131         pseudoProcessUser, err := pseudoProcessToken.GetTokenUser()
 132         if err != nil {
 133                 t.Fatal(err)
 134         }
 135         if !windows.EqualSid(realProcessUser.User.Sid, pseudoProcessUser.User.Sid) {
 136                 t.Fatal("The real process token does not have the same as the pseudo process token")
 137         }
 138
 139         runtime.LockOSThread()
 140         defer runtime.UnlockOSThread()
 141
 142         err = windows.RevertToSelf()
 143         if err != nil {
 144                 t.Fatal(err)
 145         }
 146
 147         pseudoThreadToken := windows.GetCurrentThreadToken()
 148         _, err = pseudoThreadToken.GetTokenUser()
 149         if err != windows.ERROR_NO_TOKEN {
 150                 t.Fatal("Expected an empty thread token")
 151         }
 152         pseudoThreadEffectiveToken := windows.GetCurrentThreadEffectiveToken()
 153         pseudoThreadEffectiveUser, err := pseudoThreadEffectiveToken.GetTokenUser()
 154         if err != nil {
 155                 t.Fatal(nil)
 156         }
 157         if !windows.EqualSid(realProcessUser.User.Sid, pseudoThreadEffectiveUser.User.Sid) {
 158                 t.Fatal("The real process token does not have the same as the pseudo thread effective token, even though we aren't impersonating")
 159         }
 160
 161         err = windows.ImpersonateSelf(windows.SecurityImpersonation)
 162         if err != nil {
 163                 t.Fatal(err)
 164         }
 165         defer windows.RevertToSelf()
 166         pseudoThreadUser, err := pseudoThreadToken.GetTokenUser()
 167         if err != nil {
 168                 t.Fatal(err)
 169         }
 170         if !windows.EqualSid(realProcessUser.User.Sid, pseudoThreadUser.User.Sid) {
 171                 t.Fatal("The real process token does not have the same as the pseudo thread token after impersonating self")
 172         }
 173 }
 174
 175 func TestGUID(t *testing.T) {
 176         guid, err := windows.GenerateGUID()
 177         if err != nil {
 178                 t.Fatal(err)
 179         }
 180         if guid.Data1 == 0 && guid.Data2 == 0 && guid.Data3 == 0 && guid.Data4 == [8]byte{} {
 181                 t.Fatal("Got an all zero GUID, which is overwhelmingly unlikely")
 182         }
 183         want := fmt.Sprintf("{%08X-%04X-%04X-%04X-%012X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[:2], guid.Data4[2:])
 184         got := guid.String()
 185         if got != want {
 186                 t.Fatalf("String = %q; want %q", got, want)
 187         }
 188         guid2, err := windows.GUIDFromString(got)
 189         if err != nil {
 190                 t.Fatal(err)
 191         }
 192         if guid2 != guid {
 193                 t.Fatalf("Did not parse string back to original GUID = %q; want %q", guid2, guid)
 194         }
 195         _, err = windows.GUIDFromString("not-a-real-guid")
 196         if err != syscall.Errno(windows.CO_E_CLASSSTRING) {
 197                 t.Fatalf("Bad GUID string error = %v; want CO_E_CLASSSTRING", err)
 198         }
 199 }
 200
 201 func TestKnownFolderPath(t *testing.T) {
 202         token, err := windows.OpenCurrentProcessToken()
 203         if err != nil {
 204                 t.Fatal(err)
 205         }
 206         defer token.Close()
 207         profileDir, err := token.GetUserProfileDirectory()
 208         if err != nil {
 209                 t.Fatal(err)
 210         }
 211         want := filepath.Join(profileDir, "Desktop")
 212         got, err := windows.KnownFolderPath(windows.FOLDERID_Desktop, windows.KF_FLAG_DEFAULT)
 213         if err != nil {
 214                 t.Fatal(err)
 215         }
 216         if want != got {
 217                 t.Fatalf("Path = %q; want %q", got, want)
 218         }
 219 }
 220
 221 func TestRtlGetVersion(t *testing.T) {
 222         version := windows.RtlGetVersion()
 223         major, minor, build := windows.RtlGetNtVersionNumbers()
 224         // Go is not explictly added to the application compatibility database, so
 225         // these two functions should return the same thing.
 226         if version.MajorVersion != major || version.MinorVersion != minor || version.BuildNumber != build {
 227                 t.Fatalf("%d.%d.%d != %d.%d.%d", version.MajorVersion, version.MinorVersion, version.BuildNumber, major, minor, build)
 228         }
 229 }
 230
 231 func TestGetNamedSecurityInfo(t *testing.T) {
 232         path, err := windows.GetSystemDirectory()
 233         if err != nil {
 234                 t.Fatal(err)
 235         }
 236         sd, err := windows.GetNamedSecurityInfo(path, windows.SE_FILE_OBJECT, windows.OWNER_SECURITY_INFORMATION)
 237         if err != nil {
 238                 t.Fatal(err)
 239         }
 240         if !sd.IsValid() {
 241                 t.Fatal("Invalid security descriptor")
 242         }
 243         sdOwner, _, err := sd.Owner()
 244         if err != nil {
 245                 t.Fatal(err)
 246         }
 247         if !sdOwner.IsValid() {
 248                 t.Fatal("Invalid security descriptor owner")
 249         }
 250 }
 251
 252 func TestGetSecurityInfo(t *testing.T) {
 253         sd, err := windows.GetSecurityInfo(windows.CurrentProcess(), windows.SE_KERNEL_OBJECT, windows.DACL_SECURITY_INFORMATION)
 254         if err != nil {
 255                 t.Fatal(err)
 256         }
 257         if !sd.IsValid() {
 258                 t.Fatal("Invalid security descriptor")
 259         }
 260         sdStr := sd.String()
 261         if !strings.HasPrefix(sdStr, "D:(A;") {
 262                 t.Fatalf("DACL = %q; want D:(A;...", sdStr)
 263         }
 264 }
 265
 266 func TestSddlConversion(t *testing.T) {
 267         sd, err := windows.SecurityDescriptorFromString("O:BA")
 268         if err != nil {
 269                 t.Fatal(err)
 270         }
 271         if !sd.IsValid() {
 272                 t.Fatal("Invalid security descriptor")
 273         }
 274         sdOwner, _, err := sd.Owner()
 275         if err != nil {
 276                 t.Fatal(err)
 277         }
 278         if !sdOwner.IsValid() {
 279                 t.Fatal("Invalid security descriptor owner")
 280         }
 281         if !sdOwner.IsWellKnown(windows.WinBuiltinAdministratorsSid) {
 282                 t.Fatalf("Owner = %q; want S-1-5-32-544", sdOwner)
 283         }
 284 }
 285
 286 func TestBuildSecurityDescriptor(t *testing.T) {
 287         const want = "O:SYD:(A;;GA;;;BA)"
 288
 289         adminSid, err := windows.CreateWellKnownSid(windows.WinBuiltinAdministratorsSid)
 290         if err != nil {
 291                 t.Fatal(err)
 292         }
 293         systemSid, err := windows.CreateWellKnownSid(windows.WinLocalSystemSid)
 294         if err != nil {
 295                 t.Fatal(err)
 296         }
 297
 298         access := []windows.EXPLICIT_ACCESS{{
 299                 AccessPermissions: windows.GENERIC_ALL,
 300                 AccessMode:        windows.GRANT_ACCESS,
 301                 Trustee: windows.TRUSTEE{
 302                         TrusteeForm:  windows.TRUSTEE_IS_SID,
 303                         TrusteeType:  windows.TRUSTEE_IS_GROUP,
 304                         TrusteeValue: windows.TrusteeValueFromSID(adminSid),
 305                 },
 306         }}
 307         owner := &windows.TRUSTEE{
 308                 TrusteeForm:  windows.TRUSTEE_IS_SID,
 309                 TrusteeType:  windows.TRUSTEE_IS_USER,
 310                 TrusteeValue: windows.TrusteeValueFromSID(systemSid),
 311         }
 312
 313         sd, err := windows.BuildSecurityDescriptor(owner, nil, access, nil, nil)
 314         if err != nil {
 315                 t.Fatal(err)
 316         }
 317         sd, err = sd.ToAbsolute()
 318         if err != nil {
 319                 t.Fatal(err)
 320         }
 321         err = sd.SetSACL(nil, false, false)
 322         if err != nil {
 323                 t.Fatal(err)
 324         }
 325         if got := sd.String(); got != want {
 326                 t.Fatalf("SD = %q; want %q", got, want)
 327         }
 328         sd, err = sd.ToSelfRelative()
 329         if err != nil {
 330                 t.Fatal(err)
 331         }
 332         if got := sd.String(); got != want {
 333                 t.Fatalf("SD = %q; want %q", got, want)
 334         }
 335
 336         sd, err = windows.NewSecurityDescriptor()
 337         if err != nil {
 338                 t.Fatal(err)
 339         }
 340         acl, err := windows.ACLFromEntries(access, nil)
 341         if err != nil {
 342                 t.Fatal(err)
 343         }
 344         err = sd.SetDACL(acl, true, false)
 345         if err != nil {
 346                 t.Fatal(err)
 347         }
 348         err = sd.SetOwner(systemSid, false)
 349         if err != nil {
 350                 t.Fatal(err)
 351         }
 352         if got := sd.String(); got != want {
 353                 t.Fatalf("SD = %q; want %q", got, want)
 354         }
 355         sd, err = sd.ToSelfRelative()
 356         if err != nil {
 357                 t.Fatal(err)
 358         }
 359         if got := sd.String(); got != want {
 360                 t.Fatalf("SD = %q; want %q", got, want)
 361         }
 362 }
 363
 364 func TestGetDiskFreeSpaceEx(t *testing.T) {
 365         cwd, err := windows.UTF16PtrFromString(".")
 366         if err != nil {
 367                 t.Fatalf(`failed to call UTF16PtrFromString("."): %v`, err)
 368         }
 369         var freeBytesAvailableToCaller, totalNumberOfBytes, totalNumberOfFreeBytes uint64
 370         if err := windows.GetDiskFreeSpaceEx(cwd, &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes); err != nil {
 371                 t.Fatalf("failed to call GetDiskFreeSpaceEx: %v", err)
 372         }
 373
 374         if freeBytesAvailableToCaller == 0 {
 375                 t.Errorf("freeBytesAvailableToCaller: got 0; want > 0")
 376         }
 377         if totalNumberOfBytes == 0 {
 378                 t.Errorf("totalNumberOfBytes: got 0; want > 0")
 379         }
 380         if totalNumberOfFreeBytes == 0 {
 381                 t.Errorf("totalNumberOfFreeBytes: got 0; want > 0")
 382         }
 383 }
 384
 385 func TestGetPreferredUILanguages(t *testing.T) {
 386         tab := map[string]func(flags uint32) ([]string, error){
 387                 "GetProcessPreferredUILanguages": windows.GetProcessPreferredUILanguages,
 388                 "GetThreadPreferredUILanguages":  windows.GetThreadPreferredUILanguages,
 389                 "GetUserPreferredUILanguages":    windows.GetUserPreferredUILanguages,
 390                 "GetSystemPreferredUILanguages":  windows.GetSystemPreferredUILanguages,
 391         }
 392         for fName, f := range tab {
 393                 lang, err := f(windows.MUI_LANGUAGE_ID)
 394                 if err != nil {
 395                         t.Errorf(`failed to call %v(MUI_LANGUAGE_ID): %v`, fName, err)
 396                 }
 397                 for _, l := range lang {
 398                         _, err := strconv.ParseUint(l, 16, 16)
 399                         if err != nil {
 400                                 t.Errorf(`%v(MUI_LANGUAGE_ID) returned unexpected LANGID: %v`, fName, l)
 401                         }
 402                 }
 403
 404                 lang, err = f(windows.MUI_LANGUAGE_NAME)
 405                 if err != nil {
 406                         t.Errorf(`failed to call %v(MUI_LANGUAGE_NAME): %v`, fName, err)
 407                 }
 408         }
 409 }
 410
 411 func TestProcessWorkingSetSizeEx(t *testing.T) {
 412         // Grab a handle to the current process
 413         hProcess := windows.CurrentProcess()
 414
 415         // Allocate memory to store the result of the query
 416         var minimumWorkingSetSize, maximumWorkingSetSize uintptr
 417
 418         // Make the system-call
 419         var flag uint32
 420         windows.GetProcessWorkingSetSizeEx(hProcess, &minimumWorkingSetSize, &maximumWorkingSetSize, &flag)
 421
 422         // Set the new limits to the current ones
 423         if err := windows.SetProcessWorkingSetSizeEx(hProcess, minimumWorkingSetSize, maximumWorkingSetSize, flag); err != nil {
 424                 t.Error(err)
 425         }
 426 }
 427
 428 func TestJobObjectInfo(t *testing.T) {
 429         jo, err := windows.CreateJobObject(nil, nil)
 430         if err != nil {
 431                 t.Fatalf("CreateJobObject failed: %v", err)
 432         }
 433         defer windows.CloseHandle(jo)
 434
 435         var info windows.JOBOBJECT_EXTENDED_LIMIT_INFORMATION
 436
 437         err = windows.QueryInformationJobObject(jo, windows.JobObjectExtendedLimitInformation,
 438                 uintptr(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info)), nil)
 439         if err != nil {
 440                 t.Fatalf("QueryInformationJobObject failed: %v", err)
 441         }
 442
 443         const wantMemLimit = 4 * 1024
 444
 445         info.BasicLimitInformation.LimitFlags |= windows.JOB_OBJECT_LIMIT_PROCESS_MEMORY
 446         info.ProcessMemoryLimit = wantMemLimit
 447         _, err = windows.SetInformationJobObject(jo, windows.JobObjectExtendedLimitInformation,
 448                 uintptr(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info)))
 449         if err != nil {
 450                 t.Fatalf("SetInformationJobObject failed: %v", err)
 451         }
 452
 453         err = windows.QueryInformationJobObject(jo, windows.JobObjectExtendedLimitInformation,
 454                 uintptr(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info)), nil)
 455         if err != nil {
 456                 t.Fatalf("QueryInformationJobObject failed: %v", err)
 457         }
 458
 459         if have := info.ProcessMemoryLimit; wantMemLimit != have {
 460                 t.Errorf("ProcessMemoryLimit is wrong: want %v have %v", wantMemLimit, have)
 461         }
 462 }
 463
 464 func TestIsWow64Process2(t *testing.T) {
 465         var processMachine, nativeMachine uint16
 466         err := windows.IsWow64Process2(windows.CurrentProcess(), &processMachine, &nativeMachine)
 467         if errors.Is(err, windows.ERROR_PROC_NOT_FOUND) {
 468                 maj, min, build := windows.RtlGetNtVersionNumbers()
 469                 if maj < 10 || (maj == 10 && min == 0 && build < 17763) {
 470                         t.Skip("not available on older versions of Windows")
 471                         return
 472                 }
 473         }
 474         if err != nil {
 475                 t.Fatalf("IsWow64Process2 failed: %v", err)
 476         }
 477         if processMachine == pe.IMAGE_FILE_MACHINE_UNKNOWN {
 478                 processMachine = nativeMachine
 479         }
 480         switch {
 481         case processMachine == pe.IMAGE_FILE_MACHINE_AMD64 && runtime.GOARCH == "amd64":
 482         case processMachine == pe.IMAGE_FILE_MACHINE_I386 && runtime.GOARCH == "386":
 483         case processMachine == pe.IMAGE_FILE_MACHINE_ARMNT && runtime.GOARCH == "arm":
 484         case processMachine == pe.IMAGE_FILE_MACHINE_ARM64 && runtime.GOARCH == "arm64":
 485         default:
 486                 t.Errorf("IsWow64Process2 is wrong: want %v have %v", runtime.GOARCH, processMachine)
 487         }
 488 }