Source file
src/os/os_windows_test.go
Documentation: os
1
2
3
4
5 package os_test
6
7 import (
8 "errors"
9 "fmt"
10 "internal/poll"
11 "internal/syscall/windows"
12 "internal/syscall/windows/registry"
13 "internal/testenv"
14 "io"
15 "io/fs"
16 "os"
17 osexec "os/exec"
18 "path/filepath"
19 "reflect"
20 "runtime"
21 "sort"
22 "strings"
23 "syscall"
24 "testing"
25 "unicode/utf16"
26 "unsafe"
27 )
28
29
30 type syscallDescriptor = syscall.Handle
31
32
33
34 func chdir(t *testing.T, dir string) {
35 olddir, err := os.Getwd()
36 if err != nil {
37 t.Fatalf("chdir: %v", err)
38 }
39 if err := os.Chdir(dir); err != nil {
40 t.Fatalf("chdir %s: %v", dir, err)
41 }
42
43 t.Cleanup(func() {
44 if err := os.Chdir(olddir); err != nil {
45 t.Errorf("chdir to original working directory %s: %v", olddir, err)
46 os.Exit(1)
47 }
48 })
49 }
50
51 func TestSameWindowsFile(t *testing.T) {
52 temp, err := os.MkdirTemp("", "TestSameWindowsFile")
53 if err != nil {
54 t.Fatal(err)
55 }
56 defer os.RemoveAll(temp)
57 chdir(t, temp)
58
59 f, err := os.Create("a")
60 if err != nil {
61 t.Fatal(err)
62 }
63 f.Close()
64
65 ia1, err := os.Stat("a")
66 if err != nil {
67 t.Fatal(err)
68 }
69
70 path, err := filepath.Abs("a")
71 if err != nil {
72 t.Fatal(err)
73 }
74 ia2, err := os.Stat(path)
75 if err != nil {
76 t.Fatal(err)
77 }
78 if !os.SameFile(ia1, ia2) {
79 t.Errorf("files should be same")
80 }
81
82 p := filepath.VolumeName(path) + filepath.Base(path)
83 if err != nil {
84 t.Fatal(err)
85 }
86 ia3, err := os.Stat(p)
87 if err != nil {
88 t.Fatal(err)
89 }
90 if !os.SameFile(ia1, ia3) {
91 t.Errorf("files should be same")
92 }
93 }
94
95 type dirLinkTest struct {
96 name string
97 mklink func(link, target string) error
98 issueNo int
99 }
100
101 func testDirLinks(t *testing.T, tests []dirLinkTest) {
102 tmpdir, err := os.MkdirTemp("", "testDirLinks")
103 if err != nil {
104 t.Fatal(err)
105 }
106 defer os.RemoveAll(tmpdir)
107 chdir(t, tmpdir)
108
109 dir := filepath.Join(tmpdir, "dir")
110 err = os.Mkdir(dir, 0777)
111 if err != nil {
112 t.Fatal(err)
113 }
114 fi, err := os.Stat(dir)
115 if err != nil {
116 t.Fatal(err)
117 }
118 err = os.WriteFile(filepath.Join(dir, "abc"), []byte("abc"), 0644)
119 if err != nil {
120 t.Fatal(err)
121 }
122 for _, test := range tests {
123 link := filepath.Join(tmpdir, test.name+"_link")
124 err := test.mklink(link, dir)
125 if err != nil {
126 t.Errorf("creating link for %q test failed: %v", test.name, err)
127 continue
128 }
129
130 data, err := os.ReadFile(filepath.Join(link, "abc"))
131 if err != nil {
132 t.Errorf("failed to read abc file: %v", err)
133 continue
134 }
135 if string(data) != "abc" {
136 t.Errorf(`abc file is expected to have "abc" in it, but has %v`, data)
137 continue
138 }
139
140 if test.issueNo > 0 {
141 t.Logf("skipping broken %q test: see issue %d", test.name, test.issueNo)
142 continue
143 }
144
145 fi1, err := os.Stat(link)
146 if err != nil {
147 t.Errorf("failed to stat link %v: %v", link, err)
148 continue
149 }
150 if !fi1.IsDir() {
151 t.Errorf("%q should be a directory", link)
152 continue
153 }
154 if fi1.Name() != filepath.Base(link) {
155 t.Errorf("Stat(%q).Name() = %q, want %q", link, fi1.Name(), filepath.Base(link))
156 continue
157 }
158 if !os.SameFile(fi, fi1) {
159 t.Errorf("%q should point to %q", link, dir)
160 continue
161 }
162
163 fi2, err := os.Lstat(link)
164 if err != nil {
165 t.Errorf("failed to lstat link %v: %v", link, err)
166 continue
167 }
168 if m := fi2.Mode(); m&fs.ModeSymlink == 0 {
169 t.Errorf("%q should be a link, but is not (mode=0x%x)", link, uint32(m))
170 continue
171 }
172 if m := fi2.Mode(); m&fs.ModeDir != 0 {
173 t.Errorf("%q should be a link, not a directory (mode=0x%x)", link, uint32(m))
174 continue
175 }
176 }
177 }
178
179
180 type reparseData struct {
181 substituteName namePosition
182 printName namePosition
183 pathBuf []uint16
184 }
185
186 type namePosition struct {
187 offset uint16
188 length uint16
189 }
190
191 func (rd *reparseData) addUTF16s(s []uint16) (offset uint16) {
192 off := len(rd.pathBuf) * 2
193 rd.pathBuf = append(rd.pathBuf, s...)
194 return uint16(off)
195 }
196
197 func (rd *reparseData) addString(s string) (offset, length uint16) {
198 p := syscall.StringToUTF16(s)
199 return rd.addUTF16s(p), uint16(len(p)-1) * 2
200 }
201
202 func (rd *reparseData) addSubstituteName(name string) {
203 rd.substituteName.offset, rd.substituteName.length = rd.addString(name)
204 }
205
206 func (rd *reparseData) addPrintName(name string) {
207 rd.printName.offset, rd.printName.length = rd.addString(name)
208 }
209
210 func (rd *reparseData) addStringNoNUL(s string) (offset, length uint16) {
211 p := syscall.StringToUTF16(s)
212 p = p[:len(p)-1]
213 return rd.addUTF16s(p), uint16(len(p)) * 2
214 }
215
216 func (rd *reparseData) addSubstituteNameNoNUL(name string) {
217 rd.substituteName.offset, rd.substituteName.length = rd.addStringNoNUL(name)
218 }
219
220 func (rd *reparseData) addPrintNameNoNUL(name string) {
221 rd.printName.offset, rd.printName.length = rd.addStringNoNUL(name)
222 }
223
224
225 func (rd *reparseData) pathBuffeLen() uint16 {
226 return uint16(len(rd.pathBuf)) * 2
227 }
228
229
230
231
232
233 type _REPARSE_DATA_BUFFER struct {
234 header windows.REPARSE_DATA_BUFFER_HEADER
235 detail [syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE]byte
236 }
237
238 func createDirLink(link string, rdb *_REPARSE_DATA_BUFFER) error {
239 err := os.Mkdir(link, 0777)
240 if err != nil {
241 return err
242 }
243
244 linkp := syscall.StringToUTF16(link)
245 fd, err := syscall.CreateFile(&linkp[0], syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING,
246 syscall.FILE_FLAG_OPEN_REPARSE_POINT|syscall.FILE_FLAG_BACKUP_SEMANTICS, 0)
247 if err != nil {
248 return err
249 }
250 defer syscall.CloseHandle(fd)
251
252 buflen := uint32(rdb.header.ReparseDataLength) + uint32(unsafe.Sizeof(rdb.header))
253 var bytesReturned uint32
254 return syscall.DeviceIoControl(fd, windows.FSCTL_SET_REPARSE_POINT,
255 (*byte)(unsafe.Pointer(&rdb.header)), buflen, nil, 0, &bytesReturned, nil)
256 }
257
258 func createMountPoint(link string, target *reparseData) error {
259 var buf *windows.MountPointReparseBuffer
260 buflen := uint16(unsafe.Offsetof(buf.PathBuffer)) + target.pathBuffeLen()
261 byteblob := make([]byte, buflen)
262 buf = (*windows.MountPointReparseBuffer)(unsafe.Pointer(&byteblob[0]))
263 buf.SubstituteNameOffset = target.substituteName.offset
264 buf.SubstituteNameLength = target.substituteName.length
265 buf.PrintNameOffset = target.printName.offset
266 buf.PrintNameLength = target.printName.length
267 pbuflen := len(target.pathBuf)
268 copy((*[2048]uint16)(unsafe.Pointer(&buf.PathBuffer[0]))[:pbuflen:pbuflen], target.pathBuf)
269
270 var rdb _REPARSE_DATA_BUFFER
271 rdb.header.ReparseTag = windows.IO_REPARSE_TAG_MOUNT_POINT
272 rdb.header.ReparseDataLength = buflen
273 copy(rdb.detail[:], byteblob)
274
275 return createDirLink(link, &rdb)
276 }
277
278 func TestDirectoryJunction(t *testing.T) {
279 var tests = []dirLinkTest{
280 {
281
282 name: "standard",
283 mklink: func(link, target string) error {
284 var t reparseData
285 t.addSubstituteName(`\??\` + target)
286 t.addPrintName(target)
287 return createMountPoint(link, &t)
288 },
289 },
290 {
291
292 name: "have_blank_print_name",
293 mklink: func(link, target string) error {
294 var t reparseData
295 t.addSubstituteName(`\??\` + target)
296 t.addPrintName("")
297 return createMountPoint(link, &t)
298 },
299 },
300 }
301 output, _ := osexec.Command("cmd", "/c", "mklink", "/?").Output()
302 mklinkSupportsJunctionLinks := strings.Contains(string(output), " /J ")
303 if mklinkSupportsJunctionLinks {
304 tests = append(tests,
305 dirLinkTest{
306 name: "use_mklink_cmd",
307 mklink: func(link, target string) error {
308 output, err := osexec.Command("cmd", "/c", "mklink", "/J", link, target).CombinedOutput()
309 if err != nil {
310 t.Errorf("failed to run mklink %v %v: %v %q", link, target, err, output)
311 }
312 return nil
313 },
314 },
315 )
316 } else {
317 t.Log(`skipping "use_mklink_cmd" test, mklink does not supports directory junctions`)
318 }
319 testDirLinks(t, tests)
320 }
321
322 func enableCurrentThreadPrivilege(privilegeName string) error {
323 ct, err := windows.GetCurrentThread()
324 if err != nil {
325 return err
326 }
327 var t syscall.Token
328 err = windows.OpenThreadToken(ct, syscall.TOKEN_QUERY|windows.TOKEN_ADJUST_PRIVILEGES, false, &t)
329 if err != nil {
330 return err
331 }
332 defer syscall.CloseHandle(syscall.Handle(t))
333
334 var tp windows.TOKEN_PRIVILEGES
335
336 privStr, err := syscall.UTF16PtrFromString(privilegeName)
337 if err != nil {
338 return err
339 }
340 err = windows.LookupPrivilegeValue(nil, privStr, &tp.Privileges[0].Luid)
341 if err != nil {
342 return err
343 }
344 tp.PrivilegeCount = 1
345 tp.Privileges[0].Attributes = windows.SE_PRIVILEGE_ENABLED
346 return windows.AdjustTokenPrivileges(t, false, &tp, 0, nil, nil)
347 }
348
349 func createSymbolicLink(link string, target *reparseData, isrelative bool) error {
350 var buf *windows.SymbolicLinkReparseBuffer
351 buflen := uint16(unsafe.Offsetof(buf.PathBuffer)) + target.pathBuffeLen()
352 byteblob := make([]byte, buflen)
353 buf = (*windows.SymbolicLinkReparseBuffer)(unsafe.Pointer(&byteblob[0]))
354 buf.SubstituteNameOffset = target.substituteName.offset
355 buf.SubstituteNameLength = target.substituteName.length
356 buf.PrintNameOffset = target.printName.offset
357 buf.PrintNameLength = target.printName.length
358 if isrelative {
359 buf.Flags = windows.SYMLINK_FLAG_RELATIVE
360 }
361 pbuflen := len(target.pathBuf)
362 copy((*[2048]uint16)(unsafe.Pointer(&buf.PathBuffer[0]))[:pbuflen:pbuflen], target.pathBuf)
363
364 var rdb _REPARSE_DATA_BUFFER
365 rdb.header.ReparseTag = syscall.IO_REPARSE_TAG_SYMLINK
366 rdb.header.ReparseDataLength = buflen
367 copy(rdb.detail[:], byteblob)
368
369 return createDirLink(link, &rdb)
370 }
371
372 func TestDirectorySymbolicLink(t *testing.T) {
373 var tests []dirLinkTest
374 output, _ := osexec.Command("cmd", "/c", "mklink", "/?").Output()
375 mklinkSupportsDirectorySymbolicLinks := strings.Contains(string(output), " /D ")
376 if mklinkSupportsDirectorySymbolicLinks {
377 tests = append(tests,
378 dirLinkTest{
379 name: "use_mklink_cmd",
380 mklink: func(link, target string) error {
381 output, err := osexec.Command("cmd", "/c", "mklink", "/D", link, target).CombinedOutput()
382 if err != nil {
383 t.Errorf("failed to run mklink %v %v: %v %q", link, target, err, output)
384 }
385 return nil
386 },
387 },
388 )
389 } else {
390 t.Log(`skipping "use_mklink_cmd" test, mklink does not supports directory symbolic links`)
391 }
392
393
394 runtime.LockOSThread()
395 defer runtime.UnlockOSThread()
396
397 err := windows.ImpersonateSelf(windows.SecurityImpersonation)
398 if err != nil {
399 t.Fatal(err)
400 }
401 defer windows.RevertToSelf()
402
403 err = enableCurrentThreadPrivilege("SeCreateSymbolicLinkPrivilege")
404 if err != nil {
405 t.Skipf(`skipping some tests, could not enable "SeCreateSymbolicLinkPrivilege": %v`, err)
406 }
407 tests = append(tests,
408 dirLinkTest{
409 name: "use_os_pkg",
410 mklink: func(link, target string) error {
411 return os.Symlink(target, link)
412 },
413 },
414 dirLinkTest{
415
416 name: "standard",
417 mklink: func(link, target string) error {
418 var t reparseData
419 t.addPrintName(target)
420 t.addSubstituteName(`\??\` + target)
421 return createSymbolicLink(link, &t, false)
422 },
423 },
424 dirLinkTest{
425 name: "relative",
426 mklink: func(link, target string) error {
427 var t reparseData
428 t.addSubstituteNameNoNUL(filepath.Base(target))
429 t.addPrintNameNoNUL(filepath.Base(target))
430 return createSymbolicLink(link, &t, true)
431 },
432 },
433 )
434 testDirLinks(t, tests)
435 }
436
437 func TestNetworkSymbolicLink(t *testing.T) {
438 testenv.MustHaveSymlink(t)
439
440 const _NERR_ServerNotStarted = syscall.Errno(2114)
441
442 dir, err := os.MkdirTemp("", "TestNetworkSymbolicLink")
443 if err != nil {
444 t.Fatal(err)
445 }
446 defer os.RemoveAll(dir)
447
448 chdir(t, dir)
449
450 shareName := "GoSymbolicLinkTestShare"
451 sharePath := filepath.Join(dir, shareName)
452 testDir := "TestDir"
453
454 err = os.MkdirAll(filepath.Join(sharePath, testDir), 0777)
455 if err != nil {
456 t.Fatal(err)
457 }
458
459 wShareName, err := syscall.UTF16PtrFromString(shareName)
460 if err != nil {
461 t.Fatal(err)
462 }
463 wSharePath, err := syscall.UTF16PtrFromString(sharePath)
464 if err != nil {
465 t.Fatal(err)
466 }
467
468 p := windows.SHARE_INFO_2{
469 Netname: wShareName,
470 Type: windows.STYPE_DISKTREE,
471 Remark: nil,
472 Permissions: 0,
473 MaxUses: 1,
474 CurrentUses: 0,
475 Path: wSharePath,
476 Passwd: nil,
477 }
478
479 err = windows.NetShareAdd(nil, 2, (*byte)(unsafe.Pointer(&p)), nil)
480 if err != nil {
481 if err == syscall.ERROR_ACCESS_DENIED {
482 t.Skip("you don't have enough privileges to add network share")
483 }
484 if err == _NERR_ServerNotStarted {
485 t.Skip(_NERR_ServerNotStarted.Error())
486 }
487 t.Fatal(err)
488 }
489 defer func() {
490 err := windows.NetShareDel(nil, wShareName, 0)
491 if err != nil {
492 t.Fatal(err)
493 }
494 }()
495
496 UNCPath := `\\localhost\` + shareName + `\`
497
498 fi1, err := os.Stat(sharePath)
499 if err != nil {
500 t.Fatal(err)
501 }
502 fi2, err := os.Stat(UNCPath)
503 if err != nil {
504 t.Fatal(err)
505 }
506 if !os.SameFile(fi1, fi2) {
507 t.Fatalf("%q and %q should be the same directory, but not", sharePath, UNCPath)
508 }
509
510 target := filepath.Join(UNCPath, testDir)
511 link := "link"
512
513 err = os.Symlink(target, link)
514 if err != nil {
515 t.Fatal(err)
516 }
517 defer os.Remove(link)
518
519 got, err := os.Readlink(link)
520 if err != nil {
521 t.Fatal(err)
522 }
523 if got != target {
524 t.Errorf(`os.Readlink("%s"): got %v, want %v`, link, got, target)
525 }
526
527 got, err = filepath.EvalSymlinks(link)
528 if err != nil {
529 t.Fatal(err)
530 }
531 if got != target {
532 t.Errorf(`filepath.EvalSymlinks("%s"): got %v, want %v`, link, got, target)
533 }
534 }
535
536 func TestStartProcessAttr(t *testing.T) {
537 p, err := os.StartProcess(os.Getenv("COMSPEC"), []string{"/c", "cd"}, new(os.ProcAttr))
538 if err != nil {
539 return
540 }
541 defer p.Wait()
542 t.Fatalf("StartProcess expected to fail, but succeeded.")
543 }
544
545 func TestShareNotExistError(t *testing.T) {
546 if testing.Short() {
547 t.Skip("slow test that uses network; skipping")
548 }
549 _, err := os.Stat(`\\no_such_server\no_such_share\no_such_file`)
550 if err == nil {
551 t.Fatal("stat succeeded, but expected to fail")
552 }
553 if !os.IsNotExist(err) {
554 t.Fatalf("os.Stat failed with %q, but os.IsNotExist(err) is false", err)
555 }
556 }
557
558 func TestBadNetPathError(t *testing.T) {
559 const ERROR_BAD_NETPATH = syscall.Errno(53)
560 if !os.IsNotExist(ERROR_BAD_NETPATH) {
561 t.Fatal("os.IsNotExist(syscall.Errno(53)) is false, but want true")
562 }
563 }
564
565 func TestStatDir(t *testing.T) {
566 defer chtmpdir(t)()
567
568 f, err := os.Open(".")
569 if err != nil {
570 t.Fatal(err)
571 }
572 defer f.Close()
573
574 fi, err := f.Stat()
575 if err != nil {
576 t.Fatal(err)
577 }
578
579 err = os.Chdir("..")
580 if err != nil {
581 t.Fatal(err)
582 }
583
584 fi2, err := f.Stat()
585 if err != nil {
586 t.Fatal(err)
587 }
588
589 if !os.SameFile(fi, fi2) {
590 t.Fatal("race condition occurred")
591 }
592 }
593
594 func TestOpenVolumeName(t *testing.T) {
595 tmpdir, err := os.MkdirTemp("", "TestOpenVolumeName")
596 if err != nil {
597 t.Fatal(err)
598 }
599 defer os.RemoveAll(tmpdir)
600 chdir(t, tmpdir)
601
602 want := []string{"file1", "file2", "file3", "gopher.txt"}
603 sort.Strings(want)
604 for _, name := range want {
605 err := os.WriteFile(filepath.Join(tmpdir, name), nil, 0777)
606 if err != nil {
607 t.Fatal(err)
608 }
609 }
610
611 f, err := os.Open(filepath.VolumeName(tmpdir))
612 if err != nil {
613 t.Fatal(err)
614 }
615 defer f.Close()
616
617 have, err := f.Readdirnames(-1)
618 if err != nil {
619 t.Fatal(err)
620 }
621 sort.Strings(have)
622
623 if strings.Join(want, "/") != strings.Join(have, "/") {
624 t.Fatalf("unexpected file list %q, want %q", have, want)
625 }
626 }
627
628 func TestDeleteReadOnly(t *testing.T) {
629 tmpdir := t.TempDir()
630 p := filepath.Join(tmpdir, "a")
631
632 f, err := os.OpenFile(p, os.O_CREATE, 0400)
633 if err != nil {
634 t.Fatal(err)
635 }
636 f.Close()
637
638 if err = os.Chmod(p, 0400); err != nil {
639 t.Fatal(err)
640 }
641 if err = os.Remove(p); err != nil {
642 t.Fatal(err)
643 }
644 }
645
646 func TestStatSymlinkLoop(t *testing.T) {
647 testenv.MustHaveSymlink(t)
648
649 defer chtmpdir(t)()
650
651 err := os.Symlink("x", "y")
652 if err != nil {
653 t.Fatal(err)
654 }
655 defer os.Remove("y")
656
657 err = os.Symlink("y", "x")
658 if err != nil {
659 t.Fatal(err)
660 }
661 defer os.Remove("x")
662
663 _, err = os.Stat("x")
664 if _, ok := err.(*fs.PathError); !ok {
665 t.Errorf("expected *PathError, got %T: %v\n", err, err)
666 }
667 }
668
669 func TestReadStdin(t *testing.T) {
670 old := poll.ReadConsole
671 defer func() {
672 poll.ReadConsole = old
673 }()
674
675 p, err := syscall.GetCurrentProcess()
676 if err != nil {
677 t.Fatalf("Unable to get handle to current process: %v", err)
678 }
679 var stdinDuplicate syscall.Handle
680 err = syscall.DuplicateHandle(p, syscall.Handle(syscall.Stdin), p, &stdinDuplicate, 0, false, syscall.DUPLICATE_SAME_ACCESS)
681 if err != nil {
682 t.Fatalf("Unable to duplicate stdin: %v", err)
683 }
684 testConsole := os.NewConsoleFile(stdinDuplicate, "test")
685
686 var tests = []string{
687 "abc",
688 "äöü",
689 "\u3042",
690 "“hi”™",
691 "hello\x1aworld",
692 "\U0001F648\U0001F649\U0001F64A",
693 }
694
695 for _, consoleSize := range []int{1, 2, 3, 10, 16, 100, 1000} {
696 for _, readSize := range []int{1, 2, 3, 4, 5, 8, 10, 16, 20, 50, 100} {
697 for _, s := range tests {
698 t.Run(fmt.Sprintf("c%d/r%d/%s", consoleSize, readSize, s), func(t *testing.T) {
699 s16 := utf16.Encode([]rune(s))
700 poll.ReadConsole = func(h syscall.Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) error {
701 if inputControl != nil {
702 t.Fatalf("inputControl not nil")
703 }
704 n := int(toread)
705 if n > consoleSize {
706 n = consoleSize
707 }
708 n = copy((*[10000]uint16)(unsafe.Pointer(buf))[:n:n], s16)
709 s16 = s16[n:]
710 *read = uint32(n)
711 t.Logf("read %d -> %d", toread, *read)
712 return nil
713 }
714
715 var all []string
716 var buf []byte
717 chunk := make([]byte, readSize)
718 for {
719 n, err := testConsole.Read(chunk)
720 buf = append(buf, chunk[:n]...)
721 if err == io.EOF {
722 all = append(all, string(buf))
723 if len(all) >= 5 {
724 break
725 }
726 buf = buf[:0]
727 } else if err != nil {
728 t.Fatalf("reading %q: error: %v", s, err)
729 }
730 if len(buf) >= 2000 {
731 t.Fatalf("reading %q: stuck in loop: %q", s, buf)
732 }
733 }
734
735 want := strings.Split(s, "\x1a")
736 for len(want) < 5 {
737 want = append(want, "")
738 }
739 if !reflect.DeepEqual(all, want) {
740 t.Errorf("reading %q:\nhave %x\nwant %x", s, all, want)
741 }
742 })
743 }
744 }
745 }
746 }
747
748 func TestStatPagefile(t *testing.T) {
749 fi, err := os.Stat(`c:\pagefile.sys`)
750 if err == nil {
751 if fi.Name() == "" {
752 t.Fatal(`FileInfo of c:\pagefile.sys has empty name`)
753 }
754 return
755 }
756 if os.IsNotExist(err) {
757 t.Skip(`skipping because c:\pagefile.sys is not found`)
758 }
759 t.Fatal(err)
760 }
761
762
763
764 func syscallCommandLineToArgv(cmd string) ([]string, error) {
765 var argc int32
766 argv, err := syscall.CommandLineToArgv(&syscall.StringToUTF16(cmd)[0], &argc)
767 if err != nil {
768 return nil, err
769 }
770 defer syscall.LocalFree(syscall.Handle(uintptr(unsafe.Pointer(argv))))
771
772 var args []string
773 for _, v := range (*argv)[:argc] {
774 args = append(args, syscall.UTF16ToString((*v)[:]))
775 }
776 return args, nil
777 }
778
779
780
781
782 func compareCommandLineToArgvWithSyscall(t *testing.T, cmd string) {
783 syscallArgs, err := syscallCommandLineToArgv(cmd)
784 if err != nil {
785 t.Fatal(err)
786 }
787 args := os.CommandLineToArgv(cmd)
788 if want, have := fmt.Sprintf("%q", syscallArgs), fmt.Sprintf("%q", args); want != have {
789 t.Errorf("testing os.commandLineToArgv(%q) failed: have %q want %q", cmd, args, syscallArgs)
790 return
791 }
792 }
793
794 func TestCmdArgs(t *testing.T) {
795 tmpdir := t.TempDir()
796
797 const prog = `
798 package main
799
800 import (
801 "fmt"
802 "os"
803 )
804
805 func main() {
806 fmt.Printf("%q", os.Args)
807 }
808 `
809 src := filepath.Join(tmpdir, "main.go")
810 if err := os.WriteFile(src, []byte(prog), 0666); err != nil {
811 t.Fatal(err)
812 }
813
814 exe := filepath.Join(tmpdir, "main.exe")
815 cmd := osexec.Command(testenv.GoToolPath(t), "build", "-o", exe, src)
816 cmd.Dir = tmpdir
817 out, err := cmd.CombinedOutput()
818 if err != nil {
819 t.Fatalf("building main.exe failed: %v\n%s", err, out)
820 }
821
822 var cmds = []string{
823 ``,
824 ` a b c`,
825 ` "`,
826 ` ""`,
827 ` """`,
828 ` "" a`,
829 ` "123"`,
830 ` \"123\"`,
831 ` \"123 456\"`,
832 ` \\"`,
833 ` \\\"`,
834 ` \\\\\"`,
835 ` \\\"x`,
836 ` """"\""\\\"`,
837 ` abc`,
838 ` \\\\\""x"""y z`,
839 "\tb\t\"x\ty\"",
840 ` "Брад" d e`,
841
842 ` "abc" d e`,
843 ` a\\b d"e f"g h`,
844 ` a\\\"b c d`,
845 ` a\\\\"b c" d e`,
846
847
848 ` CallMeIshmael`,
849 ` "Call Me Ishmael"`,
850 ` Cal"l Me I"shmael`,
851 ` CallMe\"Ishmael`,
852 ` "CallMe\"Ishmael"`,
853 ` "Call Me Ishmael\\"`,
854 ` "CallMe\\\"Ishmael"`,
855 ` a\\\b`,
856 ` "a\\\b"`,
857
858 ` "\"Call Me Ishmael\""`,
859 ` "C:\TEST A\\"`,
860 ` "\"C:\TEST A\\\""`,
861
862 ` "a b c" d e`,
863 ` "ab\"c" "\\" d`,
864 ` a\\\b d"e f"g h`,
865 ` a\\\"b c d`,
866 ` a\\\\"b c" d e`,
867
868 ` "a b c""`,
869 ` """CallMeIshmael""" b c`,
870 ` """Call Me Ishmael"""`,
871 ` """"Call Me Ishmael"" b c`,
872 }
873 for _, cmd := range cmds {
874 compareCommandLineToArgvWithSyscall(t, "test"+cmd)
875 compareCommandLineToArgvWithSyscall(t, `"cmd line"`+cmd)
876 compareCommandLineToArgvWithSyscall(t, exe+cmd)
877
878
879 args := os.CommandLineToArgv(exe + cmd)
880 out, err := osexec.Command(args[0], args[1:]...).CombinedOutput()
881 if err != nil {
882 t.Fatalf("running %q failed: %v\n%v", args, err, string(out))
883 }
884 if want, have := fmt.Sprintf("%q", args), string(out); want != have {
885 t.Errorf("wrong output of executing %q: have %q want %q", args, have, want)
886 continue
887 }
888 }
889 }
890
891 func findOneDriveDir() (string, error) {
892
893 const onedrivekey = `SOFTWARE\Microsoft\OneDrive`
894 k, err := registry.OpenKey(registry.CURRENT_USER, onedrivekey, registry.READ)
895 if err != nil {
896 return "", fmt.Errorf("OpenKey(%q) failed: %v", onedrivekey, err)
897 }
898 defer k.Close()
899
900 path, _, err := k.GetStringValue("UserFolder")
901 if err != nil {
902 return "", fmt.Errorf("reading UserFolder failed: %v", err)
903 }
904 return path, nil
905 }
906
907
908 func TestOneDrive(t *testing.T) {
909 dir, err := findOneDriveDir()
910 if err != nil {
911 t.Skipf("Skipping, because we did not find OneDrive directory: %v", err)
912 }
913 testDirStats(t, dir)
914 }
915
916 func TestWindowsDevNullFile(t *testing.T) {
917 testDevNullFile(t, "NUL", true)
918 testDevNullFile(t, "nul", true)
919 testDevNullFile(t, "Nul", true)
920
921 f1, err := os.Open("NUL")
922 if err != nil {
923 t.Fatal(err)
924 }
925 defer f1.Close()
926
927 fi1, err := f1.Stat()
928 if err != nil {
929 t.Fatal(err)
930 }
931
932 f2, err := os.Open("nul")
933 if err != nil {
934 t.Fatal(err)
935 }
936 defer f2.Close()
937
938 fi2, err := f2.Stat()
939 if err != nil {
940 t.Fatal(err)
941 }
942
943 if !os.SameFile(fi1, fi2) {
944 t.Errorf(`"NUL" and "nul" are not the same file`)
945 }
946 }
947
948
949
950
951 func TestSymlinkCreation(t *testing.T) {
952 if !testenv.HasSymlink() && !isWindowsDeveloperModeActive() {
953 t.Skip("Windows developer mode is not active")
954 }
955 t.Parallel()
956
957 temp := t.TempDir()
958 dummyFile := filepath.Join(temp, "file")
959 if err := os.WriteFile(dummyFile, []byte(""), 0644); err != nil {
960 t.Fatal(err)
961 }
962
963 linkFile := filepath.Join(temp, "link")
964 if err := os.Symlink(dummyFile, linkFile); err != nil {
965 t.Fatal(err)
966 }
967 }
968
969
970
971
972 func isWindowsDeveloperModeActive() bool {
973 key, err := registry.OpenKey(registry.LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\AppModelUnlock", registry.READ)
974 if err != nil {
975 return false
976 }
977
978 val, _, err := key.GetIntegerValue("AllowDevelopmentWithoutDevLicense")
979 if err != nil {
980 return false
981 }
982
983 return val != 0
984 }
985
986
987
988
989
990 func TestRootRelativeDirSymlink(t *testing.T) {
991 testenv.MustHaveSymlink(t)
992 t.Parallel()
993
994 temp := t.TempDir()
995 dir := filepath.Join(temp, "dir")
996 if err := os.Mkdir(dir, 0755); err != nil {
997 t.Fatal(err)
998 }
999
1000 volumeRelDir := strings.TrimPrefix(dir, filepath.VolumeName(dir))
1001
1002 link := filepath.Join(temp, "link")
1003 err := os.Symlink(volumeRelDir, link)
1004 if err != nil {
1005 t.Fatal(err)
1006 }
1007 t.Logf("Symlink(%#q, %#q)", volumeRelDir, link)
1008
1009 f, err := os.Open(link)
1010 if err != nil {
1011 t.Fatal(err)
1012 }
1013 defer f.Close()
1014 if fi, err := f.Stat(); err != nil {
1015 t.Fatal(err)
1016 } else if !fi.IsDir() {
1017 t.Errorf("Open(%#q).Stat().IsDir() = false; want true", f.Name())
1018 }
1019 }
1020
1021
1022
1023
1024
1025 func TestWorkingDirectoryRelativeSymlink(t *testing.T) {
1026 testenv.MustHaveSymlink(t)
1027
1028
1029 temp := t.TempDir()
1030 if v := filepath.VolumeName(temp); len(v) < 2 || v[1] != ':' {
1031 t.Skipf("Can't test relative symlinks: t.TempDir() (%#q) does not begin with a drive letter.", temp)
1032 }
1033
1034 absDir := filepath.Join(temp, `dir\sub`)
1035 if err := os.MkdirAll(absDir, 0755); err != nil {
1036 t.Fatal(err)
1037 }
1038
1039
1040
1041 oldwd, err := os.Getwd()
1042 if err != nil {
1043 t.Fatal(err)
1044 }
1045 defer func() {
1046 if err := os.Chdir(oldwd); err != nil {
1047 t.Fatal(err)
1048 }
1049 }()
1050 if err := os.Chdir(temp); err != nil {
1051 t.Fatal(err)
1052 }
1053 t.Logf("Chdir(%#q)", temp)
1054
1055 wdRelDir := filepath.VolumeName(temp) + `dir\sub`
1056 absLink := filepath.Join(temp, "link")
1057 err = os.Symlink(wdRelDir, absLink)
1058 if err != nil {
1059 t.Fatal(err)
1060 }
1061 t.Logf("Symlink(%#q, %#q)", wdRelDir, absLink)
1062
1063
1064
1065
1066 if err := os.Chdir(oldwd); err != nil {
1067 t.Fatal(err)
1068 }
1069 t.Logf("Chdir(%#q)", oldwd)
1070
1071 resolved, err := os.Readlink(absLink)
1072 if err != nil {
1073 t.Errorf("Readlink(%#q): %v", absLink, err)
1074 } else if resolved != absDir {
1075 t.Errorf("Readlink(%#q) = %#q; want %#q", absLink, resolved, absDir)
1076 }
1077
1078 linkFile, err := os.Open(absLink)
1079 if err != nil {
1080 t.Fatal(err)
1081 }
1082 defer linkFile.Close()
1083
1084 linkInfo, err := linkFile.Stat()
1085 if err != nil {
1086 t.Fatal(err)
1087 }
1088 if !linkInfo.IsDir() {
1089 t.Errorf("Open(%#q).Stat().IsDir() = false; want true", absLink)
1090 }
1091
1092 absInfo, err := os.Stat(absDir)
1093 if err != nil {
1094 t.Fatal(err)
1095 }
1096
1097 if !os.SameFile(absInfo, linkInfo) {
1098 t.Errorf("SameFile(Stat(%#q), Open(%#q).Stat()) = false; want true", absDir, absLink)
1099 }
1100 }
1101
1102
1103 func TestStatOfInvalidName(t *testing.T) {
1104 _, err := os.Stat("*.go")
1105 if err == nil {
1106 t.Fatal(`os.Stat("*.go") unexpectedly succeeded`)
1107 }
1108 }
1109
1110
1111
1112
1113 func findUnusedDriveLetter() (string, error) {
1114
1115
1116 for l := 'Z'; l >= 'D'; l-- {
1117 p := string(l) + `:\`
1118 _, err := os.Stat(p)
1119 if os.IsNotExist(err) {
1120 return p, nil
1121 }
1122 }
1123 return "", errors.New("Could not find unused drive letter.")
1124 }
1125
1126 func TestRootDirAsTemp(t *testing.T) {
1127 testenv.MustHaveExec(t)
1128
1129 if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
1130 fmt.Print(os.TempDir())
1131 os.Exit(0)
1132 }
1133
1134 newtmp, err := findUnusedDriveLetter()
1135 if err != nil {
1136 t.Fatal(err)
1137 }
1138
1139 cmd := osexec.Command(os.Args[0], "-test.run=TestRootDirAsTemp")
1140 cmd.Env = os.Environ()
1141 cmd.Env = append(cmd.Env, "GO_WANT_HELPER_PROCESS=1")
1142 cmd.Env = append(cmd.Env, "TMP="+newtmp)
1143 cmd.Env = append(cmd.Env, "TEMP="+newtmp)
1144 output, err := cmd.CombinedOutput()
1145 if err != nil {
1146 t.Fatalf("Failed to spawn child process: %v %q", err, string(output))
1147 }
1148 if want, have := newtmp, string(output); have != want {
1149 t.Fatalf("unexpected child process output %q, want %q", have, want)
1150 }
1151 }
1152
1153 func testReadlink(t *testing.T, path, want string) {
1154 got, err := os.Readlink(path)
1155 if err != nil {
1156 t.Error(err)
1157 return
1158 }
1159 if got != want {
1160 t.Errorf(`Readlink(%q): got %q, want %q`, path, got, want)
1161 }
1162 }
1163
1164 func mklink(t *testing.T, link, target string) {
1165 output, err := osexec.Command("cmd", "/c", "mklink", link, target).CombinedOutput()
1166 if err != nil {
1167 t.Fatalf("failed to run mklink %v %v: %v %q", link, target, err, output)
1168 }
1169 }
1170
1171 func mklinkj(t *testing.T, link, target string) {
1172 output, err := osexec.Command("cmd", "/c", "mklink", "/J", link, target).CombinedOutput()
1173 if err != nil {
1174 t.Fatalf("failed to run mklink %v %v: %v %q", link, target, err, output)
1175 }
1176 }
1177
1178 func mklinkd(t *testing.T, link, target string) {
1179 output, err := osexec.Command("cmd", "/c", "mklink", "/D", link, target).CombinedOutput()
1180 if err != nil {
1181 t.Fatalf("failed to run mklink %v %v: %v %q", link, target, err, output)
1182 }
1183 }
1184
1185 func TestWindowsReadlink(t *testing.T) {
1186 tmpdir, err := os.MkdirTemp("", "TestWindowsReadlink")
1187 if err != nil {
1188 t.Fatal(err)
1189 }
1190 defer os.RemoveAll(tmpdir)
1191
1192
1193 tmpdir, err = filepath.EvalSymlinks(tmpdir)
1194 if err != nil {
1195 t.Fatal(err)
1196 }
1197 chdir(t, tmpdir)
1198
1199 vol := filepath.VolumeName(tmpdir)
1200 output, err := osexec.Command("cmd", "/c", "mountvol", vol, "/L").CombinedOutput()
1201 if err != nil {
1202 t.Fatalf("failed to run mountvol %v /L: %v %q", vol, err, output)
1203 }
1204 ntvol := strings.Trim(string(output), " \n\r")
1205
1206 dir := filepath.Join(tmpdir, "dir")
1207 err = os.MkdirAll(dir, 0777)
1208 if err != nil {
1209 t.Fatal(err)
1210 }
1211
1212 absdirjlink := filepath.Join(tmpdir, "absdirjlink")
1213 mklinkj(t, absdirjlink, dir)
1214 testReadlink(t, absdirjlink, dir)
1215
1216 ntdirjlink := filepath.Join(tmpdir, "ntdirjlink")
1217 mklinkj(t, ntdirjlink, ntvol+absdirjlink[len(filepath.VolumeName(absdirjlink)):])
1218 testReadlink(t, ntdirjlink, absdirjlink)
1219
1220 ntdirjlinktolink := filepath.Join(tmpdir, "ntdirjlinktolink")
1221 mklinkj(t, ntdirjlinktolink, ntvol+absdirjlink[len(filepath.VolumeName(absdirjlink)):])
1222 testReadlink(t, ntdirjlinktolink, absdirjlink)
1223
1224 mklinkj(t, "reldirjlink", "dir")
1225 testReadlink(t, "reldirjlink", dir)
1226
1227
1228 testenv.MustHaveSymlink(t)
1229
1230 absdirlink := filepath.Join(tmpdir, "absdirlink")
1231 mklinkd(t, absdirlink, dir)
1232 testReadlink(t, absdirlink, dir)
1233
1234 ntdirlink := filepath.Join(tmpdir, "ntdirlink")
1235 mklinkd(t, ntdirlink, ntvol+absdirlink[len(filepath.VolumeName(absdirlink)):])
1236 testReadlink(t, ntdirlink, absdirlink)
1237
1238 mklinkd(t, "reldirlink", "dir")
1239 testReadlink(t, "reldirlink", "dir")
1240
1241 file := filepath.Join(tmpdir, "file")
1242 err = os.WriteFile(file, []byte(""), 0666)
1243 if err != nil {
1244 t.Fatal(err)
1245 }
1246
1247 filelink := filepath.Join(tmpdir, "filelink")
1248 mklink(t, filelink, file)
1249 testReadlink(t, filelink, file)
1250
1251 linktofilelink := filepath.Join(tmpdir, "linktofilelink")
1252 mklink(t, linktofilelink, ntvol+filelink[len(filepath.VolumeName(filelink)):])
1253 testReadlink(t, linktofilelink, filelink)
1254
1255 mklink(t, "relfilelink", "file")
1256 testReadlink(t, "relfilelink", "file")
1257 }
1258
1259
1260 func TestMkdirDevNull(t *testing.T) {
1261 err := os.Mkdir(os.DevNull, 777)
1262 oserr, ok := err.(*fs.PathError)
1263 if !ok {
1264 t.Fatalf("error (%T) is not *fs.PathError", err)
1265 }
1266 errno, ok := oserr.Err.(syscall.Errno)
1267 if !ok {
1268 t.Fatalf("error (%T) is not syscall.Errno", oserr)
1269 }
1270 if errno != syscall.ENOTDIR {
1271 t.Fatalf("error %d is not syscall.ENOTDIR", errno)
1272 }
1273 }
1274
View as plain text