github.com/mattn/anko@v0.1.10/vm/example_operators_test.go (about)

     1  package vm_test
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/mattn/anko/env"
     8  	"github.com/mattn/anko/vm"
     9  )
    10  
    11  func Example_vmBasicOperators() {
    12  	e := env.NewEnv()
    13  
    14  	err := e.Define("println", fmt.Println)
    15  	if err != nil {
    16  		log.Fatalf("define error: %v\n", err)
    17  	}
    18  
    19  	script := `
    20  a = nil
    21  println(a)
    22  a = true
    23  println(a)
    24  
    25  println("")
    26  
    27  a = 2 + 1
    28  println(a)
    29  a = 2 - 1
    30  println(a)
    31  a = 2 * 1
    32  println(a)
    33  a = 4 / 2
    34  println(a)
    35  
    36  println("")
    37  
    38  a = 1
    39  a++
    40  println(a)
    41  a--
    42  println(a)
    43  
    44  println("")
    45  
    46  a = 1
    47  a += 1
    48  println(a)
    49  a -= 1
    50  println(a)
    51  a *= 4
    52  println(a)
    53  a /= 2
    54  println(a)
    55  
    56  println("")
    57  
    58  a = 1 & 3
    59  println(a)
    60  a = 1 | 2
    61  println(a) 
    62  
    63  println("")
    64  
    65  a = 2 << 3
    66  println(a)
    67  a = 8 >> 2
    68  println(a)
    69  a = 7 % 3
    70  println(a)
    71  
    72  println("")
    73  
    74  a = 2 - (-2)
    75  println(a)
    76  a = ^2
    77  println(a)
    78  a = "a" * 4
    79  println(a)
    80  a = !true
    81  println(a)
    82  
    83  `
    84  
    85  	_, err = vm.Execute(e, nil, script)
    86  	if err != nil {
    87  		log.Fatalf("execute error: %v\n", err)
    88  	}
    89  
    90  	// output:
    91  	// <nil>
    92  	// true
    93  	//
    94  	// 3
    95  	// 1
    96  	// 2
    97  	// 2
    98  	//
    99  	// 2
   100  	// 1
   101  	//
   102  	// 2
   103  	// 1
   104  	// 4
   105  	// 2
   106  	//
   107  	// 1
   108  	// 3
   109  	//
   110  	// 16
   111  	// 2
   112  	// 1
   113  	//
   114  	// 4
   115  	// -3
   116  	// aaaa
   117  	// false
   118  
   119  }
   120  
   121  func Example_vmComparisonOperators() {
   122  	e := env.NewEnv()
   123  
   124  	err := e.Define("println", fmt.Println)
   125  	if err != nil {
   126  		log.Fatalf("define error: %v\n", err)
   127  	}
   128  
   129  	script := `
   130  a = nil == nil
   131  println(a)
   132  a = "a" != "a" 
   133  println(a)
   134  a = 1 == 1.0
   135  println(a)
   136  a = !true
   137  println(a)
   138  
   139  println("")
   140  
   141  a = 1 < 2
   142  println(a)
   143  a = 1 > 3
   144  println(a)
   145  a = 2 <= 2
   146  println(a)
   147  a = 2 >= 3
   148  println(a)
   149  
   150  println("")
   151  a = 1 == 2 && 1 == 1
   152  println(a)
   153  a = 1 == 2 || 1 == 1
   154  println(a)
   155  `
   156  
   157  	_, err = vm.Execute(e, nil, script)
   158  	if err != nil {
   159  		log.Fatalf("execute error: %v\n", err)
   160  	}
   161  
   162  	// output:
   163  	// true
   164  	// false
   165  	// true
   166  	// false
   167  	//
   168  	// true
   169  	// false
   170  	// true
   171  	// false
   172  	//
   173  	// false
   174  	// true
   175  
   176  }
   177  
   178  func Example_vmIfOperators() {
   179  	e := env.NewEnv()
   180  
   181  	err := e.Define("println", fmt.Println)
   182  	if err != nil {
   183  		log.Fatalf("define error: %v\n", err)
   184  	}
   185  
   186  	script := `
   187  a = 1
   188  b = 2
   189  
   190  if a == 1 {
   191  	println(a)
   192  }
   193  
   194  if b == 1 {
   195  	println(a)
   196  } else {
   197  	println(b)
   198  }
   199  
   200  if a == 3 {
   201  	println(a)
   202  } else if b == 3 {
   203  	println(b)
   204  } else {
   205  	println(a + b)
   206  }
   207  
   208  println("")
   209  
   210  if a == 2 || b == 2 {
   211  	println(4)
   212  }
   213  
   214  if a == 1 && b == 2 {
   215  	println(5)
   216  }
   217  `
   218  
   219  	_, err = vm.Execute(e, nil, script)
   220  	if err != nil {
   221  		log.Fatalf("execute error: %v\n", err)
   222  	}
   223  
   224  	// output:
   225  	// 1
   226  	// 2
   227  	// 3
   228  	//
   229  	// 4
   230  	// 5
   231  
   232  }
   233  
   234  func Example_vmForLoops() {
   235  	e := env.NewEnv()
   236  
   237  	err := e.Define("println", fmt.Println)
   238  	if err != nil {
   239  		log.Fatalf("define error: %v\n", err)
   240  	}
   241  
   242  	script := `
   243  i = 0
   244  for {
   245  	println(i)
   246  	i++
   247  	if i > 1 {
   248  		break
   249  	}
   250  }
   251  
   252  println("")
   253  
   254  for i in [0, 1] {
   255  	println(i)
   256  }
   257  
   258  println("")
   259  
   260  for key, value in {"a": "b"} {
   261  	println(key, value)
   262  }
   263  
   264  println("")
   265  
   266  i = 0
   267  for i < 2 {
   268  	println(i)
   269  	i++
   270  }
   271  
   272  println("")
   273  
   274  for i = 0; i < 2; i++ {
   275  	println(i)
   276  }
   277  
   278  println("")
   279  
   280  
   281  for i = 0; i < 10; i++ {
   282  	println(i)
   283  	if i < 1 {
   284  		continue
   285  	}
   286  	break
   287  }
   288  
   289  `
   290  
   291  	_, err = vm.Execute(e, nil, script)
   292  	if err != nil {
   293  		log.Fatalf("execute error: %v\n", err)
   294  	}
   295  
   296  	// output:
   297  	// 0
   298  	// 1
   299  	//
   300  	// 0
   301  	// 1
   302  	//
   303  	// a b
   304  	//
   305  	// 0
   306  	// 1
   307  	//
   308  	// 0
   309  	// 1
   310  	//
   311  	// 0
   312  	// 1
   313  
   314  }
   315  
   316  func Example_vmSlices() {
   317  	e := env.NewEnv()
   318  
   319  	err := e.Define("println", fmt.Println)
   320  	if err != nil {
   321  		log.Fatalf("define error: %v\n", err)
   322  	}
   323  
   324  	script := `
   325  a = "abc"
   326  println(a[1:])
   327  println(a[:2])
   328  println(a[1:2])
   329  
   330  println("")
   331  
   332  a = [1, 2, 3]
   333  println(a[1:])
   334  println(a[:2])
   335  println(a[1:2])
   336  `
   337  
   338  	_, err = vm.Execute(e, nil, script)
   339  	if err != nil {
   340  		log.Fatalf("execute error: %v\n", err)
   341  	}
   342  
   343  	// output:
   344  	// bc
   345  	// ab
   346  	// b
   347  	//
   348  	// [2 3]
   349  	// [1 2]
   350  	// [2]
   351  
   352  }
   353  
   354  func Example_vmChannels() {
   355  	e := env.NewEnv()
   356  
   357  	err := e.Define("println", fmt.Println)
   358  	if err != nil {
   359  		log.Fatalf("define error: %v\n", err)
   360  	}
   361  
   362  	script := `
   363  a = make(chan string, 1)
   364  a <- "a"
   365  println(<- a)
   366  
   367  a = make(chan string)
   368  go func() {
   369  	a <- "a"
   370  }()
   371  println(<- a)
   372  
   373  
   374  `
   375  
   376  	_, err = vm.Execute(e, nil, script)
   377  	if err != nil {
   378  		log.Fatalf("execute error: %v\n", err)
   379  	}
   380  
   381  	// output:
   382  	// a
   383  	// a
   384  
   385  }