github.com/devseccon/trivy@v0.47.1-0.20231123133102-bd902a0bd996/pkg/licensing/expression/lexer_test.go (about)

     1  package expression
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestLexer_Lex(t *testing.T) {
    12  	tests := []struct {
    13  		name  string
    14  		input string
    15  		want  []Token
    16  	}{
    17  		{
    18  			name:  "simple",
    19  			input: "GPL-2.0-only",
    20  			want: []Token{
    21  				{
    22  					token:   IDENT,
    23  					literal: "GPL-2.0-only",
    24  				},
    25  			},
    26  		},
    27  		{
    28  			name:  "with space",
    29  			input: "Public Domain",
    30  			want: []Token{
    31  				{
    32  					token:   IDENT,
    33  					literal: "Public",
    34  				},
    35  				{
    36  					token:   IDENT,
    37  					literal: "Domain",
    38  				},
    39  			},
    40  		},
    41  		{
    42  			name:  "and",
    43  			input: "Public Domain AND MIT",
    44  			want: []Token{
    45  				{
    46  					token:   IDENT,
    47  					literal: "Public",
    48  				},
    49  				{
    50  					token:   IDENT,
    51  					literal: "Domain",
    52  				},
    53  				{
    54  					token:   AND,
    55  					literal: "AND",
    56  				},
    57  				{
    58  					token:   IDENT,
    59  					literal: "MIT",
    60  				},
    61  			},
    62  		},
    63  		{
    64  			name:  "or",
    65  			input: "LGPL-2.1-only OR MIT OR BSD-3-Clause",
    66  			want: []Token{
    67  				{
    68  					token:   IDENT,
    69  					literal: "LGPL-2.1-only",
    70  				},
    71  				{
    72  					token:   OR,
    73  					literal: "OR",
    74  				},
    75  				{
    76  					token:   IDENT,
    77  					literal: "MIT",
    78  				},
    79  				{
    80  					token:   OR,
    81  					literal: "OR",
    82  				},
    83  				{
    84  					token:   IDENT,
    85  					literal: "BSD-3-Clause",
    86  				},
    87  			},
    88  		},
    89  		{
    90  			name:  "parenthesis",
    91  			input: "LGPL-2.1-only AND (MIT OR BSD-3-Clause)",
    92  			want: []Token{
    93  				{
    94  					token:   IDENT,
    95  					literal: "LGPL-2.1-only",
    96  				},
    97  				{
    98  					token:   AND,
    99  					literal: "AND",
   100  				},
   101  				{
   102  					token:   int('('),
   103  					literal: "(",
   104  				},
   105  				{
   106  					token:   IDENT,
   107  					literal: "MIT",
   108  				},
   109  				{
   110  					token:   OR,
   111  					literal: "OR",
   112  				},
   113  				{
   114  					token:   IDENT,
   115  					literal: "BSD-3-Clause",
   116  				},
   117  				{
   118  					token:   int(')'),
   119  					literal: ")",
   120  				},
   121  			},
   122  		},
   123  		{
   124  			name:  "exception",
   125  			input: "LGPL-2.1-only AND GPL-2.0-or-later WITH Bison-exception-2.2",
   126  			want: []Token{
   127  				{
   128  					token:   IDENT,
   129  					literal: "LGPL-2.1-only",
   130  				},
   131  				{
   132  					token:   AND,
   133  					literal: "AND",
   134  				},
   135  				{
   136  					token:   IDENT,
   137  					literal: "GPL-2.0-or-later",
   138  				},
   139  				{
   140  					token:   WITH,
   141  					literal: "WITH",
   142  				},
   143  				{
   144  					token:   IDENT,
   145  					literal: "Bison-exception-2.2",
   146  				},
   147  			},
   148  		},
   149  		{
   150  			name:  "plus",
   151  			input: "Public Domain+",
   152  			want: []Token{
   153  				{
   154  					token:   IDENT,
   155  					literal: "Public",
   156  				},
   157  				{
   158  					token:   IDENT,
   159  					literal: "Domain",
   160  				},
   161  				{
   162  					token:   int('+'),
   163  					literal: "+",
   164  				},
   165  			},
   166  		},
   167  		{
   168  			name:  "plus in the middle",
   169  			input: "ISC+IBM",
   170  			want: []Token{
   171  				{
   172  					token:   IDENT,
   173  					literal: "ISC+IBM",
   174  				},
   175  			},
   176  		},
   177  		{
   178  			name:  "plus with the parenthesis",
   179  			input: "(GPL1.0+)",
   180  			want: []Token{
   181  				{
   182  					token:   int('('),
   183  					literal: "(",
   184  				},
   185  				{
   186  					token:   IDENT,
   187  					literal: "GPL1.0",
   188  				},
   189  				{
   190  					token:   int('+'),
   191  					literal: "+",
   192  				},
   193  				{
   194  					token:   int(')'),
   195  					literal: ")",
   196  				},
   197  			},
   198  		},
   199  		{
   200  			name:  "utf-8",
   201  			input: "GPL1.0+ " + string(byte(0x20)) + "あ🇯🇵" + " and LGPL1.0",
   202  			want: []Token{
   203  				{
   204  					token:   IDENT,
   205  					literal: "GPL1.0",
   206  				},
   207  				{
   208  					token:   int('+'),
   209  					literal: "+",
   210  				},
   211  				{
   212  					token:   IDENT,
   213  					literal: "あ🇯🇵",
   214  				},
   215  				{
   216  					token:   AND,
   217  					literal: "and",
   218  				},
   219  				{
   220  					token:   IDENT,
   221  					literal: "LGPL1.0",
   222  				},
   223  			},
   224  		},
   225  	}
   226  	for _, tt := range tests {
   227  		t.Run(tt.name, func(t *testing.T) {
   228  			l := NewLexer(strings.NewReader(tt.input))
   229  			var got []Token
   230  			var lval yySymType
   231  			for l.Lex(&lval) != 0 {
   232  				got = append(got, lval.token)
   233  				lval = yySymType{}
   234  			}
   235  			require.NoError(t, l.Err())
   236  			assert.Equal(t, tt.want, got)
   237  		})
   238  	}
   239  }