← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/os/signal/signal_windows_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/os/signal/signal_windows_test.go
5
5
package signal
6
6
 
7
7
import (
8
 
        "flag"
 
8
        "bytes"
9
9
        "os"
 
10
        "os/exec"
 
11
        "path/filepath"
10
12
        "syscall"
11
13
        "testing"
12
14
        "time"
13
15
)
14
16
 
15
 
var runCtrlBreakTest = flag.Bool("run_ctlbrk_test", false, "force to run Ctrl+Break test")
16
 
 
17
 
func sendCtrlBreak(t *testing.T) {
 
17
func sendCtrlBreak(t *testing.T, pid int) {
18
18
        d, e := syscall.LoadDLL("kernel32.dll")
19
19
        if e != nil {
20
20
                t.Fatalf("LoadDLL: %v\n", e)
23
23
        if e != nil {
24
24
                t.Fatalf("FindProc: %v\n", e)
25
25
        }
26
 
        r, _, e := p.Call(0, 0)
 
26
        r, _, e := p.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
27
27
        if r == 0 {
28
28
                t.Fatalf("GenerateConsoleCtrlEvent: %v\n", e)
29
29
        }
30
30
}
31
31
 
32
32
func TestCtrlBreak(t *testing.T) {
33
 
        if !*runCtrlBreakTest {
34
 
                t.Logf("test disabled; use -run_ctlbrk_test to enable")
35
 
                return
36
 
        }
37
 
        go func() {
38
 
                time.Sleep(1 * time.Second)
39
 
                sendCtrlBreak(t)
40
 
        }()
 
33
        // create source file
 
34
        const source = `
 
35
package main
 
36
 
 
37
import (
 
38
        "log"
 
39
        "os"
 
40
        "os/signal"
 
41
        "time"
 
42
)
 
43
 
 
44
 
 
45
func main() {
41
46
        c := make(chan os.Signal, 10)
42
 
        Notify(c)
 
47
        signal.Notify(c)
43
48
        select {
44
49
        case s := <-c:
45
50
                if s != os.Interrupt {
46
 
                        t.Fatalf("Wrong signal received: got %q, want %q\n", s, os.Interrupt)
 
51
                        log.Fatalf("Wrong signal received: got %q, want %q\n", s, os.Interrupt)
47
52
                }
48
53
        case <-time.After(3 * time.Second):
49
 
                t.Fatalf("Timeout waiting for Ctrl+Break\n")
 
54
                log.Fatalf("Timeout waiting for Ctrl+Break\n")
 
55
        }
 
56
}
 
57
`
 
58
        name := filepath.Join(os.TempDir(), "ctlbreak")
 
59
        src := name + ".go"
 
60
        defer os.Remove(src)
 
61
        f, err := os.Create(src)
 
62
        if err != nil {
 
63
                t.Fatalf("Failed to create %v: %v", src, err)
 
64
        }
 
65
        defer f.Close()
 
66
        f.Write([]byte(source))
 
67
 
 
68
        // compile it
 
69
        exe := name + ".exe"
 
70
        defer os.Remove(exe)
 
71
        o, err := exec.Command("go", "build", "-o", exe, src).CombinedOutput()
 
72
        if err != nil {
 
73
                t.Fatalf("Failed to compile: %v\n%v", err, string(o))
 
74
        }
 
75
 
 
76
        // run it
 
77
        cmd := exec.Command(exe)
 
78
        var b bytes.Buffer
 
79
        cmd.Stdout = &b
 
80
        cmd.Stderr = &b
 
81
        cmd.SysProcAttr = &syscall.SysProcAttr{
 
82
                CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
 
83
        }
 
84
        err = cmd.Start()
 
85
        if err != nil {
 
86
                t.Fatalf("Start failed: %v", err)
 
87
        }
 
88
        go func() {
 
89
                time.Sleep(1 * time.Second)
 
90
                sendCtrlBreak(t, cmd.Process.Pid)
 
91
        }()
 
92
        err = cmd.Wait()
 
93
        if err != nil {
 
94
                t.Fatalf("Program exited with error: %v\n%v", err, string(b.Bytes()))
50
95
        }
51
96
}