github.com/containers/podman/v4@v4.9.4/pkg/signal/signal_common_test.go (about)

     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  }