From af759dcf42e6f00ffc32542aa7c459f6007818f2 Mon Sep 17 00:00:00 2001 From: Michael Ficarra Date: Fri, 3 Dec 2010 14:49:21 -0500 Subject: [PATCH] test_operations: removed the top-level closures that symbolized sections --- test/test_operations.coffee | 334 +++++++++++++++++------------------- 1 file changed, 161 insertions(+), 173 deletions(-) diff --git a/test/test_operations.coffee b/test/test_operations.coffee index 8797e596..df96a42f 100644 --- a/test/test_operations.coffee +++ b/test/test_operations.coffee @@ -1,4 +1,4 @@ -#### Operators +## Operators # binary (2-ary) math operators do not require spaces (-> @@ -52,214 +52,202 @@ eq (+ +1), (- -1) #### compound assignment operators + +# boolean operators (-> + a = 0 + a or= 2 + eq a, 2 - # boolean operators - (-> - a = 0 - a or= 2 - eq a, 2 + b = 1 + b or= 2 + eq b, 1 - b = 1 - b or= 2 - eq b, 1 + c = 0 + c and= 2 + eq c, 0 - c = 0 - c and= 2 - eq c, 0 + d = 1 + d and= 2 + eq d, 2 - d = 1 - d and= 2 - eq d, 2 + # ensure that RHS is treated as a group + e = f = false + e and= f or true + eq e, false +)() - # ensure that RHS is treated as a group - e = f = false - e and= f or true - eq e, false - )() +# compound assignment as a sub expression +(-> + [a, b, c] = [1, 2, 3] + eq (a + b += c), 6 + eq a, 1 + eq b, 5 + eq c, 3 +)() - # compound assignment as a sub expression - (-> - [a, b, c] = [1, 2, 3] - eq (a + b += c), 6 - eq a, 1 - eq b, 5 - eq c, 3 - )() +# compound assignment should be careful about caching variables +(-> + count = 0 + list = [] - # compound assignment should be careful about caching variables - (-> - count = 0 - list = [] + list[++count] or= 1 + eq list[1], 1 + eq count, 1 - list[++count] or= 1 - eq list[1], 1 - eq count, 1 + list[++count] ?= 2 + eq list[2], 2 + eq count, 2 - list[++count] ?= 2 - eq list[2], 2 - eq count, 2 + list[count++] and= 'two' + eq list[2], 'two' + eq count, 3 - list[count++] and= 'two' - eq list[2], 'two' - eq count, 3 + base = -> + ++count + base - base = -> - ++count - base + base().four or= 4 + eq base.four, 4 + eq count, 4 - base().four or= 4 - eq base.four, 4 - eq count, 4 + base().five ?= 5 + eq base.five, 5 + eq count, 5 +)() - base().five ?= 5 - eq base.five, 5 - eq count, 5 - )() +# compound assignment with implicit objects +(-> + obj = undefined + obj ?= + one: 1 - # compound assignment with implicit objects - (-> - obj = undefined - obj ?= - one: 1 + eq obj.one, 1 - eq obj.one, 1 - - obj and= - two: 2 - - eq obj.one, undefined - eq obj.two, 2 - )() + obj and= + two: 2 + eq obj.one, undefined + eq obj.two, 2 )() #### `is`,`isnt`,`==`,`!=` + +# `==` and `is` should be interchangeable. (-> + a = b = 1 + ok a is 1 and b == 1 + ok a == b + ok a is b +)() - # `==` and `is` should be interchangeable. - (-> - a = b = 1 - ok a is 1 and b == 1 - ok a == b - ok a is b - )() - - # `!=` and `isnt` should be interchangeable. - (-> - a = 0 - b = 1 - ok a isnt 1 and b != 0 - ok a != b - ok a isnt b - )() - +# `!=` and `isnt` should be interchangeable. +(-> + a = 0 + b = 1 + ok a isnt 1 and b != 0 + ok a != b + ok a isnt b )() #### `in`, `of` + +# - `in` should check if an array contains a value using `indexOf` +# - `of` should check if a property is defined on an object using `in` (-> + arr = [1] + ok 0 of arr + ok 1 in arr + # prefixing `not` to `in and `of` should negate them + ok 1 not of arr + ok 0 not in arr +)() - # `in` should check if an array contains a value using `indexOf` - # `of` should check if a property is defined on an object using `in` - (-> - arr = [1] - ok 0 of arr - ok 1 in arr - # prefixing `not` to `in and `of` should negate them - ok 1 not of arr - ok 0 not in arr - )() +# `in` should be able to operate on an array literal +(-> + ok 2 in [0, 1, 2, 3] + ok 4 not in [0, 1, 2, 3] + arr = [0, 1, 2, 3] + ok 2 in arr + ok 4 not in arr + # should cache the value used to test the array + arr = [0] + val = 0 + ok val++ in arr + ok val++ not in arr + val = 0 + ok val++ of arr + ok val++ not of arr +)() - # `in` should be able to operate on an array literal - (-> - ok 2 in [0, 1, 2, 3] - ok 4 not in [0, 1, 2, 3] - arr = [0, 1, 2, 3] - ok 2 in arr - ok 4 not in arr - # should cache the value used to test the array - arr = [0] - val = 0 - ok val++ in arr - ok val++ not in arr - val = 0 - ok val++ of arr - ok val++ not of arr - )() +# `of` and `in` should be able to operate on instance variables +(-> + obj = { + list: [2,3] + in_list: (value) -> value in @list + not_in_list: (value) -> value not in @list + of_list: (value) -> value of @list + not_of_list: (value) -> value not of @list + } + ok obj.in_list 3 + ok obj.not_in_list 1 + ok obj.of_list 0 + ok obj.not_of_list 2 +)() - # `of` and `in` should be able to operate on instance variables - (-> - obj = { - list: [2,3] - in_list: (value) -> value in @list - not_in_list: (value) -> value not in @list - of_list: (value) -> value of @list - not_of_list: (value) -> value not of @list - } - ok obj.in_list 3 - ok obj.not_in_list 1 - ok obj.of_list 0 - ok obj.not_of_list 2 - )() +#???: `in` with cache and `__indexOf` should work in argument lists +eq [Object() in Array()].length, 1 - #???: `in` with cache and `__indexOf` should work in argument lists - eq [Object() in Array()].length, 1 - - #737: `in` should have higher precedence than logical operators. - eq 1, 1 in [1] and 1 - - #768: `in` should preserve evaluation order. - (-> - share = 0 - a = -> share++ if share is 0 - b = -> share++ if share is 1 - c = -> share++ if share is 2 - ok a() not in [b(),c()] - eq share, 3 - )() +#737: `in` should have higher precedence than logical operators. +eq 1, 1 in [1] and 1 +#768: `in` should preserve evaluation order. +(-> + share = 0 + a = -> share++ if share is 0 + b = -> share++ if share is 1 + c = -> share++ if share is 2 + ok a() not in [b(),c()] + eq share, 3 )() #### chainable operators + +ok 100 > 10 > 1 > 0 > -1 +ok -1 < 0 < 1 < 10 < 100 + +# `is` and `isnt` may be chained +ok true is not false is true is not false +ok 0 is 0 isnt 1 is 1 + +# different comparison operators (`>`,`<`,`is`,etc.) may be combined +ok 1 < 2 > 1 +ok 10 < 20 > 2+3 is 5 + +# some chainable operators can be negated by `unless` +ok (true unless 0==10!=100) + +# operator precedence: `|` lower than `<` +eq 1, 1 | 2 < 3 < 4 + +# preserve references (-> - - ok 100 > 10 > 1 > 0 > -1 - ok -1 < 0 < 1 < 10 < 100 - - # `is` and `isnt` may be chained - ok true is not false is true is not false - ok 0 is 0 isnt 1 is 1 - - # different comparison operators (`>`,`<`,`is`,etc.) may be combined - ok 1 < 2 > 1 - ok 10 < 20 > 2+3 is 5 - - # some chainable operators can be negated by `unless` - ok (true unless 0==10!=100) - - # operator precedence: `|` lower than `<` - eq 1, 1 | 2 < 3 < 4 - - # preserve references - (-> - a = b = c = 1 - # `a == b <= c` should become `a === b && b <= c` - ok a == b <= c - )() - - # chained operations should evaluate each value only once - (-> - a = 0 - ok 1 > a++ < 1 - )() - - #891: incorrect inversion of chained comparisons - (-> - ok (true unless 0 > 1 > 2) - ok (true unless (NaN = 0/0) < 0/0 < NaN) - )() - + a = b = c = 1 + # `a == b <= c` should become `a === b && b <= c` + ok a == b <= c +)() + +# chained operations should evaluate each value only once +(-> + a = 0 + ok 1 > a++ < 1 +)() + +#891: incorrect inversion of chained comparisons +(-> + ok (true unless 0 > 1 > 2) + ok (true unless (NaN = 0/0) < 0/0 < NaN) )()