github.com/google/grumpy@v0.0.0-20171122020858-3ec87959189c/runtime/range_test.go (about) 1 // Copyright 2016 Google Inc. All Rights Reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package grumpy 16 17 import ( 18 "testing" 19 ) 20 21 func TestEnumerate(t *testing.T) { 22 fun := wrapFuncForTest(func(f *Frame, args ...*Object) (*Object, *BaseException) { 23 e, raised := enumerateType.Call(f, args, nil) 24 if raised != nil { 25 return nil, raised 26 } 27 return ListType.Call(f, Args{e}, nil) 28 }) 29 cases := []invokeTestCase{ 30 {args: wrapArgs(NewTuple()), want: NewList().ToObject()}, 31 {args: wrapArgs(newTestList("foo", "bar")), want: newTestList(newTestTuple(0, "foo"), newTestTuple(1, "bar")).ToObject()}, 32 {args: wrapArgs(newTestTuple("foo", "bar"), 1), want: newTestList(newTestTuple(1, "bar")).ToObject()}, 33 {args: wrapArgs(newTestList("foo", "bar"), 128), want: NewList().ToObject()}, 34 {args: wrapArgs(newTestTuple(42), -300), want: newTestList(newTestTuple(0, 42)).ToObject()}, 35 {args: wrapArgs(NewTuple(), 3.14), wantExc: mustCreateException(TypeErrorType, "float object cannot be interpreted as an index")}, 36 {args: wrapArgs(123), wantExc: mustCreateException(TypeErrorType, "'int' object is not iterable")}, 37 {args: wrapArgs(), wantExc: mustCreateException(TypeErrorType, "'__new__' requires 2 arguments")}, 38 } 39 for _, cas := range cases { 40 if err := runInvokeTestCase(fun, &cas); err != "" { 41 t.Error(err) 42 } 43 } 44 } 45 46 func TestRangeIteratorIter(t *testing.T) { 47 fun := wrapFuncForTest(func(f *Frame) *BaseException { 48 xrange, raised := xrangeType.Call(f, wrapArgs(5), nil) 49 if raised != nil { 50 return raised 51 } 52 iter, raised := Iter(f, xrange) 53 if raised != nil { 54 return raised 55 } 56 if !iter.isInstance(rangeIteratorType) { 57 t.Errorf("iter(xrange(5)) = %v, want rangeiterator", iter) 58 } 59 got, raised := Iter(f, iter) 60 if raised != nil { 61 return raised 62 } 63 if got != iter { 64 t.Errorf("iter(%[1]v) = %[2]v, want %[1]v", iter, got) 65 } 66 return nil 67 }) 68 if err := runInvokeTestCase(fun, &invokeTestCase{want: None}); err != "" { 69 t.Error(err) 70 } 71 } 72 73 func TestXRangeGetItem(t *testing.T) { 74 cases := []invokeTestCase{ 75 {args: wrapArgs(newTestXRange(10), 3), want: NewInt(3).ToObject()}, 76 {args: wrapArgs(newTestXRange(10, 12), 1), want: NewInt(11).ToObject()}, 77 {args: wrapArgs(newTestXRange(5, -2, -3), 2), want: NewInt(-1).ToObject()}, 78 {args: wrapArgs(newTestXRange(3), 100), wantExc: mustCreateException(IndexErrorType, "index out of range")}, 79 {args: wrapArgs(newTestXRange(5), newTestSlice(1, 3)), wantExc: mustCreateException(TypeErrorType, "sequence index must be integer, not 'slice'")}, 80 } 81 for _, cas := range cases { 82 if err := runInvokeMethodTestCase(xrangeType, "__getitem__", &cas); err != "" { 83 t.Error(err) 84 } 85 } 86 } 87 88 func TestXRangeLen(t *testing.T) { 89 cases := []invokeTestCase{ 90 {args: wrapArgs(newTestXRange(10)), want: NewInt(10).ToObject()}, 91 {args: wrapArgs(newTestXRange(10, 12)), want: NewInt(2).ToObject()}, 92 {args: wrapArgs(newTestXRange(5, 16, 5)), want: NewInt(3).ToObject()}, 93 {args: wrapArgs(newTestXRange(5, -2, -3)), want: NewInt(3).ToObject()}, 94 } 95 for _, cas := range cases { 96 if err := runInvokeMethodTestCase(xrangeType, "__len__", &cas); err != "" { 97 t.Error(err) 98 } 99 } 100 } 101 102 func TestXRangeNew(t *testing.T) { 103 fun := newBuiltinFunction("TestXRangeNew", func(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) { 104 xrange, raised := xrangeType.Call(f, args, nil) 105 if raised != nil { 106 return nil, raised 107 } 108 return ListType.Call(f, []*Object{xrange}, nil) 109 }).ToObject() 110 cases := []invokeTestCase{ 111 {args: wrapArgs(5), want: newTestList(0, 1, 2, 3, 4).ToObject()}, 112 {args: wrapArgs(-3, 1), want: newTestList(-3, -2, -1, 0).ToObject()}, 113 {args: wrapArgs(10, 0), want: NewList().ToObject()}, 114 {args: wrapArgs(4, 7, 3), want: newTestList(4).ToObject()}, 115 {args: wrapArgs(4, 8, 3), want: newTestList(4, 7).ToObject()}, 116 {args: wrapArgs(-12, -21, -5), want: newTestList(-12, -17).ToObject()}, 117 {args: wrapArgs(-12, -22, -5), want: newTestList(-12, -17).ToObject()}, 118 {args: wrapArgs(-12, -23, -5), want: newTestList(-12, -17, -22).ToObject()}, 119 {args: wrapArgs(4, -4), want: NewList().ToObject()}, 120 {args: wrapArgs(-26, MinInt), want: NewList().ToObject()}, 121 {args: wrapArgs(1, 2, 0), wantExc: mustCreateException(ValueErrorType, "xrange() arg 3 must not be zero")}, 122 {args: wrapArgs(0, MinInt, -1), wantExc: mustCreateException(OverflowErrorType, "result too large")}, 123 } 124 for _, cas := range cases { 125 if err := runInvokeTestCase(fun, &cas); err != "" { 126 t.Error(err) 127 } 128 } 129 } 130 131 func TestXRangeRepr(t *testing.T) { 132 fun := newBuiltinFunction("TestXRangeRepr", func(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) { 133 xrange, raised := xrangeType.Call(f, args, nil) 134 if raised != nil { 135 return nil, raised 136 } 137 s, raised := Repr(f, xrange) 138 if raised != nil { 139 return nil, raised 140 } 141 return s.ToObject(), nil 142 }).ToObject() 143 cases := []invokeTestCase{ 144 {args: wrapArgs(42), want: NewStr("xrange(42)").ToObject()}, 145 {args: wrapArgs(42, 48), want: NewStr("xrange(42, 48)").ToObject()}, 146 {args: wrapArgs(42, 10), want: NewStr("xrange(42, 42)").ToObject()}, 147 {args: wrapArgs(-10, 10), want: NewStr("xrange(-10, 10)").ToObject()}, 148 {args: wrapArgs(-10, 10, 10), want: NewStr("xrange(-10, 10, 10)").ToObject()}, 149 {args: wrapArgs(-10, 10, 3), want: NewStr("xrange(-10, 11, 3)").ToObject()}, 150 {args: wrapArgs(4, 7, 3), want: NewStr("xrange(4, 7, 3)").ToObject()}, 151 {args: wrapArgs(4, 8, 3), want: NewStr("xrange(4, 10, 3)").ToObject()}, 152 {args: wrapArgs(-10, 10, -3), want: NewStr("xrange(-10, -10, -3)").ToObject()}, 153 {args: wrapArgs(3, 3, -5), want: NewStr("xrange(3, 3, -5)").ToObject()}, 154 } 155 for _, cas := range cases { 156 if err := runInvokeTestCase(fun, &cas); err != "" { 157 t.Error(err) 158 } 159 } 160 } 161 162 func newTestXRange(args ...interface{}) *Object { 163 return mustNotRaise(xrangeType.Call(NewRootFrame(), wrapArgs(args...), nil)) 164 }