github.com/mvdan/u-root-coreutils@v0.0.0-20230122170626-c2eef2898555/cmds/exp/ed/address_test.go (about)

     1  // Copyright 2015-2018 the u-root Authors. All rights reserved
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"fmt"
     9  	"testing"
    10  )
    11  
    12  func TestResolveOffset(t *testing.T) {
    13  	for _, tt := range []struct {
    14  		name          string
    15  		input         string
    16  		wantOffset    int
    17  		wantOffsetCmd int
    18  		want          string
    19  	}{
    20  		{
    21  			name:          "len(ms) == 0",
    22  			input:         "",
    23  			wantOffset:    0,
    24  			wantOffsetCmd: 0,
    25  		},
    26  		{
    27  			name:  "case len(ms[2]) > 0 with err in atoi",
    28  			input: " 11111111111111111111",
    29  			want:  "strconv.Atoi: parsing \"11111111111111111111\": value out of range",
    30  		},
    31  		{
    32  			name:          "case len(ms[2]) > 0",
    33  			input:         " 1",
    34  			wantOffset:    1,
    35  			wantOffsetCmd: 2,
    36  		},
    37  		{
    38  			name:  "case len(ms[3]) > 0 with err in atoi",
    39  			input: " -11111111111111111111",
    40  			want:  "strconv.Atoi: parsing \"11111111111111111111\": value out of range",
    41  		},
    42  		{
    43  			name:          "case len(ms[3]) > 0 case -",
    44  			input:         " -1",
    45  			wantOffset:    -1,
    46  			wantOffsetCmd: 3,
    47  		},
    48  		{
    49  			name:          "case len(ms[3]) > 0 case +",
    50  			input:         " +1",
    51  			wantOffset:    1,
    52  			wantOffsetCmd: 3,
    53  		},
    54  	} {
    55  		t.Run(tt.name, func(t *testing.T) {
    56  			gotOffset, gotOffsetCmd, err := buffer.ResolveOffset(tt.input)
    57  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}, addr: 2}
    58  			if err != nil {
    59  				if err.Error() != tt.want {
    60  					t.Errorf("ResolveAddr() = %q, want: %q", err.Error(), tt.want)
    61  				}
    62  			} else {
    63  				if gotOffset != tt.wantOffset || gotOffsetCmd != tt.wantOffsetCmd {
    64  					t.Errorf("ResolveAddrs() = %d %d, want: %d %d", gotOffset, gotOffsetCmd, tt.wantOffset, tt.wantOffsetCmd)
    65  				}
    66  			}
    67  		})
    68  	}
    69  }
    70  
    71  func TestResolveAddr(t *testing.T) {
    72  	for _, tt := range []struct {
    73  		name       string
    74  		input      string
    75  		wantLine   int
    76  		wantOffset int
    77  		want       string
    78  	}{
    79  		{
    80  			name:       "case single symbol $",
    81  			input:      "$",
    82  			wantLine:   3,
    83  			wantOffset: 1,
    84  		},
    85  		{
    86  			name:       "case single symbol .",
    87  			input:      ".",
    88  			wantLine:   2,
    89  			wantOffset: 1,
    90  		},
    91  		{
    92  			name:       "case number",
    93  			input:      "1",
    94  			wantLine:   0,
    95  			wantOffset: 1,
    96  		},
    97  		{
    98  			name:  "case number with err",
    99  			input: "11111111111111111111",
   100  			want:  "strconv.Atoi: parsing \"11111111111111111111\": value out of range",
   101  		},
   102  		{
   103  			name:       "case offset with case +",
   104  			input:      "+",
   105  			wantLine:   3,
   106  			wantOffset: 1,
   107  		},
   108  		{
   109  			name:       "case offset with case -",
   110  			input:      "-",
   111  			wantLine:   1,
   112  			wantOffset: 1,
   113  		},
   114  		{
   115  			name:  "case mark",
   116  			input: "'t",
   117  			want:  "mark was cleared: t",
   118  		},
   119  		{
   120  			name:       "test7",
   121  			input:      "//",
   122  			wantLine:   2,
   123  			wantOffset: 2,
   124  		},
   125  	} {
   126  		t.Run(tt.name, func(t *testing.T) {
   127  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}, addr: 2, marks: map[byte]int{'t': 5}}
   128  			gotLine, gotOffset, err := buffer.ResolveAddr(tt.input)
   129  			if err != nil {
   130  				if err.Error() != tt.want {
   131  					t.Errorf("ResolveAddr() = %q, want: %q", err.Error(), tt.want)
   132  				}
   133  			} else {
   134  				if gotLine != tt.wantLine || gotOffset != tt.wantOffset {
   135  					t.Errorf("ResolveAddrs() = %d %d, want: %d %d", gotLine, gotOffset, tt.wantLine, tt.wantOffset)
   136  				}
   137  			}
   138  		})
   139  	}
   140  }
   141  
   142  func TestResolveAddrs(t *testing.T) {
   143  	for _, tt := range []struct {
   144  		name  string
   145  		input string
   146  		want1 int
   147  		want2 int
   148  		want  string
   149  	}{
   150  		{
   151  			name:  "test1",
   152  			input: ",,",
   153  			want1: 2,
   154  			want2: 1,
   155  		},
   156  		{
   157  			name:  "test2",
   158  			input: ";;",
   159  			want1: 2,
   160  			want2: 1,
   161  		},
   162  		{
   163  			name:  "test3",
   164  			input: "% %",
   165  			want1: 3,
   166  			want2: 2,
   167  		},
   168  		{
   169  			name:  "test4",
   170  			input: "abc",
   171  			want1: 1,
   172  			want2: 0,
   173  		},
   174  	} {
   175  		t.Run(tt.name, func(t *testing.T) {
   176  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}}
   177  			got1, got2, err := buffer.ResolveAddrs(tt.input)
   178  			if err != nil {
   179  				if err.Error() != tt.want {
   180  					t.Errorf("ResolveAddrs() = %q, want: %q", err.Error(), tt.want)
   181  				}
   182  			} else {
   183  				if len(got1) != tt.want1 || got2 != tt.want2 {
   184  					t.Errorf("ResolveAddrs() = %d %d, want: %d %d", len(got1), got2, tt.want1, tt.want2)
   185  				}
   186  			}
   187  		})
   188  	}
   189  }
   190  
   191  func TestAddrValue(t *testing.T) {
   192  	for _, tt := range []struct {
   193  		name  string
   194  		input []int
   195  		want  int
   196  		err   error
   197  	}{
   198  		{
   199  			name:  "without err",
   200  			input: []int{2},
   201  			want:  2,
   202  		},
   203  		{
   204  			name:  "len(addr) == 0",
   205  			input: []int{},
   206  			err:   ErrINV,
   207  		},
   208  		{
   209  			name:  "OOB",
   210  			input: []int{5},
   211  			err:   ErrOOB,
   212  		},
   213  	} {
   214  		t.Run(tt.name, func(t *testing.T) {
   215  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}}
   216  			got, err := buffer.AddrValue(tt.input)
   217  			if err != nil {
   218  				if err != tt.err {
   219  					t.Errorf("ResolveAddrs() = %q, want: %q", err.Error(), tt.want)
   220  				}
   221  			} else {
   222  				if got != tt.want {
   223  					t.Errorf("ResolveAddrs() = %d, want: %d", got, tt.want)
   224  				}
   225  			}
   226  		})
   227  	}
   228  }
   229  
   230  func TestAddrRange(t *testing.T) {
   231  	for _, tt := range []struct {
   232  		name  string
   233  		input []int
   234  		want  [2]int
   235  		err   error
   236  	}{
   237  		{
   238  			name:  "address out of order",
   239  			input: []int{2, 0},
   240  			err:   fmt.Errorf("address out of order"),
   241  		},
   242  		{
   243  			name:  "case 0",
   244  			input: []int{},
   245  			err:   ErrINV,
   246  		},
   247  		{
   248  			name:  "case 1",
   249  			input: []int{0},
   250  			want:  [2]int{0, 0},
   251  		},
   252  		{
   253  			name:  "OOB",
   254  			input: []int{5},
   255  			err:   ErrOOB,
   256  		},
   257  	} {
   258  		t.Run(tt.name, func(t *testing.T) {
   259  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}}
   260  			got, err := buffer.AddrRange(tt.input)
   261  			if err != nil {
   262  				if err.Error() != tt.err.Error() {
   263  					t.Errorf("ResolveAddrs() = %q, want: %q", err.Error(), tt.err.Error())
   264  				}
   265  			} else {
   266  				if got != tt.want {
   267  					t.Errorf("ResolveAddrs() = %d, want: %d", got, tt.want)
   268  				}
   269  			}
   270  		})
   271  	}
   272  }
   273  
   274  func TestAddrRangeOrLine(t *testing.T) {
   275  	for _, tt := range []struct {
   276  		name  string
   277  		input []int
   278  		want  [2]int
   279  		err   error
   280  	}{
   281  		{
   282  			name:  "len(addrs) > 1",
   283  			input: []int{2, 0},
   284  			err:   fmt.Errorf("address out of order"),
   285  		},
   286  		{
   287  			name:  "else",
   288  			input: []int{5},
   289  			err:   ErrOOB,
   290  		},
   291  		{
   292  			name:  "r[1] = r[0]",
   293  			input: []int{0},
   294  			want:  [2]int{0, 0},
   295  		},
   296  	} {
   297  		t.Run(tt.name, func(t *testing.T) {
   298  			buffer = &FileBuffer{buffer: []string{"0", "1", "2", "3"}, file: []int{0, 1, 2, 3}}
   299  			got, err := buffer.AddrRangeOrLine(tt.input)
   300  			if err != nil {
   301  				if err.Error() != tt.err.Error() {
   302  					t.Errorf("ResolveAddrs() = %q, want: %q", err.Error(), tt.err.Error())
   303  				}
   304  			} else {
   305  				if got != tt.want {
   306  					t.Errorf("ResolveAddrs() = %d, want: %d", got, tt.want)
   307  				}
   308  			}
   309  		})
   310  	}
   311  }