go.ketch.com/lib/goja@v0.0.1/builtin_map_test.go (about)

     1  package goja
     2  
     3  import (
     4  	"fmt"
     5  	"hash/maphash"
     6  	"testing"
     7  )
     8  
     9  func TestMapEvilIterator(t *testing.T) {
    10  	const SCRIPT = `
    11  	'use strict';
    12  	var o = {};
    13  
    14  	function Iter(value) {
    15  		this.value = value;
    16  		this.idx = 0;
    17  	}
    18  
    19  	Iter.prototype.next = function() {
    20  		var idx = this.idx;
    21  		if (idx === 0) {
    22  			this.idx++;
    23  			return this.value;
    24  		}
    25  		return {done: true};
    26  	}
    27  
    28  	o[Symbol.iterator] = function() {
    29  		return new Iter({});
    30  	}
    31  
    32  	assert.throws(TypeError, function() {
    33  		new Map(o);
    34  	});
    35  
    36  	o[Symbol.iterator] = function() {
    37  		return new Iter({value: []});
    38  	}
    39  
    40  	function t(prefix) {
    41  		var m = new Map(o);
    42  		assert.sameValue(1, m.size, prefix+": m.size");
    43  		assert.sameValue(true, m.has(undefined), prefix+": m.has(undefined)");
    44  		assert.sameValue(undefined, m.get(undefined), prefix+": m.get(undefined)");
    45  	}
    46  
    47  	t("standard adder");
    48  
    49  	var count = 0;
    50  	var origSet = Map.prototype.set;
    51  
    52  	Map.prototype.set = function() {
    53  		count++;
    54  		origSet.apply(this, arguments);
    55  	}
    56  
    57  	t("custom adder");
    58  	assert.sameValue(1, count, "count");
    59  
    60  	undefined;
    61  	`
    62  	testScriptWithTestLib(SCRIPT, _undefined, t)
    63  }
    64  
    65  func TestMapExportToNilMap(t *testing.T) {
    66  	vm := New()
    67  	var m map[int]interface{}
    68  	res, err := vm.RunString("new Map([[1, true]])")
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  	err = vm.ExportTo(res, &m)
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  	if len(m) != 1 {
    77  		t.Fatal(m)
    78  	}
    79  	if _, exists := m[1]; !exists {
    80  		t.Fatal(m)
    81  	}
    82  }
    83  
    84  func TestMapExportToNonNilMap(t *testing.T) {
    85  	vm := New()
    86  	m := map[int]interface{}{
    87  		2: true,
    88  	}
    89  	res, err := vm.RunString("new Map([[1, true]])")
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  	err = vm.ExportTo(res, &m)
    94  	if err != nil {
    95  		t.Fatal(err)
    96  	}
    97  	if len(m) != 1 {
    98  		t.Fatal(m)
    99  	}
   100  	if _, exists := m[1]; !exists {
   101  		t.Fatal(m)
   102  	}
   103  }
   104  
   105  func ExampleObject_Export_map() {
   106  	vm := New()
   107  	m, err := vm.RunString(`
   108  	new Map([[1, true], [2, false]]);
   109  	`)
   110  	if err != nil {
   111  		panic(err)
   112  	}
   113  	exp := m.Export()
   114  	fmt.Printf("%T, %v\n", exp, exp)
   115  	// Output: [][2]interface {}, [[1 true] [2 false]]
   116  }
   117  
   118  func ExampleRuntime_ExportTo_mapToMap() {
   119  	vm := New()
   120  	m, err := vm.RunString(`
   121  	new Map([[1, true], [2, false]]);
   122  	`)
   123  	if err != nil {
   124  		panic(err)
   125  	}
   126  	exp := make(map[int]bool)
   127  	err = vm.ExportTo(m, &exp)
   128  	if err != nil {
   129  		panic(err)
   130  	}
   131  	fmt.Println(exp)
   132  	// Output: map[1:true 2:false]
   133  }
   134  
   135  func ExampleRuntime_ExportTo_mapToSlice() {
   136  	vm := New()
   137  	m, err := vm.RunString(`
   138  	new Map([[1, true], [2, false]]);
   139  	`)
   140  	if err != nil {
   141  		panic(err)
   142  	}
   143  	exp := make([][]interface{}, 0)
   144  	err = vm.ExportTo(m, &exp)
   145  	if err != nil {
   146  		panic(err)
   147  	}
   148  	fmt.Println(exp)
   149  	// Output: [[1 true] [2 false]]
   150  }
   151  
   152  func ExampleRuntime_ExportTo_mapToTypedSlice() {
   153  	vm := New()
   154  	m, err := vm.RunString(`
   155  	new Map([[1, true], [2, false]]);
   156  	`)
   157  	if err != nil {
   158  		panic(err)
   159  	}
   160  	exp := make([][2]interface{}, 0)
   161  	err = vm.ExportTo(m, &exp)
   162  	if err != nil {
   163  		panic(err)
   164  	}
   165  	fmt.Println(exp)
   166  	// Output: [[1 true] [2 false]]
   167  }
   168  
   169  func BenchmarkMapDelete(b *testing.B) {
   170  	var key1 Value = asciiString("a")
   171  	var key2 Value = asciiString("b")
   172  	one := intToValue(1)
   173  	two := intToValue(2)
   174  	for i := 0; i < b.N; i++ {
   175  		m := newOrderedMap(&maphash.Hash{})
   176  		m.set(key1, one)
   177  		m.set(key2, two)
   178  		if !m.remove(key1) {
   179  			b.Fatal("remove() returned false")
   180  		}
   181  	}
   182  }
   183  
   184  func BenchmarkMapDeleteJS(b *testing.B) {
   185  	prg, err := Compile("test.js", `
   186  	var m = new Map([['a',1], ['b', 2]]);
   187  	
   188  	var result = m.delete('a');
   189  
   190  	if (!result || m.size !== 1) {
   191  		throw new Error("Fail!");
   192  	}
   193  	`,
   194  		false)
   195  	if err != nil {
   196  		b.Fatal(err)
   197  	}
   198  	b.ResetTimer()
   199  	for i := 0; i < b.N; i++ {
   200  		vm := New()
   201  		_, err := vm.RunProgram(prg)
   202  		if err != nil {
   203  			b.Fatal(err)
   204  		}
   205  	}
   206  }