1 package signals
2
3 import (
4 "fmt"
5 "testing"
6
7 "github.com/Microsoft/hcsshim/internal/protocol/guestrequest"
8 )
9
10 func Test_ValidateSigstr_LCOW_Empty_No_SignalsSupported(t *testing.T) {
11 ret, err := ValidateSigstrLCOW("", false)
12 if err != nil {
13 t.Fatalf("should return nil error got: %v", err)
14 }
15 if ret != nil {
16 t.Fatalf("should return nil signal for LCOW Terminate usage got: %+v", ret)
17 }
18 }
19
20 func Test_ValidateSigstr_LCOW_Empty_SignalsSupported(t *testing.T) {
21 ret, err := ValidateSigstrLCOW("", true)
22 if err != nil {
23 t.Fatalf("should return nil error got: %v", err)
24 }
25 if ret == nil {
26 t.Fatal("expected non-nil ret")
27 }
28 if ret.Signal != sigTerm {
29 t.Fatalf("expected signal: %v, got: %v", sigTerm, ret.Signal)
30 }
31 }
32
33 func Test_ValidateSigstr_LCOW_ValidSigstr_No_SignalsSupported(t *testing.T) {
34 cases := []string{"TERM", "15", "KILL", "9"}
35 for _, c := range cases {
36 ret, err := ValidateSigstrLCOW(c, false)
37 if err != nil {
38 t.Fatalf("expected nil err for signal: %v got: %v", c, err)
39 }
40 if ret != nil {
41 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
42 }
43 }
44 }
45
46 func Test_ValidateSigstr_LCOW_SignalsSupported(t *testing.T) {
47
48 for k, v := range signalMapLcow {
49 ret, err := ValidateSigstrLCOW(k, true)
50 if err != nil {
51 t.Fatalf("expected nil err for signal: %v got: %v", k, err)
52 }
53 if ret == nil {
54 t.Fatalf("expected non-nil ret for signal: %v", k)
55 }
56 if ret.Signal != v {
57 t.Fatalf("expected signal: %v, got: %v", v, ret.Signal)
58 }
59 }
60
61
62 for k, v := range signalMapLcow {
63 ret, err := ValidateSigstrLCOW(fmt.Sprintf("%d", v), true)
64 if err != nil {
65 t.Fatalf("expected nil err for signal: %v got: %v", k, err)
66 }
67 if ret == nil {
68 t.Fatalf("expected non-nil ret for signal: %v", k)
69 }
70 if ret.Signal != v {
71 t.Fatalf("expected signal: %v, got: %v", v, ret.Signal)
72 }
73 }
74 }
75
76 func Test_ValidateSigstr_Invalid_LCOW_No_SignalsSupported(t *testing.T) {
77 cases := []string{"90", "test"}
78 for _, c := range cases {
79 ret, err := ValidateSigstrLCOW(c, false)
80 if err != ErrInvalidSignal {
81 t.Fatalf("expected %v err for signal: %v got: %v", ErrInvalidSignal, c, err)
82 }
83 if ret != nil {
84 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
85 }
86 }
87 }
88
89 func Test_ValidateSigstr_Invalid_LCOW_SignalsSupported(t *testing.T) {
90 cases := []string{"90", "SIGTEST"}
91 for _, c := range cases {
92 ret, err := ValidateSigstrLCOW(c, true)
93 if err != ErrInvalidSignal {
94 t.Fatalf("expected %v err for signal: %v got: %v", ErrInvalidSignal, c, err)
95 }
96 if ret != nil {
97 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
98 }
99 }
100 }
101
102 func Test_ValidateSigstr_WCOW_Empty_No_SignalsSupported(t *testing.T) {
103 ret, err := ValidateSigstrWCOW("", false)
104 if err != nil {
105 t.Fatalf("should return nil error got: %v", err)
106 }
107 if ret != nil {
108 t.Fatalf("should return nil signal for WCOW Terminate usage got: %+v", ret)
109 }
110 }
111
112 func Test_ValidateSigstr_WCOW_Empty_SignalsSupported(t *testing.T) {
113 ret, err := ValidateSigstrWCOW("", true)
114 if err != nil {
115 t.Fatalf("should return nil error got: %v", err)
116 }
117 if ret == nil {
118 t.Fatal("expected non-nil ret")
119 }
120 if ret.Signal != guestrequest.SignalValueWCOWCtrlShutdown {
121 t.Fatalf("expected signal: %v, got: %v", guestrequest.SignalValueWCOWCtrlShutdown, ret.Signal)
122 }
123 }
124
125 func Test_ValidateSigstr_WCOW_ValidSigstr_No_SignalsSupported(t *testing.T) {
126 cases := []string{"CtrlShutdown", "6", "TERM", "15", "KILL", "9"}
127 for _, c := range cases {
128 ret, err := ValidateSigstrWCOW(c, false)
129 if err != nil {
130 t.Fatalf("expected nil err for signal: %v got: %v", c, err)
131 }
132 if ret != nil {
133 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
134 }
135 }
136 }
137
138 func Test_ValidateSigstr_WCOW_SignalsSupported(t *testing.T) {
139 type testcase struct {
140 value string
141 result guestrequest.SignalValueWCOW
142 }
143 cases := []testcase{
144 {
145 "CtrlC",
146 guestrequest.SignalValueWCOWCtrlC,
147 },
148 {
149 "0",
150 guestrequest.SignalValueWCOWCtrlC,
151 },
152 {
153 "CtrlBreak",
154 guestrequest.SignalValueWCOWCtrlBreak,
155 },
156 {
157 "1",
158 guestrequest.SignalValueWCOWCtrlBreak,
159 },
160 {
161 "CtrlClose",
162 guestrequest.SignalValueWCOWCtrlClose,
163 },
164 {
165 "2",
166 guestrequest.SignalValueWCOWCtrlClose,
167 },
168 {
169 "CtrlLogOff",
170 guestrequest.SignalValueWCOWCtrlLogOff,
171 },
172 {
173 "5",
174 guestrequest.SignalValueWCOWCtrlLogOff,
175 },
176 {
177 "CtrlShutdown",
178 guestrequest.SignalValueWCOWCtrlShutdown,
179 },
180 {
181 "6",
182 guestrequest.SignalValueWCOWCtrlShutdown,
183 },
184 {
185 "TERM",
186 guestrequest.SignalValueWCOWCtrlShutdown,
187 },
188 {
189 "15",
190 guestrequest.SignalValueWCOWCtrlShutdown,
191 },
192 {
193 "KILL",
194 guestrequest.SignalValueWCOW("<invalid>"),
195 },
196 {
197 "9",
198 guestrequest.SignalValueWCOW("<invalid>"),
199 },
200 }
201 for _, c := range cases {
202 ret, err := ValidateSigstrWCOW(c.value, true)
203 if err != nil {
204 t.Fatalf("expected nil err for signal: %v got: %v", c.value, err)
205 }
206 if c.result == guestrequest.SignalValueWCOW("<invalid>") {
207 if ret != nil {
208 t.Fatalf("expected nil ret for signal: %v got: %+v", c.value, ret)
209 }
210 } else {
211 if ret == nil {
212 t.Fatalf("expected non-nil ret for signal: %v", c.value)
213 }
214 }
215 }
216 }
217
218 func Test_ValidateSigstr_Invalid_WCOW_No_SignalsSupported(t *testing.T) {
219 cases := []string{"2", "test"}
220 for _, c := range cases {
221 ret, err := ValidateSigstrWCOW(c, false)
222 if err != ErrInvalidSignal {
223 t.Fatalf("expected %v err for signal: %v got: %v", ErrInvalidSignal, c, err)
224 }
225 if ret != nil {
226 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
227 }
228 }
229 }
230
231 func Test_ValidateSigstr_Invalid_WCOW_SignalsSupported(t *testing.T) {
232 cases := []string{"20", "CtrlTest"}
233 for _, c := range cases {
234 ret, err := ValidateSigstrWCOW(c, true)
235 if err != ErrInvalidSignal {
236 t.Fatalf("expected %v err for signal: %v got: %v", ErrInvalidSignal, c, err)
237 }
238 if ret != nil {
239 t.Fatalf("expected nil ret for signal: %v got: %+v", c, ret)
240 }
241 }
242 }
243
244 func Test_ValidateLCOW_SignalsSupported(t *testing.T) {
245 for _, v := range signalMapLcow {
246 ret, err := ValidateLCOW(v, true)
247 if err != nil {
248 t.Fatalf("expected nil err for signal: %v got: %v", v, err)
249 }
250 if ret == nil {
251 t.Fatalf("expected non-nil ret for signal: %v", v)
252 }
253 if ret.Signal != v {
254 t.Fatalf("expected signal: %v got: %v", v, ret.Signal)
255 }
256 }
257 }
258
259 func Test_ValidateWCOW_SignalsSupported(t *testing.T) {
260 type testcase struct {
261 value int
262 result guestrequest.SignalValueWCOW
263 }
264 cases := []testcase{
265 {
266 ctrlC,
267 guestrequest.SignalValueWCOWCtrlC,
268 },
269 {
270 ctrlBreak,
271 guestrequest.SignalValueWCOWCtrlBreak,
272 },
273 {
274 ctrlClose,
275 guestrequest.SignalValueWCOWCtrlClose,
276 },
277 {
278 ctrlLogOff,
279 guestrequest.SignalValueWCOWCtrlLogOff,
280 },
281 {
282 ctrlShutdown,
283 guestrequest.SignalValueWCOWCtrlShutdown,
284 },
285 {
286 sigTerm,
287 guestrequest.SignalValueWCOWCtrlShutdown,
288 },
289 {
290 sigKill,
291 guestrequest.SignalValueWCOW("<invalid>"),
292 },
293 }
294 for _, c := range cases {
295 ret, err := ValidateWCOW(c.value, true)
296 if err != nil {
297 t.Fatalf("expected nil err for signal: %v got: %v", c.value, err)
298 }
299 if c.result == guestrequest.SignalValueWCOW("<invalid>") {
300 if ret != nil {
301 t.Fatalf("expected nil ret for signal: %v got: %+v", c.value, ret)
302 }
303 } else {
304 if ret == nil {
305 t.Fatalf("expected non-nil ret for signal: %v", c.value)
306 }
307 if ret.Signal != c.result {
308 t.Fatalf("expected signal: %v, got: %v", c.result, ret.Signal)
309 }
310 }
311 }
312 }
313
View as plain text