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

     1  package vm_test
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"log"
     7  	"sync"
     8  	"time"
     9  
    10  	"github.com/mattn/anko/env"
    11  	"github.com/mattn/anko/vm"
    12  )
    13  
    14  func Example_vmExecuteContext() {
    15  	var waitGroup sync.WaitGroup
    16  	waitGroup.Add(1)
    17  	waitChan := make(chan struct{}, 1)
    18  
    19  	e := env.NewEnv()
    20  	sleepMillisecond := func() { time.Sleep(time.Millisecond) }
    21  
    22  	err := e.Define("println", fmt.Println)
    23  	if err != nil {
    24  		log.Fatalf("define error: %v\n", err)
    25  	}
    26  	err = e.Define("sleep", sleepMillisecond)
    27  	if err != nil {
    28  		log.Fatalf("define error: %v\n", err)
    29  	}
    30  
    31  	script := `
    32  # sleep for 10 seconds
    33  for i = 0; i < 10000; i++ {
    34  	sleep()
    35  }
    36  # the context should cancel before printing the next line
    37  println("this line should not be printed")
    38  `
    39  
    40  	ctx, cancel := context.WithCancel(context.Background())
    41  	go func() {
    42  		close(waitChan)
    43  		v, err := vm.ExecuteContext(ctx, e, nil, script)
    44  		fmt.Println(v, err)
    45  		waitGroup.Done()
    46  	}()
    47  
    48  	<-waitChan
    49  	cancel()
    50  
    51  	waitGroup.Wait()
    52  
    53  	// output: <nil> execution interrupted
    54  }
    55  
    56  func Example_vmEnvDefine() {
    57  	// "github.com/mattn/anko/env"
    58  
    59  	e := env.NewEnv()
    60  
    61  	err := e.Define("println", fmt.Println)
    62  	if err != nil {
    63  		log.Fatalf("define error: %v\n", err)
    64  	}
    65  
    66  	err = e.Define("a", true)
    67  	if err != nil {
    68  		log.Fatalf("define error: %v\n", err)
    69  	}
    70  	err = e.Define("b", int64(1))
    71  	if err != nil {
    72  		log.Fatalf("define error: %v\n", err)
    73  	}
    74  	err = e.Define("c", float64(1.1))
    75  	if err != nil {
    76  		log.Fatalf("define error: %v\n", err)
    77  	}
    78  	err = e.Define("d", "d")
    79  	if err != nil {
    80  		log.Fatalf("define error: %v\n", err)
    81  	}
    82  	err = e.Define("e", []interface{}{true, int64(1), float64(1.1), "d"})
    83  	if err != nil {
    84  		log.Fatalf("define error: %v\n", err)
    85  	}
    86  	err = e.Define("f", map[string]interface{}{"a": true})
    87  	if err != nil {
    88  		log.Fatalf("define error: %v\n", err)
    89  	}
    90  
    91  	script := `
    92  println(a)
    93  println(b)
    94  println(c)
    95  println(d)
    96  println(e)
    97  println(f)
    98  `
    99  
   100  	_, err = vm.Execute(e, nil, script)
   101  	if err != nil {
   102  		log.Fatalf("execute error: %v\n", err)
   103  	}
   104  
   105  	// output:
   106  	// true
   107  	// 1
   108  	// 1.1
   109  	// d
   110  	// [true 1 1.1 d]
   111  	// map[a:true]
   112  }
   113  
   114  func Example_vmEnv() {
   115  	// "github.com/mattn/anko/env"
   116  
   117  	e := env.NewEnv()
   118  
   119  	err := e.Define("a", "a")
   120  	if err != nil {
   121  		log.Fatalf("define error: %v\n", err)
   122  	}
   123  
   124  	_, err = e.Get("a")
   125  	if err != nil {
   126  		log.Fatalf("get error: %v\n", err)
   127  	}
   128  
   129  	fmt.Println(e)
   130  
   131  	// output:
   132  	// No parent
   133  	// a = "a"
   134  }
   135  
   136  func Example_vmHelloWorld() {
   137  	// "github.com/mattn/anko/env"
   138  
   139  	e := env.NewEnv()
   140  
   141  	err := e.Define("println", fmt.Println)
   142  	if err != nil {
   143  		log.Fatalf("define error: %v\n", err)
   144  	}
   145  
   146  	script := `
   147  println("Hello World :)")
   148  `
   149  
   150  	_, err = vm.Execute(e, nil, script)
   151  	if err != nil {
   152  		log.Fatalf("execute error: %v\n", err)
   153  	}
   154  
   155  	// output: Hello World :)
   156  }
   157  
   158  func Example_vmQuickStart() {
   159  	// "github.com/mattn/anko/env"
   160  
   161  	e := env.NewEnv()
   162  
   163  	err := e.Define("println", fmt.Println)
   164  	if err != nil {
   165  		log.Fatalf("define error: %v\n", err)
   166  	}
   167  
   168  	script := `
   169  // declare variables
   170  x = 1
   171  y = x + 1
   172  
   173  // print using outside the script defined println function
   174  println(x + y) // 3
   175  
   176  // if else statement
   177  if x < 1 || y < 1 {
   178  	println(x)
   179  } else if x < 1 && y < 1 {
   180  	println(y)
   181  } else {
   182  	println(x + y)
   183  }
   184  
   185  // slice
   186  a = []interface{1, 2, 3}
   187  println(a) // [1 2 3]
   188  println(a[0]) // 1
   189  
   190  // map
   191  a = map[interface]interface{"x": 1}
   192  println(a) // map[x:1]
   193  a.b = 2
   194  a["c"] = 3
   195  println(a["b"]) // 2
   196  println(a.c) // 3
   197  
   198  // struct
   199  a = make(struct {
   200  	A int64,
   201  	B float64
   202  })
   203  a.A = 4
   204  a.B = 5.5
   205  println(a.A) // 4
   206  println(a.B) // 5.5
   207  
   208  // function
   209  func a (x) {
   210  	println(x + 1)
   211  }
   212  a(5) // 6
   213  `
   214  
   215  	_, err = vm.Execute(e, nil, script)
   216  	if err != nil {
   217  		log.Fatalf("execute error: %v\n", err)
   218  	}
   219  
   220  	// output:
   221  	// 3
   222  	// 3
   223  	// [1 2 3]
   224  	// 1
   225  	// map[x:1]
   226  	// 2
   227  	// 3
   228  	// 4
   229  	// 5.5
   230  	// 6
   231  }