github.com/cnboonhan/delve@v0.0.0-20230908061759-363f2388c2fb/service/dap/config_test.go (about)

     1  package dap
     2  
     3  import (
     4  	"testing"
     5  )
     6  
     7  func TestListConfig(t *testing.T) {
     8  	type args struct {
     9  		args *launchAttachArgs
    10  	}
    11  	tests := []struct {
    12  		name string
    13  		args args
    14  		want string
    15  	}{
    16  		{
    17  			name: "empty",
    18  			args: args{
    19  				args: &launchAttachArgs{},
    20  			},
    21  			want: formatConfig(0, false, false, "", false, [][2]string{}),
    22  		},
    23  		{
    24  			name: "default values",
    25  			args: args{
    26  				args: &defaultArgs,
    27  			},
    28  			want: formatConfig(50, false, false, "", false, [][2]string{}),
    29  		},
    30  		{
    31  			name: "custom values",
    32  			args: args{
    33  				args: &launchAttachArgs{
    34  					StackTraceDepth:              35,
    35  					ShowGlobalVariables:          true,
    36  					substitutePathClientToServer: [][2]string{{"hello", "world"}},
    37  					substitutePathServerToClient: [][2]string{{"world", "hello"}},
    38  				},
    39  			},
    40  			want: formatConfig(35, true, false, "", false, [][2]string{{"hello", "world"}}),
    41  		},
    42  	}
    43  	for _, tt := range tests {
    44  		t.Run(tt.name, func(t *testing.T) {
    45  			if got := listConfig(tt.args.args); got != tt.want {
    46  				t.Errorf("listConfig() = %v, want %v", got, tt.want)
    47  			}
    48  		})
    49  	}
    50  }
    51  
    52  func TestConfigureSetSubstitutePath(t *testing.T) {
    53  	type args struct {
    54  		args *launchAttachArgs
    55  		rest string
    56  	}
    57  	tests := []struct {
    58  		name      string
    59  		args      args
    60  		wantRules [][2]string
    61  		wantErr   bool
    62  	}{
    63  		// Test add rule.
    64  		{
    65  			name: "add rule",
    66  			args: args{
    67  				args: &launchAttachArgs{
    68  					substitutePathClientToServer: [][2]string{},
    69  					substitutePathServerToClient: [][2]string{},
    70  				},
    71  				rest: "/path/to/client/dir /path/to/server/dir",
    72  			},
    73  			wantRules: [][2]string{{"/path/to/client/dir", "/path/to/server/dir"}},
    74  			wantErr:   false,
    75  		},
    76  		{
    77  			name: "add rule (multiple)",
    78  			args: args{
    79  				args: &launchAttachArgs{
    80  					substitutePathClientToServer: [][2]string{
    81  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
    82  						{"/path/to/client/dir/b", "/path/to/server/dir/b"},
    83  					},
    84  					substitutePathServerToClient: [][2]string{
    85  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
    86  						{"/path/to/server/dir/b", "/path/to/client/dir/b"},
    87  					},
    88  				},
    89  				rest: "/path/to/client/dir/c /path/to/server/dir/b",
    90  			},
    91  			wantRules: [][2]string{
    92  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
    93  				{"/path/to/client/dir/b", "/path/to/server/dir/b"},
    94  				{"/path/to/client/dir/c", "/path/to/server/dir/b"},
    95  			},
    96  			wantErr: false,
    97  		},
    98  		{
    99  			name: "add rule from empty string",
   100  			args: args{
   101  				args: &launchAttachArgs{
   102  					substitutePathClientToServer: [][2]string{},
   103  					substitutePathServerToClient: [][2]string{},
   104  				},
   105  				rest: `"" /path/to/client/dir`,
   106  			},
   107  			wantRules: [][2]string{{"", "/path/to/client/dir"}},
   108  			wantErr:   false,
   109  		},
   110  		{
   111  			name: "add rule to empty string",
   112  			args: args{
   113  				args: &launchAttachArgs{
   114  					substitutePathClientToServer: [][2]string{},
   115  					substitutePathServerToClient: [][2]string{},
   116  				},
   117  				rest: `/path/to/client/dir ""`,
   118  			},
   119  			wantRules: [][2]string{{"/path/to/client/dir", ""}},
   120  			wantErr:   false,
   121  		},
   122  		{
   123  			name: "add rule from empty string(multiple)",
   124  			args: args{
   125  				args: &launchAttachArgs{
   126  					substitutePathClientToServer: [][2]string{
   127  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   128  						{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   129  					},
   130  					substitutePathServerToClient: [][2]string{
   131  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
   132  						{"/path/to/server/dir/b", "/path/to/client/dir/b"},
   133  					},
   134  				},
   135  				rest: `"" /path/to/client/dir/c`,
   136  			},
   137  			wantRules: [][2]string{
   138  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   139  				{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   140  				{"", "/path/to/client/dir/c"},
   141  			},
   142  			wantErr: false,
   143  		},
   144  		{
   145  			name: "add rule to empty string(multiple)",
   146  			args: args{
   147  				args: &launchAttachArgs{
   148  					substitutePathClientToServer: [][2]string{
   149  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   150  						{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   151  					},
   152  					substitutePathServerToClient: [][2]string{
   153  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
   154  						{"/path/to/server/dir/b", "/path/to/client/dir/b"},
   155  					},
   156  				},
   157  				rest: `/path/to/client/dir/c ""`,
   158  			},
   159  			wantRules: [][2]string{
   160  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   161  				{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   162  				{"/path/to/client/dir/c", ""},
   163  			},
   164  			wantErr: false,
   165  		},
   166  		// Test modify rule.
   167  		{
   168  			name: "modify rule",
   169  			args: args{
   170  				args: &launchAttachArgs{
   171  					substitutePathClientToServer: [][2]string{{"/path/to/client/dir", "/path/to/server/dir"}},
   172  					substitutePathServerToClient: [][2]string{{"/path/to/server/dir", "/path/to/client/dir"}},
   173  				},
   174  				rest: "/path/to/client/dir /new/path/to/server/dir",
   175  			},
   176  			wantRules: [][2]string{{"/path/to/client/dir", "/new/path/to/server/dir"}},
   177  			wantErr:   false,
   178  		},
   179  		{
   180  			name: "modify rule with from as empty string",
   181  			args: args{
   182  				args: &launchAttachArgs{
   183  					substitutePathClientToServer: [][2]string{{"", "/path/to/server/dir"}},
   184  					substitutePathServerToClient: [][2]string{{"/path/to/server/dir", ""}},
   185  				},
   186  				rest: `"" /new/path/to/server/dir`,
   187  			},
   188  			wantRules: [][2]string{{"", "/new/path/to/server/dir"}},
   189  			wantErr:   false,
   190  		},
   191  		{
   192  			name: "modify rule with to as empty string",
   193  			args: args{
   194  				args: &launchAttachArgs{
   195  					substitutePathClientToServer: [][2]string{{"/path/to/client/dir", ""}},
   196  					substitutePathServerToClient: [][2]string{{"", "/path/to/client/dir"}},
   197  				},
   198  				rest: `/path/to/client/dir ""`,
   199  			},
   200  			wantRules: [][2]string{{"/path/to/client/dir", ""}},
   201  			wantErr:   false,
   202  		},
   203  		{
   204  			name: "modify rule (multiple)",
   205  			args: args{
   206  				args: &launchAttachArgs{
   207  					substitutePathClientToServer: [][2]string{
   208  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   209  						{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   210  						{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   211  					},
   212  					substitutePathServerToClient: [][2]string{
   213  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
   214  						{"/path/to/server/dir/b", "/path/to/client/dir/b"},
   215  						{"/path/to/server/dir/b", "/path/to/client/dir/c"},
   216  					},
   217  				},
   218  				rest: "/path/to/client/dir/b /new/path",
   219  			},
   220  			wantRules: [][2]string{
   221  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   222  				{"/path/to/client/dir/b", "/new/path"},
   223  				{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   224  			},
   225  			wantErr: false,
   226  		},
   227  		{
   228  			name: "modify rule with from as empty string(multiple)",
   229  			args: args{
   230  				args: &launchAttachArgs{
   231  					substitutePathClientToServer: [][2]string{
   232  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   233  						{"", "/path/to/server/dir/b"},
   234  						{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   235  					},
   236  					substitutePathServerToClient: [][2]string{
   237  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
   238  						{"/path/to/server/dir/b", ""},
   239  						{"/path/to/server/dir/b", "/path/to/client/dir/c"},
   240  					},
   241  				},
   242  				rest: `"" /new/path`,
   243  			},
   244  			wantRules: [][2]string{
   245  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   246  				{"", "/new/path"},
   247  				{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   248  			},
   249  			wantErr: false,
   250  		},
   251  		{
   252  			name: "modify rule with to as empty string(multiple)",
   253  			args: args{
   254  				args: &launchAttachArgs{
   255  					substitutePathClientToServer: [][2]string{
   256  						{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   257  						{"/path/to/client/dir/b", "/path/to/server/dir/b"},
   258  						{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   259  					},
   260  					substitutePathServerToClient: [][2]string{
   261  						{"/path/to/server/dir/a", "/path/to/client/dir/a"},
   262  						{"/path/to/server/dir/b", "/path/to/client/dir/b"},
   263  						{"/path/to/server/dir/b", "/path/to/client/dir/c"},
   264  					},
   265  				},
   266  				rest: `/path/to/client/dir/b ""`,
   267  			},
   268  			wantRules: [][2]string{
   269  				{"/path/to/client/dir/a", "/path/to/server/dir/a"},
   270  				{"/path/to/client/dir/b", ""},
   271  				{"/path/to/client/dir/c", "/path/to/server/dir/b"},
   272  			},
   273  			wantErr: false,
   274  		},
   275  		// Test delete rule.
   276  		{
   277  			name: "delete rule",
   278  			args: args{
   279  				args: &launchAttachArgs{
   280  					substitutePathClientToServer: [][2]string{{"/path/to/client/dir", "/path/to/server/dir"}},
   281  					substitutePathServerToClient: [][2]string{{"/path/to/server/dir", "/path/to/client/dir"}},
   282  				},
   283  				rest: "/path/to/client/dir",
   284  			},
   285  			wantRules: [][2]string{},
   286  			wantErr:   false,
   287  		},
   288  		{
   289  			name: "delete rule, empty string",
   290  			args: args{
   291  				args: &launchAttachArgs{
   292  					substitutePathClientToServer: [][2]string{{"", "/path/to/server/dir"}},
   293  					substitutePathServerToClient: [][2]string{{"/path/to/server/dir", ""}},
   294  				},
   295  				rest: `""`,
   296  			},
   297  			wantRules: [][2]string{},
   298  			wantErr:   false,
   299  		},
   300  		// Test invalid input.
   301  		{
   302  			name: "error on delete nonexistent rule",
   303  			args: args{
   304  				args: &launchAttachArgs{
   305  					substitutePathClientToServer: [][2]string{{"/path/to/client/dir", "/path/to/server/dir"}},
   306  					substitutePathServerToClient: [][2]string{{"/path/to/server/dir", "/path/to/client/dir"}},
   307  				},
   308  				rest: "/path/to/server/dir",
   309  			},
   310  			wantRules: [][2]string{{"/path/to/client/dir", "/path/to/server/dir"}},
   311  			wantErr:   true,
   312  		},
   313  	}
   314  	for _, tt := range tests {
   315  		t.Run(tt.name, func(t *testing.T) {
   316  			err := configureSetSubstitutePath(tt.args.args, tt.args.rest)
   317  			if (err != nil) != tt.wantErr {
   318  				t.Errorf("configureSetSubstitutePath() error = %v, wantErr %v", err, tt.wantErr)
   319  				return
   320  			}
   321  			if len(tt.args.args.substitutePathClientToServer) != len(tt.wantRules) {
   322  				t.Errorf("configureSetSubstitutePath() got substitutePathClientToServer=%v, want %d rules", tt.args.args.substitutePathClientToServer, len(tt.wantRules))
   323  				return
   324  			}
   325  			gotClient2Server := tt.args.args.substitutePathClientToServer
   326  			gotServer2Client := tt.args.args.substitutePathServerToClient
   327  			for i, rule := range tt.wantRules {
   328  				if gotClient2Server[i][0] != rule[0] || gotClient2Server[i][1] != rule[1] {
   329  					t.Errorf("configureSetSubstitutePath() got substitutePathClientToServer[%d]=%#v,\n want %#v rules", i, gotClient2Server[i], rule)
   330  				}
   331  				if gotServer2Client[i][1] != rule[0] || gotServer2Client[i][0] != rule[1] {
   332  					reverseRule := [2]string{rule[1], rule[0]}
   333  					t.Errorf("configureSetSubstitutePath() got substitutePathServerToClient[%d]=%#v,\n want %#v rules", i, gotClient2Server[i], reverseRule)
   334  				}
   335  			}
   336  		})
   337  	}
   338  }