podman

1
package signal
2

3
import (
4
	"syscall"
5
	"testing"
6
)
7

8
func TestParseSignal(t *testing.T) {
9
	type args struct {
10
		rawSignal string
11
	}
12
	tests := []struct {
13
		name    string
14
		args    args
15
		want    syscall.Signal
16
		wantErr bool
17
	}{
18
		{
19
			name: "KILL to SIGKILL",
20
			args: args{
21
				rawSignal: "KILL",
22
			},
23
			want:    syscall.SIGKILL,
24
			wantErr: false,
25
		},
26
		{
27
			name: "Case does not matter",
28
			args: args{
29
				rawSignal: "kIlL",
30
			},
31
			want:    syscall.SIGKILL,
32
			wantErr: false,
33
		},
34
		{
35
			name: "Garbage signal",
36
			args: args{
37
				rawSignal: "FOO",
38
			},
39
			want:    -1,
40
			wantErr: true,
41
		},
42
		{
43
			name: "Signal with prepended SIG",
44
			args: args{
45
				rawSignal: "SIGKILL",
46
			},
47
			want:    syscall.SIGKILL,
48
			wantErr: false,
49
		},
50
	}
51
	for _, tt := range tests {
52
		t.Run(tt.name, func(t *testing.T) {
53
			got, err := ParseSignal(tt.args.rawSignal)
54
			if (err != nil) != tt.wantErr {
55
				t.Errorf("ParseSignal() error = %v, wantErr %v", err, tt.wantErr)
56
				return
57
			}
58
			if got != tt.want {
59
				t.Errorf("ParseSignal() got = %v, want %v", got, tt.want)
60
			}
61
		})
62
	}
63
}
64

65
func TestParseSignalNameOrNumber(t *testing.T) {
66
	type args struct {
67
		rawSignal string
68
	}
69
	tests := []struct {
70
		name    string
71
		args    args
72
		want    syscall.Signal
73
		wantErr bool
74
	}{
75
		{
76
			name: "Kill should work",
77
			args: args{
78
				rawSignal: "kill",
79
			},
80
			want:    syscall.SIGKILL,
81
			wantErr: false,
82
		},
83
		{
84
			name: "9 for kill should work",
85
			args: args{
86
				rawSignal: "9",
87
			},
88
			want:    syscall.SIGKILL,
89
			wantErr: false,
90
		},
91
		{
92
			name: "Non-defined signal number should work",
93
			args: args{
94
				rawSignal: "923",
95
			},
96
			want:    923,
97
			wantErr: false,
98
		},
99
		{
100
			name: "garbage should fail",
101
			args: args{
102
				rawSignal: "foo",
103
			},
104
			want:    -1,
105
			wantErr: true,
106
		},
107
	}
108
	for _, tt := range tests {
109
		t.Run(tt.name, func(t *testing.T) {
110
			got, err := ParseSignalNameOrNumber(tt.args.rawSignal)
111
			if (err != nil) != tt.wantErr {
112
				t.Errorf("ParseSignalNameOrNumber() error = %v, wantErr %v", err, tt.wantErr)
113
				return
114
			}
115
			if got != tt.want {
116
				t.Errorf("ParseSignalNameOrNumber() got = %v, want %v", got, tt.want)
117
			}
118
		})
119
	}
120
}
121

122
func TestParseSysSignalToName(t *testing.T) {
123
	type args struct {
124
		signal syscall.Signal
125
	}
126
	tests := []struct {
127
		name    string
128
		args    args
129
		want    string
130
		wantErr bool
131
	}{
132
		{
133
			name: "Kill should work",
134
			args: args{
135
				signal: syscall.SIGKILL,
136
			},
137
			want:    "KILL",
138
			wantErr: false,
139
		},
140
		{
141
			name: "Non-defined signal number should not work",
142
			args: args{
143
				signal: 923,
144
			},
145
			want:    "",
146
			wantErr: true,
147
		},
148
		{
149
			name: "garbage should fail",
150
			args: args{
151
				signal: -1,
152
			},
153
			want:    "",
154
			wantErr: true,
155
		},
156
	}
157
	for _, tt := range tests {
158
		t.Run(tt.name, func(t *testing.T) {
159
			got, err := ParseSysSignalToName(tt.args.signal)
160
			if (err != nil) != tt.wantErr {
161
				t.Errorf("ParseSysSignalToName() error = %v, wantErr %v", err, tt.wantErr)
162
				return
163
			}
164
			if got != tt.want {
165
				t.Errorf("ParseSysSignalToName() got = %v, want %v", got, tt.want)
166
			}
167
		})
168
	}
169
}
170