github.com/lmorg/murex@v0.0.0-20240217211045-e081c89cd4ef/lang/interpreter_test.go (about)

     1  package lang_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	_ "github.com/lmorg/murex/builtins"
     7  	"github.com/lmorg/murex/test"
     8  )
     9  
    10  var (
    11  	testsAnd = []test.MurexTest{
    12  		{
    13  			Block:  `out "foo" && out "bar"`,
    14  			Stdout: "foo\nbar\n",
    15  		},
    16  		{
    17  			Block:   `err "foo" && out "bar"`,
    18  			Stderr:  "foo\n",
    19  			ExitNum: 1,
    20  		},
    21  		{
    22  			Block:   `out "foo" && err "bar"`,
    23  			Stdout:  "foo\n",
    24  			Stderr:  "bar\n",
    25  			ExitNum: 1,
    26  		},
    27  		{
    28  			Block:   `err "foo" && err "bar"`,
    29  			Stderr:  "foo\n",
    30  			ExitNum: 1,
    31  		},
    32  		/////
    33  		{
    34  			Block:  `out "foo"&&out "bar"`,
    35  			Stdout: "foo\nbar\n",
    36  		},
    37  		{
    38  			Block:   `err "foo"&&out "bar"`,
    39  			Stderr:  "foo\n",
    40  			ExitNum: 1,
    41  		},
    42  		{
    43  			Block:   `out "foo"&&err "bar"`,
    44  			Stdout:  "foo\n",
    45  			Stderr:  "bar\n",
    46  			ExitNum: 1,
    47  		},
    48  		{
    49  			Block:   `err "foo"&&err "bar"`,
    50  			Stderr:  "foo\n",
    51  			ExitNum: 1,
    52  		},
    53  		/////
    54  		{
    55  			Block:  `out "foo" \&& out "bar"`,
    56  			Stdout: "foo && out bar\n",
    57  		},
    58  		{
    59  			Block:  `out "foo" &\& out "bar"`,
    60  			Stdout: "foo && out bar\n",
    61  		},
    62  		{
    63  			Block:  `out "foo" \&\& out "bar"`,
    64  			Stdout: "foo && out bar\n",
    65  		},
    66  		/////
    67  		{
    68  			Block:  `out "foo" \&&& out "bar"`,
    69  			Stdout: "foo &\nbar\n",
    70  		},
    71  		{
    72  			Block:  `out "foo" &\&& out "bar"`,
    73  			Stdout: "foo &&& out bar\n",
    74  		},
    75  	}
    76  
    77  	testsOr = []test.MurexTest{
    78  		{
    79  			Block:  `out "foo" || out "bar"`,
    80  			Stdout: "foo\n",
    81  		},
    82  		{
    83  			Block:  `err "foo" || out "bar"`,
    84  			Stdout: "bar\n",
    85  			Stderr: "foo\n",
    86  		},
    87  		{
    88  			Block:  `out "foo" || err "bar"`,
    89  			Stdout: "foo\n",
    90  		},
    91  		{
    92  			Block:   `err "foo" || err "bar"`,
    93  			Stderr:  "foo\nbar\n",
    94  			ExitNum: 1,
    95  		},
    96  		/////
    97  		{
    98  			Block:  `out "foo"||out "bar"`,
    99  			Stdout: "foo\n",
   100  		},
   101  		{
   102  			Block:  `err "foo"||out "bar"`,
   103  			Stdout: "bar\n",
   104  			Stderr: "foo\n",
   105  		},
   106  		{
   107  			Block:  `out "foo"||err "bar"`,
   108  			Stdout: "foo\n",
   109  		},
   110  		{
   111  			Block:   `err "foo"||err "bar"`,
   112  			Stderr:  "foo\nbar\n",
   113  			ExitNum: 1,
   114  		},
   115  		/////
   116  		{
   117  			Block:  `out "foo" \| | regexp s/f/g/`,
   118  			Stdout: "goo |\n",
   119  		},
   120  	}
   121  )
   122  
   123  func TestOperatorLogicAndNormal(t *testing.T) {
   124  	test.RunMurexTests(testsAnd, t)
   125  }
   126  
   127  func TestOperatorLogicOrNormal(t *testing.T) {
   128  	test.RunMurexTests(testsOr, t)
   129  }
   130  
   131  func TestOperatorLogicAndTry(t *testing.T) {
   132  	var tests []test.MurexTest
   133  	for _, src := range testsAnd {
   134  		newTest := src
   135  		src.Block = "try {" + src.Block + "}"
   136  		tests = append(tests, newTest)
   137  	}
   138  
   139  	test.RunMurexTests(tests, t)
   140  }
   141  
   142  func TestOperatorLogicOrTry(t *testing.T) {
   143  	var tests []test.MurexTest
   144  	for _, src := range testsOr {
   145  		newTest := src
   146  		src.Block = "try {" + src.Block + "}"
   147  		tests = append(tests, newTest)
   148  	}
   149  	test.RunMurexTests(tests, t)
   150  }
   151  
   152  func TestOperatorLogicAndTryPipe(t *testing.T) {
   153  	var tests []test.MurexTest
   154  	for _, src := range testsAnd {
   155  		newTest := src
   156  		src.Block = "trypipe {" + src.Block + "}"
   157  		tests = append(tests, newTest)
   158  	}
   159  	test.RunMurexTests(tests, t)
   160  }
   161  
   162  func TestOperatorLogicOrTryPipe(t *testing.T) {
   163  	var tests []test.MurexTest
   164  	for _, src := range testsOr {
   165  		newTest := src
   166  		src.Block = "trypipe {" + src.Block + "}"
   167  		tests = append(tests, newTest)
   168  	}
   169  	test.RunMurexTests(tests, t)
   170  }
   171  
   172  func TestOperatorsTry(t *testing.T) {
   173  	tests := []test.MurexTest{
   174  		{
   175  			Block:  `out: 0; false; echo foobar`,
   176  			Stdout: "0\nfalsefoobar\n",
   177  		},
   178  		{
   179  			Block:  `out: 1; true || echo foobar`,
   180  			Stdout: "1\n",
   181  		},
   182  		{
   183  			Block:  `out: 1.1; true || true || echo foobar`,
   184  			Stdout: "1.1\n",
   185  		},
   186  		{
   187  			Block:  `out: 1.2; true || false || echo foobar`,
   188  			Stdout: "1.2\n",
   189  		},
   190  		{
   191  			Block:  `out: 1.3; false || true || echo foobar`,
   192  			Stdout: "1.3\n",
   193  		},
   194  		{
   195  			Block:  `out: 2; true && echo foobar`,
   196  			Stdout: "2\nfoobar\n",
   197  		},
   198  		{
   199  			Block:   `out: 2.1; false && false && echo foobar`,
   200  			Stdout:  "2.1\n",
   201  			ExitNum: 1,
   202  		},
   203  		{
   204  			Block:   `out: 2.2; true && false && echo foobar`,
   205  			Stdout:  "2.2\n",
   206  			ExitNum: 1,
   207  		},
   208  		{
   209  			Block:   `out: 2.3; false && true && echo foobar`,
   210  			Stdout:  "2.3\n",
   211  			ExitNum: 1,
   212  		},
   213  		{
   214  			Block:  `out: 3; false || echo foobar`,
   215  			Stdout: "3\nfoobar\n",
   216  		},
   217  		{
   218  			Block:   `out: 4; false && echo foobar`,
   219  			Stdout:  "4\n",
   220  			ExitNum: 1,
   221  		},
   222  		{
   223  			Block:  `out: 4.1; true || true && echo foobar`,
   224  			Stdout: "4.1\n",
   225  		},
   226  		///
   227  		{
   228  			Block:   `out: 5; try { false; echo foobar }`,
   229  			Stdout:  "5\nfalse",
   230  			ExitNum: 1,
   231  		},
   232  		{
   233  			Block:  `out: 6; try { true || echo foobar }`,
   234  			Stdout: "6\n",
   235  		},
   236  		{
   237  			Block:  `out: 7; try { true && echo foobar }`,
   238  			Stdout: "7\nfoobar\n",
   239  		},
   240  		{
   241  			Block:  `out: 8; try { false || echo foobar }`,
   242  			Stdout: "8\nfoobar\n",
   243  		},
   244  		{
   245  			Block:   `out: 9; try { false && echo foobar }`,
   246  			Stdout:  "9\n",
   247  			ExitNum: 1,
   248  		},
   249  		{
   250  			Block:  `out: 9.1; try { true || true; echo foobar }`,
   251  			Stdout: "9.1\nfoobar\n",
   252  		},
   253  		{
   254  			Block:  `out: 9.1; try { true || true && echo foobar }`,
   255  			Stdout: "9.1\nfoobar\n",
   256  		},
   257  		///
   258  		{
   259  			Block:   `out: 10; trypipe { false; echo foobar }`,
   260  			Stdout:  "10\nfalse",
   261  			ExitNum: 1,
   262  		},
   263  		{
   264  			Block:  `out: 11; trypipe { true || echo foobar }`,
   265  			Stdout: "11\n",
   266  		},
   267  		{
   268  			Block:  `out: 12; trypipe { true && echo foobar }`,
   269  			Stdout: "12\nfoobar\n",
   270  		},
   271  		{
   272  			Block:  `out: 13; trypipe { false || echo foobar }`,
   273  			Stdout: "13\nfoobar\n",
   274  		},
   275  		{
   276  			Block:   `out: 14; trypipe { false && echo foobar }`,
   277  			Stdout:  "14\n",
   278  			ExitNum: 1,
   279  		},
   280  		{
   281  			Block:  `out: 14.1; trypipe { true || true ; echo foobar }`,
   282  			Stdout: "14.1\nfoobar\n",
   283  		},
   284  		{
   285  			Block:  `out: 14.1; trypipe { true || true && echo foobar }`,
   286  			Stdout: "14.1\nfoobar\n",
   287  		},
   288  	}
   289  
   290  	test.RunMurexTests(tests, t)
   291  }