javascript - jsx_test.go

     1  package javascript
     2  
     3  import (
     4  	"testing"
     5  
     6  	"vimagination.zapto.org/parser"
     7  )
     8  
     9  func TestJSXElementName(t *testing.T) {
    10  	doTests(t, []sourceFn{
    11  		{"</>", func(t *test, tk Tokens) { // 1
    12  			t.Err = Error{
    13  				Err:     ErrMissingIdentifier,
    14  				Parsing: "JSXElementName",
    15  				Token:   tk[1],
    16  			}
    17  		}},
    18  		{"<a />", func(t *test, tk Tokens) { // 2
    19  			t.Output = JSXElementName{
    20  				Identifier: &tk[1],
    21  				Tokens:     tk[1:2],
    22  			}
    23  		}},
    24  		{"<a: />", func(t *test, tk Tokens) { // 3
    25  			t.Err = Error{
    26  				Err:     ErrMissingIdentifier,
    27  				Parsing: "JSXElementName",
    28  				Token:   tk[3],
    29  			}
    30  		}},
    31  		{"<a:b />", func(t *test, tk Tokens) { // 4
    32  			t.Output = JSXElementName{
    33  				Namespace:  &tk[1],
    34  				Identifier: &tk[3],
    35  				Tokens:     tk[1:4],
    36  			}
    37  		}},
    38  		{"<a. />", func(t *test, tk Tokens) { // 5
    39  			t.Err = Error{
    40  				Err:     ErrMissingIdentifier,
    41  				Parsing: "JSXElementName",
    42  				Token:   tk[3],
    43  			}
    44  		}},
    45  		{"<a.b />", func(t *test, tk Tokens) { // 6
    46  			t.Output = JSXElementName{
    47  				Identifier: &tk[1],
    48  				MemberExpression: []*Token{
    49  					&tk[3],
    50  				},
    51  				Tokens: tk[1:4],
    52  			}
    53  		}},
    54  		{"<a.b. />", func(t *test, tk Tokens) { // 7
    55  			t.Err = Error{
    56  				Err:     ErrMissingIdentifier,
    57  				Parsing: "JSXElementName",
    58  				Token:   tk[5],
    59  			}
    60  		}},
    61  		{"<a.b.c />", func(t *test, tk Tokens) { // 8
    62  			t.Output = JSXElementName{
    63  				Identifier: &tk[1],
    64  				MemberExpression: []*Token{
    65  					&tk[3],
    66  					&tk[5],
    67  				},
    68  				Tokens: tk[1:6],
    69  			}
    70  		}},
    71  	}, func(t *test) (Type, error) {
    72  		var jn JSXElementName
    73  
    74  		t.Tokens = t.Tokens[1:1]
    75  
    76  		err := jn.parse(&t.Tokens)
    77  
    78  		return jn, err
    79  	}, true)
    80  }
    81  
    82  func TestJSXElementNameEqual(t *testing.T) {
    83  	for n, test := range [...]struct {
    84  		A, B  JSXElementName
    85  		Match bool
    86  	}{
    87  		{ // 1
    88  			A:     JSXElementName{},
    89  			B:     JSXElementName{},
    90  			Match: true,
    91  		},
    92  		{ // 2
    93  			A:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "A"}}},
    94  			B:     JSXElementName{},
    95  			Match: false,
    96  		},
    97  		{ // 3
    98  			A:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "A"}}},
    99  			B:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "B"}}},
   100  			Match: false,
   101  		},
   102  		{ // 4
   103  			A:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "A"}}},
   104  			B:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "A"}}},
   105  			Match: true,
   106  		},
   107  		{ // 5
   108  			A:     JSXElementName{Namespace: &Token{Token: parser.Token{Data: "B"}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   109  			B:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "B"}}},
   110  			Match: false,
   111  		},
   112  		{ // 6
   113  			A:     JSXElementName{Namespace: &Token{Token: parser.Token{Data: "B"}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   114  			B:     JSXElementName{Namespace: &Token{Token: parser.Token{Data: "B"}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   115  			Match: true,
   116  		},
   117  		{ // 7
   118  			A:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   119  			B:     JSXElementName{Identifier: &Token{Token: parser.Token{Data: "A"}}},
   120  			Match: false,
   121  		},
   122  		{ // 8
   123  			A:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   124  			B:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   125  			Match: true,
   126  		},
   127  		{ // 9
   128  			A:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "C"}}, {Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   129  			B:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "C"}}, {Token: parser.Token{Data: "D"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   130  			Match: false,
   131  		},
   132  		{ // 10
   133  			A:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "C"}}, {Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   134  			B:     JSXElementName{MemberExpression: []*Token{{Token: parser.Token{Data: "C"}}, {Token: parser.Token{Data: "B"}}}, Identifier: &Token{Token: parser.Token{Data: "A"}}},
   135  			Match: true,
   136  		},
   137  	} {
   138  		if test.A.equal(&test.B) != test.Match {
   139  			t.Errorf("test %d.1: expected match = %v, got %v", n+1, test.Match, !test.Match)
   140  		} else if test.B.equal(&test.A) != test.Match {
   141  			t.Errorf("test %d.2: expected match = %v, got %v", n+1, test.Match, !test.Match)
   142  		}
   143  	}
   144  }
   145  
   146  func TestJSXAttribute(t *testing.T) {
   147  	doTests(t, []sourceFn{
   148  		{"</>", func(t *test, tk Tokens) { // 1
   149  			t.Err = Error{
   150  				Err:     ErrMissingIdentifier,
   151  				Parsing: "JSXAttribute",
   152  				Token:   tk[1],
   153  			}
   154  		}},
   155  		{"<a''/>", func(t *test, tk Tokens) { // 2
   156  			t.Err = Error{
   157  				Err:     ErrMissingEquals,
   158  				Parsing: "JSXAttribute",
   159  				Token:   tk[2],
   160  			}
   161  		}},
   162  		{"<a />", func(t *test, tk Tokens) { // 3
   163  			t.Output = JSXAttribute{
   164  				Identifier: &tk[1],
   165  				Tokens:     tk[1:2],
   166  			}
   167  		}},
   168  		{"<a/>", func(t *test, tk Tokens) { // 4
   169  			t.Output = JSXAttribute{
   170  				Identifier: &tk[1],
   171  				Tokens:     tk[1:2],
   172  			}
   173  		}},
   174  		{"<a\n/>", func(t *test, tk Tokens) { // 5
   175  			t.Output = JSXAttribute{
   176  				Identifier: &tk[1],
   177  				Tokens:     tk[1:2],
   178  			}
   179  		}},
   180  		{"<a=/>", func(t *test, tk Tokens) { // 6
   181  			t.Err = Error{
   182  				Err:     ErrMissingAttribute,
   183  				Parsing: "JSXAttribute",
   184  				Token:   tk[3],
   185  			}
   186  		}},
   187  		{"<a=''/>", func(t *test, tk Tokens) { // 7
   188  			t.Output = JSXAttribute{
   189  				Identifier: &tk[1],
   190  				JSXString:  &tk[3],
   191  				Tokens:     tk[1:4],
   192  			}
   193  		}},
   194  		{"<a:=''/>", func(t *test, tk Tokens) { // 8
   195  			t.Err = Error{
   196  				Err:     ErrMissingIdentifier,
   197  				Parsing: "JSXAttribute",
   198  				Token:   tk[3],
   199  			}
   200  		}},
   201  		{"<a:b=''/>", func(t *test, tk Tokens) { // 9
   202  			t.Output = JSXAttribute{
   203  				Namespace:  &tk[1],
   204  				Identifier: &tk[3],
   205  				JSXString:  &tk[5],
   206  				Tokens:     tk[1:6],
   207  			}
   208  		}},
   209  		{"<a={b}/>", func(t *test, tk Tokens) { // 10
   210  			t.Output = JSXAttribute{
   211  				Identifier: &tk[1],
   212  				AssignmentExpression: &AssignmentExpression{
   213  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   214  						IdentifierReference: &tk[4],
   215  						Tokens:              tk[4:5],
   216  					}),
   217  					Tokens: tk[4:5],
   218  				},
   219  				Tokens: tk[1:6],
   220  			}
   221  		}},
   222  		{"<a={b c}/>", func(t *test, tk Tokens) { // 11
   223  			t.Err = Error{
   224  				Err:     ErrMissingClosingBrace,
   225  				Parsing: "JSXAttribute",
   226  				Token:   tk[6],
   227  			}
   228  		}},
   229  		{"<a={,}/>", func(t *test, tk Tokens) { // 12
   230  			t.Err = Error{
   231  				Err:     assignmentCustomError(tk[4], ErrMissingIdentifier),
   232  				Parsing: "JSXAttribute",
   233  				Token:   tk[4],
   234  			}
   235  		}},
   236  		{"<a=<></>/>", func(t *test, tk Tokens) { // 13
   237  			t.Output = JSXAttribute{
   238  				Identifier: &tk[1],
   239  				JSXFragment: &JSXFragment{
   240  					Tokens: tk[3:8],
   241  				},
   242  				Tokens: tk[1:8],
   243  			}
   244  		}},
   245  		{"<a=<></b>/>", func(t *test, tk Tokens) { // 14
   246  			t.Err = Error{
   247  				Err: Error{
   248  					Err:     ErrMissingTagClose,
   249  					Parsing: "JSXFragment",
   250  					Token:   tk[7],
   251  				},
   252  				Parsing: "JSXAttribute",
   253  				Token:   tk[3],
   254  			}
   255  		}},
   256  		{"<a=<b/>/>", func(t *test, tk Tokens) { // 15
   257  			t.Output = JSXAttribute{
   258  				Identifier: &tk[1],
   259  				JSXElement: &JSXElement{
   260  					ElementName: JSXElementName{
   261  						Identifier: &tk[4],
   262  						Tokens:     tk[4:5],
   263  					},
   264  					SelfClosing: true,
   265  					Tokens:      tk[3:7],
   266  				},
   267  				Tokens: tk[1:7],
   268  			}
   269  		}},
   270  		{"<a=<b></c>/>", func(t *test, tk Tokens) { // 16
   271  			t.Err = Error{
   272  				Err: Error{
   273  					Err:     ErrInvalidClosingTag,
   274  					Parsing: "JSXElement",
   275  					Token:   tk[9],
   276  				},
   277  				Parsing: "JSXAttribute",
   278  				Token:   tk[3],
   279  			}
   280  		}},
   281  		{"<{}/>", func(t *test, tk Tokens) { // 17
   282  			t.Err = Error{
   283  				Err:     ErrMissingSpread,
   284  				Parsing: "JSXAttribute",
   285  				Token:   tk[2],
   286  			}
   287  		}},
   288  		{"<{...,}/>", func(t *test, tk Tokens) { // 18
   289  			t.Err = Error{
   290  				Err:     assignmentCustomError(tk[3], ErrMissingIdentifier),
   291  				Parsing: "JSXAttribute",
   292  				Token:   tk[3],
   293  			}
   294  		}},
   295  		{"<{...a}/>", func(t *test, tk Tokens) { // 19
   296  			t.Output = JSXAttribute{
   297  				AssignmentExpression: &AssignmentExpression{
   298  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   299  						IdentifierReference: &tk[3],
   300  						Tokens:              tk[3:4],
   301  					}),
   302  					Tokens: tk[3:4],
   303  				},
   304  				Tokens: tk[1:5],
   305  			}
   306  		}},
   307  		{"<{...a b}/>", func(t *test, tk Tokens) { // 20
   308  			t.Err = Error{
   309  				Err:     ErrMissingClosingBrace,
   310  				Parsing: "JSXAttribute",
   311  				Token:   tk[5],
   312  			}
   313  		}},
   314  		{"<a={ // A\n\n// B\nb // C\n\n// D\n}/>", func(t *test, tk Tokens) { // 21
   315  			t.Output = JSXAttribute{
   316  				Identifier: &tk[1],
   317  				AssignmentExpression: &AssignmentExpression{
   318  					ConditionalExpression: WrapConditional(&MemberExpression{
   319  						PrimaryExpression: &PrimaryExpression{
   320  							IdentifierReference: &tk[9],
   321  							Tokens:              tk[9:10],
   322  						},
   323  						Comments: [5]Comments{{&tk[7]}, nil, nil, nil, {&tk[11]}},
   324  						Tokens:   tk[7:12],
   325  					}),
   326  					Tokens: tk[7:12],
   327  				},
   328  				Comments: [3]Comments{{&tk[5]}, nil, {&tk[13]}},
   329  				Tokens:   tk[1:16],
   330  			}
   331  		}},
   332  		{"<{ // A\n\n// B\n... // C\na // D\n\n// E\n}/>", func(t *test, tk Tokens) { // 22
   333  			t.Output = JSXAttribute{
   334  				AssignmentExpression: &AssignmentExpression{
   335  					ConditionalExpression: WrapConditional(&MemberExpression{
   336  						PrimaryExpression: &PrimaryExpression{
   337  							IdentifierReference: &tk[11],
   338  							Tokens:              tk[11:12],
   339  						},
   340  						Comments: [5]Comments{{&tk[9]}, nil, nil, nil, {&tk[13]}},
   341  						Tokens:   tk[9:14],
   342  					}),
   343  					Tokens: tk[9:14],
   344  				},
   345  				Comments: [3]Comments{{&tk[3]}, {&tk[5]}, {&tk[15]}},
   346  				Tokens:   tk[1:18],
   347  			}
   348  		}},
   349  	}, func(t *test) (Type, error) {
   350  		var ja JSXAttribute
   351  
   352  		t.Tokens = t.Tokens[1:1]
   353  
   354  		err := ja.parse(&t.Tokens)
   355  
   356  		return ja, err
   357  	}, true)
   358  }
   359  
   360  func TestJSXChild(t *testing.T) {
   361  	doTests(t, []sourceFn{
   362  		{"<>a</>", func(t *test, tk Tokens) { // 1
   363  			t.Output = JSXChild{
   364  				JSXText: &tk[2],
   365  				Tokens:  tk[2:3],
   366  			}
   367  		}},
   368  		{"<>{}</>", func(t *test, tk Tokens) { // 2
   369  			t.Output = JSXChild{
   370  				Tokens: tk[2:4],
   371  			}
   372  		}},
   373  		{"<>{a}</>", func(t *test, tk Tokens) { // 2
   374  			t.Output = JSXChild{
   375  				JSXChildExpression: &AssignmentExpression{
   376  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   377  						IdentifierReference: &tk[3],
   378  						Tokens:              tk[3:4],
   379  					}),
   380  					Tokens: tk[3:4],
   381  				},
   382  				Tokens: tk[2:5],
   383  			}
   384  		}},
   385  		{"<>{,}</>", func(t *test, tk Tokens) { // 3
   386  			t.Err = Error{
   387  				Err:     assignmentCustomError(tk[3], ErrMissingIdentifier),
   388  				Parsing: "JSXChild",
   389  				Token:   tk[3],
   390  			}
   391  		}},
   392  		{"<>{ a }</>", func(t *test, tk Tokens) { // 4
   393  			t.Output = JSXChild{
   394  				JSXChildExpression: &AssignmentExpression{
   395  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   396  						IdentifierReference: &tk[4],
   397  						Tokens:              tk[4:5],
   398  					}),
   399  					Tokens: tk[4:5],
   400  				},
   401  				Tokens: tk[2:7],
   402  			}
   403  		}},
   404  		{"<>{a b}</>", func(t *test, tk Tokens) { // 5
   405  			t.Err = Error{
   406  				Err:     ErrMissingClosingBrace,
   407  				Parsing: "JSXChild",
   408  				Token:   tk[5],
   409  			}
   410  		}},
   411  		{"<>{...a}</>", func(t *test, tk Tokens) { // 6
   412  			t.Output = JSXChild{
   413  				Spread: true,
   414  				JSXChildExpression: &AssignmentExpression{
   415  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   416  						IdentifierReference: &tk[4],
   417  						Tokens:              tk[4:5],
   418  					}),
   419  					Tokens: tk[4:5],
   420  				},
   421  				Tokens: tk[2:6],
   422  			}
   423  		}},
   424  		{"<>{ ... a }</>", func(t *test, tk Tokens) { // 7
   425  			t.Output = JSXChild{
   426  				Spread: true,
   427  				JSXChildExpression: &AssignmentExpression{
   428  					ConditionalExpression: WrapConditional(&PrimaryExpression{
   429  						IdentifierReference: &tk[6],
   430  						Tokens:              tk[6:7],
   431  					}),
   432  					Tokens: tk[6:7],
   433  				},
   434  				Tokens: tk[2:9],
   435  			}
   436  		}},
   437  		{"<><a/></>", func(t *test, tk Tokens) { // 8
   438  			t.Output = JSXChild{
   439  				JSXElement: &JSXElement{
   440  					ElementName: JSXElementName{
   441  						Identifier: &tk[3],
   442  						Tokens:     tk[3:4],
   443  					},
   444  					SelfClosing: true,
   445  					Tokens:      tk[2:6],
   446  				},
   447  				Tokens: tk[2:6],
   448  			}
   449  		}},
   450  		{"<><></></>", func(t *test, tk Tokens) { // 9
   451  			t.Output = JSXChild{
   452  				JSXFragment: &JSXFragment{
   453  					Tokens: tk[2:7],
   454  				},
   455  				Tokens: tk[2:7],
   456  			}
   457  		}},
   458  		{"<><></b></>", func(t *test, tk Tokens) { // 10
   459  			t.Err = Error{
   460  				Err: Error{
   461  					Err:     ErrMissingTagClose,
   462  					Parsing: "JSXFragment",
   463  					Token:   tk[6],
   464  				},
   465  				Parsing: "JSXChild",
   466  				Token:   tk[2],
   467  			}
   468  		}},
   469  		{"<><b></c></>", func(t *test, tk Tokens) { // 11
   470  			t.Err = Error{
   471  				Err: Error{
   472  					Err:     ErrInvalidClosingTag,
   473  					Parsing: "JSXElement",
   474  					Token:   tk[8],
   475  				},
   476  				Parsing: "JSXChild",
   477  				Token:   tk[2],
   478  			}
   479  		}},
   480  		{"<>{ // A\n\n// B\na // C\n\n// D\n}</>", func(t *test, tk Tokens) { // 12
   481  			t.Output = JSXChild{
   482  				JSXChildExpression: &AssignmentExpression{
   483  					ConditionalExpression: WrapConditional(&MemberExpression{
   484  						PrimaryExpression: &PrimaryExpression{
   485  							IdentifierReference: &tk[8],
   486  							Tokens:              tk[8:9],
   487  						},
   488  						Comments: [5]Comments{{&tk[6]}, nil, nil, nil, {&tk[10]}},
   489  						Tokens:   tk[6:11],
   490  					}),
   491  					Tokens: tk[6:11],
   492  				},
   493  				Comments: [3]Comments{{&tk[4]}, nil, {&tk[12]}},
   494  				Tokens:   tk[2:15],
   495  			}
   496  		}},
   497  		{"<>{ // A\n\n// B\n... // C\na // D\n\n// E\n}</>", func(t *test, tk Tokens) { // 13
   498  			t.Output = JSXChild{
   499  				Spread: true,
   500  				JSXChildExpression: &AssignmentExpression{
   501  					ConditionalExpression: WrapConditional(&MemberExpression{
   502  						PrimaryExpression: &PrimaryExpression{
   503  							IdentifierReference: &tk[12],
   504  							Tokens:              tk[12:13],
   505  						},
   506  						Comments: [5]Comments{{&tk[10]}, nil, nil, nil, {&tk[14]}},
   507  						Tokens:   tk[10:15],
   508  					}),
   509  					Tokens: tk[10:15],
   510  				},
   511  				Comments: [3]Comments{{&tk[4]}, {&tk[6]}, {&tk[16]}},
   512  				Tokens:   tk[2:19],
   513  			}
   514  		}},
   515  		{"<>{ // A\n\n// B\n\n// C\n}</>", func(t *test, tk Tokens) { // 15
   516  			t.Output = JSXChild{
   517  				Comments: [3]Comments{{&tk[4]}, nil, {&tk[6], &tk[8]}},
   518  				Tokens:   tk[2:11],
   519  			}
   520  		}},
   521  	}, func(t *test) (Type, error) {
   522  		var jc JSXChild
   523  
   524  		t.Tokens = t.Tokens[2:2]
   525  
   526  		err := jc.parse(&t.Tokens)
   527  
   528  		return jc, err
   529  	}, true)
   530  }
   531  
   532  func TestJSXElement(t *testing.T) {
   533  	doTests(t, []sourceFn{
   534  		{"<''/>", func(t *test, tk Tokens) { // 1
   535  			t.Err = Error{
   536  				Err: Error{
   537  					Err:     ErrMissingIdentifier,
   538  					Parsing: "JSXElementName",
   539  					Token:   tk[1],
   540  				},
   541  				Parsing: "JSXElement",
   542  				Token:   tk[1],
   543  			}
   544  		}},
   545  		{"<a/>", func(t *test, tk Tokens) { // 2
   546  			t.Output = JSXElement{
   547  				ElementName: JSXElementName{
   548  					Identifier: &tk[1],
   549  					Tokens:     tk[1:2],
   550  				},
   551  				SelfClosing: true,
   552  				Tokens:      tk[:4],
   553  			}
   554  		}},
   555  		{"<a/b>", func(t *test, tk Tokens) { // 3
   556  			t.Err = Error{
   557  				Err:     ErrMissingTagClose,
   558  				Parsing: "JSXElement",
   559  				Token:   tk[3],
   560  			}
   561  		}},
   562  		{"<a></>", func(t *test, tk Tokens) { // 4
   563  			t.Err = Error{
   564  				Err: Error{
   565  					Err:     ErrMissingIdentifier,
   566  					Parsing: "JSXElementName",
   567  					Token:   tk[5],
   568  				},
   569  				Parsing: "JSXElement",
   570  				Token:   tk[5],
   571  			}
   572  		}},
   573  		{"<a></a>", func(t *test, tk Tokens) { // 5
   574  			t.Output = JSXElement{
   575  				ElementName: JSXElementName{
   576  					Identifier: &tk[1],
   577  					Tokens:     tk[1:2],
   578  				},
   579  				Tokens: tk[:7],
   580  			}
   581  		}},
   582  		{"<a></a b>", func(t *test, tk Tokens) { // 6
   583  			t.Err = Error{
   584  				Err:     ErrMissingTagClose,
   585  				Parsing: "JSXElement",
   586  				Token:   tk[7],
   587  			}
   588  		}},
   589  		{"<a b/>", func(t *test, tk Tokens) { // 7
   590  			t.Output = JSXElement{
   591  				ElementName: JSXElementName{
   592  					Identifier: &tk[1],
   593  					Tokens:     tk[1:2],
   594  				},
   595  				Attributes: []JSXAttribute{
   596  					{
   597  						Identifier: &tk[3],
   598  						Tokens:     tk[3:4],
   599  					},
   600  				},
   601  				SelfClosing: true,
   602  				Tokens:      tk[:6],
   603  			}
   604  		}},
   605  		{"<a b''/>", func(t *test, tk Tokens) { // 8
   606  			t.Err = Error{
   607  				Err: Error{
   608  					Err:     ErrMissingEquals,
   609  					Parsing: "JSXAttribute",
   610  					Token:   tk[4],
   611  				},
   612  				Parsing: "JSXElement",
   613  				Token:   tk[3],
   614  			}
   615  		}},
   616  		{"<a b='c' d />", func(t *test, tk Tokens) { // 9
   617  			t.Output = JSXElement{
   618  				ElementName: JSXElementName{
   619  					Identifier: &tk[1],
   620  					Tokens:     tk[1:2],
   621  				},
   622  				Attributes: []JSXAttribute{
   623  					{
   624  						Identifier: &tk[3],
   625  						JSXString:  &tk[5],
   626  						Tokens:     tk[3:6],
   627  					},
   628  					{
   629  						Identifier: &tk[7],
   630  						Tokens:     tk[7:8],
   631  					},
   632  				},
   633  				SelfClosing: true,
   634  				Tokens:      tk[:11],
   635  			}
   636  		}},
   637  		{"<a>b</a>", func(t *test, tk Tokens) { // 10
   638  			t.Output = JSXElement{
   639  				ElementName: JSXElementName{
   640  					Identifier: &tk[1],
   641  					Tokens:     tk[1:2],
   642  				},
   643  				Children: []JSXChild{
   644  					{
   645  						JSXText: &tk[3],
   646  						Tokens:  tk[3:4],
   647  					},
   648  				},
   649  				Tokens: tk[:8],
   650  			}
   651  		}},
   652  		{"<a><b/></a>", func(t *test, tk Tokens) { // 11
   653  			t.Output = JSXElement{
   654  				ElementName: JSXElementName{
   655  					Identifier: &tk[1],
   656  					Tokens:     tk[1:2],
   657  				},
   658  				Children: []JSXChild{
   659  					{
   660  						JSXElement: &JSXElement{
   661  							ElementName: JSXElementName{
   662  								Identifier: &tk[4],
   663  								Tokens:     tk[4:5],
   664  							},
   665  							SelfClosing: true,
   666  							Tokens:      tk[3:7],
   667  						},
   668  						Tokens: tk[3:7],
   669  					},
   670  				},
   671  				Tokens: tk[:11],
   672  			}
   673  		}},
   674  		{"<a>\nb\n<c/> </a>", func(t *test, tk Tokens) { // 12
   675  			t.Output = JSXElement{
   676  				ElementName: JSXElementName{
   677  					Identifier: &tk[1],
   678  					Tokens:     tk[1:2],
   679  				},
   680  				Children: []JSXChild{
   681  					{
   682  						JSXText: &tk[4],
   683  						Tokens:  tk[4:5],
   684  					},
   685  					{
   686  						JSXElement: &JSXElement{
   687  							ElementName: JSXElementName{
   688  								Identifier: &tk[7],
   689  								Tokens:     tk[7:8],
   690  							},
   691  							SelfClosing: true,
   692  							Tokens:      tk[6:10],
   693  						},
   694  						Tokens: tk[6:10],
   695  					},
   696  				},
   697  				Tokens: tk[:15],
   698  			}
   699  		}},
   700  		{"<a><b/c></a>", func(t *test, tk Tokens) { // 13
   701  			t.Err = Error{
   702  				Err: Error{
   703  					Err: Error{
   704  						Err:     ErrMissingTagClose,
   705  						Parsing: "JSXElement",
   706  						Token:   tk[6],
   707  					},
   708  					Parsing: "JSXChild",
   709  					Token:   tk[3],
   710  				},
   711  				Parsing: "JSXElement",
   712  				Token:   tk[3],
   713  			}
   714  		}},
   715  	}, func(t *test) (Type, error) {
   716  		var je JSXElement
   717  
   718  		err := je.parse(&t.Tokens)
   719  
   720  		return je, err
   721  	}, true)
   722  }
   723  
   724  func TestJSXFragment(t *testing.T) {
   725  	doTests(t, []sourceFn{
   726  		{"<></>", func(t *test, tk Tokens) { // 1
   727  			t.Output = JSXFragment{
   728  				Tokens: tk[:5],
   729  			}
   730  		}},
   731  		{"<></a>", func(t *test, tk Tokens) { // 2
   732  			t.Err = Error{
   733  				Err:     ErrMissingTagClose,
   734  				Parsing: "JSXFragment",
   735  				Token:   tk[4],
   736  			}
   737  		}},
   738  		{"<>b</>", func(t *test, tk Tokens) { // 3
   739  			t.Output = JSXFragment{
   740  				Children: []JSXChild{
   741  					{
   742  						JSXText: &tk[2],
   743  						Tokens:  tk[2:3],
   744  					},
   745  				},
   746  				Tokens: tk[:6],
   747  			}
   748  		}},
   749  		{"<><b/></>", func(t *test, tk Tokens) { // 4
   750  			t.Output = JSXFragment{
   751  				Children: []JSXChild{
   752  					{
   753  						JSXElement: &JSXElement{
   754  							ElementName: JSXElementName{
   755  								Identifier: &tk[3],
   756  								Tokens:     tk[3:4],
   757  							},
   758  							SelfClosing: true,
   759  							Tokens:      tk[2:6],
   760  						},
   761  						Tokens: tk[2:6],
   762  					},
   763  				},
   764  				Tokens: tk[:9],
   765  			}
   766  		}},
   767  		{"<>\nb\n<c/> </>", func(t *test, tk Tokens) { // 5
   768  			t.Output = JSXFragment{
   769  				Children: []JSXChild{
   770  					{
   771  						JSXText: &tk[3],
   772  						Tokens:  tk[3:4],
   773  					},
   774  					{
   775  						JSXElement: &JSXElement{
   776  							ElementName: JSXElementName{
   777  								Identifier: &tk[6],
   778  								Tokens:     tk[6:7],
   779  							},
   780  							SelfClosing: true,
   781  							Tokens:      tk[5:9],
   782  						},
   783  						Tokens: tk[5:9],
   784  					},
   785  				},
   786  				Tokens: tk[:13],
   787  			}
   788  		}},
   789  		{"<><b/c></>", func(t *test, tk Tokens) { // 6
   790  			t.Err = Error{
   791  				Err: Error{
   792  					Err: Error{
   793  						Err:     ErrMissingTagClose,
   794  						Parsing: "JSXElement",
   795  						Token:   tk[5],
   796  					},
   797  					Parsing: "JSXChild",
   798  					Token:   tk[2],
   799  				},
   800  				Parsing: "JSXFragment",
   801  				Token:   tk[2],
   802  			}
   803  		}},
   804  	}, func(t *test) (Type, error) {
   805  		var jf JSXFragment
   806  
   807  		err := jf.parse(&t.Tokens)
   808  
   809  		return jf, err
   810  	}, true)
   811  }
   812